From 6205a2088bbbc31a09d0a2a3d460add1a7622801 Mon Sep 17 00:00:00 2001
From: Alkalus <3060479+draknyte1@users.noreply.github.com>
Date: Mon, 29 Oct 2018 05:09:01 +0000
Subject: + Added recipe for heating Titanium Ingots, required for Krypton
 processing. + Added custom GT TextureSets. $ Lots of small fixes to Material,
 Material Generation & Recipe Generation. $ Lots of small fixes to Fluids,
 Fluid Generation and Fluid Cell Generation. $ Fixed Creative Tabs. $ Possibly
 fixed issue where tickable items would instantly tick to 0. $ Fixed display
 names of Throwable Potions. $ Fixed NPE in removeCrudeTurbineRotors(). %
 Adjusted lots of textures. % Adjusted handling of Thermal Foundation Fluids.
 % Moved Furnace/EBF and Maceration recipes out of BaseItemDust.java. % Made
 Tooltips of GT++ Material Blocks, Frames and ores more informational. % Made
 Bromine a Fluid Material, this will remove all Bromine solid material items
 from the world. (Ingots, Blocks, etc.) % Increased cost of GT++ Ores in
 processing. - Broke lots of recipes. > EBF/ABS & All Table Crafting. TBA~

---
 .../gtPlusPlus/api/objects/data/TypeCounter.java   | 178 +++++++++++++++++++++
 1 file changed, 178 insertions(+)
 create mode 100644 src/Java/gtPlusPlus/api/objects/data/TypeCounter.java

(limited to 'src/Java/gtPlusPlus/api/objects/data')

diff --git a/src/Java/gtPlusPlus/api/objects/data/TypeCounter.java b/src/Java/gtPlusPlus/api/objects/data/TypeCounter.java
new file mode 100644
index 0000000000..3d562bf76e
--- /dev/null
+++ b/src/Java/gtPlusPlus/api/objects/data/TypeCounter.java
@@ -0,0 +1,178 @@
+package gtPlusPlus.api.objects.data;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+
+import gtPlusPlus.api.objects.Logger;
+
+
+public class TypeCounter<V> implements Set<V> {
+
+	private Map<String, InternalTypeCounterObject<V>> mInternalMap = new LinkedHashMap<String, InternalTypeCounterObject<V>>();
+	private String mHighestValueKey;
+	private int mHighestValue = 0;
+	private final Class mClass;
+
+	public TypeCounter(Class o) {
+		Logger.INFO("Created new TypeCounter for "+o.getName());
+		mClass = o;
+	}
+
+	public static class InternalTypeCounterObject<Z> {
+		private final Z mObject;
+		private int mCounter = 0;
+
+		public InternalTypeCounterObject(Z o) {
+			mObject = o;
+		}
+
+		public String hash() {
+			return String.valueOf(mObject.hashCode());
+		}
+
+		public Z get() {
+			return mObject;
+		}
+
+		public void add() {
+			mCounter++;
+		}
+
+		public int count() {
+			return mCounter;
+		}
+
+	}
+
+	public boolean add(V arg0) {
+		return add(arg0, null);
+	}
+
+	public boolean add(V arg0, String aKeyName) {
+		String aKey = aKeyName != null ? aKeyName : arg0.toString();
+		InternalTypeCounterObject<V> aValue = mInternalMap.get(aKey);
+		if (aValue == null) {
+			aValue = new InternalTypeCounterObject<V>((V) arg0);
+			Logger.INFO("Adding new key to map: "+aKey);
+		}
+		aValue.add();
+		int a = aValue.count();
+		if (a > mHighestValue) {
+			mHighestValue = a;
+			mHighestValueKey = aKey;
+			Logger.INFO("New Highest Count - "+aKey+":"+a);
+		}		
+		mInternalMap.put(aKey, aValue);
+		Logger.INFO(aKey+":"+a);
+		return true;
+	}
+
+	@Override
+	public boolean addAll(Collection arg0) {
+		boolean aReturn = true;
+		for (Object o : arg0) {
+			if (mClass.isInstance(o)) {
+				V j = (V) o;
+				boolean b = add(j);
+				if (!b) {
+					aReturn = false;
+				}
+			}			
+		}
+		return aReturn;
+	}
+
+	@Override
+	public void clear() {
+		mInternalMap.clear();		
+	}
+
+	@Override
+	public boolean contains(Object arg0) {
+		return mInternalMap.containsKey(arg0.toString());
+	}
+
+	@Override
+	public boolean containsAll(Collection arg0) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	@Override
+	public boolean isEmpty() {
+		return mInternalMap.isEmpty();
+	}
+
+	@Override
+	public Iterator iterator() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public boolean remove(Object arg0) {		
+		InternalTypeCounterObject<V> aValue = mInternalMap.remove(arg0.toString());
+		if (aValue != null) {
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+
+	@Override
+	public boolean removeAll(Collection arg0) {
+		boolean aReturn = true;
+		for (Object o : arg0) {
+			boolean a = remove(o);
+			if (!a) {
+				aReturn = false;
+			}
+		}
+		return aReturn;
+	}
+
+	@Override
+	public boolean retainAll(Collection arg0) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	@Override
+	public int size() {
+		return this.mInternalMap.size();
+	}
+
+	@Override
+	public Object[] toArray() {
+		Object[] aArray = new Object[this.mInternalMap.size()];
+		int aPos = 0;
+		for (String k : this.mInternalMap.keySet()) {
+			if (k != null) {
+				InternalTypeCounterObject<V> aVal = this.mInternalMap.get(k);
+				aArray[aPos++] = new Pair<String, InternalTypeCounterObject<V>>(k, aVal);
+			}
+		}
+		return aArray;		
+	}
+
+	@Override
+	public V[] toArray(Object[] a) {
+		Object[] aArray = new Object[a.length];
+		int aPos = 0;
+		for (Object k : a) {
+			if (k != null) {
+				aArray[aPos++] = k;
+			}
+		}
+		return (V[]) aArray;
+	}
+
+	public V getResults() {
+		InternalTypeCounterObject<V> x = mInternalMap.get(mHighestValueKey);
+		return x.get();
+	}
+}
-- 
cgit