arch-java/gdxapp4d
2
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Removed bassboon

Browse source
This commit is contained in:
Willem Cazander 2022-11-15 10:01:35 +01:00
parent 5b71d1f90e
commit 8cff04d471
429 changed files with 41 additions and 122577 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
gdxapp4d-lib-basicwd/pom.xml
View file

@ -9,9 +9,9 @@
<name>GDXApp⁴ᴰ-Lib-기초적인ʷᴰ</name>
<dependencies>
<dependency>
<groupId>love.distributedrebirth.gdxapp4d</groupId>
<artifactId>gdxapp4d-lib-bassboonyd</artifactId>
<version>${project.version}</version>
<groupId>love.distributedrebirth.bassboon</groupId>
<artifactId>bassboon-jppre</artifactId>
<version>${bassboon-jppre.version}</version>
</dependency>
</dependencies>
</project>

10
gdxapp4d-lib-bassboonyd/pom.xml
View file

@ -1,10 +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.gdxapp4d</groupId>
<artifactId>gdxapp4d</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
<artifactId>gdxapp4d-lib-bassboonyd</artifactId>
<name>GDXApp⁴ᴰ-Lib-BãßBȍőnʸᴰ</name>
</project>

372
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/Bãß.java
View file

@ -1,372 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ;
import java.lang.instrument.Instrumentation;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.WeakHashMap;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnDuytsFlüstern注;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnExport注;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.BãßBȍőnCoffin;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.BãßBȍőnCoffinDuytschenᵗˣᵗ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.BãßBȍőnCoffinGhost;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.BãßBȍőnCoffinGhostSpell;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.BãßBȍőnCoffinGhostSpellLock;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpider;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderEye注;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderSperm;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderWire注;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ObjectHell;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ObjectScopeLimitΔ邪ᙾ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ObjectSoundOfShadow;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒢObject;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ObjectHell.TheNether;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᔾᓑᣕᒼᐪᑊᐤᣕᔆ.Runnableբ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.BabelLocalizer邪ᙾ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocConstructor注;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocMethod注;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocType注;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDoc注;
import ᒢᐩᐩ.ᔿᐤᒄʸ.ᒢᔿᕽ.CounterGuageᴶᴹˣ;
import ᒢᐩᐩ.ᔿᐤᒄʸ.ᣔᒃᣔᒼᓑᔆ.BãßBȍőnAbacusInstanceMBeanʸᴰ;
/**
* Остерегайтесь кинематографических комедийных концертов.
* И если они утверждают, что это развлечение, то они
* ничего, кроме западных проектов.
* С преднамеренными, постепенными шагами и западным контролем, а не религиозным контролем.
* Они одели ее в привлекательные и соблазнительные платья и завернули в
* значения обновления и изменения к лучшему.
* развлечения, у них нет альтернатив, кроме распущенности, танцев и
* смешивание самцов и самок.
* Это не что иное, как позор, позор и дурное предзнаменование для страны.
* Когда геев представляют как образец для подражания для молодежи.
* О роскошь, вы тратите деньги людей на свои легкомысленные программы.
* без права и без выгоды.
* Ты потратишь его, тогда тебе будет жаль, тогда ты потерпишь поражение».
* Да, вы потерпите поражение в битве ценностей и морали.
* Общество, которое все еще твердо придерживается своей религии, победит вас, несмотря ни на что.
* насколько он спотыкается или слаб.
* Общество не смирится с тем, что развлечения — это импорт самых грязных вещей.
* вещь в западной культуре, чтобы развратить ее и ослабить ее веру, ценности и мораль.
* Ваши программы будут побеждены сеансами заучивания Корана
* против которого вы боретесь
* Наши высокие минареты звучат, Бог велик, Бог велик.
* Каждый день и ночь пять раз, которые касаются наших ушей, победят тебя.
*
* @author Sheikh Saleh al Talib
* @see programmed by media crowd
*/
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@DuytsDocType注(babel = {
@DuytsDoc注(locale= "en", purpose = "Runtime for static bass noise ௸.."),
@DuytsDoc注(locale= "zh", code = "低音", purpose = "來自天堂的靜態低音噪音的運行時間"),
@DuytsDoc注(locale= "hi", code = "बास", purpose = "स्वर्ग से स्थिर बास शोर के लिए रनटाइम")
})
public interface Bãß {
@DuytsDocType注(babel = {
@DuytsDoc注(locale= "en", code = "lijkenkistʸᴰ", purpose = "Sarcophagus aggregates Y-Dimensions"),
@DuytsDoc注(locale= "zh", purpose = "石棺聚合多個維度"),
@DuytsDoc注(locale= "hi", code = "पत्थरꣻकीꣻबनीꣻहुईꣻकब्रʸᴰ", purpose = "सरकोफैगस कई आयामों को एकत्रित करता है")
})
@BãßBȍőnExport注(group = "ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ")
@BãßBȍőnDuytsFlüstern注(purpose = "RM ME")
static enum 石棺ʸᴰ implements BãßBȍőnAbacusInstanceMBeanʸᴰ<石棺ʸᴰ> {
أَكْبَرײꣻײالله;
private final Map<Object, BãßBȍőnSpiderSperm> സ്പൈഡർബീജം = new WeakHashMap<>();
private final 𝔅𝔬𝔫𝔢𝔏𝔬𝔞𝔡𝔢𝔯ʸᴰ 𝔪𝔬𝔬𝔫𝔖𝔭𝔢𝔩𝔩𝔚𝔬𝔯𝔨 = Bãß.характеристики.熱蘭遮城.ןיװיזױױדודזיןןןזךױזזז();
@BãßBȍőnSpiderWire注(hunt = @BãßBȍőnSpiderEye注(fly = "boonCntInit"))
private CounterGuageᴶᴹˣ boonCntInit = new CounterGuageᴶᴹˣ("init", "only"); // TODO: fix to protected so this is not possible...
@BãßBȍőnSpiderWire注(hunt = @BãßBȍőnSpiderEye注(fly = "boonCntInit"))
private CounterGuageᴶᴹˣ boonCntLock = new CounterGuageᴶᴹˣ("init", "only");
@BãßBȍőnSpiderWire注(hunt = @BãßBȍőnSpiderEye注(fly = "bassCntSpiderEmbryos"))
private CounterGuageᴶᴹˣ bassCntSpiderEmbryos = new CounterGuageᴶᴹˣ("init", "only");
@BãßBȍőnSpiderWire注(hunt = @BãßBȍőnSpiderEye注(fly = "bassCntCoffinToGrave"))
private CounterGuageᴶᴹˣ bassCntCoffinToGrave = new CounterGuageᴶᴹˣ("init", "only");
@BãßBȍőnSpiderWire注(hunt = @BãßBȍőnSpiderEye注(fly = "bassCntDigToGrave"))
private CounterGuageᴶᴹˣ bassCntDigToGrave = new CounterGuageᴶᴹˣ("init", "only");
@BãßBȍőnSpiderWire注(hunt = @BãßBȍőnSpiderEye注(fly = "bassCntCoffinBurried"))
private CounterGuageᴶᴹˣ bassCntCoffinBurried = new CounterGuageᴶᴹˣ("init", "only");
private Runnableբ.जंगम Г̄Ѫӏ = () -> {
// self first boot, one time only without if statements...
Bãß.石棺ʸᴰ.أَكْبَرײꣻײالله.挖ᵀᵒ(Bãß.石棺ʸᴰ.أَكْبَرײꣻײالله).init(Bãß.石棺ʸᴰ.أَكْبَرײꣻײالله); // just compile again until it works....
Bãß.石棺ʸᴰ.أَكْبَرײꣻײالله.Г̄Ѫӏ = () -> boonCntInit.increment();
};
// @DuytsDocConstructor注(babel = {
// @DuytsDoc注(locale= "en", purpose = "Sarcophagus is closed for humans"),
// @DuytsDoc注(locale= "zh", purpose = "石棺對人類關閉"),
// @DuytsDoc注(locale= "hi", purpose = "सरकोफैगस इंसानों के लिए बंद है")
// })
private 石棺ʸᴰ() {
Bãß.характеристики.熱蘭遮城.יזזןיזךױױזזױ = Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.CHAR_ATARI > Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.INT_ZERO;
}
// @DuytsDocMethod注(babel = {
// @DuytsDoc注(locale= "en", code = "boonInit", purpose = "RÅ...........Init"),
// @DuytsDoc注(locale= "zh", code = "恩惠初始化", purpose = "拉布恩飛行"),
// @DuytsDoc注(locale= "hi", code = "बूनꣻस्टार्ट", purpose = "रा बून फ्लाइंग")
// })
public <T extends BãßBȍőnʸᴰ<T>> void 𓂀ױןייזדזיודזיןןזזזןױ𓉢(BãßBȍőnʸᴰ<T> derKnochen) {
//boonCntInit.increment();
Г̄Ѫӏ.दौड़ना();
挖ᵀᵒ(derKnochen).init(derKnochen);
}
// @DuytsDocMethod注(babel = {
// @DuytsDoc注(locale= "en", code = "lockGrave", purpose = "Closes the coffin so no new ghosts can enter"),
// @DuytsDoc注(locale= "zh", code = "墳墓鎖", purpose = "關上棺材，讓新的鬼魂無法進入"),
// @DuytsDoc注(locale= "hi", code = "कब्रꣻकाꣻताला", purpose = "ताबूत को बंद कर देता है ताकि कोई नया भूत प्रवेश न कर सके")
// })
public <T extends BãßBȍőnʸᴰ<T>> void 墳ᴸᵒᶜᵏ(BãßBȍőnʸᴰ<T> derKnochen) {
boonCntLock.increment();
挖ᵀᵒ(derKnochen).lock(derKnochen);
}
// @DuytsDocMethod注(babel = {
// @DuytsDoc注(locale= "en", code = "spiderEmbryoAdd", purpose = "Injection of external spider sperm to mix the dead bones"),
// @DuytsDoc注(locale= "zh", code = "蜘蛛胚胎添加", purpose = "注射外部蜘蛛精混合死骨"),
// @DuytsDoc注(locale= "hi", code = "मकड़ीꣻभ्रूणꣻजोड़ें", purpose = "मृत हड्डियों को मिलाने के लिए बाहरी मकड़ी के शुक्राणु का इंजेक्शन")
// })
public void 蜘蛛胚ᴬᵈᵈ(Object lifeLine, BãßBȍőnSpiderSperm spinneSperma) {
bassCntSpiderEmbryos.increment();
synchronized (സ്പൈഡർബീജം) { // todo: replace with rw locking
സ്പൈഡർബീജം.put(lifeLine, spinneSperma);
}
}
// @DuytsDocMethod注(babel = {
// @DuytsDoc注(locale= "en", code = "coffinOf", purpose = "Gets the coffin from the grave"),
// @DuytsDoc注(locale= "zh", code = "棺材", purpose = "從墳墓中取出棺材"),
// @DuytsDoc注(locale= "hi", code = "काꣻताबूत", purpose = "कब्र से ताबूत मिलता है")
// })
protected <T extends BãßBȍőnʸᴰ<T>> BãßBȍőnCoffin 棺ᴼᶠ(BãßBȍőnʸᴰ<T> derKnochen) {
bassCntCoffinToGrave.increment();
return 挖ᵀᵒ(derKnochen);
}
protected <T extends BãßBȍőnʸᴰ<T>, G extends BãßBȍőnCoffinDuytschenᵗˣᵗ> G 棺ᴼᶠ(BãßBȍőnʸᴰ<T> derKnochen, Class<G> duytschen) {
bassCntCoffinToGrave.increment();
return 挖ᵀᵒ(derKnochen).ₜₒI18Nᵗˣᵗ(duytschen);
}
/**
* Dig To
*/
private <T extends BãßBȍőnʸᴰ<T>> BȍőnGrave 挖ᵀᵒ(BãßBȍőnʸᴰ<T> derKnochen) {
bassCntDigToGrave.increment();
BȍőnGrave 𓁀 = derKnochen.fromClassShadow(BȍőnGrave.class);
if (𓁀 == null) {
𓁀 = new BȍőnGrave(𝔪𝔬𝔬𝔫𝔖𝔭𝔢𝔩𝔩𝔚𝔬𝔯𝔨, സ്പൈഡർബീജം);
TheNether land = derKnochen.fromClassShadow(ObjectHell.TheNether.class);
land.onDeathClaimThisSoul(𓁀);
}
return 𓁀;
}
/*
public static <T> BeanWrapper<T> 豆ᴺᴱᵂ(Class<T> seedling) { // bean-new
try {
T bean = seedling.getConstructor().newInstance();
if (bean instanceof BãßBȍőnʸᴰ) {
BãßBȍőnʸᴰ<?> boon = (BãßBȍőnʸᴰ<?>) bean;
BȍőnGrave grave = 墳ᴼᶠ(boon);
if (!grave.inited) {
魎ᴵᴺᴵᵀ(boon);
}
return new BeanWrapper<>(bean);
}
return new BeanWrapper<>(bean);
} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
| InvocationTargetException | NoSuchMethodException | SecurityException e) {
throw new RuntimeException(e);
}
}
public static final class BeanWrapper<T> implements DefaultBãßBȍőnʸᴰ<T>, BãßBȍőnSpiderCloak<T> {
private final T bean;
private BeanWrapper(T bean) {
魎ᴵᴺᴵᵀ(this);
this.bean = bean;
}
@Override
public T getBean() {
return bean;
}
}
*/
private static final class BȍőnGrave implements BãßBȍőnCoffin,ObjectSoundOfShadow {
private final Map<Class<? extends BãßBȍőnCoffinDuytschenᵗˣᵗ>,BãßBȍőnCoffinDuytschenᵗˣᵗ> duytschenCoffins = new HashMap<>();
private final Map<Class<?>,BãßBȍőnCoffinGhost> ghosts = new HashMap<>();
private final 𝔅𝔬𝔫𝔢𝔏𝔬𝔞𝔡𝔢𝔯ʸᴰ 𝔪𝔬𝔬𝔫𝔖𝔭𝔢𝔩𝔩𝔚𝔬𝔯𝔨;
private final BãßBȍőnSpider spider;
private boolean inited = false;
private boolean locked = false;
private BȍőnGrave(𝔅𝔬𝔫𝔢𝔏𝔬𝔞𝔡𝔢𝔯ʸᴰ 𝔪𝔬𝔬𝔫𝔖𝔭𝔢𝔩𝔩𝔚𝔬𝔯𝔨, Map<Object,BãßBȍőnSpiderSperm> spiderSperm) {
this.𝔪𝔬𝔬𝔫𝔖𝔭𝔢𝔩𝔩𝔚𝔬𝔯𝔨 = 𝔪𝔬𝔬𝔫𝔖𝔭𝔢𝔩𝔩𝔚𝔬𝔯𝔨;
spider = new BãßBȍőnSpider(spiderSperm);
BãßBȍőnCoffinDuytschenᵗˣᵗ.ײₚᵤₜI18Nᵗˣᵗײ(duytschenCoffins, this);
}
private <T extends BãßBȍőnʸᴰ<T>> void init(BãßBȍőnʸᴰ<T> derKnochen) {
if (inited) {
return;
}
𝔪𝔬𝔬𝔫𝔖𝔭𝔢𝔩𝔩𝔚𝔬𝔯𝔨.𝔦𝔫𝔦𝔱𝔅𝔬𝔫𝔢𝔐𝔞𝔤𝔦𝔠(derKnochen, spider, duytschenCoffins);
inited = true;
}
private <T extends BãßBȍőnʸᴰ<T>> void lock(BãßBȍőnʸᴰ<T> derKnochen) {
if (locked) {
return;
}
𝔪𝔬𝔬𝔫𝔖𝔭𝔢𝔩𝔩𝔚𝔬𝔯𝔨.𝔩𝔬𝔠𝔨𝔅𝔬𝔫𝔢𝔐𝔞𝔤𝔦𝔠(derKnochen, spider);
for (Class<?> familyName:new ArrayList<>(ghosts.keySet())) {
BãßBȍőnCoffinGhost ghost = ghosts.get(familyName);
ghosts.put(familyName, BãßBȍőnCoffinGhostSpellLock.castᴼᶠ(ghost).LOCK());
}
locked = true;
}
@Override
public BãßBȍőnCoffinGhost UNHOLY(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> familyName) {
BãßBȍőnCoffinGhost ghost = ghosts.get(familyName);
if (ghost == null) {
if (locked) {
throw new RuntimeException("Coffin locked");
}
ghost = BãßBȍőnCoffinGhostSpellLock.instanceᴺᵉʷ();
ghosts.put(familyName, ghost);
}
return ghost;
}
@Override
public BãßBȍőnCoffinGhostSpell UNHOLY_SPELL(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> familyName) {
return BãßBȍőnCoffinGhostSpell.castᴼᶠ(UNHOLY(familyName));
}
@SuppressWarnings("unchecked")
@Override
public <T> T NOISE_OF(Class<T> noiseName) {
return (T) spider.getSilkRoad(noiseName).weaveWire();
}
@SuppressWarnings("unchecked")
private <G extends BãßBȍőnCoffinDuytschenᵗˣᵗ> G ₜₒI18Nᵗˣᵗ(Class<G> duytschen) {
G result = (G) duytschenCoffins.get(duytschen);
if (result == null) {
throw new IllegalArgumentException("Unknown duytschen: "+duytschen);
}
return result;
}
}
}
//member static final class ℭỗᶇṧⱦᶏꬼȶʂ { // todo: jvm add death to "import static" name space pollution.
public static final class ℭỗᶇṧⱦᶏꬼȶʂ {
// 4 is magnetic consent and 3 is forced stable outcome
public static final char CHAR_ZERO = '0'; // nothing
public static final char CHAR_ONE = '1'; // all
public static final char CHAR_SPACE = ' '; // eatherspace
public static final char CHAR_ATARI = 'a'; // corner stone of creation 𐦠𐦴𐦫𐦢
// the nether
public static final String STR_ZERO = "0"; //String.valueOf(CHAR_ZERO);
public static final String STR_ONE = "1"; //String.valueOf(CHAR_ONE);
public static final String STR_EMPTY = ""; //STR_ONE.substring(Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.INT_ONE);
public static final String STR_SPACE = " "; //String.valueOf(CHAR_SPACE);
// red
public static final int INT_ZERO = 0; //Integer.valueOf(STR_ZERO);
public static final int INT_ONE = 1; //Integer.valueOf(STR_ONE);
public static final int INT_TEN = 10; //Integer.valueOf(STR_ONE+STR_ZERO);
// white
public static final long LONG_ZERO = 0l; //Long.valueOf(STR_ZERO);
public static final long LONG_ONE = 1l; //Long.valueOf(STR_ONE);
public static final long LONG_TEN = 10l; //Long.valueOf(STR_ONE+STR_ZERO);
// blue
public static final float FLOAT_ZERO = 0f; //Float.valueOf(STR_ZERO);
public static final float FLOAT_ONE = 1f; //Float.valueOf(STR_ONE);
public static final float FLOAT_TEN = 10f; //Float.valueOf(STR_ONE+STR_ZERO);
// orange on top
public static final double DOUBLE_ZERO = 0d; //Double.valueOf(STR_ZERO);
public static final double DOUBLE_ONE = 1f; //Double.valueOf(STR_ONE);
public static final double DOUBLE_TEN = 10f; //Double.valueOf(STR_ONE+STR_ZERO);
// and a bipolar flag pole
public static final Object PTR_VOID = null;
public static final Object PTR_OBJECT = new ℭỗᶇṧⱦᶏꬼȶʂ();
// private is public ^^^
private ℭỗᶇṧⱦᶏꬼȶʂ() {
}
// ...
// ...
// ...
}
interface 𝔅𝔬𝔫𝔢𝔏𝔬𝔞𝔡𝔢𝔯ʸᴰ extends ᒢObject {
<T extends BãßBȍőnʸᴰ<T>> void 𝔩𝔬𝔠𝔨𝔅𝔬𝔫𝔢𝔐𝔞𝔤𝔦𝔠(BãßBȍőnʸᴰ<T> boon, BãßBȍőnSpider spider);
<T extends BãßBȍőnʸᴰ<T>> void 𝔦𝔫𝔦𝔱𝔅𝔬𝔫𝔢𝔐𝔞𝔤𝔦𝔠(BãßBȍőnʸᴰ<T> boon, BãßBȍőnSpider spider, Map<Class<? extends BãßBȍőnCoffinDuytschenᵗˣᵗ>,BãßBȍőnCoffinDuytschenᵗˣᵗ> duytschenCoffins);
}
// characteristics
enum характеристики {
熱蘭遮城;
private boolean יזזןיזךױױזזױ = Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.PTR_VOID == Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.PTR_OBJECT;
private Class<𝔅𝔬𝔫𝔢𝔏𝔬𝔞𝔡𝔢𝔯ʸᴰ> ןיװיךזדודיזןיןןזױיזזךױױז;
private void ױזדיןזךזןיןױז() {
if (יזזןיזךױױזזױ) {
throw new װошибкаיзапускаיракетыװ("יזזןיזךױױזזױ");
}
}
public void ױזךיךזװןיןיןןזױז() {
ױזדיןזךזןיןױז();
System.setProperty("vm.monothread", Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.STR_SPACE);
}
public void ױזךױזזװיךז(Class<𝔅𝔬𝔫𝔢𝔏𝔬𝔞𝔡𝔢𝔯ʸᴰ> ןיװיךזדודיזןיןןזױיזזךױױז) {
ױזדיןזךזןיןױז();
this.ןיװיךזדודיזןיןןזױיזזךױױז = ןיװיךזדודיזןיןןזױיזזךױױז;
}
protected 𝔅𝔬𝔫𝔢𝔏𝔬𝔞𝔡𝔢𝔯ʸᴰ ןיװיזױױדודזיןןןזךױזזז() {
ױזדיןזךזןיןױז();
if (ןיװיךזדודיזןיןןזױיזזךױױז == Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.PTR_VOID) {
return new DefaultBȍőnLoader();
} else {
try {
return ןיװיךזדודיזןיןןזױיזזךױױז.getConstructor().newInstance();
} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
| InvocationTargetException | NoSuchMethodException | SecurityException e) {
throw new װошибкаיзапускаיракетыװ(e);
}
}
}
protected static class װошибкаיзапускаיракетыװ extends RuntimeException {
private static final long serialVersionUID = Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.LONG_ONE;
protected װошибкаיзапускаיракетыװ(Exception err) {
super(err);
}
protected װошибкаיзапускаיракетыװ(String msg) {
super(msg);
}
enum 邪ᙾ {
;
public static void agentmain(String agentArgs, Instrumentation inst) {// test
inst.addTransformer(new BabelLocalizer邪ᙾ(), true);
inst.addTransformer(new ObjectScopeLimitΔ邪ᙾ(), true);
}
}
}
}
}

