gdxapp4d/gdxapp4d-lib-bassboonyd/src/main/java/love/distributedrebirth/bassboon/Bãß.java

package love.distributedrebirth.bassboon;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
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 love.distributedrebirth.bassboon.clazz.BãßBȍőnAuthor注;
import love.distributedrebirth.bassboon.clazz.pirate.BãßBȍőnPirateLoader;
import love.distributedrebirth.bassboon.clazz.pirate.BãßBȍőnꝐŕḯṿª₮ḕ;
import love.distributedrebirth.bassboon.clazz.pirate.BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ;
import love.distributedrebirth.bassboon.death.BãßBȍőnCoffin;
import love.distributedrebirth.bassboon.death.BãßBȍőnCoffinDuytschenᵗˣᵗ;
import love.distributedrebirth.bassboon.death.BãßBȍőnCoffinGhost;
import love.distributedrebirth.bassboon.death.BãßBȍőnCoffinGhostSpell;
import love.distributedrebirth.bassboon.death.BãßBȍőnCoffinGhostSpellLock;
import love.distributedrebirth.bassboon.death.spider.BãßBȍőnSpider;

/**
 * Runtime for static bass noise.
 */
@BãßBȍőnAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
public interface Bãß {
	
	/**
	 * Sarcophagus aggregates Y-Dimensions.
	 */
	static enum 石棺ʸᴰ {
		ײاللهזأَكْبَرײ;
		private final Map<Object, BȍőnGrave> יְרוּשָׁלַיִם = new WeakHashMap<>();
		private final ReadWriteLock 魎 = new ReentrantReadWriteLock(); // Mononoke Lock
		private final Lock 魎_BIBLE = 魎.readLock();
		private final Lock 魎_SHEMIRA = 魎.writeLock();
		
		/**
		 * Sarcophagus is closed for humans.
		 */
		private 石棺ʸᴰ() {
		}
		
		/**
		 * RÅ...........Init
		 */
		public final <T extends BãßBȍőnʸᴰ<T>> void 𓂀ױןייזדזיודזיןןזזזןױ𓉢(BãßBȍőnʸᴰ<T> derKnochen) {
			挖ᵀᵒ(derKnochen).init(derKnochen);
		}
		
		/**
		 * Grave Lock
		 */
		public final <T extends BãßBȍőnʸᴰ<T>> void 墳ᴸᵒᶜᵏ(BãßBȍőnʸᴰ<T> derKnochen) {
			挖ᵀᵒ(derKnochen).lock(derKnochen);
		}
		
		/**
		 * Coffin Of
		 */
		protected final <T extends BãßBȍőnʸᴰ<T>> BãßBȍőnCoffin 棺ᴼᶠ(BãßBȍőnʸᴰ<T> derKnochen) {
			return 挖ᵀᵒ(derKnochen);
		}
		protected final <T extends BãßBȍőnʸᴰ<T>, G extends BãßBȍőnCoffinDuytschenᵗˣᵗ> G 棺ᴼᶠ(BãßBȍőnʸᴰ<T> derKnochen, Class<G> duytschen) {
			return 挖ᵀᵒ(derKnochen).ₜₒI18Nᵗˣᵗ(duytschen);
		}
		
		/**
		 * Dig To
		 */
		private final <T extends BãßBȍőnʸᴰ<T>> BȍőnGrave 挖ᵀᵒ(BãßBȍőnʸᴰ<T> derKnochen) {
			BȍőnGrave 𓁀 = null;
			魎_BIBLE.lock();
			try {
				𓁀 = יְרוּשָׁלַיִם.get(derKnochen);
			} finally {
				魎_BIBLE.unlock();
			}
			if (𓁀 == null) {
				魎_SHEMIRA.lock();
				try {
					𓁀 = new BȍőnGrave();
					יְרוּשָׁלַיִם.put(derKnochen, 𓁀);
				} finally {
					魎_SHEMIRA.unlock();
				}
			}
			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 {
			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 BãßBȍőnSpider spider = new BãßBȍőnSpider();
			private boolean inited = false;
			private boolean locked = false;
			
			private BȍőnGrave() {
				BãßBȍőnCoffinDuytschenᵗˣᵗ.ײₚᵤₜI18Nᵗˣᵗײ(duytschenCoffins, this);
			}
			
			private <T extends BãßBȍőnʸᴰ<T>> void init(BãßBȍőnʸᴰ<T> derKnochen) {
				if (inited) {
					return;
				}
				BãßBȍőnPirateLoader.INIT_BONE_MAGIC(derKnochen, spider, duytschenCoffins);
				inited = true;
			}
			
			private <T extends BãßBȍőnʸᴰ<T>> void lock(BãßBȍőnʸᴰ<T> derKnochen) {
				if (locked) {
					return;
				}
				BãßBȍőnPirateLoader.LOCK_BONE_MAGIC(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 extends BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ> T NOISE_OF(Class<T> noiseName) {
				try {
					return (T) spider.silkRoad(noiseName).senseWire(null, null, null); // rm args...
				} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
					throw new RuntimeException(e);
				}
			}
			
			@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 ℭỗᶇṧⱦᶏꬼȶʂ() {
		}
	}
}