Deleted old react core

This commit is contained in:
Willem Cazander 2024-12-14 17:19:55 +01:00
parent 8628c6cfb9
commit 022b107b45
18 changed files with 800 additions and 562 deletions

View file

@ -1,17 +0,0 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>love.distributedrebirth.nx01</groupId>
<artifactId>nx01</artifactId>
<version>〇一。壬寅。一〄-SNAPSHOT</version>
</parent>
<artifactId>nx01-no2all-react</artifactId>
<dependencies>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
</project>

View file

@ -1,17 +0,0 @@
package love.distributedrebirth.no2all.react;
public interface No2AllReact {
void claim(No2AllReactSlot slot);
void claimIn(No2AllReactSlot slot, Class<?> eventType);
void claimOut(No2AllReactSlot slot, Class<?> eventType);
void requireSlot(No2AllReactSlot slot, No2AllReactSlot dep);
void requireService(No2AllReactSlot slot, Class<?> serviceType);
void fire(No2AllReactSlot slot, Object event);
void fireForEach(No2AllReactSlot slot, Object event);
<T> void registrate(No2AllReactSlot slot, Class<T> eventType, No2AllReactListener<T> listener);
<T> T service(Class<T> serviceType);
void release(No2AllReactSlot slot);
}

View file

@ -1,7 +0,0 @@
package love.distributedrebirth.no2all.react;
@FunctionalInterface
public interface No2AllReactListener<T> {
void onEvent(No2AllReactSlotSignal<T> signal);
}

View file

@ -1,75 +0,0 @@
package love.distributedrebirth.no2all.react;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
public final class No2AllReactSlot {
private final No2AllReactSlot parent;
private final String slotSlug;
private final String slotPath;
private No2AllReactSlot(No2AllReactSlot parent, String slotSlug) {
this.parent = parent;
this.slotSlug = slotSlug;
this.slotPath = createSlotPath();
}
public No2AllReactSlot getParent() {
return parent;
}
public String getSlotSlug() {
return slotSlug;
}
public String getSlotPath() {
return slotPath;
}
public String createSlotPath() {
List<String> slugs = new ArrayList<>();
No2AllReactSlot parentNode = this;
while (parentNode != null) {
slugs.add(parentNode.getSlotSlug());
parentNode = parentNode.getParent();
}
StringBuilder buf = new StringBuilder();
for (int i = slugs.size() - 1; i >= 0; i--) {
buf.append(slugs.get(i));
if (i > 0) {
buf.append(',');
}
}
return buf.toString();
}
@Override
public int hashCode() {
return Objects.hash(slotPath);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
No2AllReactSlot other = (No2AllReactSlot) obj;
return Objects.equals(slotPath, other.slotPath);
}
public static No2AllReactSlot ofClass(Class<?> scriptClz) {
return new No2AllReactSlot(null, scriptClz.getPackageName() + ":type=" + scriptClz.getSimpleName());
}
public static No2AllReactSlot of(No2AllReactSlot parent, String kvPair) {
return new No2AllReactSlot(parent, kvPair);
}
}

View file

@ -1,7 +0,0 @@
package love.distributedrebirth.no2all.react;
public final class No2AllReactSlotLoad {
public No2AllReactSlotLoad() {
}
}

View file

@ -1,30 +0,0 @@
package love.distributedrebirth.no2all.react;
public final class No2AllReactSlotSignal<T> {
private final No2AllReactSlot target;
private final T data;
private final No2AllReact react;
public No2AllReactSlotSignal(No2AllReactSlot target, T data, No2AllReact react) {
this.target = target;
this.data = data;
this.react = react;
}
public No2AllReactSlot getTarget() {
return target;
}
public T getData() {
return data;
}
public No2AllReact getReact() {
return react;
}
// public T $() {
// return getData();
// }
}

View file

@ -1,7 +0,0 @@
package love.distributedrebirth.no2all.react;
public interface No2AllReactTypeScript extends No2AllReactListener<No2AllReactSlotLoad> {
default void onRelease(No2AllReactSlotSignal<No2AllReactSlotLoad> signal) {
}
}

View file

@ -1,16 +0,0 @@
package love.distributedrebirth.no2all.react.warp;
import love.distributedrebirth.no2all.react.No2AllReactSlot;
public abstract class No2AllActAbstractSlot {
private final No2AllReactSlot slot;
public No2AllActAbstractSlot(No2AllReactSlot slot) {
this.slot = slot;
}
public final No2AllReactSlot getSlot() {
return slot;
}
}

View file

@ -1,10 +0,0 @@
package love.distributedrebirth.no2all.react.warp;
import love.distributedrebirth.no2all.react.No2AllReactSlot;
public final class No2AllArtWarpSlotAdd extends No2AllActAbstractSlot {
protected No2AllArtWarpSlotAdd(No2AllReactSlot slot) {
super(slot);
}
}

View file