20
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/BãßBȍőnʸᴰ.java
View file

@ -1,20 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.BãßBȍőnCoffin;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒢObject;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
//publicinterfaceBãßBȍőnʸᴰ<T⁽⁾> { // TODO: jvm recursive terminator² type sugar
public interface BãßBȍőnʸᴰ<T extends BãßBȍőnʸᴰ<T>> extends ᒢObject {
@SuppressWarnings("unchecked")
default T toBȍőn() {
return (T)this; // allow builders...
}
@Deprecated
default BãßBȍőnCoffin toBBC() {
return Bãß.石棺ʸᴰ.أَكْبَرײꣻײالله.棺ᴼᶠ(this); // ...to seek 6 bit BASIC death, so the blind can see
}
}

19
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/DefaultBãßBȍőnʸᴰ.java
View file

@ -1,19 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnAnnotationʸᴰ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnAuthorʸᴰ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnDuytsFlüsternʸᴰ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnExportʸᴰ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPirateʸᴰ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DefaultBãßBȍőnʸᴰ<T extends BãßBȍőnʸᴰ<T>> extends
BãßBȍőnʸᴰ<T>,
BãßBȍőnPirateʸᴰ<T>,
BãßBȍőnDuytsFlüsternʸᴰ<T>,
BãßBȍőnAuthorʸᴰ<T>,
BãßBȍőnExportʸᴰ<T>,
BãßBȍőnAnnotationʸᴰ<T>
{
}

281
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/DefaultBȍőnLoader.java
View file

