From 884627caa32082af7e99db2f7d5537499d86d880 Mon Sep 17 00:00:00 2001
From: Jordan Byrne <draknyte1@hotmail.com>
Date: Wed, 23 May 2018 03:53:53 +1000
Subject: + Added another data storage object. Examine ReverseAutoMap.java for
 information. $ Massive overhaul to the Chunk Loaders. $ Hopefully added a way
 to check OreGen per dimension. % Gave the BlockPos.java object a better UID.

---
 src/Java/gtPlusPlus/api/objects/data/AutoMap.java  |   6 +-
 .../api/objects/data/ReverseAutoMap.java           | 157 +++++++++++++++++++++
 2 files changed, 162 insertions(+), 1 deletion(-)
 create mode 100644 src/Java/gtPlusPlus/api/objects/data/ReverseAutoMap.java

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

diff --git a/src/Java/gtPlusPlus/api/objects/data/AutoMap.java b/src/Java/gtPlusPlus/api/objects/data/AutoMap.java
index e5b5ded0ad..de565ab95a 100644
--- a/src/Java/gtPlusPlus/api/objects/data/AutoMap.java
+++ b/src/Java/gtPlusPlus/api/objects/data/AutoMap.java
@@ -8,7 +8,7 @@ public class AutoMap<V> implements Iterable<V>, Cloneable, Serializable {
 	/**
 	 * The Internal Map
 	 */
-	private Map<Integer, V> mInternalMap = new HashMap<Integer, V>();
+	protected Map<Integer, V> mInternalMap = new HashMap<Integer, V>();
 	
 	/**
 	 * The Internal ID
@@ -80,5 +80,9 @@ public class AutoMap<V> implements Iterable<V>, Cloneable, Serializable {
 		V[] val = (V[]) col.toArray();		
 		return val;
 	}
+
+	public synchronized final int getInternalID() {
+		return mInternalID;
+	}
   
 }
diff --git a/src/Java/gtPlusPlus/api/objects/data/ReverseAutoMap.java b/src/Java/gtPlusPlus/api/objects/data/ReverseAutoMap.java
new file mode 100644
index 0000000000..dd50d456d2
--- /dev/null
+++ b/src/Java/gtPlusPlus/api/objects/data/ReverseAutoMap.java
@@ -0,0 +1,157 @@
+package gtPlusPlus.api.objects.data;
+
+import java.util.*;
+
+public class ReverseAutoMap<N> extends AutoMap<N> {
+
+	/**
+	 * The Internal Map
+	 */
+	private Map<N, Integer> mInternalMapReverseLookup = new HashMap<N, Integer>();
+
+	/**
+	 * The Internal ID
+	 */
+	private int mInternalID = 0;
+	private static final long serialVersionUID = 3771412318075131790L;
+
+	@Override
+	public Iterator<N> iterator() {		
+		return values().iterator();
+	}
+
+	public synchronized boolean setValue(N object){
+		int mOriginalID = this.mInternalID;
+		put(object);		
+		if (this.mInternalMap.get(mOriginalID).equals(object) || mOriginalID > this.mInternalID){
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+
+	@Override
+	public synchronized N put(N object){
+		return set(object);
+	}
+
+	@Override
+	public synchronized N set(N object){
+		raiseInternalID();
+		int newID = getNextFreeMapID();
+		mInternalMapReverseLookup.put(object, newID);
+		return mInternalMap.put(newID, object);
+	}
+
+	public synchronized int putToInternalMap(N object){
+		return setInternalMap(object);
+	}
+
+	public synchronized int setInternalMap(N object){
+		raiseInternalID();		
+		int newID = getNextFreeMapID();			
+		mInternalMap.put(newID, object);		
+		return mInternalMapReverseLookup.put(object, newID);
+	}
+
+	private boolean raiseInternalID() {
+		int mOld = mInternalID;
+		mInternalID++;
+		return mInternalID > mOld;
+	}
+
+	public synchronized int getNextFreeMapID() {
+		if (this.mInternalMap.size() < 1 || this.mInternalMapReverseLookup.size() < 1) {
+			return 0;
+		}
+		if (this.mInternalMap.size() == getInternalID()-1) {
+			return getInternalID();
+		}		
+		AutoMap<Integer> free = new AutoMap<Integer>();
+		values: for (int d : this.mInternalMapReverseLookup.values()) {
+			sequential: for (int m=0;m<this.mInternalMap.size();m++) {
+
+				//Counter is lower than current ID, keep counting.
+				if (m < d || m == d) {
+					continue sequential;
+				}
+				//Possible that d is missing in sequence i.e.  (m=0,1,2,3 & d=0,1,3,4)
+				else if (m > d) {
+					free.put(m);
+					continue values;
+				}
+			}
+		}		
+		if (free.isEmpty()) {
+			return 0;
+		}
+		else {
+			return free.get(0);
+		}
+	}
+
+	@Override
+	public synchronized N get(int id){		
+		return mInternalMap.get(id);
+	}
+
+	public synchronized int get(N key) {		
+		return mInternalMapReverseLookup.get(key);
+	}
+
+	@Override
+	public synchronized Collection<N> values(){
+		return mInternalMap.values();
+	}
+
+	@Override
+	public synchronized int size(){
+		return mInternalMap.size();
+	}
+
+	@Override
+	public synchronized int hashCode(){
+		return mInternalMap.hashCode()+mInternalMapReverseLookup.hashCode();
+	}
+
+	@Override
+	public synchronized boolean containsKey(int key){
+		return mInternalMap.containsKey(key);
+	}
+
+	@Override
+	public synchronized boolean containsValue(N value){
+		return mInternalMap.containsValue(value);
+	}
+
+	public synchronized boolean containsKey(N key){
+		return mInternalMapReverseLookup.containsKey(key);
+	}
+
+	public synchronized boolean containsValue(int value){
+		return mInternalMapReverseLookup.containsValue(value);
+	}
+
+	@Override
+	public synchronized boolean isEmpty(){
+		return mInternalMap.isEmpty() && mInternalMapReverseLookup.isEmpty();
+	}
+
+	@Override
+	public synchronized boolean clear(){
+		this.mInternalID = 0;
+		this.mInternalMap.clear();
+		this.mInternalMapReverseLookup.clear();
+		return true;
+	}
+
+	@Override
+	public synchronized N[] toArray() {		
+		Collection<N> col = this.mInternalMap.values();
+		@SuppressWarnings("unchecked")
+		N[] val = (N[]) col.toArray();		
+		return val;
+	}
+
+}
-- 
cgit