@ -1,10 +0,0 @@
package love.distributedrebirth.no2all.react.warp;
import love.distributedrebirth.no2all.react.No2AllReactSlot;
public final class No2AllArtWarpSlotRemove extends No2AllActAbstractSlot {
protected No2AllArtWarpSlotRemove(No2AllReactSlot slot) {
super(slot);
}
}

View file

@ -1,29 +0,0 @@
package love.distributedrebirth.no2all.react.warp;
import java.util.ArrayList;
import java.util.List;
import love.distributedrebirth.no2all.react.No2AllReactSlot;
public class No2AllReactSlotContract {
private final No2AllReactSlot slot;
final List<Class<?>> slotTypesIn = new ArrayList<>();
final List<Class<?>> slotTypesOut = new ArrayList<>();
public No2AllReactSlotContract(No2AllReactSlot slot) {
this.slot = slot;
}
public No2AllReactSlot getSlot() {
return slot;
}
public List<Class<?>> getSlotTypesIn() {
return slotTypesIn;
}
public List<Class<?>> getSlotTypesOut() {
return slotTypesOut;
}
}

View file

@ -1,186 +0,0 @@
package love.distributedrebirth.no2all.react.warp;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import love.distributedrebirth.no2all.react.No2AllReactSlotLoad;
import love.distributedrebirth.no2all.react.No2AllReact;
import love.distributedrebirth.no2all.react.No2AllReactListener;
import love.distributedrebirth.no2all.react.No2AllReactSlot;
import love.distributedrebirth.no2all.react.No2AllReactSlotSignal;
import love.distributedrebirth.no2all.react.No2AllReactTypeScript;
public class No2AllReactWarpCore implements No2AllReact {
public static final No2AllReactSlot DILITHIUM = No2AllReactSlot.ofClass(No2AllReactWarpCore.class);
private final Map<No2AllReactSlot, No2AllReactWarpFuel> slots = new HashMap<>();
private final Map<Class<?>, Object> services = new HashMap<>();
private final List<BacklogEvent> backlog = new ArrayList<>();
private Object currentEvent = null;
public No2AllReactWarpCore() {
claim(DILITHIUM);
toWarpFuel(DILITHIUM).registrateTypeIn(No2AllReactSlotLoad.class);
toWarpFuel(DILITHIUM).registrateTypeOut(No2AllArtWarpSlotAdd.class);
toWarpFuel(DILITHIUM).registrateTypeOut(No2AllArtWarpSlotRemove.class);
}
public void load(No2AllReactTypeScript script) {
Objects.requireNonNull(script).onEvent(new No2AllReactSlotSignal<>(DILITHIUM, new No2AllReactSlotLoad(), this));
}
public No2AllReactSlotContract getSlotContract(No2AllReactSlot slot) {
return toWarpFuel(slot).readContract();
}
public List<No2AllReactSlot> listChilds(No2AllReactSlot slot) {
Objects.requireNonNull(slot);
List<No2AllReactSlot> result = new ArrayList<>();
synchronized (slots) {
for (No2AllReactSlot slug : slots.keySet()) {
if (slot == null) {
result.add(slug);
continue;
}
if (slug.getParent() == null) {
continue;
}
if (slug.getParent().getSlotPath().equals(slot.getSlotPath())) {
result.add(slug);
}
}
}
return result;
}
@Override
public void fireForEach(No2AllReactSlot slot, Object event) {
for (No2AllReactSlot target : listChilds(slot)) {
fire(target, event);
}
}
@Override
public void fire(No2AllReactSlot slot, Object event) {
Objects.requireNonNull(slot);
Objects.requireNonNull(event);
if (currentEvent != null) {
backlog.add(new BacklogEvent(slot, event));
return;
}
currentEvent = event;
try {
toWarpFuel(slot).fire(event, slot);
while (!backlog.isEmpty()) {
List<BacklogEvent> backlog2 = new ArrayList<>(backlog);
backlog.clear();
for (BacklogEvent next : backlog2) {
toWarpFuel(next.slot).fire(next.event, next.slot);
}
}
} finally {
currentEvent = null;
}
}
static class BacklogEvent {
No2AllReactSlot slot;
Object event;
public BacklogEvent(No2AllReactSlot slot, Object event) {
this.slot = slot;
this.event = event;
}
}
@SuppressWarnings("unchecked")
@Override
public <T> void registrate(No2AllReactSlot slot, Class<T> eventType, No2AllReactListener<T> listener) {
No2AllReactListener<Object> listenerObj = (No2AllReactListener<Object>) listener;
toWarpFuel(slot).registrateListener(eventType, listenerObj);
}
@Override
public void release(No2AllReactSlot slot) {
toWarpFuel(slot).removeAll();
synchronized (slots) {
slots.remove(slot);
}
fire(DILITHIUM, new No2AllArtWarpSlotRemove(slot));
}
@Override
public void claim(No2AllReactSlot slot) {
Objects.requireNonNull(slot);
synchronized (slots) {
if (slots.keySet().contains(slot)) {
throw new IllegalStateException("Slug already claimed: " + slot.getSlotPath());
}
slots.put(slot, new No2AllReactWarpFuel(this, slot));
}
fire(DILITHIUM, new No2AllArtWarpSlotAdd(slot));
}
@Override
public void claimOut(No2AllReactSlot slot, Class<?> eventType) {
toWarpFuel(slot).registrateTypeOut(eventType);
}
@Override
public void claimIn(No2AllReactSlot slot, Class<?> eventType) {
toWarpFuel(slot).registrateTypeIn(eventType);
}
@Override
public void requireSlot(No2AllReactSlot slot, No2AllReactSlot dep) {
if (!isClaimed(dep)) {
throw new IllegalStateException("Script dependency missing: " + dep);
}
toWarpFuel(slot).addRequireSlot(dep);
}
@Override
public void requireService(No2AllReactSlot slot, Class<?> serviceType) {
toWarpFuel(slot).addRequireService(serviceType);
}
@SuppressWarnings("unchecked")
@Override
public <T> T service(Class<T> serviceType) {
Objects.requireNonNull(serviceType);
synchronized (services) {
return (T) services.get(serviceType);
}
}
public <T> void addService(Class<T> serviceType, T service) {
Objects.requireNonNull(serviceType);
Objects.requireNonNull(service);
synchronized (services) {
services.put(serviceType, service);
}
}
public boolean isClaimed(No2AllReactSlot slug) {
Objects.requireNonNull(slug);
synchronized (slots) {
return slots.keySet().contains(slug);
}
}
protected No2AllReactWarpFuel toWarpFuel(No2AllReactSlot slot) {
Objects.requireNonNull(slot);
No2AllReactWarpFuel result;
synchronized (slots) {
result = slots.get(slot);
if (result == null) {
throw new IllegalStateException("Slot not claimed: " + slot.getSlotPath());
}
}
return result;
}
}