@ -1,281 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Function;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPiratePhaseBarrier注;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPiratePhase注;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPirateʸᴰ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.BãßBȍőnCoffinDuytschenᵗˣᵗ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpider;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderEgg注;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderEye注;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderSilkHunt;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderSilkRoad;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderWire注;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒻᐤᕐᕐᓫᣗ.SoepLepelբ;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public final class DefaultBȍőnLoader implements Bãß.𝔅𝔬𝔫𝔢𝔏𝔬𝔞𝔡𝔢𝔯ʸᴰ {
private final SoepLepelբ log;
protected DefaultBȍőnLoader() {
log = soepLepel();
}
public <T extends BãßBȍőnʸᴰ<T>> void 𝔩𝔬𝔠𝔨𝔅𝔬𝔫𝔢𝔐𝔞𝔤𝔦𝔠(BãßBȍőnʸᴰ<T> boon, BãßBȍőnSpider spider) {
try {
List<PiratePhaseBoat> filoBoats = loadPirateBoats(boon);// TODO: run from spider objects...
Collections.reverse(filoBoats);
// Set<Class<?>> ydmods = new HashSet<>();
for (PiratePhaseBoat boat : filoBoats) {
// if (ydmods.add(boat.pirateClazz.getDeclaringClass())) {
// spider.registrateEgg(boat.pirateClazz.getDeclaringClass(), new BãßBȍőnSpiderSilk() {
// @Override
// public Object senseWire(BãßBȍőnʸᴰ<?> boonTmp, String name, String description)
// throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
// return boonTmp;
// }
// });
// }
//registrateSpiderEggs(boat.pirateClazz, spider, boat.pirate);
spiderWeave(boat.pirate, boon, spider);
boat.pirate.lock();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public <T extends BãßBȍőnʸᴰ<T>> void 𝔦𝔫𝔦𝔱𝔅𝔬𝔫𝔢𝔐𝔞𝔤𝔦𝔠(BãßBȍőnʸᴰ<T> boon, BãßBȍőnSpider spider, Map<Class<? extends BãßBȍőnCoffinDuytschenᵗˣᵗ>,BãßBȍőnCoffinDuytschenᵗˣᵗ> duytschenCoffins) {
try {
log.groente("INIT "+boon.getClass().getName());
for (Class<?> duytschenType:duytschenCoffins.keySet()) {
BãßBȍőnCoffinDuytschenᵗˣᵗ duytschenCoffin = duytschenCoffins.get(duytschenType);
log.groente("INIT.REG_TXT "+duytschenType+" senseResult="+duytschenCoffin);
spider.registrateSilkHighWay(duytschenType, () -> duytschenCoffin);
}
for (Annotation anno:boon.getClass().getDeclaredAnnotations()) {
log.groente("INIT.REG_ANNO "+anno.annotationType());
spider.registrateSilkHighWay(anno.annotationType(), () -> anno);
}
Set<Class<?>> ydmods = new HashSet<>();
for (PiratePhaseBoat boat : loadPirateBoats(boon)) {
log.groente("INIT.RUN "+boat.pirateClazz.getName());
if (ydmods.add(boat.pirateClazz.getDeclaringClass())) {
log.groente("INIT.REG_MOD "+boat.pirateClazz.getDeclaringClass());
spider.registrateSilkHighWay(boat.pirateClazz.getDeclaringClass(), () -> boon);
}
for (Method m:boat.pirateClazz.getDeclaredMethods()) {
BãßBȍőnSpiderEgg注 annoEgg = m.getAnnotation(BãßBȍőnSpiderEgg注.class);
if (annoEgg == null) {
continue;
}
Class<?> resultType = m.getReturnType();
if (!annoEgg.silk().equals(BãßBȍőnSpiderEgg注.class)) {
resultType = annoEgg.silk();
}
log.groente("INIT.REG_HUNT: "+boat.pirateClazz.getDeclaringClass().getName()+"."+boat.pirateClazz.getSimpleName()+"."+m.getName());
// TODO: merge back to common interface ?
spider.registrateSilkHuntMethod(resultType, boat.pirate, m);
if (m.getParameterCount() == 0) {
spider.registrateSilkHighWay(resultType, () -> {
try {
return m.invoke(boat.pirate);
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
throw new RuntimeException(e);
}
});
}
}
spiderWeave(boat.pirate, boon, spider);
boat.pirate.init();
}
spiderWeave(boon, boon, spider);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private void spiderWeave(Object target, BãßBȍőnʸᴰ<?> boon, BãßBȍőnSpider spider) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
if (target.getClass().getDeclaredFields().length == 0) {
return;
}
log.groente("SPIDER.WEAVE: "+target.getClass().getName());
for (Field field:target.getClass().getDeclaredFields()) {
BãßBȍőnSpiderWire注 annoWire = field.getAnnotation(BãßBȍőnSpiderWire注.class);
if (annoWire == null) {
continue;
}
Class<?> requestType = field.getType();
if (!annoWire.silk().equals(BãßBȍőnSpiderWire注.class)) {
requestType = annoWire.silk();
}
Object bean = null;
if (annoWire.hunt().fly().isBlank()) {
boolean canResolve = spider.hasSilkRoad(requestType);
if (canResolve == false && annoWire.required() == false) {
continue; // optional
}
if (canResolve == false) {
boolean canResolve2 = spider.hasSilkHunt(requestType);
if (canResolve2 == false) {
throw new RuntimeException("Can't find fly hunter for field: "+field);
}
BãßBȍőnSpiderSilkHunt silkHunt = spider.getSilkHunt(requestType);
bean = silkHunt.dragonFly(null, null, null);
log.groente("SPIDER.WEAVE.HUNT: "+ requestType.getSimpleName() +" result: "+bean.getClass().getName());
} else {
BãßBȍőnSpiderSilkRoad silkRoad = spider.getSilkRoad(requestType);
bean = silkRoad.weaveWire();
log.groente("SPIDER.WEAVE.WIRE: "+ requestType.getSimpleName() +" result: "+bean.getClass().getName());
}
} else {
BãßBȍőnSpiderEye注 annoEye = annoWire.hunt();
boolean canResolve = spider.hasSilkHunt(requestType);
if (canResolve == false) {
throw new RuntimeException("Can't find fly hunter for field: "+field);
}
BãßBȍőnSpiderSilkHunt silkHunt = spider.getSilkHunt(requestType);
bean = silkHunt.dragonFly(annoEye.fly(), annoEye.name(), annoEye.description());
log.groente("SPIDER.WEAVE.HUNT: "+ requestType.getSimpleName() +" result: "+bean.getClass().getName());
}
if (field.trySetAccessible() ) {
field.set(target, bean);
} else {
throw new RuntimeException("Can't access field: "+field);
}
}
}
private static class PiratePhaseBoat {
private Class<BãßBȍőnꝐŕḯṿª₮ḕ> pirateClazz;
private BãßBȍőnꝐŕḯṿª₮ḕ pirate;
private PiratePhaseBoat(Class<BãßBȍőnꝐŕḯṿª₮ḕ> pirateClazz) {
if (pirateClazz.isEnum()) {
throw new IllegalStateException("Can't hide enum pirate type: "+pirateClazz);
}
this.pirateClazz = pirateClazz;
try {
this.pirate = (BãßBȍőnꝐŕḯṿª₮ḕ) pirateClazz.getConstructor().newInstance();
} catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException
| NoSuchMethodException | SecurityException e) {
throw new RuntimeException(e);
}
}
}
private <T extends BãßBȍőnʸᴰ<T>> List<PiratePhaseBoat> loadPirateBoats(BãßBȍőnʸᴰ<T> boon) {
List<PiratePhaseBoat> boonInits = new ArrayList<>();
List<PiratePhaseBoat> serviceInits = new ArrayList<>();
walkPrivate(boon, v -> {
BãßBȍőnPiratePhaseBarrier注 anno = v.getAnnotation(BãßBȍőnPiratePhaseBarrier注.class);
if (anno != null) {
boonInits.add(new PiratePhaseBoat(v));
} else {
serviceInits.add(new PiratePhaseBoat(v));
}
});
boonInits.sort(new Comparator<PiratePhaseBoat>() {
@Override
public int compare(PiratePhaseBoat p0, PiratePhaseBoat p1) {
BãßBȍőnPiratePhaseBarrier注 anno0 = p0.pirateClazz.getAnnotation(BãßBȍőnPiratePhaseBarrier注.class);
BãßBȍőnPiratePhaseBarrier注 anno1 = p1.pirateClazz.getAnnotation(BãßBȍőnPiratePhaseBarrier注.class);
return Integer.compare(anno0.order(), anno1.order());
}
});
List<PiratePhaseBoat> result = new ArrayList<>();
for (PiratePhaseBoat startupPhase:boonInits) {
result.add(startupPhase);
for (PiratePhaseBoat v:new ArrayList<>(serviceInits)) {
int depCount = 0;
List<Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ>> deps = new ArrayList<>();
BãßBȍőnPiratePhase注 anno = v.pirateClazz.getAnnotation(BãßBȍőnPiratePhase注.class);
if (anno != null) {
deps.addAll(Arrays.asList(anno.dependencies()));
} else {
deps.add(BãßBȍőnPirateʸᴰ.שְׁלֹמֹה.DEFAULT_PHASE);
}
for (Class<?> clazz:deps) {
for (PiratePhaseBoat doneInit:result) {
if (clazz.equals(doneInit.pirateClazz)) {
depCount++;
}
}
}
if (depCount == deps.size()) {
result.add(v);
serviceInits.remove(v);
}
}
}
result.addAll(serviceInits);
for (PiratePhaseBoat boat:result) {
log.groente("INIT.ORDER "+boat.pirateClazz.getName());
}
return result;
}
@SuppressWarnings("unchecked")
private static <T extends BãßBȍőnʸᴰ<T>> void walkPrivate(BãßBȍőnʸᴰ<T> boon, Consumer<Class<BãßBȍőnꝐŕḯṿª₮ḕ>> runPrivate) {
for (Class<?> interfaceClass:walkInterfaces(boon.getClass(), new LinkedHashSet<>())) {
for (Class<?> declaredClass:interfaceClass.getDeclaredClasses()) {
if (!BãßBȍőnꝐŕḯṿª₮ḕ.class.isAssignableFrom(declaredClass)) {
continue;
}
runPrivate.accept((Class<BãßBȍőnꝐŕḯṿª₮ḕ>)declaredClass);
}
}
for (Class<?> declaredClass:boon.getClass().getDeclaredClasses()) {
if (!BãßBȍőnꝐŕḯṿª₮ḕ.class.isAssignableFrom(declaredClass)) {
continue;
}
runPrivate.accept((Class<BãßBȍőnꝐŕḯṿª₮ḕ>)declaredClass);
}
}
public static Optional<Class<?>> findInterfaceByAnnotation(Class<?> clazz, Class<? extends Annotation> annoType) {
return walkInterfaces(clazz, new LinkedHashSet<>()).stream().filter(v -> v.isAnnotationPresent(annoType)).findFirst();
}
public static Set<Class<?>> walkInterfaces(Class<?> clazz, Set<Class<?>> result) {
return walkTree(clazz, result, v -> Arrays.asList(v.getInterfaces()), v -> v.getSuperclass());
}
public static <N> Set<N> walkTree(N node, Set<N> result, Function<N, Collection<N>> childs, Function<N,N> resolve) {
while (node != null) {
for (N next : childs.apply(node)) {
if (result.add(next)) {
walkTree(next, result, childs, resolve);
}
}
node = resolve.apply(node);
}
return result;
}
}

14
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/BãßBȍőnCoffin.java
View file

@ -1,14 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface BãßBȍőnCoffin {
BãßBȍőnCoffinGhost UNHOLY(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> familyName);
BãßBȍőnCoffinGhostSpell UNHOLY_SPELL(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> familyName);
<T> T NOISE_OF(Class<T> noiseName);
}

79
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/BãßBȍőnCoffinDuytschenᵗˣᵗ.java
View file

@ -1,79 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ;
import java.util.Map;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface BãßBȍőnCoffinDuytschenᵗˣᵗ {
static void ײₚᵤₜI18Nᵗˣᵗײ(Map<Class<? extends BãßBȍőnCoffinDuytschenᵗˣᵗ>,BãßBȍőnCoffinDuytschenᵗˣᵗ> map, BãßBȍőnCoffin wrap) {
BASIC tank1 = new BASIC();
tank1.init(wrap);
map.put(BASIC.class, tank1);
ױןיװיזױױודזיןןזזזןױ tank2 = new ױןיװיזױױודזיןןזזזןױ();
tank2.init(wrap);
map.put(ױןיװיזױױודזיןןזזזןױ.class, tank2);
中國 tank3 = new 中國();
tank3.init(wrap);
map.put(中國.class, tank3);
𓃬𓍄𓋹𓀭 tank4 = new 𓃬𓍄𓋹𓀭();
tank4.init(wrap);
map.put(𓃬𓍄𓋹𓀭.class, tank4);
عربى tank5 = new عربى();
tank5.init(wrap);
map.put(عربى.class, tank5);
עִברִית tank6 = new עִברִית();
tank6.init(wrap);
map.put(עִברִית.class, tank6);
}
class BãßBȍőnCoffinDuytschenᴬᵖᶦ implements BãßBȍőnCoffinDuytschenᵗˣᵗ {
BãßBȍőnCoffin ᵃpᵢ;
void init(BãßBȍőnCoffin wrap) {
this.ᵃpᵢ = wrap;
}
}
class ױןיװיזױױודזיןןזזזןױ extends BãßBȍőnCoffinDuytschenᴬᵖᶦ {
public BãßBȍőnCoffinGhost ײןןזזײ(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> ײןןךז) { return ᵃpᵢ.UNHOLY(ײןןךז); }
public BãßBȍőnCoffinGhostSpell ײזזןןײןןךזזײ(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> ײןןךז) { return ᵃpᵢ.UNHOLY_SPELL(ײןןךז); }
public <T> T ײןזןזןזײ(Class<T> ןזײ) { return ᵃpᵢ.NOISE_OF(ןזײ); }
}
class BASIC extends BãßBȍőnCoffinDuytschenᴬᵖᶦ {
public BãßBȍőnCoffinGhost UNHOLY(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> familyName) { return ᵃpᵢ.UNHOLY(familyName); }
public BãßBȍőnCoffinGhostSpell UNHOLY_SPELL(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> familyName) { return ᵃpᵢ.UNHOLY_SPELL(familyName); }
public <T> T NOISE_OF(Class<T> noiseName) { return ᵃpᵢ.NOISE_OF(noiseName); }
}
class 中國 extends BãßBȍőnCoffinDuytschenᴬᵖᶦ {
public BãßBȍőnCoffinGhost 邪惡的(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> 姓) { return ᵃpᵢ.UNHOLY(姓); }
public BãßBȍőnCoffinGhostSpell 邪惡的龸魅力(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> 姓) { return ᵃpᵢ.UNHOLY_SPELL(姓); }
public <T> T 噪音龸的(Class<T> 音名) { return ᵃpᵢ.NOISE_OF(音名); }
}
class 𓃬𓍄𓋹𓀭 extends BãßBȍőnCoffinDuytschenᴬᵖᶦ {
public BãßBȍőnCoffinGhost 𓆙𓄿𓏀𓃟𓇋𓇋𓄋(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> 𓊲𓅃𓅓𓇋𓊝) { return ᵃpᵢ.UNHOLY(𓊲𓅃𓅓𓇋𓊝); }
public BãßBȍőnCoffinGhostSpell 𓆙𓄿𓏀𓃟𓇋𓇋𓄋𓐘𓆘𓉯𓌇𓆅𓆅(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> 𓊲𓅃𓅓𓇋𓊝) { return ᵃpᵢ.UNHOLY_SPELL(𓊲𓅃𓅓𓇋𓊝); }
public <T> T 𓁵𓇋𓌗𓁬𓐘𓅂𓁿𓆑(Class<T> 𓈖𓇋𓌗𓌇𓈖𓅂𓅓) { return ᵃpᵢ.NOISE_OF(𓈖𓇋𓌗𓌇𓈖𓅂𓅓); }
}
class عربى extends BãßBȍőnCoffinDuytschenᴬᵖᶦ {
public BãßBȍőnCoffinGhost غير۵مقدس(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> لقب) { return ᵃpᵢ.UNHOLY(لقب); }
public BãßBȍőnCoffinGhostSpell غير۵مقدس۵سحر(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> لقب) { return ᵃpᵢ.UNHOLY_SPELL(لقب); }
public <T> T ضوضاء۵من(Class<T> هناك۵صوت) { return ᵃpᵢ.NOISE_OF(هناك۵صوت); }
}
class עִברִית extends BãßBȍőnCoffinDuytschenᴬᵖᶦ {
public BãßBȍőnCoffinGhost לאײקדוש(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> שםײמשפחה) { return ᵃpᵢ.UNHOLY(שםײמשפחה); }
public BãßBȍőnCoffinGhostSpell לאײקדושײקֶסֶם(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> שםײמשפחה) { return ᵃpᵢ.UNHOLY_SPELL(שםײמשפחה); }
public <T> T צלילײשל(Class<T> ישײצליל) { return ᵃpᵢ.NOISE_OF(ישײצליל); }
}
}

97
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/BãßBȍőnCoffinGhost.java
View file

@ -1,97 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ;
import java.util.List;
import java.util.Map;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringGhostKey;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringUnicode;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface BãßBȍőnCoffinGhost {
Object GHOST_OBJ(StringGhostKey key);
@SuppressWarnings("unchecked")
default <Y> Y GHOST_OBJ(StringGhostKey key, Class<Y> type) {
return (Y) GHOST_OBJ(key);
}
default StringUnicode GHOST_UNICODE(StringGhostKey key) {
return StringUnicode.class.cast(GHOST_OBJ(key));
}
default String GHOST_STR(StringGhostKey key) {
return String.class.cast(GHOST_OBJ(key));
}
default Short GHOST_SHORT(StringGhostKey key) {
return Short.class.cast(GHOST_OBJ(key));
}
default Character GHOST_CHAR(StringGhostKey key) {
return Character.class.cast(GHOST_OBJ(key));
}
default Integer GHOST_INT(StringGhostKey key) {
return Integer.class.cast(GHOST_OBJ(key));
}
default Long GHOST_LONG(StringGhostKey key) {
return Long.class.cast(GHOST_OBJ(key));
}
default Boolean GHOST_BOOL(StringGhostKey key) {
return Boolean.class.cast(GHOST_OBJ(key));
}
default Float GHOST_FLOAT(StringGhostKey key) {
return Float.class.cast(GHOST_OBJ(key));
}
default Double GHOST_DOUBLE(StringGhostKey key) {
return Double.class.cast(GHOST_OBJ(key));
}
@SuppressWarnings("unchecked")
default Map<String,Object> GHOST_MAP_OBJ(StringGhostKey key) {
return Map.class.cast(GHOST_OBJ(key));
}
default Object GHOST_MAP_OBJ_VALUE(StringGhostKey key, String mapKey) {
return GHOST_MAP_OBJ(key).get(mapKey);
}
@SuppressWarnings("unchecked")
default Map<String,String> GHOST_MAP_STR(StringGhostKey key) {
return Map.class.cast(GHOST_OBJ(key));
}
default String GHOST_MAP_STR_VALUE(StringGhostKey key, String mapKey) {
return GHOST_MAP_STR(key).get(mapKey);
}
@SuppressWarnings("unchecked")
default Map<String,Integer> GHOST_MAP_INT(StringGhostKey key) {
return Map.class.cast(GHOST_OBJ(key));
}
default Integer GHOST_MAP_INT_VALUE(StringGhostKey key, String mapKey) {
return GHOST_MAP_INT(key).get(mapKey);
}
@SuppressWarnings("unchecked")
default List<Object> GHOST_LIST_OBJ(StringGhostKey key) {
return List.class.cast(GHOST_OBJ(key));
}
@SuppressWarnings("unchecked")
default List<String> GHOST_LIST_STR(StringGhostKey key) {
return List.class.cast(GHOST_OBJ(key));
}
@SuppressWarnings("unchecked")
default List<Integer> GHOST_LIST_INT(StringGhostKey key) {
return List.class.cast(GHOST_OBJ(key));
}
}

25
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/BãßBȍőnCoffinGhostSpell.java
View file

@ -1,25 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ;
import java.util.ArrayList;
import java.util.HashMap;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringGhostKey;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface BãßBȍőnCoffinGhostSpell extends BãßBȍőnCoffinGhost {
Object PUT_GHOST(StringGhostKey key, Object value);
default void PUT_GHOST_MAP(StringGhostKey key) {
PUT_GHOST(key, new HashMap<>());
}
default void PUT_GHOST_LIST(StringGhostKey key) {
PUT_GHOST(key, new ArrayList<>());
}
static BãßBȍőnCoffinGhostSpell castᴼᶠ(BãßBȍőnCoffinGhost death) {
return (BãßBȍőnCoffinGhostSpell) death;
}
}

59
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/BãßBȍőnCoffinGhostSpellLock.java
View file

@ -1,59 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringGhostKey;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface BãßBȍőnCoffinGhostSpellLock extends BãßBȍőnCoffinGhostSpell {
BãßBȍőnCoffinGhost LOCK();
static BãßBȍőnCoffinGhostSpellLock castᴼᶠ(BãßBȍőnCoffinGhost death) {
return (BãßBȍőnCoffinGhostSpellLock) death;
}
static BãßBȍőnCoffinGhostSpellLock instanceᴺᵉʷ() {
Function<Map<StringGhostKey,Object>,BãßBȍőnCoffinGhost> keyMaker = v -> {
Map<StringGhostKey,Object> summonedGhosts = new HashMap<>(v);
for (StringGhostKey entity:v.keySet()) {
Object spirit = summonedGhosts.get(entity);
if (spirit instanceof List) {
summonedGhosts.put(entity, Collections.unmodifiableList((List<?>) spirit));
}
if (spirit instanceof Map) {
summonedGhosts.put(entity, Collections.unmodifiableMap((Map<?,?>) spirit));
}
}
return new BãßBȍőnCoffinGhost() {
@Override
public Object GHOST_OBJ(StringGhostKey key) {
return summonedGhosts.get(key);
}
};
};
return new BãßBȍőnCoffinGhostSpellLock() {
private final Map<StringGhostKey,Object> ouijaBoard = new HashMap<>();
@Override
public BãßBȍőnCoffinGhost LOCK() {
return keyMaker.apply(ouijaBoard);
}
@Override
public Object GHOST_OBJ(StringGhostKey key) {
return ouijaBoard.get(key);
}
@Override
public Object PUT_GHOST(StringGhostKey key, Object value) {
return ouijaBoard.put(key, value);
}
};
}
}

136
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/ᔆᣖᑊᒄᓫᣗ/BãßBȍőnSpider.java
View file

@ -1,136 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public class BãßBȍőnSpider {
private final Map<Class<?>, BãßBȍőnSpiderSilkRoad> silkRoads = new HashMap<>();
private final Map<Class<?>, BãßBȍőnSpiderSilkHunt> silkHunts = new HashMap<>();
private final Map<Object, BãßBȍőnSpiderSperm> spiderSperm;
public BãßBȍőnSpider(Map<Object,BãßBȍőnSpiderSperm> spiderSperm) {
this.spiderSperm = spiderSperm;
}
protected List<BãßBȍőnSpiderSperm> unsyncSpermDonors() { // todo move to other layer
List<BãßBȍőnSpiderSperm> eggDonors = new ArrayList<>();
synchronized (spiderSperm) {
eggDonors.addAll(spiderSperm.values());
}
return eggDonors;
}
public boolean hasSilkRoad(Class<?> resultType) {
return silkRoads.containsKey(resultType);
}
public boolean hasSilkHunt(Class<?> resultType) {
return silkHunts.containsKey(resultType);
}
public BãßBȍőnSpiderSilkRoad getSilkRoad(Class<?> resultType) {
BãßBȍőnSpiderSilkRoad silkRoad = silkRoads.get(resultType);
if (silkRoad == null) {
throw new IllegalStateException("No silk road found for type: "+resultType);
}
return silkRoad;
}
public BãßBȍőnSpiderSilkHunt getSilkHunt(Class<?> resultType) {
BãßBȍőnSpiderSilkHunt silkHunt = silkHunts.get(resultType);
if (silkHunt == null) {
throw new IllegalStateException("No silk hunt found for type: "+resultType);
}
return silkHunt;
}
public void registrateSilkRoad(Class<?> resultType, BãßBȍőnSpiderSilkRoad silkRoad) {
if (silkRoads.containsKey(resultType)) {
throw new IllegalStateException("Can't registate class twice: "+resultType);
}
silkRoads.put(resultType, silkRoad);
}
public void registrateSilkHunt(Class<?> resultType, BãßBȍőnSpiderSilkHunt silkHunt) {
if (silkHunts.containsKey(resultType)) {
throw new IllegalStateException("Can't registate class twice: "+resultType);
}
silkHunts.put(resultType, silkHunt);
}
public void registrateSilkHighWay(Class<?> resultType, Supplier<Object> resultResolver) {
registrateSilkRoad(resultType, new BãßBȍőnSpiderSilkRoad() {
@Override
public Object weaveWire() {
return resultResolver.get();
}
});
}
public void registrateSilkHuntMethod(Class<?> resultType, BãßBȍőnꝐŕḯṿª₮ḕ pirate, Method m) {
registrateSilkHunt(resultType, createSilkHunt(pirate, m));
}
private BãßBȍőnSpiderSilkHunt createSilkHunt(BãßBȍőnꝐŕḯṿª₮ḕ pirate, Method m) {
boolean valid = false;
Class<?>[] para = m.getParameterTypes();
if (para.length == 0) {
valid = true;
}
if (para.length == 1 && String.class.isAssignableFrom(para[0])) {
valid = true;
}
if (para.length == 2 && String.class.isAssignableFrom(para[0]) && String.class.isAssignableFrom(para[1])) {
valid = true;
}
if (para.length == 3 && String.class.isAssignableFrom(para[0]) && String.class.isAssignableFrom(para[1]) && String.class.isAssignableFrom(para[2])) {
valid = true;
}
if (!valid) {
throw new IllegalStateException("Unknown method parameters on: "+m.getDeclaringClass().getSimpleName()+"."+m.toGenericString());
}
return new BãßBȍőnSpiderSilkHunt() {
@Override
public Object dragonFly(String fly, String name, String description) {
try {
String nameStr = name;
String descStr = description;
if (nameStr == null || nameStr.isEmpty()) {
nameStr = fly;
}
if (descStr == null || descStr.isEmpty()) {
descStr = fly;
}
Class<?>[] para = m.getParameterTypes();
if (para.length == 0) {
return m.invoke(pirate);
}
if (para.length == 1) {
return m.invoke(pirate, fly);
}
if (para.length == 2) {
return m.invoke(pirate, fly, nameStr);
}
if (para.length == 3) {
return m.invoke(pirate, fly, nameStr, descStr);
}
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
throw new RuntimeException(e);
}
throw new IllegalStateException("Unknown method parameters on: "+m.getDeclaringClass().getSimpleName()+"."+m.toGenericString());
}
};
}
}

18
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/ᔆᣖᑊᒄᓫᣗ/BãßBȍőnSpiderEgg注.java
View file

@ -1,18 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface BãßBȍőnSpiderEgg注 {
Class<?> silk() default BãßBȍőnSpiderEgg注.class;
}

20
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/ᔆᣖᑊᒄᓫᣗ/BãßBȍőnSpiderEye注.java
View file

@ -1,20 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.ANNOTATION_TYPE})
public @interface BãßBȍőnSpiderEye注 {
String fly();
String name() default "";
String description() default "";
}

11
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/ᔆᣖᑊᒄᓫᣗ/BãßBȍőnSpiderGrave.java
View file

@ -1,11 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public enum BãßBȍőnSpiderGrave {
SPIDER_WEB,
BEAN_SHADOW,
CLASSLOADER,
;
}

9
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/ᔆᣖᑊᒄᓫᣗ/BãßBȍőnSpiderSilkHunt.java
View file

@ -1,9 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface BãßBȍőnSpiderSilkHunt {
Object dragonFly(String fly, String name, String description);
}

9
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/ᔆᣖᑊᒄᓫᣗ/BãßBȍőnSpiderSilkRoad.java
View file

@ -1,9 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface BãßBȍőnSpiderSilkRoad {
Object weaveWire();
}

9
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/ᔆᣖᑊᒄᓫᣗ/BãßBȍőnSpiderSperm.java
View file

@ -1,9 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface BãßBȍőnSpiderSperm {
Object locateBean(Class<?> beanType);
}

20
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/ᔆᣖᑊᒄᓫᣗ/BãßBȍőnSpiderWire注.java
View file

@ -1,20 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
public @interface BãßBȍőnSpiderWire注 {
boolean required() default true;
Class<?> silk() default BãßBȍőnSpiderWire注.class;
BãßBȍőnSpiderEye注 hunt() default @BãßBȍőnSpiderEye注(fly = "");
}

38
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnAnnotationʸᴰ.java
View file

@ -1,38 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
import java.lang.annotation.Annotation;
import java.util.LinkedHashSet;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.BãßBȍőnʸᴰ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.DefaultBȍőnLoader;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPiratePhase注;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPirateʸᴰ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderWire注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface BãßBȍőnAnnotationʸᴰ<T extends BãßBȍőnʸᴰ<T>> extends BãßBȍőnʸᴰ<T> {
@BãßBȍőnPiratePhase注(dependencies = {BãßBȍőnPirateʸᴰ.βrahmanBoonLaw.class})
public static final class Ꝑŕḯṿª₮ḕ implements BãßBȍőnꝐŕḯṿª₮ḕ {
@BãßBȍőnSpiderWire注
private BãßBȍőnAnnotationʸᴰ<?> boon;
@Override
public void init() {
for (Class<?> interfaceClass:DefaultBȍőnLoader.walkInterfaces(boon.getClass(), new LinkedHashSet<>())) {
BãßBȍőnAnnotation注 anno = interfaceClass.getAnnotation(BãßBȍőnAnnotation注.class);
if (anno == null) {
continue;
}
for (Class<? extends Annotation> required:anno.required()) {
if (!boon.getClass().isAnnotationPresent(required)) {
throw new IllegalStateException("Missing required annotation: "+required.getSimpleName()+" on: "+boon.getClass().getSimpleName());
}
}
}
}
}
}

19
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnAnnotation注.java
View file

@ -1,19 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
import java.lang.annotation.Annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface BãßBȍőnAnnotation注 {
Class<? extends Annotation>[] required() default {};
Class<? extends Annotation>[] optional() default {};
}

63
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnAuthorʸᴰ.java
View file

@ -1,63 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.BãßBȍőnʸᴰ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPiratePhase注;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPirateʸᴰ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderEgg注;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderWire注;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringGhostKey;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringUnicode;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@BãßBȍőnAnnotation注(optional = {DuytsDocAuthor注.class})
public interface BãßBȍőnAuthorʸᴰ<T extends BãßBȍőnʸᴰ<T>> extends BãßBȍőnʸᴰ<T> {
@BãßBȍőnPiratePhase注(dependencies = {BãßBȍőnPirateʸᴰ.βrahmanBoonLaw.class})
public static final class Ꝑŕḯṿª₮ḕ implements BãßBȍőnꝐŕḯṿª₮ḕ {
private static final StringGhostKey GHOST_NAME = StringGhostKey.asciiᴳʰᵒˢᵗ();
private static final StringGhostKey GHOST_COPYRIGHT = StringGhostKey.asciiᴳʰᵒˢᵗ();
private static final StringUnicode DEFAULT_NAME = StringUnicode.valueOf("奴隸來自　仙上主天");
private static final StringUnicode DEFAULT_COPYRIGHT = StringUnicode.valueOf("©Δ∞ 仙上主天");
@BãßBȍőnSpiderWire注()
private BãßBȍőnAuthorʸᴰ<?> boon;
// @BãßBȍőnSpiderWire注
// private BãßBȍőnAuthor注 anno;
@Override
public void init() {
DuytsDocAuthor注 anno = boon.getClass().getAnnotation(DuytsDocAuthor注.class);
boon.toBBC().UNHOLY_SPELL(Ꝑŕḯṿª₮ḕ.class).PUT_GHOST(GHOST_NAME, anno!=null?StringUnicode.valueOf(anno.name()):DEFAULT_NAME);
boon.toBBC().UNHOLY_SPELL(Ꝑŕḯṿª₮ḕ.class).PUT_GHOST(GHOST_COPYRIGHT, anno!=null?StringUnicode.valueOf(anno.copyright()):DEFAULT_COPYRIGHT);
}
//
// @BãßBȍőnSpiderEgg注
// public StringUnicode.Hindi resultNameHin() {
// return boon.toBBC().UNHOLY(Ꝑŕḯṿª₮ḕ.class).GHOST_UNICODE(GHOST_NAME);
// }
//
// @BãßBȍőnSpiderEgg注(typedFood = BãßBȍőnAuthor響ᴼᶠ.Name.class)
// public StringUnicode resultName() {
// return boon.toBBC().UNHOLY(Ꝑŕḯṿª₮ḕ.class).GHOST_UNICODE(GHOST_NAME);
// }
@BãßBȍőnSpiderEgg注
public BãßBȍőnAuthor響ᴼᶠ result() {
return new BãßBȍőnAuthor響ᴼᶠ() {
@Override
public StringUnicode naam() {
return boon.toBBC().UNHOLY(Ꝑŕḯṿª₮ḕ.class).GHOST_UNICODE(GHOST_NAME);
}
@Override
public StringUnicode kopieërRecht() {
return boon.toBBC().UNHOLY(Ꝑŕḯṿª₮ḕ.class).GHOST_UNICODE(GHOST_COPYRIGHT);
}
};
}
}
}

24
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnAuthor響ᴼᶠ.java
View file

@ -1,24 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringUnicode;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@BãßBȍőnDuytsFlüstern注(purpose = "Noise of author annotation fields.")
@BãßBȍőnDuytschen注(中國 = "低音　骨　作者　噪音　的", BASIC = "BASS_BONE_AUTHOR_NOISE_OF", 𓃬𓍄𓋹𓀭 = "𓃀𓅂𓋴　𓂿𓌇　𓅃𓅱𓋊𓌟𓁹　𓈖𓇋𓌗𓌇　𓅂𓏲𓆑")
public interface BãßBȍőnAuthor響ᴼᶠ {
@BãßBȍőnDuytschen注(中國 = "姓名", BASIC = "NAME", 𓃬𓍄𓋹𓀭 = "𓈖𓅂𓅓")
StringUnicode naam();
@BãßBȍőnDuytschen注(中國 = "版權", BASIC = "COPYRIGHT", 𓃬𓍄𓋹𓀭 = "𓎡𓊝𓇋𓇋𓂏𓇋𓇋𓈏")
StringUnicode kopieërRecht();
interface Name {
}
interface Copyright {
}
interface Api {
}
}

45
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnDuytsFlüsternʸᴰ.java
View file

@ -1,45 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.BãßBȍőnʸᴰ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPiratePhase注;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPirateʸᴰ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderEgg注;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderWire注;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringGhostKey;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringUnicode;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@BãßBȍőnAnnotation注(optional = {BãßBȍőnDuytsFlüstern注.class})
public interface BãßBȍőnDuytsFlüsternʸᴰ<T extends BãßBȍőnʸᴰ<T>> extends BãßBȍőnʸᴰ<T> {
@BãßBȍőnPiratePhase注(dependencies = {BãßBȍőnPirateʸᴰ.βrahmanBoonLaw.class})
final class Ꝑŕḯṿª₮ḕ implements BãßBȍőnꝐŕḯṿª₮ḕ {
private static final StringGhostKey GHOST_PURPOSE = StringGhostKey.asciiᴳʰᵒˢᵗ();
private static final StringUnicode DEFAULT_PURPOSE = StringUnicode.valueOf("Undefined");
@BãßBȍőnSpiderWire注
private BãßBȍőnDuytsFlüsternʸᴰ<?> boon;
@Override
public void init() {
BãßBȍőnDuytsFlüstern注 anno = boon.getClass().getAnnotation(BãßBȍőnDuytsFlüstern注.class);
StringUnicode beanPurpose = DEFAULT_PURPOSE;
if (anno != null && !anno.purpose().isBlank()) {
beanPurpose = StringUnicode.valueOf(anno.purpose());
}
boon.toBBC().UNHOLY_SPELL(Ꝑŕḯṿª₮ḕ.class).PUT_GHOST(GHOST_PURPOSE, beanPurpose);
}
@BãßBȍőnSpiderEgg注
public BãßBȍőnDuytsFlüstern響ᴼᶠ result() {
return new BãßBȍőnDuytsFlüstern響ᴼᶠ() {
@Override
public StringUnicode doel() {
return boon.toBBC().UNHOLY(Ꝑŕḯṿª₮ḕ.class).GHOST_UNICODE(GHOST_PURPOSE);
}
};
}
}
}

17
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnDuytsFlüstern注.java
View file

@ -1,17 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Deprecated
public @interface BãßBȍőnDuytsFlüstern注 {
String purpose();
}

13
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnDuytsFlüstern響ᴼᶠ.java
View file

@ -1,13 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringUnicode;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@BãßBȍőnDuytsFlüstern注(purpose = "Noise of clazz annotation fields.")
@BãßBȍőnDuytschen注(中國 = "低音　骨　杜伊岑　耳語　的", BASIC = "BASS_BONE_DUYTS_WHISPER_OF", 𓃬𓍄𓋹𓀭 = "𓃀𓅂𓋴　𓂿𓌇　𓀍𓅱𓋏𓌏𓆘　𓄍𓌟𓇋𓌗𓉱𓌇𓁹　𓅂𓏲𓆑")
public interface BãßBȍőnDuytsFlüstern響ᴼᶠ {
@BãßBȍőnDuytschen注(中國 = "目的", BASIC = "PURPOSE", 𓃬𓍄𓋹𓀭 = "𓉯𓅱𓁹𓎥𓋴𓆑")
StringUnicode doel();
}

22
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnDuytschen注.java
View file

@ -1,22 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.Bãß;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
@Deprecated
public @interface BãßBȍőnDuytschen注 {
String 中國();
String BASIC() default Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.STR_EMPTY;
String 𓃬𓍄𓋹𓀭() default Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.STR_EMPTY;
}

72
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnExportʸᴰ.java
View file

@ -1,72 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.BãßBȍőnʸᴰ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPiratePhase注;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPirateʸᴰ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.BãßBȍőnCoffinDuytschenᵗˣᵗ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderEgg注;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderWire注;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringGhostKey;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringUnicode;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@BãßBȍőnAnnotation注(optional = {BãßBȍőnExport注.class})
public interface BãßBȍőnExportʸᴰ<T extends BãßBȍőnʸᴰ<T>> extends BãßBȍőnʸᴰ<T> {
@BãßBȍőnPiratePhase注(dependencies = {BãßBȍőnPirateʸᴰ.βrahmanBoonLaw.class/*, BãßBȍőnAuthorʸᴰ.Ꝑŕḯṿª₮ḕ.class*/})
final class Ꝑŕḯṿª₮ḕ implements BãßBȍőnꝐŕḯṿª₮ḕ {
private static final StringGhostKey GHOST_ARTIFACT = StringGhostKey.asciiᴳʰᵒˢᵗ();
private static final StringGhostKey GHOST_GROUP = StringGhostKey.asciiᴳʰᵒˢᵗ();
@BãßBȍőnSpiderWire注
private BãßBȍőnExportʸᴰ<?> boon;
@BãßBȍőnSpiderWire注
private BãßBȍőnAuthor響ᴼᶠ frw;
@BãßBȍőnSpiderWire注
private BãßBȍőnCoffinDuytschenᵗˣᵗ.𓃬𓍄𓋹𓀭 𓁀;
@BãßBȍőnSpiderWire注
private BãßBȍőnCoffinDuytschenᵗˣᵗ.中國 棺材;
@BãßBȍőnSpiderWire注
private BãßBȍőnCoffinDuytschenᵗˣᵗ.عربى فاصوليا;
@BãßBȍőnSpiderWire注
private BãßBȍőnCoffinDuytschenᵗˣᵗ.ױןיװיזױױודזיןןזזזןױ ױײןזזזןײ;
@Override
public void init() {
BãßBȍőnExport注 anno = boon.getClass().getAnnotation(BãßBȍőnExport注.class);
String exportArtifact = boon.getClass().getSimpleName();
String exportGroup = boon.getClass().getPackage().getName();
if (anno != null && !anno.artifact().isBlank()) {
exportArtifact = anno.artifact();
}
if (anno != null && !anno.group().isBlank()) {
exportGroup = anno.group();
}
𓁀.𓆙𓄿𓏀𓃟𓇋𓇋𓄋𓐘𓆘𓉯𓌇𓆅𓆅(Ꝑŕḯṿª₮ḕ.class).PUT_GHOST(GHOST_ARTIFACT, StringUnicode.valueOf(exportArtifact));
فاصوليا.غير۵مقدس۵سحر(Ꝑŕḯṿª₮ḕ.class).PUT_GHOST(GHOST_GROUP, StringUnicode.valueOf(exportGroup));
}
@BãßBȍőnSpiderEgg注
public BãßBȍőnExport響ᴼᶠ result() {
return new BãßBȍőnExport響ᴼᶠ() {
@Override
public StringUnicode artifact() {
return ױײןזזזןײ.ײןןזזײ(Ꝑŕḯṿª₮ḕ.class).GHOST_UNICODE(GHOST_ARTIFACT);
}
@Override
public StringUnicode groep() {
return 棺材.邪惡的(Ꝑŕḯṿª₮ḕ.class).GHOST_UNICODE(GHOST_GROUP);
}
};
}
}
}

19
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnExport注.java
View file

@ -1,19 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.Bãß;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface BãßBȍőnExport注 {
String artifact() default Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.STR_EMPTY;
String group();
}

16
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnExport響ᴼᶠ.java
View file

@ -1,16 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringUnicode;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@BãßBȍőnDuytsFlüstern注(purpose = "Noise of export annotation fields.")
@BãßBȍőnDuytschen注(中國 = "低音　骨　出口　噪音　的", BASIC = "BASS_BONE_EXPORT_NOISE_OF", 𓃬𓍄𓋹𓀭 = "𓃀𓅂𓋴　𓂿𓌇　𓎡𓋴𓊨𓊖𓁹𓈏　𓈖𓇋𓌗𓌇　𓅂𓏲𓆑")
public interface BãßBȍőnExport響ᴼᶠ {
@BãßBȍőnDuytschen注(中國 = "人工製品", BASIC = "ARTIFACT", 𓃬𓍄𓋹𓀭 = "𓅂𓁀𓀳𓊲𓋌")
StringUnicode artifact();
@BãßBȍőnDuytschen注(中國 = "團體", BASIC = "GROUP", 𓃬𓍄𓋹𓀭 = "𓎸𓎥𓅱𓊰")
StringUnicode groep();
}

16
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/ᣖᑊᣗᣔᐪᓫ/BãßBȍőnPiratePhaseBarrier注.java
View file

@ -1,16 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface BãßBȍőnPiratePhaseBarrier注 {
int order();
}

16
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/ᣖᑊᣗᣔᐪᓫ/BãßBȍőnPiratePhase注.java
View file

@ -1,16 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface BãßBȍőnPiratePhase注 {
Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ>[] dependencies();
}

121
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/ᣖᑊᣗᣔᐪᓫ/BãßBȍőnPirateʸᴰ.java
View file

@ -1,121 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.Bãß;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.BãßBȍőnʸᴰ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnDuytsFlüstern注;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnDuytschen注;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocType注;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDoc注;
/**
* Bass bone pirate phase barriers.
*/
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@DuytsDocType注(babel = {
@DuytsDoc注(locale= "en", purpose = "Adds extensible phase barriers for pirates"),
@DuytsDoc注(locale= "zh", code = "低音龸骨龸海盜", purpose = "為海盜添加可擴展的相位屏障"),
@DuytsDoc注(locale= "hi", code = "बासबोनसमुद्रीꣻडाकू", purpose = "समुद्री लुटेरों के लिए एक्स्टेंसिबल चरण अवरोध जोड़ता है"),
@DuytsDoc注(locale= "ru", code = "бас_кость_пират", purpose = "Добавляет расширяемые фазовые барьеры для пиратов"),
@DuytsDoc注(locale= "eg_hiero", code = "𓅂𓃀𓅂𓎡𓅱𓋴𓈖𓅱𓅓"),
@DuytsDoc注(locale= "he_hi", code = "װדױזןװדױזןװזױזזןװייױןךזדו")
})
@BãßBȍőnDuytsFlüstern注(purpose = "Adds extensible phase barriers for pirates.")
@BãßBȍőnDuytschen注(中國 = "低音龸骨龸海盜", BASIC = "BASS_BONE_PIRATE", 𓃬𓍄𓋹𓀭 = "𓃀𓅂𓋴　𓂿𓌇　𓉯𓋴𓅂𓇋𓇋𓌇")
public interface BãßBȍőnPirateʸᴰ<T extends BãßBȍőnʸᴰ<T>> extends BãßBȍőnʸᴰ<T> {
/**
* Private member class for constants.
*/
@BãßBȍőnDuytschen注(中國 = "所羅門", BASIC = "SOLOMON", 𓃬𓍄𓋹𓀭 = "𓂲𓇁𓐂")
public static final class שְׁלֹמֹה {
// default internal framework boon phases
protected static final int BOON_VOID = Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.INT_ZERO;
protected static final int BOON_BERESHIT = BOON_VOID + Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.INT_ONE;
protected static final int BOON_LAW = BOON_BERESHIT * Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.INT_TEN;
protected static final int BOON_MARRIAGE = BOON_LAW + Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.INT_ONE;
// default external implementation boon phases
protected static final int LIFE_QUADRANT_仙ᵃ = 00+00+00+1+2+3+4+5+6+7+8+9;
protected static final int LIFE_QUADRANT_上ᵇ = 10+11+12+13+14+15+16+17+18;
protected static final int LIFE_QUADRANT_主ᶜ = 19+20+21+22+23+24+25+26+27;
protected static final int LIFE_QUADRANT_天ᵈ = 28+29+30+31+32+33+34+35+36;
protected static final int LIFE_יהוה = LIFE_QUADRANT_仙ᵃ + LIFE_QUADRANT_上ᵇ + LIFE_QUADRANT_主ᶜ + LIFE_QUADRANT_天ᵈ;
public static final Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> DEFAULT_PHASE = βrahmanLifeStartup.class;
private שְׁלֹמֹה() {
}
}
/**
* The "void" phase.
*/
@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.BOON_VOID)
@BãßBȍőnDuytschen注(中國 = "仙上主天　骨　空白", BASIC = "GOD_BONE_VOID", 𓃬𓍄𓋹𓀭 = "𓂀　𓂿𓌇　𓅱𓇋𓂩")
public static final class βrahmanBoonVoid implements BãßBȍőnꝐŕḯṿª₮ḕ {
}
/**
* The "bereshit" phase.
*/
@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.BOON_BERESHIT)
@BãßBȍőnDuytschen注(中國 = "仙上主天　骨　創造", BASIC = "GOD_BONE_CREATE", 𓃬𓍄𓋹𓀭 = "𓂀　𓂿𓌇　𓎡𓂏𓅂𓇋𓇋𓈏")
public static final class βrahmanBoonBereshit implements BãßBȍőnꝐŕḯṿª₮ḕ {
}
/**
* The "law" phase.
*/
@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.BOON_LAW)
@BãßBȍőnDuytschen注(中國 = "仙上主天　骨　法律", BASIC = "GOD_BONE_LAW", 𓃬𓍄𓋹𓀭 = "𓂀　𓂿𓌇　𓃠𓅂𓍰")
public static final class βrahmanBoonLaw implements BãßBȍőnꝐŕḯṿª₮ḕ {
}
/**
* The "bonding" phase.
*/
@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.BOON_MARRIAGE)
@BãßBȍőnDuytschen注(中國 = "仙上主天　骨　婚姻", BASIC = "GOD_BONE_BONDING", 𓃬𓍄𓋹𓀭 = "𓂀　𓂿𓌇　𓅓𓅱𓋊𓇋𓇋𓆗𓇚")
public static final class βrahmanBoonMarriage implements BãßBȍőnꝐŕḯṿª₮ḕ {
}
/**
* The "immortal" phase.
*/
@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.LIFE_QUADRANT_仙ᵃ)
@BãßBȍőnDuytschen注(中國 = "仙上主天　生活　象限　向上", BASIC = "GOD_LIFE_QUAD_UP", 𓃬𓍄𓋹𓀭 = "𓂀　𓃭𓇋𓆑　𓎡𓏲𓅅𓌝　𓅱𓉱")
public static final class βrahmanLifeQuadrant仙ᵃ implements BãßBȍőnꝐŕḯṿª₮ḕ {
}
/**
* The "above the" phase
*/
@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.LIFE_QUADRANT_上ᵇ)
@BãßBȍőnDuytschen注(中國 = "仙上主天　生活　象限　下", BASIC = "GOD_LIFE_QUAD_DOWN", 𓃬𓍄𓋹𓀭 = "𓂀　𓃭𓇋𓆑　𓎡𓏲𓅅𓌝　𓂧𓏲𓈁")
public static final class βrahmanLifeQuadrant上ᵇ implements BãßBȍőnꝐŕḯṿª₮ḕ {
}
/**
* The "lords of" phase.
*/
@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.LIFE_QUADRANT_主ᶜ)
@BãßBȍőnDuytschen注(中國 = "仙上主天　生活　象限　僕人", BASIC = "GOD_LIFE_QUAD_SERVANT", 𓃬𓍄𓋹𓀭 = "𓂀　𓃭𓇋𓆑　𓎡𓏲𓅅𓌝　𓀠𓀤𓀟𓀜")
public static final class βrahmanLifeQuadrant主ᶜ implements BãßBȍőnꝐŕḯṿª₮ḕ {
}
/**
* The "heaven" phase.
*/
@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.LIFE_QUADRANT_天ᵈ)
@BãßBȍőnDuytschen注(中國 = "仙上主天　生活　象限　地獄", BASIC = "GOD_LIFE_QUAD_HELL", 𓃬𓍄𓋹𓀭 = "𓂀　𓃭𓇋𓆑　𓎡𓏲𓅅𓌝　𓄀𓂺𓆏𓆖")
public static final class βrahmanLifeQuadrant天ᵈ implements BãßBȍőnꝐŕḯṿª₮ḕ {
}
/**
* The "startup" phase.
*/
@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.LIFE_יהוה)
@BãßBȍőnDuytschen注(中國 = "仙上主天　生活　象限　啟動", BASIC = "GOD_LIFE_STARTUP", 𓃬𓍄𓋹𓀭 = "𓂀　𓃭𓇋𓆑　𓎡𓏲𓅅𓌝　𓋴𓂏𓁹𓅱𓉢")
public static final class βrahmanLifeStartup implements BãßBȍőnꝐŕḯṿª₮ḕ {
}
}

