1 files changed, 157 insertions, 0 deletions
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;
+	}
+
+}