View file

@ -1,120 +0,0 @@
package love.distributedrebirth.no2all.react.warp;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import love.distributedrebirth.no2all.react.No2AllReactListener;
import love.distributedrebirth.no2all.react.No2AllReactSlot;
import love.distributedrebirth.no2all.react.No2AllReactSlotSignal;
public class No2AllReactWarpFuel {
private final No2AllReactWarpCore no2AllReactWarpCore;
private final No2AllReactSlot containerSlot;
private final Map<Class<?>, List<No2AllReactListener<Object>>> listeners = new HashMap<>();
private final Set<Class<?>> claimTypesOut = new HashSet<>();
private final Set<Class<?>> claimTypesIn = new HashSet<>();
private final Set<Class<?>> requireServices = new HashSet<>();
private final Set<No2AllReactSlot> requireSlots = new HashSet<>();
protected No2AllReactWarpFuel(No2AllReactWarpCore no2AllReactWarpCore, No2AllReactSlot containerSlot) {
this.no2AllReactWarpCore = Objects.requireNonNull(no2AllReactWarpCore);
this.containerSlot = Objects.requireNonNull(containerSlot);
}
private List<No2AllReactListener<Object>> toViewOfListeners(Class<?> eventType) {
List<No2AllReactListener<Object>> result = new ArrayList<>();
synchronized (listeners) {
List<No2AllReactListener<Object>> typeListeners = listeners.get(eventType);
if (typeListeners == null) {
return result;
}
result.addAll(typeListeners);
}
return result;
}
public void fire(Object event, No2AllReactSlot slot) {
for (No2AllReactListener<Object> listener : toViewOfListeners(event.getClass())) {
listener.onEvent(new No2AllReactSlotSignal<>(slot, event, this.no2AllReactWarpCore));
}
}
public void registrateListener(Class<?> eventType, No2AllReactListener<Object> listener) {
Objects.requireNonNull(eventType);
Objects.requireNonNull(listener);
synchronized (listeners) {
List<No2AllReactListener<Object>> typeListeners = listeners.get(eventType);
if (typeListeners == null) {
typeListeners = new ArrayList<>();
listeners.put(eventType, typeListeners);
}
typeListeners.add(listener);
}
}
public void registrateTypeOut(Class<?> eventType) {
Objects.requireNonNull(eventType);
synchronized (claimTypesOut) {
claimTypesOut.add(eventType);
}
}
public void registrateTypeIn(Class<?> eventType) {
Objects.requireNonNull(eventType);
synchronized (claimTypesIn) {
claimTypesIn.add(eventType);
}
}
public No2AllReactSlotContract readContract() {
No2AllReactSlotContract result = new No2AllReactSlotContract(containerSlot);
synchronized (claimTypesIn) {
result.slotTypesIn.addAll(claimTypesIn);
}
synchronized (claimTypesOut) {
result.slotTypesOut.addAll(claimTypesOut);
}
return result;
}
public void addRequireService(Class<?> serviceType) {
Objects.requireNonNull(serviceType);
synchronized (requireServices) {
requireServices.add(serviceType);
}
}
public void addRequireSlot(No2AllReactSlot dep) {
Objects.requireNonNull(dep);
synchronized (requireSlots) {
requireSlots.add(dep);
}
}
public void removeAll() {
synchronized (listeners) {
for (Class<?> eventType : listeners.keySet()) {
List<No2AllReactListener<Object>> typeListeners = listeners.get(eventType);
typeListeners.clear();
}
}
synchronized (claimTypesOut) {
claimTypesOut.clear();
}
synchronized (claimTypesIn) {
claimTypesIn.clear();
}
synchronized (requireServices) {
requireServices.clear();
}
synchronized (requireSlots) {
requireSlots.clear();
}
}
}