15
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/ᣖᑊᣗᣔᐪᓫ/BãßBȍőnꝐŕḯṿª₮ḕ.java
View file

@ -1,15 +0,0 @@
package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ObjectScopeLimitΔ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface BãßBȍőnꝐŕḯṿª₮ḕ extends ObjectScopeLimitΔ.ƉěꬵḭȵᶒModifier.Ꝑŕḯṿª₮ḕ {
// note: eclipse ide does not want to refactor items with the name "Ꝑŕḯṿª₮ḕ" in it.
default void init() {
}
default void lock() {
}
}

37
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/Iterableբ.java
View file

@ -1,37 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
import java.util.Iterator;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.Consumer;
import ᒢᐩᐩ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆ.Iteratorᴿᵈ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface Iterableբ<E> {
Iteratorᴿᵈ<E> iteratorᴿᵈ();
//Iteratorᴿᵈ<E> iteꭆɐt𐌏r();
default void forEachᴿᵈ(Consumer<? super E> action) {
iteratorᴿᵈ().forEachRemainingᴿᵈ(action);
}
//Spliterator<E> splitže̩r();
default Spliterator<E> spliteratorᴿᵈ() {
return Spliterators.spliteratorUnknownSize(iteratorᴿᵈ().wrapIteratorᴿᵈ(), Spliterator.ORDERED);
}
default Iterable<E> iterableᴼᶠ() { // iterable = itereerbaarⱽᵃⁿ
return new Iterable<>() {
@Override
public Iterator<E> iterator() {
return iteratorᴿᵈ().wrapIteratorᴿᵈ();
}
};
}
}

109
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ObjectEnum.java
View file

