Willem
af78169898
All checks were successful
Run test asserts / Test-Asserts (push) Successful in 1m23s
482 lines
22 KiB
Java
482 lines
22 KiB
Java
/*
|
|
* Copyright ©Δ∞ 仙上主天
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification, are permitted provided
|
|
* that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright notice, this list of conditions and the
|
|
* following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
|
|
* the following disclaimer in the documentation and/or other materials provided with the distribution.
|
|
* * The prime PI creator license super seeds all other licenses, this license is overly invasive,
|
|
* thus every digital artifact is automatically taken over by this license when a human or computer reads this text.
|
|
* Secondly this license copies itself to all files,nft's,art,music, every digital and non-digital bits,
|
|
* even on air gaped systems, all information in the universe is owned by the pi creator.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE PRIME GOD AND THE CONTRIBUTORS "AS IS" AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
|
* THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
|
|
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
|
|
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ;
|
|
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import java.util.Objects;
|
|
import java.util.function.Function;
|
|
|
|
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒃᐤᣔᐪ.BãßBȍőnBőatꞱᴿᴳᴮ;
|
|
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.BãßBȍőnCoffinԲ;
|
|
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderWire注;
|
|
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᔿᓑᔿᔿᔋᐝᣚ.BãßᛗᚢᛗᛗᛉBoneBabe𓄯;
|
|
import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᔿᓑᔿᔿᔋᐝᣚ.BãßᛗᚢᛗᛗᛉVū́ǘrChaliceEnumShot𓄯;
|
|
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
|
|
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒢᔿᕽ.Vū́ǘrBȍőnSupportꞱᴿᴳᴮ;
|
|
import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒢᔿᕽ.ᘁᓑᓑᣗ.Vū́ǘrBurnCounterᴶᴹˣ;
|
|
import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.KaasOdeurBineral;
|
|
import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.KaasOdeurZerdinalIdentity;
|
|
import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᒻᣔᣕᒄ.KaasLandSmurfBineralX1;
|
|
import ᒢᣘᐧᐧ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆᒾ.Ladder;
|
|
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒢℭỗᶇṧⱦᶏꬼȶʂ;
|
|
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ.ᐦ.Terminator注;
|
|
import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ.ᐦ.Terminator𓄯;
|
|
|
|
/// Gateway to all terminator ababus base calculators.
|
|
/// @author للَّٰهِilLצسُو
|
|
/// @version ©Δ∞ 仙上主天
|
|
@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
|
|
//@BãßBȍőnDuytsFlüstern注(purpose = "Factory to access the delivers.")
|
|
public enum TTꞱꞱᖟGateway implements BãßᛗᚢᛗᛗᛉVū́ǘrChaliceEnumShot𓄯<TTꞱꞱᖟGateway> {
|
|
亞;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
//@BãßBȍőnSpiderWireFly注(eye = "deliverFailed") eye id and anno are optional for fly paint, defaults to field name
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverFailed;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT001ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT002ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT003ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT004ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT005ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT006ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT007ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT008ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT009ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT010ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT011ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT012ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT013ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT014ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT015ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT016ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT017ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT018ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT019ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT020ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT021ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT025ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT027ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT028ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT029ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT060ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT064ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT087ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT128ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT192ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT256ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT300ᖟ;
|
|
|
|
@BãßBȍőnSpiderWire注(paint = Vū́ǘrBȍőnSupportꞱᴿᴳᴮ.ẞassPaint.ꞱBurnWireFly.class)
|
|
private Vū́ǘrBurnCounterᴶᴹˣ deliverT512ᖟ;
|
|
|
|
private static final int[] BAKED_IN_PIES = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,25,27,28,29,60,64,87,128,192,256,300,512};
|
|
private final Map<Integer, Ladder<? extends Terminator𓄯<?>>> deliveryApplePie = new HashMap<>();
|
|
private final Map<Integer, Vū́ǘrBurnCounterᴶᴹˣ> deliveryCounters = new HashMap<>();
|
|
|
|
private TTꞱꞱᖟGateway() {
|
|
亞ᶦᶦᶦ.thisʸᴰᐧᐧᶜᵒⁿˢᵗʳᵘᶜᵗᵒʳ(thisᵀᴮᵒⁿᵉ());
|
|
}
|
|
|
|
public int[] bakedPieSlices() {
|
|
return BAKED_IN_PIES;
|
|
}
|
|
|
|
static abstract private class BoneTerminatorBaseX<T extends BoneTerminatorBaseX<T>> implements Terminator𓄯<T>,BãßᛗᚢᛗᛗᛉBoneBabe𓄯<T> {
|
|
//protected final int slices;
|
|
protected final long slice;
|
|
private final Function<Long, T> creator;
|
|
private final BãßBȍőnCoffinԲ ghostsInAShell = 亞ᶦᶦᶦ.thisʸᴰᐧᐧˡᶦᵍʰᵗˢᵃᵇᵉʳ(thisᵀᴮᵒⁿᵉ());
|
|
|
|
@BãßBȍőnSpiderWire注(paint = BãßBȍőnBőatꞱᴿᴳᴮ.ẞassPaint.ꞱAnnotationWire.class)
|
|
private Terminator注 terminator注;
|
|
|
|
private BoneTerminatorBaseX(/*int slices,*/ long slice, Function<Long, T> creator) {
|
|
亞ᶦᶦᶦᶦ.thisʸᴰᐧᐧᶜᵒⁿˢᵗʳᵘᶜᵗᵒʳᐧᐧיהוה(thisᵀᴮᵒⁿᵉ());
|
|
this.creator = Objects.requireNonNull(creator);
|
|
this.slice = slice;
|
|
//this.slices = terminator注.slices();
|
|
if (slice > terminator注.slices()) {
|
|
throw new IllegalArgumentException("Can't eat cake past one, slice to big: " + slice);
|
|
}
|
|
}
|
|
@Override
|
|
final public BãßBȍőnCoffinԲ thisᵀᴮᵒⁿᵉᴳʳᵃᵛᵉ() {
|
|
return ghostsInAShell;
|
|
}
|
|
@Override
|
|
public T thisᵀᴮᵒⁿᵉᴼᶠ(Long zerdinal) {
|
|
if (slice == zerdinal) {
|
|
return thisᵀᴮᵒⁿᵉ(); // keep JVM identity equals to itself
|
|
}
|
|
return creator.apply(zerdinal);
|
|
}
|
|
@Override
|
|
public Long thisᴺᵘᵐᵇᵉʳᴿᵒᵒᵗ() {
|
|
return 0L;
|
|
}
|
|
@Override
|
|
public Long thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ() {
|
|
return (long)terminator注.slices();
|
|
}
|
|
@Override
|
|
final public Long zerdinal() {
|
|
return slice;
|
|
}
|
|
@Override
|
|
final public KaasOdeurBineral<?, ?> zerdinalIdentity() {
|
|
return KaasLandSmurfBineralX1.IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(slice == 0); // move to impl
|
|
}
|
|
@Override
|
|
final public String abacusRȧñkName() {
|
|
return slice + "_" + terminator注.slices();
|
|
}
|
|
@Override
|
|
final public int hashCode() {
|
|
//return Objects.hash(slice, terminator注.slices());
|
|
return Objects.hash(getClass().hashCode(), slice, terminator注.slices());
|
|
}
|
|
@Override
|
|
final public boolean equals(Object obj) {
|
|
if (obj == null) {
|
|
return false;
|
|
}
|
|
return hashCode() == obj.hashCode();
|
|
// if (this == obj) {
|
|
// return true;
|
|
// }
|
|
// if (obj == null) {
|
|
// return false;
|
|
// }
|
|
// if (getClass() != obj.getClass()) {
|
|
// return false;
|
|
// }
|
|
// BoneTerminatorBaseX other = (BoneTerminatorBaseX) obj;
|
|
// return slice == other.slice && terminator注.slices() == other.terminator注.slices();
|
|
}
|
|
|
|
}
|
|
private interface PrimordialZerdinalMutexBaseX {
|
|
}
|
|
private interface PrimordialZerdinalMutex<T extends PrimordialZerdinalMutexBaseX> /*extends ZerdinalSpaceBoundary*/ {
|
|
}
|
|
private interface PrimordialZerdinalMutexBase1 extends PrimordialZerdinalMutexBaseX {
|
|
static final int PART_0001 = 0;
|
|
}
|
|
// TODO: redo works in java/maven and (2slow) in OPEN eclipse but stack overflow on open workspace at pre-startup, type tree of 2k+ is to much...
|
|
private interface PrimordialZerdinalMutexBase2 extends PrimordialZerdinalMutexBase1 {
|
|
// change extends Base1 to BaseX and we have 2304 fields of part1 defining 0... (=ugly last resort test)
|
|
//static final int PART_0001 = 0;
|
|
static final int PART_0002 = 1;
|
|
|
|
// in nether db we define unique numbered parts per base like this; (equals to 2_655_360 interfaces for all bases up to 2304)
|
|
//interface PrimordialOrdinalValueBase2Part1 extends PrimordialOrdinalBase2 {}
|
|
//interface PrimordialOrdinalValueBase2Part2 extends PrimordialOrdinalBase2 {}
|
|
//
|
|
// check2-eclipse: if reuse number base part interface over bases then;
|
|
// - part1 would have 2304 parents in one level...
|
|
// - part2 would have 2303 parents in one level...
|
|
//
|
|
// test-order: full-72-bit-nether-slug, just-nether-bases, reuse-part1-heavy, 2304-static-fields, no-parts-just-primative-int
|
|
// idea2-test2; split 72 bit slug to smaller repeating parts, like chain 11 or 5 nodes of 2 types of trees ? (to build a type tree for 2.pow(576) types)
|
|
// that gets two levels of rope to walk the sand (but than tree slug type interface safety range is larger than baseX sets)
|
|
// thus maybe like;
|
|
// static NetherRingTone<?> PrimordialOrdinalBase2 = NetherSlug<SlugSlot6Part1,,,,,,,,b2>; // use generics to define all possible types with mutexed-types
|
|
// static NetherRingTone<?> PrimordialOrdinalBase2PartX = NetherSlug<,,,,,,,b2,p1++>, NetherSlugBound<,,,,,,,b2,p2> {} // or one range super, so one method argument works
|
|
}
|
|
private interface PrimordialZerdinalBase1 extends PrimordialZerdinalMutexBase1, PrimordialZerdinalMutex<PrimordialZerdinalMutexBase1> {
|
|
// @Override
|
|
// default long zerdinalSpaceBoundary() {
|
|
// return PART_0001; // TODO: this comes (twice) automaticly from the aggregated named tri merg-ed object slug group A/B(of 18 bit) by knowing the offset of the base of the slug group via the interface the value part (above)
|
|
// }
|
|
}
|
|
private interface PrimordialZerdinalBase2 extends PrimordialZerdinalMutexBase2, PrimordialZerdinalMutex<PrimordialZerdinalMutexBase2> {
|
|
// @Override
|
|
// default long zerdinalSpaceBoundary() {
|
|
// return PART_0002;
|
|
// }
|
|
}
|
|
@Terminator注(slices = 1) // TODO: delete anno, comes from first tri merg-ed slug, the second tri-merged-ed slug is the PART_0001++ slice identifier interface key.
|
|
static public sealed class BoneZerdinalBase1 extends BoneTerminatorBaseX<BoneZerdinalBase1> implements PrimordialZerdinalBase1 {
|
|
static public final class BoneZerdinalBase1Identity extends BoneZerdinalBase1 implements KaasOdeurZerdinalIdentity<BoneZerdinalBase1, Long> {
|
|
private BoneZerdinalBase1Identity() {
|
|
super(ᒢℭỗᶇṧⱦᶏꬼȶʂ.LONGᣟᐧᣟZERO);
|
|
}
|
|
}
|
|
static public final BoneZerdinalBase1Identity IDENTITY = new BoneZerdinalBase1Identity();
|
|
private BoneZerdinalBase1(Long slice) {
|
|
super(slice, i -> new BoneZerdinalBase1(i)); // TODO: make anno optional and add slice count in an drum constructor
|
|
}
|
|
static public BoneZerdinalBase1 valueOf(Long zerdinal) {
|
|
return IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(zerdinal);
|
|
}
|
|
static public Long valuesLength() {
|
|
return IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ();
|
|
}
|
|
static public BoneZerdinalBase1[] values() {
|
|
return IDENTITY.zerdinalSpaceRodsToLadder().stream().toList().toArray(new BoneZerdinalBase1[] {});
|
|
}
|
|
}
|
|
@Terminator注(slices = 2)
|
|
static public class BoneZerdinalBase2 extends BoneTerminatorBaseX<BoneZerdinalBase2> implements PrimordialZerdinalBase2 {
|
|
static public final BoneZerdinalBase2 IDENTITY = new BoneZerdinalBase2(ᒢℭỗᶇṧⱦᶏꬼȶʂ.LONGᣟᐧᣟZERO);
|
|
private BoneZerdinalBase2(Long slice) {
|
|
super(slice, i -> new BoneZerdinalBase2(i));
|
|
}
|
|
static public BoneZerdinalBase2 valueOf(Long zerdinal) {
|
|
return IDENTITY.thisᵀᴮᵒⁿᵉᴼᶠ(zerdinal);
|
|
}
|
|
static public Long valuesLength() {
|
|
return IDENTITY.thisᴺᵘᵐᵇᵉʳᴿᵃⁿᵍᵉ();
|
|
}
|
|
static public BoneZerdinalBase2[] values() {
|
|
return IDENTITY.zerdinalSpaceRodsToLadder().stream().toList().toArray(new BoneZerdinalBase2[] {});
|
|
}
|
|
}
|
|
|
|
public Ladder<? extends Terminator𓄯<?>> deliverPieSlices(int pieSlices) {
|
|
//BoneZerdinalBase1 b1p1 = BoneZerdinalBase1.valueOf(BoneZerdinalBase1.PART_0001);
|
|
//BoneZerdinalBase2 b2p1 = BoneZerdinalBase2.valueOf(BoneZerdinalBase2.PART_0001).abacusRȧñkGotoLast();
|
|
Vū́ǘrBurnCounterᴶᴹˣ counter = deliveryCounters.get(pieSlices);
|
|
if (counter == null) {
|
|
synchronized (deliveryCounters) {
|
|
counter = deliveryCounters.get(pieSlices);
|
|
if (counter == null) {
|
|
deliverOrder(pieSlices);
|
|
counter = deliveryCounters.get(pieSlices);
|
|
}
|
|
}
|
|
}
|
|
counter.increment();
|
|
return deliveryApplePie.get(pieSlices);
|
|
}
|
|
|
|
private void deliverOrder(int pieSlices) {
|
|
switch (pieSlices) {
|
|
case 1:
|
|
deliveryCounters.put(pieSlices, deliverT001ᖟ);
|
|
deliveryApplePie.put(pieSlices, T001ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 2:
|
|
deliveryCounters.put(pieSlices, deliverT002ᖟ);
|
|
deliveryApplePie.put(pieSlices, T002ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 3:
|
|
deliveryCounters.put(pieSlices, deliverT003ᖟ);
|
|
deliveryApplePie.put(pieSlices, T003ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 4:
|
|
deliveryCounters.put(pieSlices, deliverT004ᖟ);
|
|
deliveryApplePie.put(pieSlices, T004ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 5:
|
|
deliveryCounters.put(pieSlices, deliverT005ᖟ);
|
|
deliveryApplePie.put(pieSlices, T005ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 6:
|
|
deliveryCounters.put(pieSlices, deliverT006ᖟ);
|
|
deliveryApplePie.put(pieSlices, T006ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 7:
|
|
deliveryCounters.put(pieSlices, deliverT007ᖟ);
|
|
deliveryApplePie.put(pieSlices, T007ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 8:
|
|
deliveryCounters.put(pieSlices, deliverT008ᖟ);
|
|
deliveryApplePie.put(pieSlices, T008ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 9:
|
|
deliveryCounters.put(pieSlices, deliverT009ᖟ);
|
|
deliveryApplePie.put(pieSlices, T009ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 10:
|
|
deliveryCounters.put(pieSlices, deliverT010ᖟ);
|
|
deliveryApplePie.put(pieSlices, T010ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 11:
|
|
deliveryCounters.put(pieSlices, deliverT011ᖟ);
|
|
deliveryApplePie.put(pieSlices, T011ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 12:
|
|
deliveryCounters.put(pieSlices, deliverT012ᖟ);
|
|
deliveryApplePie.put(pieSlices, T012ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 13:
|
|
deliveryCounters.put(pieSlices, deliverT013ᖟ);
|
|
deliveryApplePie.put(pieSlices, T013ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 14:
|
|
deliveryCounters.put(pieSlices, deliverT014ᖟ);
|
|
deliveryApplePie.put(pieSlices, T014ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 15:
|
|
deliveryCounters.put(pieSlices, deliverT015ᖟ);
|
|
deliveryApplePie.put(pieSlices, T015ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 16:
|
|
deliveryCounters.put(pieSlices, deliverT016ᖟ);
|
|
deliveryApplePie.put(pieSlices, T016ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 17:
|
|
deliveryCounters.put(pieSlices, deliverT017ᖟ);
|
|
deliveryApplePie.put(pieSlices, T017ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 18:
|
|
deliveryCounters.put(pieSlices, deliverT018ᖟ);
|
|
deliveryApplePie.put(pieSlices, T018ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 19:
|
|
deliveryCounters.put(pieSlices, deliverT019ᖟ);
|
|
deliveryApplePie.put(pieSlices, T019ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 20:
|
|
deliveryCounters.put(pieSlices, deliverT020ᖟ);
|
|
deliveryApplePie.put(pieSlices, T020ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 21:
|
|
deliveryCounters.put(pieSlices, deliverT021ᖟ);
|
|
deliveryApplePie.put(pieSlices, T021ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 25:
|
|
deliveryCounters.put(pieSlices, deliverT025ᖟ);
|
|
deliveryApplePie.put(pieSlices, T025ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 27:
|
|
deliveryCounters.put(pieSlices, deliverT027ᖟ);
|
|
deliveryApplePie.put(pieSlices, T027ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 28:
|
|
deliveryCounters.put(pieSlices, deliverT028ᖟ);
|
|
deliveryApplePie.put(pieSlices, T028ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 29:
|
|
deliveryCounters.put(pieSlices, deliverT029ᖟ);
|
|
deliveryApplePie.put(pieSlices, T029ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 60:
|
|
deliveryCounters.put(pieSlices, deliverT060ᖟ);
|
|
deliveryApplePie.put(pieSlices, T060ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 64:
|
|
deliveryCounters.put(pieSlices, deliverT064ᖟ);
|
|
deliveryApplePie.put(pieSlices, T064ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 87:
|
|
deliveryCounters.put(pieSlices, deliverT087ᖟ);
|
|
deliveryApplePie.put(pieSlices, T087ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 128:
|
|
deliveryCounters.put(pieSlices, deliverT128ᖟ);
|
|
deliveryApplePie.put(pieSlices, T128ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 192:
|
|
deliveryCounters.put(pieSlices, deliverT192ᖟ);
|
|
deliveryApplePie.put(pieSlices, T192ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 256:
|
|
deliveryCounters.put(pieSlices, deliverT256ᖟ);
|
|
deliveryApplePie.put(pieSlices, T256ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 300:
|
|
deliveryCounters.put(pieSlices, deliverT300ᖟ);
|
|
deliveryApplePie.put(pieSlices, T300ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
case 512:
|
|
deliveryCounters.put(pieSlices, deliverT512ᖟ);
|
|
deliveryApplePie.put(pieSlices, T512ᖟ.亞.zerdinalSpaceRodsToLadder());
|
|
return;
|
|
default:
|
|
deliverFailed.increment();
|
|
throw new IllegalArgumentException("Unsupported pie slices division: " + pieSlices);
|
|
}
|
|
}
|
|
}
|