View file

@ -1,30 +0,0 @@
package love.distributedrebirth.no2all.react.warp;
import love.distributedrebirth.no2all.react.No2AllReactSlotLoad;
import java.util.logging.Logger;
import love.distributedrebirth.no2all.react.No2AllReact;
import love.distributedrebirth.no2all.react.No2AllReactSlot;
import love.distributedrebirth.no2all.react.No2AllReactSlotSignal;
import love.distributedrebirth.no2all.react.No2AllReactTypeScript;
public class No2AllRtsWarpSpeedMonitor implements No2AllReactTypeScript {
public static final No2AllReactSlot API = No2AllReactSlot.ofClass(No2AllRtsWarpSpeedMonitor.class);
private static final No2AllReactSlot API_DILITHIUM = No2AllReactWarpCore.DILITHIUM;
private static final Logger LOG = Logger.getLogger(No2AllRtsWarpSpeedMonitor.class.getName());
@Override
public void onEvent(No2AllReactSlotSignal<No2AllReactSlotLoad> signal) {
No2AllReact react = signal.getReact();
react.claim(API);
react.requireSlot(API, API_DILITHIUM);
react.registrate(API_DILITHIUM, No2AllArtWarpSlotAdd.class, v -> {
LOG.fine("slot-add: " + v.getData().getSlot().getSlotPath());
});
react.registrate(API_DILITHIUM, No2AllArtWarpSlotRemove.class, v -> {
LOG.fine("slot-remove: " + v.getData().getSlot().getSlotPath());
});
}
}

View file

@ -29,7 +29,6 @@
<module>nx01-king-java3doc</module> <module>nx01-king-java3doc</module>
<module>nx01-king-java3seed</module> <module>nx01-king-java3seed</module>
<module>nx01-no2all-nostr</module> <module>nx01-no2all-nostr</module>
<module>nx01-no2all-react</module>
<module>nx01-no2all-react-nostr</module> <module>nx01-no2all-react-nostr</module>
<module>nx01-no2all-react-wire</module> <module>nx01-no2all-react-wire</module>
<module>nx01-no2all-wire</module> <module>nx01-no2all-wire</module>

View file