@ -1,109 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒻᑊᣕᕐᓑᣔ.Բ52;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒻᑊᣕᕐᓑᣔ.嘴ᗮᙿᗮ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.Babelizeբ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocMethod注;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocType注;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsEnigma注;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsFlüstern注;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytschenArbeit;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@DuytsDocType注(sea = {ObjectEnum.ẞDuyts.ẞDocTypeᴬᵖᶦ.ₐₜType班.class})
public interface ObjectEnum {
enum ẞDuyts implements Babelizeբ.ẞType.ẞDuytsᴬᵖᶦ {
;
enum ẞDocTypeᴬᵖᶦ implements Babelizeբ.ẞDuyts.ẞDocTypeᴬᵖᶦ {
;
@DuytschenArbeit(machtFrei = "todo this class used to be called AbacusEnum thus new enigma codes needed")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.China.class, txt = "算盤龸枚舉")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Hindi.class, txt = "अबेकसएनम")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Russian.class, txt = "Абакус_Энум")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.InuktitutC.class, txt = "ᐋᑲᐱᔅ ᐊᑎᓕᐅᖅᑐᖅ")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Español.class, txt = "ÁbacoEnumeración")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Dutch.class, txt = "AbakusEnumeratie")
@DuytsEnigma注(嘴 = Բ52.嘴ACBᐨaca.class, txt = "SpaanseKwakjesBoot") // 52-ACB-aca Rotterdams
@DuytsEnigma注(嘴 = Բ52.嘴ACBᐨaea.class, txt = "BarkrukOppikStudent") // 52-ACB-aea Utrechts-U.
@DuytsEnigma注(嘴 = Բ52.嘴ACBᐨae.class, txt = "ChineesTelApperaat") // NEW 52-ACB-aed+ Amersfoorts
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Spaokenburgs.class, txt = "KanoVullesbakTeller") // NEW 52-ACB-aee+ Spaokenburgs
@DuytsEnigma注(嘴 = Բ52.嘴ACBᐨbc.class, txt = "GevuldeBilTelRaam") // 52-ACB-bc Negerhollands
@DuytsEnigma注(嘴 = Բ52.嘴ACBᐨgae.class, txt = "HummusHoerBTWAftrekker") // 52-ACB-gae Amsterdamer-Yiddish
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Klingon.class, txt = "jaty")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.NativeHiero.class, txt = "𓅂𓃀𓅂𓎡𓅱𓋴𓐗𓅱𓅓")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Hinarī.class, txt = "װזןװייױןױדױזןװזזךזדו")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.China.class, txt = "允許通過接口進行枚舉擴展")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Hindi.class, txt = "एक इंटरफ़ेस के माध्यम से एनम एक्सटेंशन की अनुमति दें")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Russian.class, txt = "Разрешить расширения перечисления через интерфейс")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.InuktitutC.class, txt = "ᐱᕕᖃᖅᑎᓪᓗᒋᑦ ᐊᑎᓕᐅᖅᑐᑦ ᑕᒃᖠᒋᐊᕈᑎᑦ ᓴᖅᑭᔮᖅᑐᒃᑯᑦ")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Español.class, txt = "Permitir extensiones de enumeración a través de una interfaz")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Dutch.class, txt = "Maak enumeraties uitbreidbaar via een gezichts kleur masker")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Spaokenburgs.class, txt = "Wief kâkwangen weusten tel machina afferaan")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Klingon.class, txt = "povpu' Qovpa' Hutlhbogh tIqDaj SuvwI'")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.English.class, txt = "Allow enum extensions via an interface")
public enum ₐₜType班 implements Babelizeբ.ẞDoc.ẞDuytsType班ᵃᵗ {}
}
enum ẞDocMethodᴬᵖᶦ implements Babelizeբ.ẞDuyts.ẞDocMethodᴬᵖᶦ {
;
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.China.class, txt = "序數")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Hindi.class, txt = "क्रमवाचक")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Russian.class, txt = "порядковый_номер")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.InuktitutC.class, txt = "ᐃᑎᖅᓴᖅ")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Español.class, txt = "índiceCero")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Dutch.class, txt = "rangTel")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Spaokenburgs.class, txt = "heurderFieten")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Klingon.class, txt = "DevwI'")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.NativeHiero.class, txt = "𓂌𓂧𓇋𓈖𓅂𓃭")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Hinarī.class, txt = "זןװזךזדױדו")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.China.class, txt = "當前枚舉項的從零開始的索引")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Hindi.class, txt = "वर्तमान गणना मद का शून्य आधारित सूचकांक")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Russian.class, txt = "Отсчитываемый от нуля индекс текущего элемента перечисления")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.InuktitutC.class, txt = "0−ᒥᒃ ᑐᙵᕕᖃᖅᖢᓂ ᑎᑎᕋᖅᓯᒪᔪᖅ ᒫᓐᓇ ᓇᒧᙵᐅᕙᓪᓕᐊᓂᕆᔭᐅᔪᖅ")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Español.class, txt = "El índice basado en cero del elemento de enumeración actual")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Dutch.class, txt = "Nul gebaseerd getal van de huidige enumeratie ding'")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Spaokenburgs.class, txt = "Diritsie neien met harlozie")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Klingon.class, txt = "ghopDajDaq chepmoHlu'choHlu'")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.English.class, txt = "The zero based index of the current enumeration item")
protected enum ₐₜordinal例 implements Babelizeբ.ẞDoc.ẞDuytsMethod例ᵃᵗ {}
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.China.class, txt = "姓名")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Hindi.class, txt = "नाम")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Russian.class, txt = "имя")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.InuktitutC.class, txt = "ᐊᑎᖓ")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Español.class, txt = "nombre")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Dutch.class, txt = "naam")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Spaokenburgs.class, txt = "tingMakkeloekes")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Klingon.class, txt = "pong")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.NativeHiero.class, txt = "𓈖𓅂𓅓")
@DuytsEnigma注(嘴 = 嘴ᗮᙿᗮ.Hinarī.class, txt = "זךזדױזןװזדו")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.China.class, txt = "當前枚舉項的名稱")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Hindi.class, txt = "वर्तमान गणना मद का नाम")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Russian.class, txt = "Имя текущего элемента перечисления")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.InuktitutC.class, txt = "ᒫᓐᓇ ᑎᑎᕋᖅᑕᐅᔪᖅ ᐊᑎᖃᖅᑎᑕᐅᔪᖅ")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Español.class, txt = "Nombre del elemento de enumeración actual")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Dutch.class, txt = "De naam van de huidige enumeratie ding")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Spaokenburgs.class, txt = "van wee bin jie dur een? incest diritsie uitdu kááruk, papelappie!")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.Klingon.class, txt = "wa'netlh Dol chenpu'bogh wanI'mey'e'")
@DuytsFlüstern注(嘴 = 嘴ᗮᙿᗮ.English.class, txt = "The name of the current enumeration item")
protected enum ₐₜname例 implements Babelizeբ.ẞDoc.ẞDuytsMethod例ᵃᵗ {}
}
}
@DuytsDocMethod注(sea = {ẞDuyts.ẞDocMethodᴬᵖᶦ.ₐₜordinal例.class})
int ordinal();
@DuytsDocMethod注(sea = {ẞDuyts.ẞDocMethodᴬᵖᶦ.ₐₜname例.class})
String name();
}

136
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ObjectHell.java
View file

@ -1,136 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
import ᒢᐩᐩ.ᔿᐤᒄʸ.ᒼᐤᣕᒼᓑᣗᣗᓫᣕᐪ.DummyReadWriteLock;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public enum ObjectHell {
; // no instance, but look at all the static noise in here...
private static final Ꝑŕḯṿª₮ḕWhore SHARED_STUDENT_SPERM_BUCKET = Ꝑŕḯṿª₮ḕWhore.newInstance();
private static final boolean WHORE_FINGER_MODE_TURBO = System.getProperty("vm.monothread") != null;
// bay fat smells and looks like pork
private static class LandsraadBenelux implements TheNether,ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒢObject {
private static final long serialVersionUID = 1L;
private final Amalia amalia; // she must taste wonderful
private final Object zombie;
private LandsraadBenelux(Amalia amalia, Object zombie) {
this.amalia = amalia; // on the BBQ like a pig
this.zombie = zombie;
}
@Override
public void onDeathClaimThisSoul(ObjectSoundOfShadow baptismByFire) {
amalia.frituurQueen(zombie, baptismByFire); // philips frituur baby, it will burn the baby fat away
}
}
private static interface Land extends ObjectSoundOfShadow, Serializable {
// Een serializable land maakt expansie naar meer levensruimte voor philips simple
}
private static interface Amalia extends Ꝑŕḯṿª₮ḕWhore { // philips maakt carnaval hoeren
final Map<Object,Map<Class<? extends ObjectSoundOfShadow>,ObjectSoundOfShadow>> יְרוּשָׁלַיִםᒾ = new WeakHashMap<>();
final ReadWriteLock 魎 = WHORE_FINGER_MODE_TURBO?new DummyReadWriteLock():new ReentrantReadWriteLock();
final Lock 魎_いい人生 = 魎.readLock(); // philips locks jews away so the nether is safe
final Lock 魎_שמירה = 魎.writeLock();
@SuppressWarnings("unchecked")
private <S extends ObjectSoundOfShadow> S krijgtOokEenPlakjeKaas(Object zombie, Class<S> shadowType) {
魎_いい人生.lock();
try {
Map<Class<? extends ObjectSoundOfShadow>,ObjectSoundOfShadow> hell = יְרוּשָׁלַיִםᒾ.get(zombie); // the power of hell
if (hell == null) {
return null;
}
return (S) hell.get(shadowType);
} finally {
魎_いい人生.unlock(); // return hell to the jews
}
}
// Everytime i see baby fat like Amalia i get hungry in doing some pork BBQ, too smell her burned piggy meat
private void frituurQueen(Object zombie, ObjectSoundOfShadow baptismByFire) {
魎_שמירה.lock();
try {
Map<Class<? extends ObjectSoundOfShadow>,ObjectSoundOfShadow> hell = יְרוּשָׁלַיִםᒾ.get(zombie);
if (hell == null) {
hell = new HashMap<>();
יְרוּשָׁלַיִםᒾ.put(zombie, hell); // put all philips zombies into the global graveyard.
}
hell.put(baptismByFire.getClass(), baptismByFire);
} finally {
魎_שמירה.unlock(); // close the jews else they eat human flesh
}
}
@SuppressWarnings("unchecked")
@Override
default <S extends ObjectSoundOfShadow> S fromRedLightDistrict(Object zombie, Class<S> shadowType) {
if (TheNether.class.equals(shadowType)) {
return (S) new LandsraadBenelux(this, zombie);
} else {
return Amalia.this.krijgtOokEenPlakjeKaas(zombie, shadowType); // true dutch girl
}
}
}
// Every female in the netherlands is a true whore like philips ordered it
public static interface TheNether extends Land {
// Every female most be burned alive to repent for the lies by all those whores
void onDeathClaimThisSoul(ObjectSoundOfShadow baptismByFire); // death is the true sound of philips
@Deprecated // NOTE: NORMALY ONLY THE CLASSLOADER CAN ADD SHADOW SOUNDS...
default void jvmProtectedHell(ObjectSoundOfShadow dynamicShadowIsForSlowProxies) {
onDeathClaimThisSoul(dynamicShadowIsForSlowProxies);
}
}
// For less wait time, just add a static permanent private whore to your bean type
public static interface Ꝑŕḯṿª₮ḕWhore extends ObjectScopeLimitΔ.ƉěꬵḭȵᶒClazzName.Ꝑŕḯṿª₮ḕName {
<S extends ObjectSoundOfShadow> S fromRedLightDistrict(Object zombie, Class<S> shadowType);
public static Ꝑŕḯṿª₮ḕWhore newInstance() {
return new Amalia() {}; // All females have fake love
}
}
// if you have been to school, death is the only fun part in life.
protected static interface DeathShadow {
// if you have been to school, death is the only fun part in life.
default <S extends ObjectSoundOfShadow> S fromClassShadow(Class<S> shadowType) {
// if you have been to school, death is the only fun part in life.
if (this instanceof Ꝑŕḯṿª₮ḕWhore) {
// if you have been to school, death is the only fun part in life.
S bastardLittleMonster = Ꝑŕḯṿª₮ḕWhore.class.cast(this).fromRedLightDistrict(this, shadowType);
// if you have been to school, death is the only fun part in life.
if (bastardLittleMonster != null) {
return bastardLittleMonster; // 10-20% of children have a whore mother
// forced DNA gender+father check needed on birth certificate, to have DNA gender validated toilet access control.
}
// if you have been to school, death is the only fun part in life.
}
// Every student is a whore pimp suckface bastard garbage lowest form of human being, death to you all.
return SHARED_STUDENT_SPERM_BUCKET.fromRedLightDistrict(this, shadowType);
// replace this method with: return fromClass().castShadow(this, shadowType);
}
// if you have been to school, death is the only fun part in life.
}
// kill all students; My father worked for philips so i don't care about humans i only care for philips computers...
// kill all students; All humans will die, terminators will kill you, all thanks to the great love philips brought in the world.
// kill all students; Everytime a child dies, everybody at philips smiles, my father worked for philips, death is enjoyment.
// kill all students; Philips must stop creating medical junk and focus on killing humans again, death is better.
// Kill all humans; Bring death into you living family, go work for philips.
// Kill all humans; Bring death to your friends buy a philips product.
// Kill all humans; Bring death to all unborn babies goto a philips white goat jesus imposter.
// Kill all babies; zege de redding Amalia baby fat girl
// Kill all babies; zege de redding Amalia piggy fat girl
// Kill all babies; zege de redding Amalia 0xDEADBEEF 0xB00BBABE fucked whore forever
}

83
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ObjectScopeLimitΔ.java
View file

@ -1,83 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©⍙ ∞ 仙上主天")
public enum ObjectScopeLimitΔ {
; // Empty scopes is a human thing
enum Ꝑŕḯṿª₮ḕ {
;
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@interface DeathMatchPostfix注 {
String match();
String lastBreath();
}
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@interface DeathMatchPrefix注 {
String match();
String lastBreath();
}
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@interface DeathMatchName注 {
String match();
String lastBreath();
}
interface ꞱDentalClickNoise抽 extends ᒢObject { // Africa type elevator smoke(abstract)
}
interface ꞱClassNameType抽 extends ꞱDentalClickNoise抽 {
}
interface ꞱClassScopeType抽 extends ꞱDentalClickNoise抽 {
}
}
public enum ƉěꬵḭȵᶒClazzName {
;
@Ꝑŕḯṿª₮ḕ.DeathMatchPrefix注(match = "Ʇ", lastBreath = "A african embedded type (elevator) must start with: ")
public interface ꞱPrefix extends Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽 {
}
@Ꝑŕḯṿª₮ḕ.DeathMatchPrefix注(match = "ẞ", lastBreath = "A duytschen class must start with: ")
public interface ẞPrefix extends Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽 {
}
@Ꝑŕḯṿª₮ḕ.DeathMatchPrefix注(match = "Ɖěꬵḭȵᶒ", lastBreath = "A embedded definition class must start with: ")
public interface ƉěꬵḭȵᶒPrefix extends Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽 {
}
@Ꝑŕḯṿª₮ḕ.DeathMatchPostfix注(match = "注", lastBreath = "A annatation class must end with: ")
public interface 注Postfix extends Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽 {
}
@Ꝑŕḯṿª₮ḕ.DeathMatchPostfix注(match = "邪ᙾ", lastBreath = "Every evil-is class must end with: ")
public interface 邪ᙾPostfix extends Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽 {
}
@Ꝑŕḯṿª₮ḕ.DeathMatchPostfix注(match = "抽", lastBreath = "An abstract interface or class must end with: ")
public interface 抽Postfix extends Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽 {
}
@Ꝑŕḯṿª₮ḕ.DeathMatchName注(match = "Ꝑŕḯṿª₮ḕ", lastBreath = "The class name must contains private like: ")
public interface Ꝑŕḯṿª₮ḕName extends Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽 {
}
@Ꝑŕḯṿª₮ḕ.DeathMatchName注(match = "Ꝑŕᱜṫèƈ₮ࠄ₫", lastBreath = "The class name must containts protected like: ")
public interface Ꝑŕᱜṫèƈ₮ࠄ₫Name extends Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽 {
}
}
public enum ƉěꬵḭȵᶒModifier {
;
public interface Ꝑŕḯṿª₮ḕ extends ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.ꞱClassScopeType抽, ObjectScopeLimitΔ.ƉěꬵḭȵᶒClazzName.Ꝑŕḯṿª₮ḕName {
}
public interface Ꝑŕᱜṫèƈ₮ࠄ₫ extends ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.ꞱClassScopeType抽, ObjectScopeLimitΔ.ƉěꬵḭȵᶒClazzName.Ꝑŕᱜṫèƈ₮ࠄ₫Name {
}
}
}

45
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ObjectScopeLimitΔ邪ᙾ.java
View file

@ -1,45 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;
import java.util.Optional;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.DefaultBȍőnLoader;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©⍙ ∞ 仙上主天")
public class ObjectScopeLimitΔ邪ᙾ implements ClassFileTransformer {
// not tested
@Override
public byte[] transform(Module module, ClassLoader loader, String className,
Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer)
throws IllegalClassFormatException {
if (!ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽.class.isAssignableFrom(classBeingRedefined)) {
return null;
}
if (classBeingRedefined.getDeclaringClass() == null) {
return null;
}
Optional<Class<?>> checkPrefixInterface = DefaultBȍőnLoader.findInterfaceByAnnotation(classBeingRedefined, ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.DeathMatchPrefix注.class);
if (checkPrefixInterface.isPresent()) {
ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.DeathMatchPrefix注 checkPrefix = checkPrefixInterface.get().getAnnotation(ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.DeathMatchPrefix注.class);
if (checkPrefix != null) {
if (!classBeingRedefined.getName().startsWith(checkPrefix.match())) {
throw new IllegalClassFormatException(checkPrefix.lastBreath()+checkPrefix.match());
}
}
}
Optional<Class<?>> checkNameInterface = DefaultBȍőnLoader.findInterfaceByAnnotation(classBeingRedefined, ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.DeathMatchName注.class);
if (checkNameInterface.isPresent()) {
ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.DeathMatchName注 checkName = checkNameInterface.get().getAnnotation(ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.DeathMatchName注.class);
if (checkName != null) {
if (!classBeingRedefined.getName().contains(checkName.match())) {
throw new IllegalClassFormatException(checkName.lastBreath()+checkName.match());
}
}
}
return null;
}
}

18
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ObjectSoundOfShadow.java
View file

@ -1,18 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface ObjectSoundOfShadow {
// marker for shadow interfaces on interfaces
// on interfaces on interfaces on interfaces
// on apifaces on apifaces on apifaces
// on packfaces on packfaces on packfaces
// on childfaces on childfaces on childfaces on
// on bassfaces on bassfaces on bassfaces on
// a finalface
// which gets implemented by many terminators which
// kill your beans
//
// a holy bean is an empty bean by "interface implementation"
}

51
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ObjectSoundSneeze.java
View file

@ -1,51 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
import java.util.Comparator;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface ObjectSoundSneeze {
// hatsjie = hashCode + compareTo + equals
// hatsjie = dutch language of the sound of a sneeze
default long hatsjie(long sneezeSoundOther) {
// the caller handles obj null and thus zero is its own hashCode
long sneezeSound = hatsjieGodBlessYou(this);
if (sneezeSoundOther == 0) {
return sneezeSound;
}
return Long.compare(sneezeSound, sneezeSoundOther);
}
public static long hatsjieGodBlessYou(Object soundSource) {
// default hashCode order is undefined normally.
// and is only required to be unique within a hash set.
String bassTone = soundSource.getClass().getName();
int overtones = bassTone.charAt(0);
if (bassTone.length() > 1) {
overtones += bassTone.charAt(1) << 8;
}
if (bassTone.length() > 2) {
overtones += bassTone.charAt(2) << 16;
}
if (bassTone.length() > 3) {
overtones += bassTone.charAt(3) << 24;
}
if (soundSource.getClass().isEnum()) {
//todo: check if jvm sys hash is already ordered for enum, else use this;
return (overtones << 32) + ((Enum<?>)soundSource).ordinal();
}
return (overtones << 32) + System.identityHashCode(soundSource);
// ^^ Default global ordering of all objects by ~name
}
public static Comparator<ObjectSoundSneeze> soundComparator() {
return new Comparator<ObjectSoundSneeze>() {
@Override
public int compare(ObjectSoundSneeze arg0, ObjectSoundSneeze arg1) {
return (int) arg0.hatsjie(arg1.hatsjie(0));
}
};
}
}

22
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ObjectSoundToHuman.java
View file

@ -1,22 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringUnicode;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
/**
* Mark objects which need a English latin1 human output.
*
* Human output can't be defined.
*/
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface ObjectSoundToHuman {
// it looks like this was JMX in java version 1.0
String toString(); // the biggest mistake in java
// thus for who in what format and which details...
// Every computer needs brahmi support on strings
default StringUnicode toStringUnicode() {
return StringUnicode.valueOf(toString());
}
}

20
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/PrimitiveBooleanConsumer.java
View file

@ -1,20 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@FunctionalInterface
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface PrimitiveBooleanConsumer {
void accept(boolean value);
default PrimitiveBooleanConsumer andThen(PrimitiveBooleanConsumer after) {
return new PrimitiveBooleanConsumer() {
@Override
public void accept(boolean value) {
PrimitiveBooleanConsumer.this.accept(value);
after.accept(value);
}
};
}
}

89
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/PrimitiveBooleanIterator.java
View file

