From d6b2a223a7973941e5e4fb45c8ceec4885891496 Mon Sep 17 00:00:00 2001
From: jeff
Date: Mon, 9 Mar 2015 12:53:11 -0400
Subject: starting on field matching gui

---
 src/cuchaz/enigma/convert/ClassMatches.java | 153 ++++++++++++++++++++++++++++
 1 file changed, 153 insertions(+)
 create mode 100644 src/cuchaz/enigma/convert/ClassMatches.java

(limited to 'src/cuchaz/enigma/convert/ClassMatches.java')

diff --git a/src/cuchaz/enigma/convert/ClassMatches.java b/src/cuchaz/enigma/convert/ClassMatches.java
new file mode 100644
index 0000000..f8b2afd
--- /dev/null
+++ b/src/cuchaz/enigma/convert/ClassMatches.java
@@ -0,0 +1,153 @@
+package cuchaz.enigma.convert;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+
+import cuchaz.enigma.mapping.ClassEntry;
+
+
+public class ClassMatches implements Iterable<ClassMatch> {
+
+	Collection<ClassMatch> m_matches;
+	Map<ClassEntry,ClassMatch> m_matchesBySource;
+	Map<ClassEntry,ClassMatch> m_matchesByDest;
+	BiMap<ClassEntry,ClassEntry> m_uniqueMatches;
+	Map<ClassEntry,ClassMatch> m_ambiguousMatchesBySource;
+	Map<ClassEntry,ClassMatch> m_ambiguousMatchesByDest;
+	Set<ClassEntry> m_unmatchedSourceClasses;
+	Set<ClassEntry> m_unmatchedDestClasses;
+	
+	public ClassMatches() {
+		this(new ArrayList<ClassMatch>());
+	}
+	
+	public ClassMatches(Collection<ClassMatch> matches) {
+		m_matches = matches;
+		m_matchesBySource = Maps.newHashMap();
+		m_matchesByDest = Maps.newHashMap();
+		m_uniqueMatches = HashBiMap.create();
+		m_ambiguousMatchesBySource = Maps.newHashMap();
+		m_ambiguousMatchesByDest = Maps.newHashMap();
+		m_unmatchedSourceClasses = Sets.newHashSet();
+		m_unmatchedDestClasses = Sets.newHashSet();
+		
+		for (ClassMatch match : matches) {
+			indexMatch(match);
+		}
+	}
+
+	public void add(ClassMatch match) {
+		m_matches.add(match);
+		indexMatch(match);
+	}
+	
+	public void remove(ClassMatch match) {
+		for (ClassEntry sourceClass : match.sourceClasses) {
+			m_matchesBySource.remove(sourceClass);
+			m_uniqueMatches.remove(sourceClass);
+			m_ambiguousMatchesBySource.remove(sourceClass);
+			m_unmatchedSourceClasses.remove(sourceClass);
+		}
+		for (ClassEntry destClass : match.destClasses) {
+			m_matchesByDest.remove(destClass);
+			m_uniqueMatches.inverse().remove(destClass);
+			m_ambiguousMatchesByDest.remove(destClass);
+			m_unmatchedDestClasses.remove(destClass);
+		}
+		m_matches.remove(match);
+	}
+
+	public int size() {
+		return m_matches.size();
+	}
+
+	@Override
+	public Iterator<ClassMatch> iterator() {
+		return m_matches.iterator();
+	}
+	
+	private void indexMatch(ClassMatch match) {
+		if (!match.isMatched()) {
+			// unmatched
+			m_unmatchedSourceClasses.addAll(match.sourceClasses);
+			m_unmatchedDestClasses.addAll(match.destClasses);
+		} else {
+			if (match.isAmbiguous()) {
+				// ambiguously matched
+				for (ClassEntry entry : match.sourceClasses) {
+					m_ambiguousMatchesBySource.put(entry, match);
+				}
+				for (ClassEntry entry : match.destClasses) {
+					m_ambiguousMatchesByDest.put(entry, match);
+				}
+			} else {
+				// uniquely matched
+				m_uniqueMatches.put(match.getUniqueSource(), match.getUniqueDest());
+			}
+		}
+		for (ClassEntry entry : match.sourceClasses) {
+			m_matchesBySource.put(entry, match);
+		}
+		for (ClassEntry entry : match.destClasses) {
+			m_matchesByDest.put(entry, match);
+		}
+	}
+	
+	public BiMap<ClassEntry,ClassEntry> getUniqueMatches() {
+		return m_uniqueMatches;
+	}
+	
+	public Set<ClassEntry> getUnmatchedSourceClasses() {
+		return m_unmatchedSourceClasses;
+	}
+	
+	public Set<ClassEntry> getUnmatchedDestClasses() {
+		return m_unmatchedDestClasses;
+	}
+
+	public Set<ClassEntry> getAmbiguouslyMatchedSourceClasses() {
+		return m_ambiguousMatchesBySource.keySet();
+	}
+	
+	public ClassMatch getAmbiguousMatchBySource(ClassEntry sourceClass) {
+		return m_ambiguousMatchesBySource.get(sourceClass);
+	}
+
+	public ClassMatch getMatchBySource(ClassEntry sourceClass) {
+		return m_matchesBySource.get(sourceClass);
+	}
+	
+	public ClassMatch getMatchByDest(ClassEntry destClass) {
+		return m_matchesByDest.get(destClass);
+	}
+	
+	public void removeSource(ClassEntry sourceClass) {
+		ClassMatch match = m_matchesBySource.get(sourceClass);
+		if (match != null) {
+			remove(match);
+			match.sourceClasses.remove(sourceClass);
+			if (!match.sourceClasses.isEmpty() || !match.destClasses.isEmpty()) {
+				add(match);
+			}
+		}
+	}
+	
+	public void removeDest(ClassEntry destClass) {
+		ClassMatch match = m_matchesByDest.get(destClass);
+		if (match != null) {
+			remove(match);
+			match.destClasses.remove(destClass);
+			if (!match.sourceClasses.isEmpty() || !match.destClasses.isEmpty()) {
+				add(match);
+			}
+		}
+	}
+}
-- 
cgit v1.2.3