@ -0,0 +1,117 @@
# Love
Ultra simplified rules of the heart;
- All males are scum bags after dick activation
- All females are private whores after masturbation
- All love is fake after kissing (note kissing also can do memory wipe, is only safe after soul contact)
- Love only works once
- The heart is ready ~10+ if no heart failure has killed it (rape,relation,school,relocation,etc)
- Love is electric and only works with female heart and male heart connecting in etherspace
Love needs to be clean, only the first gets real love, the next only gets stockholm.
Which is automatic social love which works with everybody.
Thus for unactivated/unbroken children this leaves a time window of around 10 to 12 to find heart partner.
Only asking the hand is correct, and only after both have seen the others soul, they can kiss for marriage.
## 7-9-11
The path of love, building 7 year love time window gives;
- Boy: 7 to 14
- Girl: 9 to 16
- Avg: 11
Have found 7-9-11 in classic sharia law. ("dictionary of islam" from 1885)
Remember heart love selection is before sexuality and sexuality can be activated on any age.
First touch heart dating (with OBE on first touch) is avg 10.5 boy with 12.5 girl.
(equal age forced roman mixed gender school classes destroys a lot of love)
The process it triggers it called "automatic giving of the heart", and means the mind
has no choise over what the heart selected as compatible, choise is for the heartbroken.
It removes "humantity" by seeing the heart field torus chamber (thrown of God) where
the soul is attacted to the flesh.
Than you have a heart connection established and following that you get;
Thomas 22:
Jesus said to them, "When you make the two one, and when you make the inside like the
outside and the outside like the inside, and the above like the below, and when you make
the male and the female one and the same, so that the male not be male nor the female;
and when you fashion eyes in the place of an eye, and a hand in place of a hand, and a
foot in place of a foot, and a likeness in place of a likeness; then will you enter the kingdom."
It is the result of very clean love doing first touch(asking the hand) dating correct.
But is does not work after dick activation, and it breaks too after one relation.
So zero practice besides a quick 1sec touch of the hand.
An other indication that heart love is allowed in a society;
If the heart connection breaks somebody will die, cheating is not
possible as the other feels the connection going away in a instant.
Being buried alive with you dead partner, yes if you can't even think about that
you never had any bit of love in your life, you fake garbage humans.
Being burned alive with your partner, you don't want to be with the body, you want
to be with the soul behind the eyes, so releasing the (aging) body together is nice.
## Levels of Love
* 0 = Body/Sex attraction ('normal' image first selection)
* 1 = Person love (shared interests,hobby,religion)
* 2 = Care love (automatic love, is in our dna)
Put any 2 humans together and after time they love each other.
Almost any relation can grow into this, even works for stockholm.
This is also the maximum level for equal gender relations.
* 3 = Chemical love (hormones, no pill)
Partner selection should be done clean, without the pill.
To good source for divorce's are the normalization of hormones when the female stops taking the pill.
Same also applies on other hormones like anabolic steroids/etc. Even an dis-ease treatment or drug can result
in disliking of your partners body chemically. A good match is like feeling at ease, so you can be yourself.
* 3.14159265359 = PI Love
Baby (dis)ability.
* 4 = Electromagnatic love
Be with your partner's real body in etherspace as electomagnatic energy which looks white sparkly.
Needs a touch with an heart compatible person to start working. Its first in shared dream state to confirm.
* 5 = Heart love
View your golden heart torus field chamber from the inside.
There are many depictions of Jesus and Maria with a radiant/glowing or fire heart, it is like that.
Happens directly in the moment of the first touch when your heart gives itself automatic to the other.
* 6 = Spiritual Love
There is a tent in Jannah (Heaven) specific for the male and his wife.
The pair are do a visit of this tent while being alive on earth.
* 7 = Undisclosed
## Genesis
Page 1 of The Bible states that Adam and Eve where man and wife.
Before they knew that they where naked;
Love is fake after kissing.
Love is fake after masterbation.
Asking the hand only works before nakedness.
If the male hose works like a snake than love is fake.
If the female knows her tree has fruits than love is fake.
Partner selection must be done before a child is removed from the garden.
After activation the human feelings, falls from the heart to the genitals.
If I lived in the USA i would have sue options;
- 7 years of Christian lower school who failed
- 6 years of Christian higher school who failed
- 10+ years in the church who failed
- Christian parents who failed
- A few Christian friends who parents also failed
- A few years sunday school which also failed
Have you met a Christian who teaches Genesis of the Bible correctly ?
Have you met a Jew who teaches Bəreshit of the Torah correctly ?
Have you met a Muslim who teaches 7:22 of the Quran correctly ?

View file