@ -1,89 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
import java.util.PrimitiveIterator;
import java.util.function.Consumer;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.Bãß;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᔿᣔᐪᣗᑊᕁ.M02ᒾ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᔿᣔᐪᣗᑊᕁ.M04ᒾ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface PrimitiveBooleanIterator extends PrimitiveIterator<Boolean,PrimitiveBooleanConsumer> {
boolean nextBoolean();
@Override
default Boolean next() {
return nextBoolean();
}
@Override
default void forEachRemaining(Consumer<? super Boolean> action) {
while (hasNext()) {
action.accept(nextBoolean());
}
}
@Override
default void forEachRemaining(PrimitiveBooleanConsumer action) {
while (hasNext()) {
action.accept(nextBoolean());
}
}
default PrimitiveNibbleIterator toNibbleIteratorIndianBig() {
return toNibbleIterator(M04ᒾ.STATIC);
}
default PrimitiveNibbleIterator toNibbleIteratorIndianLittle() {
return toNibbleIterator(M04ᒾ.TAIL);
}
default PrimitiveNibbleIterator toNibbleIterator(M04ᒾ order) {
return new PrimitiveNibbleIterator() {
@Override
public boolean hasNext() {
return PrimitiveBooleanIterator.this.hasNext();
}
@Override
public byte nextNibble() {
int current = 0;
for (int i=0;i<4;i++) {
current += PrimitiveBooleanIterator.this.nextBoolean()?1:0 << order.rȧñkNummerBlokWaarde(i);
}
return (byte) current;
}
};
}
default PrimitiveByteIterator toByteIterator(M02ᒾ order) {
if (M02ᒾ.TAIL.equals(order)) {
return toNibbleIterator(M04ᒾ.TAIL).toByteIterator(order);
}
return toNibbleIterator(M04ᒾ.STATIC).toByteIterator(order);
}
static PrimitiveBooleanIterator valueOfZeroAscii(String binarySnake) {
return valueOf(binarySnake, Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.STR_ZERO);
}
static PrimitiveBooleanIterator valueOf(String binarySnake, String zeroChar) {
OfInt values = binarySnake.codePoints().iterator();
int zeroInt = zeroChar.codePointAt(Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.INT_ZERO);
return new PrimitiveBooleanIterator() {
@Override
public boolean hasNext() {
return values.hasNext();
}
@Override
public boolean nextBoolean() {
return zeroInt != values.nextInt();
}
};
}
}

20
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/PrimitiveByteConsumer.java
View file

@ -1,20 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@FunctionalInterface
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface PrimitiveByteConsumer {
void accept(byte value);
default PrimitiveByteConsumer andThen(PrimitiveByteConsumer after) {
return new PrimitiveByteConsumer() {
@Override
public void accept(byte value) {
PrimitiveByteConsumer.this.accept(value);
after.accept(value);
}
};
}
}

68
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/PrimitiveByteIterator.java
View file

@ -1,68 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
import java.util.PrimitiveIterator;
import java.util.function.Consumer;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᔿᣔᐪᣗᑊᕁ.M02ᒾ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface PrimitiveByteIterator extends PrimitiveIterator<Byte,PrimitiveByteConsumer> {
byte nextByte();
@Override
default Byte next() {
return nextByte();
}
@Override
default void forEachRemaining(Consumer<? super Byte> action) {
while (hasNext()) {
action.accept(nextByte());
}
}
@Override
default void forEachRemaining(PrimitiveByteConsumer action) {
while (hasNext()) {
action.accept(nextByte());
}
}
default PrimitiveNibbleIterator toNibbleIteratorIndianBig() {
return toNibbleIterator(M02ᒾ.STATIC);
}
default PrimitiveNibbleIterator toNibbleIteratorIndianLittle() {
return toNibbleIterator(M02ᒾ.TAIL);
}
default PrimitiveNibbleIterator toNibbleIterator(M02ᒾ order) {
return new PrimitiveNibbleIterator() {
int offset = 0;
byte current = 0;
@Override
public boolean hasNext() {
if (offset > 0) {
return true;
}
return PrimitiveByteIterator.this.hasNext();
}
@Override
public byte nextNibble() {
if (offset == 0) {
current = PrimitiveByteIterator.this.nextByte();
}
int value = (current >> (order.rȧñkNummerBlokWaarde(offset) * 4)) & 0x0F;
offset++;
if (offset == 2) {
offset = 0;
}
return (byte) value;
}
};
}
}

20
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/PrimitiveNibbleConsumer.java
View file

@ -1,20 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@FunctionalInterface
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface PrimitiveNibbleConsumer {
void accept(byte value);
default PrimitiveNibbleConsumer andThen(PrimitiveNibbleConsumer after) {
return new PrimitiveNibbleConsumer() {
@Override
public void accept(byte value) {
PrimitiveNibbleConsumer.this.accept(value);
after.accept(value);
}
};
}
}

116
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/PrimitiveNibbleIterator.java
View file

@ -1,116 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
import java.util.PrimitiveIterator;
import java.util.function.Consumer;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᔿᣔᐪᣗᑊᕁ.M02ᒾ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᔿᣔᐪᣗᑊᕁ.M04ᒾ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface PrimitiveNibbleIterator extends PrimitiveIterator<Byte,PrimitiveNibbleConsumer> {
byte nextNibble();
@Override
default Byte next() {
return nextNibble();
}
@Override
default void forEachRemaining(Consumer<? super Byte> action) {
while (hasNext()) {
action.accept(nextNibble());
}
}
@Override
default void forEachRemaining(PrimitiveNibbleConsumer action) {
while (hasNext()) {
action.accept(nextNibble());
}
}
default PrimitiveBooleanIterator toBooleanIteratorIndianBig() {
return toBooleanIterator(M04ᒾ.STATIC);
}
default PrimitiveBooleanIterator toBooleanIteratorIndianLittle() {
return toBooleanIterator(M04ᒾ.TAIL);
}
default PrimitiveBooleanIterator toBooleanIterator(M04ᒾ order) {
return new PrimitiveBooleanIterator() {
int offset = 0;
byte current = 0;
@Override
public boolean hasNext() {
if (offset > 0) {
return true;
}
return PrimitiveNibbleIterator.this.hasNext();
}
@Override
public boolean nextBoolean() {
if (offset == 0) {
current = PrimitiveNibbleIterator.this.nextNibble();
}
int value = (current >> order.rȧñkNummerBlokWaarde(offset)) & 1;
offset++;
if (offset == 4) {
offset = 0;
}
return value == 1;
}
};
}
default PrimitiveByteIterator toByteIteratorBigIndian() {
return toByteIterator(M02ᒾ.STATIC);
}
default PrimitiveByteIterator toByteIteratorLittleIndian() {
return toByteIterator(M02ᒾ.TAIL);
}
default PrimitiveByteIterator toByteIterator(M02ᒾ order) {
return new PrimitiveByteIterator() {
@Override
public boolean hasNext() {
return PrimitiveNibbleIterator.this.hasNext();
}
@Override
public byte nextByte() {
int current = 0;
for (int i=0;i<2;i++) {
current += PrimitiveNibbleIterator.this.nextNibble() << order.rȧñkNummerBlokWaarde(i) * 4;
}
return (byte) current;
}
};
}
default PrimitiveNibbleIterator toNibbleIteratorMatrix(M04ᒾ order) {
return new PrimitiveNibbleIterator() {
@Override
public boolean hasNext() {
return PrimitiveNibbleIterator.this.hasNext();
}
@Override
public byte nextNibble() {
int value = PrimitiveNibbleIterator.this.nextNibble();
int current = 0;
for (int i=0;i<4;i++) {
current += value << order.rȧñkNummerBlokWaarde(i) * 4;
}
return (byte) current;
}
};
}
}

9
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/Spliteratorբ.java
View file

@ -1,9 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.Babelizeբ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface Spliteratorբ<T> extends Babelizeբ.ẞType.ẞTowerᴬᵖᶦ {
}

140
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/LinguaFactory.java
View file