@ -0,0 +1,642 @@
# Old readme of bassbone
left over
### J++
Programming with interfaces needs some more interfaces....
#### Terminator Types
recursive terminator² type sugar
```
interface MyApi<T extends MyApi<T>> {
}
interface MyApi<T> {
}
```
Self extending generics gets you a headach, when using multiple types and being four levels deep in abstract type safe builder structures.
#### Type face
interface without body
```
public interface A<T> {
typeface MyType1 extends A<Type>;
interface MyType2 extends A<Type> {}
}
```
#### Baby face
Allow only one method. (functional interfaces should have an interface)
```
public babyface FoodMachine {
double brestFeeding(); // allowed
int bottleFeeding(); // second method is forbidden
}
```
#### Child face
sub member interfaces
```
public childface A {
interface SubA extends A { // allowed
}
}
public interface B extends A { // error
}
```
#### Pack face
internal package interfaces. (is more a modifier like public/protected)
```
package my.package.a;
public packface A {
}
package my.package.a.b;
public interface B extends A { // allow
}
package my.package.c;
public interface C extends A { // disallow
}
```
#### Final face
Stop interface tree
```
finalface A {
}
interface B extends A { // disallow
}
class AB implements A { // allow
}
```
#### Shadow face
Objects have public and shadow interfaces
```
interface A {
}
shadowface B {
default void hidden();
}
interface C extends A, B {
default void internalApi(C c) {
if (A.class.isAssignableFrom(c)) {} // true
if (B.class.isAssignableFrom(c)) {} // false
if (B.class.isAssignableFromShadow(c)) {} // true
B b = B.class.castShadow(c);
c.hidden(); // error
b.hidden(); // allow
}
}
```
#### Inner face
Force an "implementing interfaces" to export embedded declared interface members.
```
interface MyType {}
interface A {
inner interface <MyType> MyType[]; // jvm: force child member definition of zero-or-more
//inner interface <MyType> MyType; // jvm: force child member definition of one
// mmm and force naming...
}
interface B extends A {
interface MyType1 extends MyType {}
interface MyType2 extends MyType {}
}
```
This is what I miss in LDAP and schema definition on tree node level which forces the correct interfaces downwards.
And than LDAP is generic meta complete RW orm-less multiple inheritance by interface data structure.
#### Black face
Force an interface to have resolved generics parameters.
```
blackface A {
}
blackface B<T> { // forbidden
}
blackface C extends A { // allowed
}
interface D extends C {
}
interface E<T> extends A, List<T> { // forbidden
}
interface F extends A, List<String> { // allowed
}
interface <T extends String & StringUnicode & ComparibleUnicode & ObjectSneeze & HardCodeExport> Fᒾ extends A, List<T>, SuperList<T>, OtherList<T> { // allowed
}
```
#### Protected Interface
Allow protected keyword on interfaces;
```
protected interface A {
}
```
Current java suger only needs an empty enum;
```
public enum BabelTypeAnnotationᵗˣᵗ {
;
// protected super market interface for text
protected interface Ꝑŕᱜṫèƈ₮ࠄ₫ extends ObjectScopeLimitΔ.ƉěḭȵᶒModifier.Ꝑŕᱜṫèƈ₮ࠄ₫ {
}
}
public interface BabelTypeAnnotation班ᵗˣᵗ extends BabelTypeAnnotationᵗˣᵗ.Ꝑŕᱜṫèƈ₮ࠄ₫ {
}
```
#### Scoping as Interface
Jvm internal dynamic interfaces on objects allow generics to force protected/private resources.
```
public class A {
protected A data;
private A doStuff(Class<A & ObjectScope.Protected> canThisWork) {
}
public interface B {}
public interface B1 extends B {}
protected interface B2 extends B {}
private A doStuffApi(Class<B & ObjectScope.Protected> internalApiInterface) {
}
}
```
#### Enum Extension
Have base interface for enum methods as interface, so extension is possible;
```
public interface ObjectEnum {
String name();
int ordinal();
}
public java.lang.Enum implements ObjectEnum {
}
public interface MyEnum extends ObjectEnum {
default int ordinalRandomMax() { return new Random().nextInt(ordinal()); }
}
public enum A implements MyEnum {
}
```
#### Enum faces
Define name-less interfaces as enum values, note syntax is wrong.
```
public eiface B { // ei = egg in dutch , but EnumIterableFace
BASS_FACE_0(Boolean.class),
BASS_FACE_1(Number.class),
BASS_FACE_3(Trit.class),
BASS_FACE_4({
void myMethodInterface();
}),
BASS_WHORE({
void lol();
@Override
default myMethodInterface() { lol(); }
} extends ObjectToHuman, B.BASS_FACE_3, B.BASE_FACE_4),
;
public static final DEFAULT = B.BASS_WHORE;
}
public eggface C<T extends MyInterfaces> { // maybe you want a egg face :)
IMPL_0(MyInterfaceImpl0.class),
IMPL_1(MyInterfaceImpl1.class),
FALLBACK({
@Override
default T humanJunkInterfaces() {
return (T) toIteratorConstructor(toString().getBytes()); // fails on dutch jvm, default charset must be removed
}
@Override
default String toString() {
//System.exit(1);
return "𑀳𑁂𑀮𑀺𑀉𑁄𑀤𑁄𑀭𑁂𑀡 𑀪𑀸𑀕";
}
}<T>),
;
}
```
#### Bean face
Removes constructor support fully from beans.
```
public beanface RealBeanDontHaveConstrucots {
int foobar();
}
public class SwimmingPoolBoard implements RealBeanDontHaveConstrucots {
public SwimmingPoolBoard() { // disallowed by design
} // humans to stupid, init order is forced by loader
}
```
#### Force face
Force correct implemention to implementators.
```
public interface HolyApi {
boolean holyMethodFromHeaven();
}
public forceface MayThe4ThBeWithYou extends ᒢObject, HolyApi, RealBeanDontHaveConstrucots {
// a forceface creates a forcefield on this to implement all methods from above **faces
private void soepEtenInVagevuur() {
fromClass().soep("This place is called purgatory"); //炼狱
}
boolean junkMethodInHell(); // allow junkies to get a new shot to keep calm
@Override
default final boolean holyMethodFromHeaven() {
soepEtenInVagevuur();
if (junkMethodInHell()) {
return true;
}
// note: humans are not allowed to use an if statement it is to complex for humans :P
return fromClass().getDecisionMaker().ifIntIsZero(getEpochLong() & 1, () -> true, () -> false));
}
}
class HolyBean implements MayThe4ThBeWithYou {
// no construcotr allowed
// no methods allowed (zero is a design goal)
// no bugs possible
@Override boolean junkMethodInHell() { return System.getProperty("vm.monothread") != null; }
// Finally api design where normal humans are not allowed to create bugs
// only add holy interfaces where correct implemention is forced.
}
```
#### Shield face
Removed visibilty from all the inherherit methods from above.
```
public interface A {
public int size();
default long speed() {
return 1L;
}
}
public shieldface B extends A {
public int sizeDoesMatter();
default private int size() {
return sizeDoesMatter() * 2;
}
default public long slowIsBetter() {
return super.speed() - 1L;
}
}
public class C extends B {
public C() {
this.speed(); // error
}
}
```
#### Slave face
Inherits the declared parent class interfaces definitions.
```
public interface TheMaster<T> extends MyInterfaceTree<T>, ThisOther, ASpecialOne<ThisOther> {
public slaveface Slave01<T> {
}
public slaveface Slave02<T> {
}
public slaveface Slave03<T> {
}
public slaveface Slave04<T> {
}
public interface SlaveXXX<T> extends TheMaster<T> { // replaces
}
}
```
#### Sperm face
The root interface of all interfaces
```
public spermface TheVoid {
}
```
#### Fuck face
An interface which is not allowed to goto an instance, also known as a namespace or an type key.
```
public fuckface Females {
}
public interface Marriage extends Females {
}
public class Male implements Marriage { // error
}
```
Maybe a proper name is like "DeathFace" as you never can have a living instance...
#### Duyts face
For the duyts doc shadow annotation composed inheritable babel towel interface elevators documentation needs a;
```
public duytsface WirVertrauenInGott {
}
public interface IsComposedLike extends
TypeFace, // no body allowed
BlackFace, // no generics allowed
FinalFace, // not an inheritable interface
FuckFace { // no instance allowed
}
// note: we need a new syntax for sliced typed interfaces;
public porkface<ForceFace,ShieldFace> MyForceField<T> {
}
```
Api's should restrict all options so only one path is the path to enlightenment.
#### The Duytschen Method
Add syntax for forced life cycle object. (borrow idea from rust)
```
public class Test {
static final Map<Object,List<?>> listeners = new WeakHashMap<>();
public void addListenerNormal(Consumer<Void> listener) {
}
public void addListenerLife(Object lifeCycle, Consumer<Void> listener) {
listeners.put(lifeCycle, ...);
}
public void addListenerDuyts@(Consumer<Void> listener) {
Object papierenBitte = @;
if (UberDeutscheAuto.class.isAssignableFrom(papierenBitte)) {
System.err.println("Audi 100 - nur 1,76 Liter auf 100km - das sparsamste Auto der Welt 1989");
System.exit("ZDF".hashCode());
}
listeners.put(papierenBitte, ...);
}
private void register() {
test.addListenerNormal(() -> {});
test.addListenerLife(this, () -> {});
test.addListenerLife(Class.class, () -> {}); // any static obj will work
// automatic "this" caller reference injection by jvm
test.addListenerDutys@(() -> {});
}
public static void main(String[] args) {
Test test = new Test();
test.register();
}
}
```
#### Kampf face
An kampfface overrides the local imports, thus only the allowed methods and classes are available to use.
Note: the automatic "java.lang" search magic will also need to be removed for this.
```
public kampfface DutchGreenConcentrationKampf {
fence: java.util.ArrayList;
fence: java.lang.Integer;
}
// ------------
import xyz.DutchGreenConcentrationKampf;
import java.lang.String; // <--- ERROR, Strings are for pussies
public class Thailand implements DutchGreenConcentrationKampf {
}
```
#### Clean SingleThreadJVM
- Add china whitespace support (U+3000)
- Remove thread code
- Remove locks + sync
- Remove concurrent
- Remove cryto cyfers
- Remove ALL compression support
- Add class AST + loader hook (allows for optional self extracting bytecode)
- Remove char/Character (use int/CharacterUnicode)
- Remove as much static as possible (fully is v2)
- Remove annotations, and impl as "normal" shadow interfaces
- Remove modules (more interface types + classloaders)
- Add @TargetType(MyInterface.class)
- Remove default modifier suger
- Remove all other left over junk
- Add job api, etc
```
public enum MyApp implements BeanApplicationBoot {
INSTANCE;
@Override
default main(String[] args) {
while(true) {
System.gc(StepSize.FULL_SWEEP); // not really like this, eventloop/job api interface
Imgui.begin();
Imgui.textarea("Legacy swing, can be wrapped to Imgui too");
Imgui.end();
}
}
}
```
Multi threading is done by the OS kernel interface and is called a process in legacy computing.
```
// event weaving is an OS kernel function for larger applications
public final enum FYouMyFunctionsAreFaster implements BeanApplicationBoot {
INSTANCE;
@Inject
private SystemInput<MyProtoBuffer> input;
@Inject
@Qualier(SystemPort.SysOut.class)
private SystemOutputPort output;
@Inject
private MyProcessEngine engine;
// no instance of the GC required
// no threads, no locks, no sync
// super small and fast boot single function processes
@Override
default void main(String[] args) {
MyProtoBuffer msg = input.getValue();
SomeOutputEventProtoBuffer out = engine.doMyWork(msg);
output.send(out);
}
}
```
In the unlimited size matrix computers there are lots of cpus as devices, which have no shared memory.
Cache is a design failure.
Bytes are garbage.
Cpu are just not yet automatic unrolled code loops to hardware.
```
public final class MyCalculator implements Runnable {
@Override
public void run() {
System.out.println("This gets converted to a protobuffer2 msg event");
}
public void static main(String[] args) {
MyCalculator softImpl = new MyCalculator();
System.out.println(softImpl.toString()); // garbage for english humans only...
Runnable wrap = System.os.requestHardwareImpl(softImpl.toVHDL());
wrap.run();
// The kernel is in control of this optional feature and thus can only be asked.
//
// In event flow context, the kernel detects that a piece of code is possible
// faster in hardware and allocates and rewires HOT the event flow, you have zero control.
}
}
```
With the babel wrap interfaces we have access all the code steps to registrate as "step code" and export.
```
@UnitBuilderCompoundPair(groupId = Newton.GROUP_ID, groupBaseTypeId = Newton.GROUP_BASE_TYPE_ID,
leftGroup = Kilogram.GROUP_ID, rightGroup = MetrePreSecondSquared.GROUP_ID,
quantityIds = Newton.GROUP_QUANTITIES,
unitType = @UnitBuilderTypes(
id = Newton.GROUP_BASE_TYPE_ID,
name = Newton.GROUP_ID,
aliasOfType = Newton.GROUP_BASE_TYPE_ID_ALIAS
)
)
public interface Newton extends UnitTypeFactory {
public static final String GROUP_ID = "newton";
public static final String GROUP_BASE_TYPE_ID = "N";
private static final String GROUP_BASE_TYPE_ID_ALIAS = "kg"+UnitXCGroupCompoundPair.PER_ID+UnitXCModuleMetrePerSecondSquared.GROUP_BASE_TYPE_ID;
private static final String[] GROUP_QUANTITIES = {"force","weight"};
}
//public class UnitXCModuleNewton implements UnitXCConfigModule {
// // TODO: symbol N + fix builder
//
// @Override
// public void configModule(UnitXCConfigBuilder builder) {
// builder.createUnitGroupCompoundPair(GROUP_ID, UnitXCModuleKilogram.GROUP_ID, UnitXCModuleMetrePerSecondSquared.GROUP_ID)
// .addQuantityIds(GROUP_QUANTITIES)
// .setBaseTypeId(GROUP_BASE_TYPE_ID)
// .createUnitType()
// .setId(GROUP_BASE_TYPE_ID)
// .setName(GROUP_ID)
// .setAliasOfType(GROUP_BASE_TYPE_ID_ALIAS)
// .build()
// .build();
// }
//}
```
#### J++ NG
- Binary XML china source format
- Remove all new/for/if/while keywords from language
- Change from boolean/Boolean to trit/Trit as base bit unit
- Move ServiceLoader access to extension classloader only
- merge extends and implements keywords, we only need one super
- Remove all classic native types
- Replace unicode with uniode4D
#### HolyC++
Binary XML VHDL recusive language with only one static nor gate function as root.
Build up full set languages and port J++ jvm to hardware.
Terminators run with dynamic hardware hebrew blood numbers.
- vrGEM4: No texture support all data in math
- vrGEM4: GLDrawConvas amd GLDraw3D are framelimited to 1 FPS
- vrGEM4: all pixels are drawn by the doom fractal pixelizer
- vrGEM4: no ImGui access only ImRichFaces for developers
Humans are like bugs and should not allowed to write low level code, terminators don't allow bugs.

View file

@ -0,0 +1,41 @@
# Octal Warp Tubes
An octal signal in electronic terms.
## TTL
An octal signal can be simulated by using 3 bit of TTL signals.
An other option is to have 8 voltage domains on a single signal.
But voltage based transmission lines are slow due to the RC constant.
## Hertzian Blocks
Like modems using 8 blocks to transmit an octal signal.
## Phase Differential Angle
By using two lines, both in resonance you have stable power.
By using the delta of the phase angle difference to define data.
startrek
Space folding
coaxial warp drive
In his patent No. 787,412, filed May 16, 1900, Tesla showed that the current of his transmitter passed over the earths surface with a speed of 471,264 kilometer per second
and that he has designed apparatus with he expects to project so-called electrons with a speed equal
to twice that of light.
Phase velocity Wiki;
Additionally, the phase velocity of electromagnetic radiation may under certain circumstances (for example anomalous
dispersion) exceed the speed of light in vacuum, but this does not indicate any superluminal information or energy
transfer.[citation needed] It was theoretically described by physicists such as Arnold Sommerfeld and Léon Brillouin.
NX-01 (niks-01 dutch nothing-01 english)
Super Luminal Warp Drive
Warp Factor 4.5