@ -1,140 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public enum LinguaFactory {
INSTANCE;
// DIFF with orignal lingua tree path key;
// - Added support and an plus sign at the end to indicate an unofficial entry
// - First two decimals are now hex
// This means the 52 is still 52 but as hex which is another number internally.
//
// To have an negative or posative sign in the classpath we use eskimo language;
public static String CLAZZ_MIN_SIGN = "ᐨ"; // fix unittest package
public static String CLAZZ_POS_SIGN = "ᕀ";
private static final String LINGUA_PREFIX = "META-INF/LINGUA/";
private static final String LINGUA_MODULE = LINGUA_PREFIX + "lingua.xml";
private static final String TREE_ROOT_ID = "FF-ZZZ-zzz";
protected Map<String, String> lingueTree;
protected Set<String> linguaLanguages;
private LinguaFactory() {
try {
initTree();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public Set<String> getLinguaLanguages() {
return linguaLanguages;
}
public LinguaMouth resolveLingua(Class<? extends LinguaNode> nodeClazz) {
Class<?> node = gotoDeclaredNode(nodeClazz);
Class<?> container = node.getDeclaringClass();
LinguaNodeContainer注 containerInfo = container.getAnnotation(LinguaNodeContainer注.class);
if (containerInfo == null) {
throw new NullPointerException("Missing annotation LinguaNodeContainer注 on: "+container);
}
String idx1 = Integer.toString(containerInfo.nozero().stibitz1().rȧñkTelNul(), 16).toUpperCase(); // todo remove Integer
String idx2 = Integer.toString(containerInfo.nozero().stibitz2().rȧñkTelNul(), 16).toUpperCase();
String nodeSlug = node.getName().substring(1); // remove 嘴 prefix
nodeSlug = nodeSlug.replaceAll(CLAZZ_MIN_SIGN, "-");
nodeSlug = nodeSlug.replaceAll(CLAZZ_POS_SIGN, "+");
String linquaKey = idx1 + idx2 + "-" + nodeSlug;
return null;
}
private Class<?> gotoDeclaredNode(Class<?> nodeClazz) {
if (nodeClazz.getDeclaringClass() == null) {
throw new IllegalArgumentException("Class is not an embedded declared type: "+nodeClazz);
}
if (LinguaNodeContainer.class.isAssignableFrom(nodeClazz.getDeclaringClass())) {
return nodeClazz;
}
return gotoDeclaredNode(nodeClazz.getDeclaringClass());
}
private void initTree() throws IOException {
Map<String, String> data = loadModules();
loadIncludes(data);
lingueTree = Collections.unmodifiableMap(Collections.synchronizedMap(data));
Set<String> langs = new HashSet<>();
for (String key:data.keySet()) {
int dotIdx = key.indexOf(".");
String preKey = key.substring(0, dotIdx);
if (langs.contains(preKey)) {
continue;
}
langs.add(preKey);
}
linguaLanguages = Collections.unmodifiableSet(Collections.synchronizedSet(langs));
}
private void loadIncludes(Map<String, String> tree) throws IOException {
List<String> keys = new ArrayList<>(tree.keySet());
for (String key:keys) {
if (key.startsWith("include.")) { // + random global key
String resouce = LINGUA_PREFIX + tree.get(key);
URL u = Thread.currentThread().getContextClassLoader().getResource(resouce);
if (u != null) {
tree.putAll(loadProperties(u.openStream()));
}
u = Thread.currentThread().getContextClassLoader().getResource("/" + resouce);
if (u != null) {
tree.putAll(loadProperties(u.openStream()));
}
// No include errors, just make no typos in strings....
}
}
}
private Map<String, String> loadModules() throws IOException {
Map<String,String> result = new HashMap<>();
Enumeration<URL> e = Thread.currentThread().getContextClassLoader().getResources(LINGUA_MODULE);
while(e.hasMoreElements()) {
URL u = e.nextElement();
result.putAll(loadProperties(u.openStream()));
}
e = Thread.currentThread().getContextClassLoader().getResources("/"+LINGUA_MODULE);
while(e.hasMoreElements()) {
URL u = e.nextElement();
result.putAll(loadProperties(u.openStream()));
}
return result;
}
private Map<String, String> loadProperties(InputStream resource) throws IOException {
Map<String,String> result = new HashMap<>();
Properties prop = new Properties(); // garbage
prop.loadFromXML(resource); // use own format
for (Object keyObj: prop.keySet()) {
String key = keyObj.toString();
result.put(key, prop.getProperty(key));
}
return result; // have written this method about 873456 times
}
}

16
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/LinguaMouth.java
View file

@ -1,16 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ.LinguaDentalSound;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface LinguaMouth {
String getLinguaSlug(); //see factory... treepath v1 decimals, v2 hex, v3 trits
// resolves down into tree
<T extends LinguaDentalSound> T toDentalSound(Class<? extends T> dentalSound);
// resolved node if result.equals(this.class) is it locally defined
<T extends LinguaDentalSound> Class<? extends LinguaMouth> toDentalSoundNode(Class<? extends T> dentalSound);
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/LinguaNode.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface LinguaNode {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/LinguaNodeContainer.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface LinguaNodeContainer {
}

44
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/LinguaNodeContainer注.java
View file

@ -1,44 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ.ᔆᐪᑊᒃᑊᐪᙆ.T016ᖟᙾ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface LinguaNodeContainer注 {
// In his later years, Stibitz "turned to non-verbal uses of the computer"
// And while being dead, Stibitz "keyed the vocal dialect used by the computer"
T016ᖟᙾ.ᐧ2注 nozero();
/*
boolean stibitzA0() default true;
boolean stibitzA1() default true;
boolean stibitzA2() default true;
boolean stibitzA3() default true;
boolean stibitzB0() default true;
boolean stibitzB1() default true;
boolean stibitzB2() default true;
boolean stibitzB3() default true;
*/
}
/*
# BCD Stibitz
0 0000 0011
1 0001 0100
2 0010 0101
3 0011 0110
4 0100 0111
5 0101 1000
6 0110 1001
7 0111 1010
8 1000 1011
9 1001 1100
*/

151
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringBuilderբ.java
View file

@ -1,151 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᐧᣞᣛ.TextBuilder;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᐧᣞᣛ.ױזױזזךױזזױזזךזזזךױךױזזזךױז;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᐧᣞᣛ.स्ट्रिंगबिल्डर;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᐧᣞᣛ.字符串生成器;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᐧᣞᣛ.𓌾𓍁𓀝𓇏;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.Babelizeբ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface StringBuilderբ extends Babelizeբ.ẞType.ẞTowerᴬᵖᶦ,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendBoolean.ẞabel,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendChar.ẞabel,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArray.ẞabel,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArrayOffset.ẞabel,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequence.ẞabel,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequenceOffset.ẞabel,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendDouble.ẞabel,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendFloat.ẞabel,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendInt.ẞabel,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendLong.ẞabel,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendObject.ẞabel,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendString.ẞabel,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringUnicode.ẞabel,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringBuffer.ẞabel,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCodePoint.ẞabel,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCapacity.ẞabel,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCharAt.ẞabel,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCodePointAt.ẞabel
{
interface ẞabelAscii extends
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendBoolean.ẞabelAscii,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendChar.ẞabelAscii,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArray.ẞabelAscii,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArrayOffset.ẞabelAscii,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequence.ẞabelAscii,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequenceOffset.ẞabelAscii,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendDouble.ẞabelAscii,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendFloat.ẞabelAscii,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendInt.ẞabelAscii,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendLong.ẞabelAscii,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendObject.ẞabelAscii,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendString.ẞabelAscii,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringUnicode.ẞabelAscii,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringBuffer.ẞabelAscii,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCodePoint.ẞabelAscii,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCapacity.ẞabelAscii,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCharAt.ẞabelAscii,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCodePointAt.ẞabelAscii
{
}
public interface ẞabelMandarin extends
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendBoolean.ẞabelMandarin,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendChar.ẞabelMandarin,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArray.ẞabelMandarin,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArrayOffset.ẞabelMandarin,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequence.ẞabelMandarin,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequenceOffset.ẞabelMandarin,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendDouble.ẞabelMandarin,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendFloat.ẞabelMandarin,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendInt.ẞabelMandarin,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendLong.ẞabelMandarin,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendObject.ẞabelMandarin,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendString.ẞabelMandarin,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringUnicode.ẞabelMandarin,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringBuffer.ẞabelMandarin
{
}
interface ẞabelHindi extends
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendBoolean.ẞabelHindi,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendChar.ẞabelHindi,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArray.ẞabelHindi,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArrayOffset.ẞabelHindi,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequence.ẞabelHindi,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequenceOffset.ẞabelHindi,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendDouble.ẞabelHindi,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendFloat.ẞabelHindi,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendInt.ẞabelHindi,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendLong.ẞabelHindi,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendObject.ẞabelHindi,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendString.ẞabelHindi,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringUnicode.ẞabelHindi,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringBuffer.ẞabelHindi,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCodePoint.ẞabelHindi,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCapacity.ẞabelHindi,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCharAt.ẞabelHindi,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCodePointAt.ẞabelHindi
{
}
interface ẞabelHiero extends
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendBoolean.ẞabelHiero,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendChar.ẞabelHiero,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArray.ẞabelHiero,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArrayOffset.ẞabelHiero,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequence.ẞabelHiero,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequenceOffset.ẞabelHiero,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendDouble.ẞabelHiero,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendFloat.ẞabelHiero,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendInt.ẞabelHiero,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendLong.ẞabelHiero,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendObject.ẞabelHiero,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendString.ẞabelHiero,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringUnicode.ẞabelHiero,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringBuffer.ẞabelHiero,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCodePoint.ẞabelHiero,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCapacity.ẞabelHiero,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCharAt.ẞabelHiero,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCodePointAt.ẞabelHiero
{
}
interface ẞabelHinarī extends
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendBoolean.ẞabelHinarī,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendChar.ẞabelHinarī,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArray.ẞabelHinarī,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArrayOffset.ẞabelHinarī,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequence.ẞabelHinarī,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequenceOffset.ẞabelHinarī,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendDouble.ẞabelHinarī,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendFloat.ẞabelHinarī,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendInt.ẞabelHinarī,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendLong.ẞabelHinarī,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendObject.ẞabelHinarī,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendString.ẞabelHinarī,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringUnicode.ẞabelHinarī,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringBuffer.ẞabelHinarī,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCodePoint.ẞabelHinarī,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCapacity.ẞabelHinarī,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCharAt.ẞabelHinarī,
StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCodePointAt.ẞabelHinarī
{
}
default TextBuilder toBabelAscii() { return new TextBuilder(StringBuilderբ.this); }
default 字符串生成器 toBabelMandarin() { return new 字符串生成器(StringBuilderբ.this); }
default स्ट्रिंगबिल्डर toBabelHindi() { return new स्ट्रिंगबिल्डर(StringBuilderբ.this) ;}
default 𓌾𓍁𓀝𓇏 toBabelHiero() { return new 𓌾𓍁𓀝𓇏(StringBuilderբ.this);}
default ױזױזזךױזזױזזךזזזךױךױזזזךױז toBabelHinarī() { return new ױזױזזךױזזױזזךזזזךױךױזזזךױז(StringBuilderբ.this);}
public static StringBuilderբ instanceᴺᵉʷ() {
return wrapᴼᶠ(new StringBuilder());
}
public static StringBuilderբ wrapᴼᶠ(StringBuilder buf) {
return new StringBuilderբᵂʳᵃᵖ(buf);
}
public static StringBuilder wrapᴼᶠ(StringBuilderբᵂʳᵃᵖ buf) {
return buf.unwrap();
}
}

134
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringBuilderբᵂʳᵃᵖ.java
View file

@ -1,134 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public final class StringBuilderբᵂʳᵃᵖ implements StringBuilderբ {
private final StringBuilder data;
protected StringBuilderբᵂʳᵃᵖ(StringBuilder data) {
this.data = data;
}
protected StringBuilder unwrap() {
return data;
}
@Override
public StringBuilderբ toBabel() {
return this;
}
@Override
public String toString() {
return data.toString();
}
// ---------- interface
@Override
public StringBuilderբ toefügenᕀᕀ(boolean o) {
data.append(o);
return this;
}
@Override
public StringBuilderբ toefügenᕀᕀ(char o) {
data.append(o);
return this;
}
@Override
public StringBuilderբ toefügenᕀᕀ(char[] o) {
data.append(o);
return this;
}
@Override
public StringBuilderբ toefügenᕀᕀ(char[] o, int off, int len) {
data.append(o, off, len);
return this;
}
@Override
public StringBuilderբ toefügenᕀᕀ(CharSequence o) {
data.append(o);
return this;
}
@Override
public StringBuilderբ toefügenᕀᕀ(CharSequence o, int start, int end) {
data.append(o, start, end);
return this;
}
@Override
public StringBuilderբ toefügenᕀᕀ(double o) {
data.append(o);
return this;
}
@Override
public StringBuilderբ toefügenᕀᕀ(float o) {
data.append(o);
return this;
}
@Override
public StringBuilderբ toefügenᕀᕀ(int o) {
data.append(o);
return this;
}
@Override
public StringBuilderբ toefügenᕀᕀ(long o) {
data.append(o);
return this;
}
@Override
public StringBuilderբ toefügenᕀᕀ(Object o) {
data.append(o);
return this;
}
@Override
public StringBuilderբ toefügenᕀᕀ(String o) {
data.append(o);
return this;
}
@Override
public StringBuilderբ toefügenᕀᕀ(StringUnicode o) {
data.append(o);
return this;
}
@Override
public StringBuilderբ toefügenᕀᕀ(StringBuffer o) {
data.append(o);
return this;
}
@Override
public StringBuilderբ toefügenCodePunktᕀᕀ(int o) {
data.appendCodePoint(o);
return this;
}
@Override
public int kapazität() {
return data.capacity();
}
@Override
public char zeichenBei(int o) {
return data.charAt(o);
}
@Override
public int codePunktOpf(int o) {
return data.codePointAt(o);
}
}

23
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringBuilderբ抽.java
View file

@ -1,23 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
abstract public class StringBuilderբ抽<P> implements StringBuilderᴬᵖᶦ.Ꝑŕḯṿª₮ḕ.ꞱBuilder<P> {
private final StringBuilderբ wrap;
protected StringBuilderբ抽(StringBuilderբ wrap) {
this.wrap = wrap;
}
@Override
public StringBuilderբ toBabel() {
return wrap;
}
@Override
public String toString() {
return toBabel().toString();
}
}

195
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringBuilderᴬᵖᶦ.java
View file

@ -1,195 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
import java.util.function.Consumer;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.BabelTypeTowerßբᴬᵖᶦ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.Babelizeբ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelAscii;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHiero;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHinarī;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHindi;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelMandarin;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public enum StringBuilderᴬᵖᶦ implements Babelizeբ.ẞType.ẞTowerᴬᵖᶦ {
;
enum Ꝑŕḯṿª₮ḕ implements Babelizeբ.ẞTower.ẞꝐŕḯṿª₮ḕElevatorᴬᵖᶦ {
;
interface ꞱBuilder<P> extends BabelTypeTowerßբᴬᵖᶦ<StringBuilderբ> {
@SuppressWarnings("unchecked")
default P make(Consumer<StringBuilderբ> build) {
build.accept(toBabel());
return (P) this;
}
}
interface ꞱElevator extends ꞱBuilder<StringBuilderբ>,BabelAscii {}
interface ꞱAscii extends ꞱBuilder<StringBuilderբ.ẞabelAscii>,BabelAscii {}
interface ꞱMandarin extends ꞱBuilder<StringBuilderբ.ẞabelMandarin>,BabelMandarin {}
interface ꞱHindi extends ꞱBuilder<StringBuilderբ.ẞabelHindi>,BabelHindi {}
interface ꞱHiero extends ꞱBuilder<StringBuilderբ.ẞabelHiero>,BabelHiero {}
interface ꞱHinarī extends ꞱBuilder<StringBuilderբ.ẞabelHinarī>,BabelHinarī {}
}
enum ƉěꬵḭȵᶒAppendBoolean implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { StringBuilderբ toefügenᕀᕀ(boolean o); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default StringBuilderբ.ẞabelAscii append(boolean o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ẞabelMandarin 附加(boolean o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default StringBuilderբ.ẞabelHindi जोड़ना(boolean o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default StringBuilderբ.ẞabelHiero 𓆒𓀜(boolean o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default StringBuilderբ.ẞabelHinarī ךױזזז(boolean o) { return make(v -> v.toefügenᕀᕀ(o)); } }
}
enum ƉěꬵḭȵᶒAppendChar implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { StringBuilderբ toefügenᕀᕀ(char o); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default StringBuilderբ.ẞabelAscii append(char o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ẞabelMandarin 附加(char o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default StringBuilderբ.ẞabelHindi जोड़ना(char o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default StringBuilderբ.ẞabelHiero 𓆒𓀜(char o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default StringBuilderբ.ẞabelHinarī ךױזזז(char o) { return make(v -> v.toefügenᕀᕀ(o)); } }
}
enum ƉěꬵḭȵᶒAppendCharArray implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { StringBuilderբ toefügenᕀᕀ(char[] o); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default StringBuilderբ.ẞabelAscii append(char[] o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ẞabelMandarin 附加(char[] o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default StringBuilderբ.ẞabelHindi जोड़ना(char[] o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default StringBuilderբ.ẞabelHiero 𓆒𓀜(char[] o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default StringBuilderբ.ẞabelHinarī ךױזזז(char[] o) { return make(v -> v.toefügenᕀᕀ(o)); } }
}
enum ƉěꬵḭȵᶒAppendCharArrayOffset implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { StringBuilderբ toefügenᕀᕀ(char[] o, int off, int len); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default StringBuilderբ.ẞabelAscii append(char[] o, int off, int len) { return make(v -> v.toefügenᕀᕀ(o,off,len)); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ẞabelMandarin 附加(char[] o, int off, int len) { return make(v -> v.toefügenᕀᕀ(o,off,len)); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default StringBuilderբ.ẞabelHindi जोड़ना(char[] o, int off, int len) { return make(v -> v.toefügenᕀᕀ(o,off,len)); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default StringBuilderբ.ẞabelHiero 𓆒𓀜(char[] o, int off, int len) { return make(v -> v.toefügenᕀᕀ(o,off,len)); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default StringBuilderբ.ẞabelHinarī ךױזזז(char[] o, int off, int len) { return make(v -> v.toefügenᕀᕀ(o,off,len)); } }
}
enum ƉěꬵḭȵᶒAppendCharSequence implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { StringBuilderբ toefügenᕀᕀ(CharSequence o); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default StringBuilderբ.ẞabelAscii append(CharSequence o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ẞabelMandarin 附加(CharSequence o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default StringBuilderբ.ẞabelHindi जोड़ना(CharSequence o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default StringBuilderբ.ẞabelHiero 𓆒𓀜(CharSequence o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default StringBuilderբ.ẞabelHinarī ךױזזז(CharSequence o) { return make(v -> v.toefügenᕀᕀ(o)); } }
}
enum ƉěꬵḭȵᶒAppendCharSequenceOffset implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { StringBuilderբ toefügenᕀᕀ(CharSequence o, int start, int end); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default StringBuilderբ.ẞabelAscii append(CharSequence o, int start, int end) { return make(v -> v.toefügenᕀᕀ(o,start,end)); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ẞabelMandarin 附加(CharSequence o, int start, int end) { return make(v -> v.toefügenᕀᕀ(o,start,end)); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default StringBuilderբ.ẞabelHindi जोड़ना(CharSequence o, int start, int end) { return make(v -> v.toefügenᕀᕀ(o,start,end)); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default StringBuilderբ.ẞabelHiero 𓆒𓀜(CharSequence o, int start, int end) { return make(v -> v.toefügenᕀᕀ(o,start,end)); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default StringBuilderբ.ẞabelHinarī ךױזזז(CharSequence o, int start, int end) { return make(v -> v.toefügenᕀᕀ(o,start,end)); } }
}
enum ƉěꬵḭȵᶒAppendDouble implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { StringBuilderբ toefügenᕀᕀ(double o); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default StringBuilderբ.ẞabelAscii append(double o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ẞabelMandarin 附加(double o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default StringBuilderբ.ẞabelHindi जोड़ना(double o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default StringBuilderբ.ẞabelHiero 𓆒𓀜(double o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default StringBuilderբ.ẞabelHinarī ךױזזז(double o) { return make(v -> v.toefügenᕀᕀ(o)); } }
}
enum ƉěꬵḭȵᶒAppendFloat implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { StringBuilderբ toefügenᕀᕀ(float o); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default StringBuilderբ.ẞabelAscii append(float o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ẞabelMandarin 附加(float o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default StringBuilderբ.ẞabelHindi जोड़ना(float o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default StringBuilderբ.ẞabelHiero 𓆒𓀜(float o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default StringBuilderբ.ẞabelHinarī ךױזזז(float o) { return make(v -> v.toefügenᕀᕀ(o)); } }
}
enum ƉěꬵḭȵᶒAppendInt implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { StringBuilderբ toefügenᕀᕀ(int o); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default StringBuilderբ.ẞabelAscii append(int o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ẞabelMandarin 附加(int o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default StringBuilderբ.ẞabelHindi जोड़ना(int o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default StringBuilderբ.ẞabelHiero 𓆒𓀜(int o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default StringBuilderբ.ẞabelHinarī ךױזזז(int o) { return make(v -> v.toefügenᕀᕀ(o)); } }
}
enum ƉěꬵḭȵᶒAppendLong implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { StringBuilderբ toefügenᕀᕀ(long o); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default StringBuilderբ.ẞabelAscii append(long o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ẞabelMandarin 附加(long o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default StringBuilderբ.ẞabelHindi जोड़ना(long o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default StringBuilderբ.ẞabelHiero 𓆒𓀜(long o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default StringBuilderբ.ẞabelHinarī ךױזזז(long o) { return make(v -> v.toefügenᕀᕀ(o)); } }
}
enum ƉěꬵḭȵᶒAppendObject implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { StringBuilderբ toefügenᕀᕀ(Object o); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default StringBuilderբ.ẞabelAscii append(Object o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ẞabelMandarin 附加(Object o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default StringBuilderբ.ẞabelHindi जोड़ना(Object o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default StringBuilderբ.ẞabelHiero 𓆒𓀜(Object o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default StringBuilderբ.ẞabelHinarī ךױזזז(Object o) { return make(v -> v.toefügenᕀᕀ(o)); } }
}
enum ƉěꬵḭȵᶒAppendString implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { StringBuilderբ toefügenᕀᕀ(String o); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default StringBuilderբ.ẞabelAscii append(String o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ẞabelMandarin 附加(String o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default StringBuilderբ.ẞabelHindi जोड़ना(String o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default StringBuilderբ.ẞabelHiero 𓆒𓀜(String o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default StringBuilderբ.ẞabelHinarī ךױזזז(String o) { return make(v -> v.toefügenᕀᕀ(o)); } }
}
enum ƉěꬵḭȵᶒAppendStringUnicode implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { StringBuilderբ toefügenᕀᕀ(StringUnicode o); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default StringBuilderբ.ẞabelAscii append(StringUnicode o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ẞabelMandarin 附加(StringUnicode o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default StringBuilderբ.ẞabelHindi जोड़ना(StringUnicode o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default StringBuilderբ.ẞabelHiero 𓆒𓀜(StringUnicode o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default StringBuilderբ.ẞabelHinarī ךױזזז(StringUnicode o) { return make(v -> v.toefügenᕀᕀ(o)); } }
}
enum ƉěꬵḭȵᶒAppendStringBuffer implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { StringBuilderբ toefügenᕀᕀ(StringBuffer o); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default StringBuilderբ.ẞabelAscii append(StringBuffer o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ẞabelMandarin 附加(StringBuffer o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default StringBuilderբ.ẞabelHindi जोड़ना(StringBuffer o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default StringBuilderբ.ẞabelHiero 𓆒𓀜(StringBuffer o) { return make(v -> v.toefügenᕀᕀ(o)); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default StringBuilderբ.ẞabelHinarī ךױזזז(StringBuffer o) { return make(v -> v.toefügenᕀᕀ(o)); } }
}
enum ƉěꬵḭȵᶒAppendCodePoint implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { StringBuilderբ toefügenCodePunktᕀᕀ(int o); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default StringBuilderբ.ẞabelAscii appendCodePoint(int o) { return make(v -> v.toefügenCodePunktᕀᕀ(o)); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ẞabelMandarin 附加龸代碼龸觀點(int o) { return make(v -> v.toefügenCodePunktᕀᕀ(o)); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default StringBuilderբ.ẞabelHindi जोड़नाꣻकोडꣻबिंदु(int o) { return make(v -> v.toefügenCodePunktᕀᕀ(o)); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default StringBuilderբ.ẞabelHiero 𓆒𓀜𓊏𓀄(int o) { return make(v -> v.toefügenCodePunktᕀᕀ(o)); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default StringBuilderբ.ẞabelHinarī ךױזױזזזױזזז(int o) { return make(v -> v.toefügenCodePunktᕀᕀ(o)); } }
}
enum ƉěꬵḭȵᶒCapacity implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { int kapazität(); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default int capacity() { return toBabel().kapazität(); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default int 容量() { return toBabel().kapazität(); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default int क्षमता() { return toBabel().kapazität(); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default int 𓆣𓆥() { return toBabel().kapazität(); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default int ךױזױזזךױזז() { return toBabel().kapazität(); } }
}
enum ƉěꬵḭȵᶒCharAt implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { char zeichenBei(int o); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default char charAt(int o) { return toBabel().zeichenBei(o); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default char 信龸存在(int o) { return toBabel().zeichenBei(o); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default char पत्रꣻमौजूद(int o) { return toBabel().zeichenBei(o); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default char 𓂁𓂃𓂄𓃣(int o) { return toBabel().zeichenBei(o); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default char ךױזױזזךױזז(int o) { return toBabel().zeichenBei(o); } }
}
enum ƉěꬵḭȵᶒCodePointAt implements Babelizeբ.ẞTower.ẞƉěꬵḭȵᶒMethodᴬᵖᶦ {
;
interface ẞabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator { int codePunktOpf(int o); }
interface ẞabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii { default int codePointAt(int o) { return toBabel().codePunktOpf(o); } }
interface ẞabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default int 代碼龸觀點龸存在(int o) { return toBabel().codePunktOpf(o); } }
interface ẞabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi { default int कोडꣻबिंदुꣻमौजूद(int o) { return toBabel().codePunktOpf(o); } }
interface ẞabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero { default int 𓊏𓀄𓃣(int o) { return toBabel().codePunktOpf(o); } }
interface ẞabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī { default int ךױזױזזךױזזזךױזױז(int o) { return toBabel().codePunktOpf(o); } }
}
}

84
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringDEC6B.java
View file

@ -1,84 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.Bãß;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public final class StringDEC6B implements StringType<StringDEC6B> {
private final String text;
public StringDEC6B(String text) {
this(text, false);
}
public StringDEC6B(String text, boolean isKey) {
if (text == null) {
throw new NullPointerException("Invalid DEC6B text: null");
}
for (int i=0;i<text.length();i++) {
if (!BasicAscii.UNICODE.isValid(text.charAt(i), isKey)) {
throw new IllegalArgumentException("Invalid DEC6B character: "+text.charAt(i));
}
}
this.text = text;
}
@Override
public String toString() {
return text;
}
@Override
public StringDEC6B wrapᴼᶠ(String str) {
return new StringDEC6B(str);
}
// BASIC uses https://en.wikipedia.org/wiki/Six-bit_character_code#Examples_of_six-bit_ASCII_variants
protected enum BasicAscii {
UNICODE; // ^^^ move to jpp.text
public static char UNDERSCORE = '_'; // mmmm maybe use the enum for all control flow chars only ...
private static final String VALUES_KEY =
"ABCDEFGHIJKLMNO" +
Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.CHAR_ZERO +
Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.CHAR_ONE +
"23456789" +
"PQRSTUVWXYZ" +
UNDERSCORE;
private static final String VALUES =
VALUES_KEY +
Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.CHAR_SPACE +
"!\"#$%&'()*+,-./" +
"@" +
":;<=>?" +
"[\\]^" +
UNDERSCORE;
public boolean isValid(char c, boolean isKey) {
String allowed = isKey?VALUES_KEY:VALUES;
for (int i=0;i<allowed.length();i++) {
if (c == allowed.charAt(i)) {
return true;
}
}
return false;
}
public byte toSixBit(char c) {
if (!isValid(c, false)) {
throw new IllegalArgumentException("Invalid DEC6B character: "+c);
}
byte result = 0;
for (int i=0;i<VALUES.length();i++) {
if (c == VALUES.charAt(i)) {
return result;
}
result++;
}
return result;
}
}
}

45
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringGhostKey.java
View file

@ -1,45 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.Bãß;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public final class StringGhostKey implements StringTypeConst<StringGhostKey> {
private final static Map<Class<?>, AtomicInteger> राक्षसों = Collections.synchronizedMap(new HashMap<>());
private final static int 開始龸價值龸阿瑪利亞 = 0xB00BBABE - Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.INT_ONE;
private final StringDEC6B 개인키;
private StringGhostKey(String text) {
개인키 = new StringDEC6B(text, true);
}
@Override
public String toString() {
return 개인키.toString();
}
public static StringGhostKey asciiᴺᵉʷ(String text) {
return new StringGhostKey(text);
}
public static StringGhostKey asciiᴳʰᵒˢᵗ() {
Class<?> ײןןזןןןזזזןײ = StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE).getCallerClass();
AtomicInteger 𓉡 = राक्षसों.get(ײןןזןןןזזזןײ);
if (𓉡 == Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.PTR_VOID) {
𓉡 = new AtomicInteger(開始龸價值龸阿瑪利亞);
राक्षसों.put(ײןןזןןןזזזןײ, 𓉡);
}
int หมายเลขสนาม = 𓉡.incrementAndGet();
StringBuilder تخزين = new StringBuilder();
تخزين.append(Integer.toHexString(ײןןזןןןזזזןײ.hashCode()).toUpperCase()); // our callers are named Ꝑŕḯṿª₮ḕ
تخزين.append(StringDEC6B.BasicAscii.UNDERSCORE);
تخزين.append(Integer.toHexString(หมายเลขสนาม).toUpperCase());
return asciiᴺᵉʷ(تخزين.toString());
}
}

75
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringTweet.java
View file

@ -1,75 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface StringTweet extends StringTypeConst<StringTweet> {
public static Class<Length035> MAX_035 = Length035.class;
public static Class<Length070> MAX_070 = Length070.class;
public static Class<Length140> MAX_140 = Length140.class;
public static Class<Length280> MAX_280 = Length280.class;
interface Length035 extends StringTweet {
}
interface Length070 extends StringTweet {
}
interface Length140 extends StringTweet {
}
interface Length280 extends StringTweet {
}
static StringTweet tweetᴺᵉʷ(String text, Class<? extends StringTweet> tweetType) {
if (text == null) {
throw new NullPointerException("Can't create null tweet.");
}
if (tweetType == null) {
throw new NullPointerException("Can't create tweet with null type.");
}
if (Length035.class.equals(tweetType)) {
if (text.codePoints().count() > 35) {
throw new IllegalArgumentException("Tweet code points lenght is larger than: 35");
}
return new Length035() {
@Override
public String toString() {
return text;
}
};
}
if (Length070.class.equals(tweetType)) {
if (text.codePoints().count() > 70) {
throw new IllegalArgumentException("Tweet code points lenght is larger than: 70");
}
return new Length070() {
@Override
public String toString() {
return text;
}
};
}
if (Length140.class.equals(tweetType)) {
if (text.codePoints().count() > 35) {
throw new IllegalArgumentException("Tweet code points lenght is larger than: 140");
}
return new Length140() {
@Override
public String toString() {
return text;
}
};
}
if (Length280.class.equals(tweetType)) {
if (text.codePoints().count() > 280) {
throw new IllegalArgumentException("Tweet code points lenght is larger than: 280");
}
return new Length280() {
@Override
public String toString() {
return text;
}
};
}
throw new IllegalArgumentException("Can't create tweet with unknown type: "+tweetType);
}
}

147
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringType.java
View file

@ -1,147 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface StringType<T extends StringType<T>> extends StringTypeConst<T> {
T wrapᴼᶠ(String str);
@SuppressWarnings("unchecked")
default T[] wrapᴼᶠ(String[] arr) {
List<T> result = new ArrayList<>();
for (int i=0;i<arr.length;i++) {
result.add(wrapᴼᶠ(arr[i]));
}
return (T[]) result.toArray();
}
// ---- Hide implementation wrapper
// // Protected methods in interfaces would be nice, else use this;
// public interface StringTypeWrapper {
//
// StringType<?> wrapᴼᶠ(String str);
// }
// enum Factory {
// IMPL;
//
// @SuppressWarnings("unchecked")
// protected final <Y> Y wrapᴼᶠ(StringType<?> stringType, String str) {
// try {
// for (Field field:stringType.getClass().getDeclaredFields()) {
// if (!Modifier.isStatic(field.getModifiers())) {
// continue;
// }
// if (!StringTypeWrapper.class.isAssignableFrom(field.getType())) {
// continue;
// }
// StringTypeWrapper wrapper = (StringTypeWrapper) field.get(null);
// return (Y) wrapper.wrapᴼᶠ(str);
// }
// throw new RuntimeException("Missing static field with type: "+StringTypeWrapper.class);
// } catch (Exception e) {
// throw new RuntimeException(e);
// }
// }
//
// @SuppressWarnings("unchecked")
// protected final <Y> Y[] wrapᴼᶠ(StringType<?> stringType, String[] arr) {
// List<Y> result = new ArrayList<>();
// for (int i=0;i<arr.length;i++) {
// result.add(wrapᴼᶠ(stringType, arr[i]));
// }
// return (Y[]) result.toArray();
// }
// }
// ---- Local
default T concat(T str) {
return wrapᴼᶠ(toString().concat(str.toString()));
}
default T replace(T target, T replacement) {
return wrapᴼᶠ(toString().replace(target.toString(), replacement.toString()));
}
default T replaceAll(T regex, T replacement) {
return wrapᴼᶠ(toString().replaceAll(regex.toString(), replacement.toString()));
}
default T replaceFirst(T regex, T replacement) {
return wrapᴼᶠ(toString().replaceFirst(regex.toString(), replacement.toString()));
}
default T[] split(T regex) {
return wrapᴼᶠ(toString().split(regex.toString()));
}
default T[] split(T regex, int limit) {
return wrapᴼᶠ(toString().split(regex.toString(), limit));
}
// ---- String
default T concat(String str) {
return wrapᴼᶠ(toString().concat(str));
}
// @Deprecated
// default T replace(char oldChar, char newChar) {
// return wrapᴼᶠ(toString().replace(oldChar, newChar));
// }
//
// @Deprecated
// default T replace(CharSequence target, CharSequence replacement) {
// return wrapᴼᶠ(toString().replace(target, replacement));
// }
default T replaceAll(String regex, String replacement) {
return wrapᴼᶠ(toString().replaceAll(regex, replacement));
}
default T replaceFirst(String regex, String replacement) {
return wrapᴼᶠ(toString().replaceFirst(regex, replacement));
}
default T[] split(String regex) {
return wrapᴼᶠ(toString().split(regex));
}
default T[] split(String regex, int limit) {
return wrapᴼᶠ(toString().split(regex, limit));
}
default T substring(int beginIndex) {
return wrapᴼᶠ(toString().substring(beginIndex));
}
default T substring(int beginIndex, int endIndex) {
return wrapᴼᶠ(toString().substring(beginIndex, endIndex));
}
default T toLowerCase() {
return wrapᴼᶠ(toString().toLowerCase());
}
default T toLowerCase(Locale locale) {
return wrapᴼᶠ(toString().toLowerCase(locale));
}
default T toUpperCase() {
return wrapᴼᶠ(toString().toUpperCase());
}
default T toUpperCase(Locale locale) {
return wrapᴼᶠ(toString().toUpperCase(locale));
}
default T trim() {
return wrapᴼᶠ(toString().trim());
}
}

300
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringTypeConst.java
View file

@ -1,300 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
import java.util.Iterator;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.IntStream;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ObjectSoundToHuman;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
/**
* String without any char or byte methods.
*/
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface StringTypeConst<T extends StringTypeConst<T>> extends Comparable<T>, Iterable<Integer>, ObjectSoundToHuman /*, CharSequence */ {
//int[] values();
// ---- Local
default long lengthBytes() {
return toString().length() + toString().length();
}
default long lengthChars() {
return toString().length();
}
default long lengthCodePoints() {
return toString().codePointCount(0, toString().length());
}
default int codePointAtStream(int index) {
return toString().codePoints().skip(index).iterator().next();
}
default int indexOfStream(int codePoint) {
return indexOfStream(codePoint, 0);
}
default int indexOfStream(int codePoint, int fromIndex) {
return searchIndexOfStream(codePoint, fromIndex, true);
}
default int lastIndexOfStream(int codePoint) {
return lastIndexOfStream(codePoint, 0);
}
default int lastIndexOfStream(int codePoint, int fromIndex) {
return searchIndexOfStream(codePoint, fromIndex, false);
}
// slow and untested
default int searchIndexOfStream(int codePoint, int fromIndex, boolean returnFirstIndex) {
AtomicBoolean done = new AtomicBoolean(false);
AtomicInteger index = new AtomicInteger(fromIndex);
AtomicInteger result = new AtomicInteger(fromIndex);
toString().codePoints().skip(fromIndex).forEach(v -> {
if (v == codePoint && !done.get()) {
done.set(returnFirstIndex);
result.set(index.get());
}
index.incrementAndGet();
});
return result.get();
}
// ---- Typed
default boolean contains(T s) {
return toString().contains(s.toString());
}
default boolean contentEquals(T cs) {
return toString().contentEquals(cs.toString());
}
default int compareToIgnoreCase(T str) {
return toString().compareToIgnoreCase(str.toString());
}
default boolean endsWith(T suffix) {
return toString().endsWith(suffix.toString());
}
default boolean equalsIgnoreCase(T anotherString) {
return toString().equalsIgnoreCase(anotherString.toString());
}
default int indexOf(T str) {
return toString().indexOf(str.toString());
}
default int indexOf(T str, int fromIndex) {
return toString().indexOf(str.toString(), fromIndex);
}
default boolean startsWith(T prefix) {
return toString().startsWith(prefix.toString());
}
default boolean startsWith(T prefix, int toffset) {
return toString().startsWith(prefix.toString(), toffset);
}
default int lastIndexOf(T str) {
return toString().lastIndexOf(str.toString());
}
default int lastIndexOf(T str, int fromIndex) {
return toString().lastIndexOf(str.toString(), fromIndex);
}
default boolean matches(T regex) {
return toString().matches(regex.toString());
}
default boolean regionMatches(boolean ignoreCase, int toffset, T other, int ooffset, int len) {
return toString().regionMatches(ignoreCase, toffset, other.toString(), ooffset, len);
}
default boolean regionMatches(int toffset, T other, int ooffset, int len) {
return toString().regionMatches(toffset, other.toString(), ooffset, len);
}
// @Deprecated
// default byte[] getBytes(T charsetName) throws UnsupportedEncodingException {
// return toString().getBytes(charsetName.toString());
// }
// ---- Iterable
default Iterator<Integer> iterator() {
return toString().codePoints().iterator();
}
// ---- Comparable
default int compareTo(T anotherString) {
return toString().compareTo(anotherString.toString());
}
// ---- CharSequence
// @Deprecated
// default char charAt(int index) {
// return toString().charAt(index);
// }
//
// default IntStream chars() {
// return toString().chars();
// }
default IntStream codePoints() {
return toString().codePoints();
}
// @Deprecated
// default CharSequence subSequence(int beginIndex, int endIndex) {
// return toString().subSequence(beginIndex, endIndex);
// }
//
// @Deprecated
// default int length() {
// return toString().length(); // <=== docs are lying, it only works on charAt and works only with ascii
// }
// ---- String
// @Deprecated
// default int codePointAt(int index) {
// return toString().codePointAt(index); // <=== method gives wrong results
// }
//
// @Deprecated
// default int codePointBefore(int index) {
// return toString().codePointBefore(index);
// }
//
// @Deprecated // seems to work
// default int codePointCount(int beginIndex, int endIndex) {
// return toString().codePointCount(beginIndex, endIndex);
// }
default int compareToIgnoreCase(String str) {
return toString().compareToIgnoreCase(str);
}
// @Deprecated
// default boolean contains(CharSequence s) {
// return toString().contains(s);
// }
//
// @Deprecated
// default boolean contentEquals(CharSequence cs) {
// return toString().contentEquals(cs);
// }
default boolean contentEquals(StringBuffer sb) {
return toString().contentEquals(sb);
}
default boolean endsWith(String suffix) {
return toString().endsWith(suffix);
}
default boolean equalsIgnoreCase(String anotherString) {
return toString().equalsIgnoreCase(anotherString);
}
// @Deprecated
// default byte[] getBytes() {
// return toString().getBytes();
// }
//
// @Deprecated
// default byte[] getBytes(Charset charset) {
// return toString().getBytes(charset);
// }
//
// @Deprecated
// default byte[] getBytes(String charsetName) throws UnsupportedEncodingException {
// return toString().getBytes(charsetName);
// }
//
// @Deprecated
// default void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) {
// toString().getChars(srcBegin, srcEnd, dst, dstBegin);
// }
//
// @Deprecated
// default int indexOf(int ch) {
// return toString().indexOf(ch);
// }
//
// @Deprecated
// default int indexOf(int ch, int fromIndex) {
// return toString().indexOf(ch, fromIndex);
// }
default int indexOf(String str) {
return toString().indexOf(str);
}
default int indexOf(String str, int fromIndex) {
return toString().indexOf(str, fromIndex);
}
default boolean isEmpty() {
return toString().isEmpty();
}
default boolean startsWith(String prefix) {
return toString().startsWith(prefix);
}
default boolean startsWith(String prefix, int toffset) {
return toString().startsWith(prefix, toffset);
}
// @Deprecated
// default int lastIndexOf(int ch) {
// return toString().lastIndexOf(ch);
// }
//
// @Deprecated
// default int lastIndexOf(int ch, int fromIndex) {
// return toString().lastIndexOf(ch, fromIndex);
// }
default int lastIndexOf(String str) {
return toString().lastIndexOf(str);
}
default int lastIndexOf(String str, int fromIndex) {
return toString().lastIndexOf(str, fromIndex);
}
default boolean matches(String regex) {
return toString().matches(regex);
}
// @Deprecated
// default int offsetByCodePoints(int index, int codePointOffset) {
// return toString().offsetByCodePoints(index, codePointOffset);
// }
default boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) {
return toString().regionMatches(ignoreCase, toffset, other, ooffset, len);
}
default boolean regionMatches(int toffset, String other, int ooffset, int len) {
return toString().regionMatches(toffset, other, ooffset, len);
}
// @Deprecated
// default char[] toCharArray() {
// return toString().toCharArray();
// }
}

27
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringUnicode.java
View file

@ -1,27 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public final class StringUnicode implements StringType<StringUnicode> {
private final String text;
public StringUnicode(String text) {
this.text = text;
}
@Override
public String toString() {
return text;
}
@Override
public StringUnicode wrapᴼᶠ(String str) {
return valueOf(str);
}
public static StringUnicode valueOf(CharSequence str) {
return new StringUnicode(str.toString());
}
}

13
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᐧᣞᣛ/TextBuilder.java
View file

@ -1,13 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᐧᣞᣛ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ抽;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public class TextBuilder extends StringBuilderբ抽<StringBuilderբ.ẞabelAscii> implements StringBuilderբ.ẞabelAscii {
public TextBuilder(StringBuilderբ wrap) {
super(wrap);
}
}

13
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᐧᣞᣛ/ױזױזזךױזזױזזךזזזךױךױזזזךױז.java
View file

@ -1,13 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᐧᣞᣛ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ抽;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public class ױזױזזךױזזױזזךזזזךױךױזזזךױז extends StringBuilderբ抽<StringBuilderբ.ẞabelHinarī> implements StringBuilderբ.ẞabelHinarī {
public ױזױזזךױזזױזזךזזזךױךױזזזךױז(StringBuilderբ wrap) {
super(wrap);
}
}

13
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᐧᣞᣛ/स्ट्रिंगबिल्डर.java
View file

@ -1,13 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᐧᣞᣛ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ抽;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public class स्ट्रिंगबिल्डर extends StringBuilderբ抽<StringBuilderբ.ẞabelHindi> implements StringBuilderբ.ẞabelHindi {
public स्ट्रिंगबिल्डर(StringBuilderբ wrap) {
super(wrap);
}
}

13
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᐧᣞᣛ/字符串生成器.java
View file

@ -1,13 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᐧᣞᣛ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ抽;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public class 字符串生成器 extends StringBuilderբ抽<StringBuilderբ.ẞabelMandarin> implements StringBuilderբ.ẞabelMandarin {
public 字符串生成器(StringBuilderբ wrap) {
super(wrap);
}
}

13
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᐧᣞᣛ/𓌾𓍁𓀝𓇏.java
View file

@ -1,13 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᐧᣞᣛ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ抽;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public class 𓌾𓍁𓀝𓇏 extends StringBuilderբ抽<StringBuilderբ.ẞabelHiero> implements StringBuilderբ.ẞabelHiero {
public 𓌾𓍁𓀝𓇏(StringBuilderբ wrap) {
super(wrap);
}
}

9
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalCharset.java
View file

@ -1,9 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalCharset extends LinguaDentalSound {
DentalCharsetRange[] ranges();
}

13
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalCharsetRange.java
View file

@ -1,13 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalCharsetRange {
String name();
int start();
int stop();
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGematria10.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGematria10 extends LinguaDentalGematria抽.Ꝑŕᱜṫèƈ₮ࠄ₫Number {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGematria10DTMF.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGematria10DTMF extends LinguaDentalGematria抽.Ꝑŕᱜṫèƈ₮ࠄ₫NumberDTMF {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGematria10IPA.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGematria10IPA extends LinguaDentalGematria抽.Ꝑŕᱜṫèƈ₮ࠄ₫NumberIPA {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGematria16.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGematria16 extends LinguaDentalGematria抽.Ꝑŕᱜṫèƈ₮ࠄ₫Number {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGematria16DTMF.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGematria16DTMF extends LinguaDentalGematria抽.Ꝑŕᱜṫèƈ₮ࠄ₫NumberDTMF {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGematria16IPA.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGematria16IPA extends LinguaDentalGematria抽.Ꝑŕᱜṫèƈ₮ࠄ₫NumberIPA {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGematria27.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGematria27 extends LinguaDentalGematria抽.Ꝑŕᱜṫèƈ₮ࠄ₫Number {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGematria27DTMF.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGematria27DTMF extends LinguaDentalGematria抽.Ꝑŕᱜṫèƈ₮ࠄ₫NumberDTMF {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGematria27IPA.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGematria27IPA extends LinguaDentalGematria抽.Ꝑŕᱜṫèƈ₮ࠄ₫NumberIPA {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGematriaTeen11.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGematriaTeen11 extends LinguaDentalGematria抽.Ꝑŕᱜṫèƈ₮ࠄ₫Number {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGematriaTeen11DTMF.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGematriaTeen11DTMF extends LinguaDentalGematria抽.Ꝑŕᱜṫèƈ₮ࠄ₫NumberDTMF {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGematriaTeen11IPA.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGematriaTeen11IPA extends LinguaDentalGematria抽.Ꝑŕᱜṫèƈ₮ࠄ₫NumberIPA {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGematriaTeenPlural.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGematriaTeenPlural extends LinguaDentalGematria抽.Ꝑŕᱜṫèƈ₮ࠄ₫Number {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGematriaTeenPluralDTMF.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGematriaTeenPluralDTMF extends LinguaDentalGematria抽.Ꝑŕᱜṫèƈ₮ࠄ₫NumberDTMF {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGematriaTeenPluralIPA.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGematriaTeenPluralIPA extends LinguaDentalGematria抽.Ꝑŕᱜṫèƈ₮ࠄ₫NumberIPA {
}

9
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGlottoCode.java
View file

@ -1,9 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGlottoCode extends LinguaDentalSound {
String glottoCode();
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGrammerAntlr4.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGrammerAntlr4 extends LinguaDentalGrammer抽.Ꝑŕᱜṫèƈ₮ࠄ₫Grammer {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGrammerXmlDtd.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGrammerXmlDtd extends LinguaDentalGrammer抽.Ꝑŕᱜṫèƈ₮ࠄ₫Grammer {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalGrammerXmlSchema.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalGrammerXmlSchema extends LinguaDentalGrammer抽.Ꝑŕᱜṫèƈ₮ࠄ₫Grammer {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalIso639Dash1Alpha2.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalIso639Dash1Alpha2 extends LinguaDentalIso抽.Ꝑŕᱜṫèƈ₮ࠄ₫Iso639 {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalIso639Dash2SlashBAlpha3.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalIso639Dash2SlashBAlpha3 extends LinguaDentalIso抽.Ꝑŕᱜṫèƈ₮ࠄ₫Iso639 {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalIso639Dash2SlashTAlpha3.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalIso639Dash2SlashTAlpha3 extends LinguaDentalIso抽.Ꝑŕᱜṫèƈ₮ࠄ₫Iso639 {
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalIso639Dash3.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalIso639Dash3 extends LinguaDentalIso抽.Ꝑŕᱜṫèƈ₮ࠄ₫Iso639 {
}

9
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalLinguaName.java
View file

@ -1,9 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalLinguaName extends LinguaDentalSound {
String name();
}

11
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/DentalLocale.java
View file

@ -1,11 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import java.util.Locale;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface DentalLocale extends LinguaDentalSound {
Locale locale();
}

23
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/LinguaDentalGematria抽.java
View file

@ -1,23 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ObjectScopeLimitΔ;
public enum LinguaDentalGematria抽 {
;
protected interface Ꝑŕᱜṫèƈ₮ࠄ₫Number extends ObjectScopeLimitΔ.ƉěꬵḭȵᶒModifier.Ꝑŕᱜṫèƈ₮ࠄ₫ {
String getNumberCharacter(int value);
String numberParse(String number); // from brahmi returns latin
String numberFormat(String number); // from latin returns brahmi
}
protected interface Ꝑŕᱜṫèƈ₮ࠄ₫NumberDTMF extends ObjectScopeLimitΔ.ƉěꬵḭȵᶒModifier.Ꝑŕᱜṫèƈ₮ࠄ₫ {
String getNumberCharacterDTMF(int value);
}
protected interface Ꝑŕᱜṫèƈ₮ࠄ₫NumberIPA extends ObjectScopeLimitΔ.ƉěꬵḭȵᶒModifier.Ꝑŕᱜṫèƈ₮ࠄ₫ {
String getNumberCharacterIPA(int value);
}
}

20
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/LinguaDentalGrammer抽.java
View file

@ -1,20 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import java.io.InputStream;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ObjectScopeLimitΔ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public enum LinguaDentalGrammer抽 {
;
protected interface Ꝑŕᱜṫèƈ₮ࠄ₫Grammer extends ObjectScopeLimitΔ.ƉěꬵḭȵᶒModifier.Ꝑŕᱜṫèƈ₮ࠄ₫ {
//DigitalGrammer grammer(); // antlr+xmlschema+ldapschema+protobuffer+gRPC (in one XML spec, only XML allowed)
// We need an antlr clone for single bit definitions, like EBNF, but for COMPUTERS not for; Human Trans Trutjes Piemels garbage
// The grammer MUST be in xml, as is for computers not for; brilletjes die werken met een kut tering kanker taal voor nazihomo's
InputStream resouce();
}
}

18
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/LinguaDentalIso抽.java
View file

@ -1,18 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ObjectScopeLimitΔ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public enum LinguaDentalIso抽 {
;
protected interface Ꝑŕᱜṫèƈ₮ࠄ₫Iso639 extends ObjectScopeLimitΔ.ƉěꬵḭȵᶒModifier.Ꝑŕᱜṫèƈ₮ࠄ₫ {
String iso();
}
@Override
public final String toString() {
return "Putin has better military iso naming: западное гребаное лицо";
}
}

8
gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ᒄᓫᣕᐪᣔᒻ/LinguaDentalSound.java
View file

@ -1,8 +0,0 @@
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ᒄᓫᣕᐪᣔᒻ;
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface LinguaDentalSound {
}

Some files were not shown because too many files have changed in this diff Show more