From 741e3472f76d959645ee0e025547d69a03e5b6f2 Mon Sep 17 00:00:00 2001 From: jeff Date: Sat, 28 Feb 2015 18:00:25 -0500 Subject: fix up conversion tool to handle Minecraft 1.8.3 --- src/cuchaz/enigma/convert/ClassMatching.java | 200 ++++++++++++--------------- 1 file changed, 91 insertions(+), 109 deletions(-) (limited to 'src/cuchaz/enigma/convert/ClassMatching.java') diff --git a/src/cuchaz/enigma/convert/ClassMatching.java b/src/cuchaz/enigma/convert/ClassMatching.java index 53b6f7f..b94fd8b 100644 --- a/src/cuchaz/enigma/convert/ClassMatching.java +++ b/src/cuchaz/enigma/convert/ClassMatching.java @@ -10,164 +10,146 @@ ******************************************************************************/ package cuchaz.enigma.convert; -import java.util.AbstractMap; import java.util.ArrayList; -import java.util.Arrays; import java.util.Collection; import java.util.List; -import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; -import com.google.common.collect.ArrayListMultimap; import com.google.common.collect.BiMap; import com.google.common.collect.HashBiMap; import com.google.common.collect.Lists; -import com.google.common.collect.Maps; -import com.google.common.collect.Multimap; +import com.google.common.collect.Sets; + +import cuchaz.enigma.mapping.ClassEntry; public class ClassMatching { - private Multimap m_sourceClasses; - private Multimap m_matchedDestClasses; - private List m_unmatchedDestClasses; - - public ClassMatching() { - m_sourceClasses = ArrayListMultimap.create(); - m_matchedDestClasses = ArrayListMultimap.create(); - m_unmatchedDestClasses = Lists.newArrayList(); - } + private ClassForest m_sourceClasses; + private ClassForest m_destClasses; + private BiMap m_knownMatches; - public void addSource(ClassIdentity c) { - m_sourceClasses.put(c, c); + public ClassMatching(ClassIdentifier sourceIdentifier, ClassIdentifier destIdentifier) { + m_sourceClasses = new ClassForest(sourceIdentifier); + m_destClasses = new ClassForest(destIdentifier); + m_knownMatches = HashBiMap.create(); } - public void matchDestClass(ClassIdentity destClass) { - Collection matchedSourceClasses = m_sourceClasses.get(destClass); - if (matchedSourceClasses.isEmpty()) { - // no match - m_unmatchedDestClasses.add(destClass); - } else { - // found a match - m_matchedDestClasses.put(destClass, destClass); - - // DEBUG - ClassIdentity sourceClass = matchedSourceClasses.iterator().next(); - assert (sourceClass.hashCode() == destClass.hashCode()); - assert (sourceClass.equals(destClass)); - } + public void addKnownMatches(BiMap knownMatches) { + m_knownMatches.putAll(knownMatches); } - public void removeSource(ClassIdentity sourceClass) { - m_sourceClasses.remove(sourceClass, sourceClass); + public void match(Iterable sourceClasses, Iterable destClasses) { + m_sourceClasses.addAll(sourceClasses); + m_destClasses.addAll(destClasses); } - public void removeDest(ClassIdentity destClass) { - m_matchedDestClasses.remove(destClass, destClass); - m_unmatchedDestClasses.remove(destClass); + public Collection matches() { + List matches = Lists.newArrayList(); + for (Entry entry : m_knownMatches.entrySet()) { + matches.add(new ClassMatch( + entry.getKey(), + entry.getValue() + )); + } + for (ClassIdentity identity : m_sourceClasses.identities()) { + matches.add(new ClassMatch( + m_sourceClasses.getClasses(identity), + m_destClasses.getClasses(identity) + )); + } + for (ClassIdentity identity : m_destClasses.identities()) { + if (!m_sourceClasses.containsIdentity(identity)) { + matches.add(new ClassMatch( + new ArrayList(), + m_destClasses.getClasses(identity) + )); + } + } + return matches; } - public List getSourceClasses() { - return new ArrayList(m_sourceClasses.values()); + public Collection sourceClasses() { + Set classes = Sets.newHashSet(); + for (ClassMatch match : matches()) { + classes.addAll(match.sourceClasses); + } + return classes; } - public List getDestClasses() { - List classes = Lists.newArrayList(); - classes.addAll(m_matchedDestClasses.values()); - classes.addAll(m_unmatchedDestClasses); + public Collection destClasses() { + Set classes = Sets.newHashSet(); + for (ClassMatch match : matches()) { + classes.addAll(match.destClasses); + } return classes; } - public BiMap getUniqueMatches() { - BiMap uniqueMatches = HashBiMap.create(); - for (ClassIdentity sourceClass : m_sourceClasses.keySet()) { - Collection matchedSourceClasses = m_sourceClasses.get(sourceClass); - Collection matchedDestClasses = m_matchedDestClasses.get(sourceClass); - if (matchedSourceClasses.size() == 1 && matchedDestClasses.size() == 1) { - ClassIdentity matchedSourceClass = matchedSourceClasses.iterator().next(); - ClassIdentity matchedDestClass = matchedDestClasses.iterator().next(); - uniqueMatches.put(matchedSourceClass, matchedDestClass); + public BiMap uniqueMatches() { + BiMap uniqueMatches = HashBiMap.create(); + for (ClassMatch match : matches()) { + if (match.isMatched() && !match.isAmbiguous()) { + uniqueMatches.put(match.getUniqueSource(), match.getUniqueDest()); } } return uniqueMatches; } - public BiMap,List> getAmbiguousMatches() { - BiMap,List> ambiguousMatches = HashBiMap.create(); - for (ClassIdentity sourceClass : m_sourceClasses.keySet()) { - Collection matchedSourceClasses = m_sourceClasses.get(sourceClass); - Collection matchedDestClasses = m_matchedDestClasses.get(sourceClass); - if (matchedSourceClasses.size() > 1 && matchedDestClasses.size() > 1) { - ambiguousMatches.put( - new ArrayList(matchedSourceClasses), - new ArrayList(matchedDestClasses) - ); + public Collection ambiguousMatches() { + List ambiguousMatches = Lists.newArrayList(); + for (ClassMatch match : matches()) { + if (match.isMatched() && match.isAmbiguous()) { + ambiguousMatches.add(match); } } return ambiguousMatches; } - public int getNumAmbiguousSourceMatches() { - int num = 0; - for (Map.Entry,List> entry : getAmbiguousMatches().entrySet()) { - num += entry.getKey().size(); - } - return num; - } - - public int getNumAmbiguousDestMatches() { - int num = 0; - for (Map.Entry,List> entry : getAmbiguousMatches().entrySet()) { - num += entry.getValue().size(); + public Collection unmatchedSourceClasses() { + List classes = Lists.newArrayList(); + for (ClassMatch match : matches()) { + if (!match.isMatched() && !match.sourceClasses.isEmpty()) { + classes.addAll(match.sourceClasses); + } } - return num; + return classes; } - public List getUnmatchedSourceClasses() { - List classes = Lists.newArrayList(); - for (ClassIdentity sourceClass : getSourceClasses()) { - if (m_matchedDestClasses.get(sourceClass).isEmpty()) { - classes.add(sourceClass); + public Collection unmatchedDestClasses() { + List classes = Lists.newArrayList(); + for (ClassMatch match : matches()) { + if (!match.isMatched() && !match.destClasses.isEmpty()) { + classes.addAll(match.destClasses); } } return classes; } - public List getUnmatchedDestClasses() { - return new ArrayList(m_unmatchedDestClasses); + public ClassIdentifier getSourceIdentifier() { + return m_sourceClasses.getIdentifier(); } - public Map>> getIndex() { - Map>> conversion = Maps.newHashMap(); - for (Map.Entry entry : getUniqueMatches().entrySet()) { - conversion.put( - entry.getKey().getClassEntry().getName(), - new AbstractMap.SimpleEntry>(entry.getKey(), Arrays.asList(entry.getValue())) - ); - } - for (Map.Entry,List> entry : getAmbiguousMatches().entrySet()) { - for (ClassIdentity sourceClass : entry.getKey()) { - conversion.put( - sourceClass.getClassEntry().getName(), - new AbstractMap.SimpleEntry>(sourceClass, entry.getValue()) - ); - } - } - for (ClassIdentity sourceClass : getUnmatchedSourceClasses()) { - conversion.put( - sourceClass.getClassEntry().getName(), - new AbstractMap.SimpleEntry>(sourceClass, getUnmatchedDestClasses()) - ); - } - return conversion; + public ClassIdentifier getDestIdentifier() { + return m_destClasses.getIdentifier(); } @Override public String toString() { + + // count the ambiguous classes + int numAmbiguousSource = 0; + int numAmbiguousDest = 0; + for (ClassMatch match : ambiguousMatches()) { + numAmbiguousSource += match.sourceClasses.size(); + numAmbiguousDest += match.destClasses.size(); + } + StringBuilder buf = new StringBuilder(); - buf.append(String.format("%12s%8s%8s\n", "", "Source", "Dest")); - buf.append(String.format("%12s%8d%8d\n", "Classes", getSourceClasses().size(), getDestClasses().size())); - buf.append(String.format("%12s%8d%8d\n", "Unique", getUniqueMatches().size(), getUniqueMatches().size())); - buf.append(String.format("%12s%8d%8d\n", "Ambiguous", getNumAmbiguousSourceMatches(), getNumAmbiguousDestMatches())); - buf.append(String.format("%12s%8d%8d\n", "Unmatched", getUnmatchedSourceClasses().size(), getUnmatchedDestClasses().size())); + buf.append(String.format("%20s%8s%8s\n", "", "Source", "Dest")); + buf.append(String.format("%20s%8d%8d\n", "Classes", sourceClasses().size(), destClasses().size())); + buf.append(String.format("%20s%8d%8d\n", "Uniquely matched", uniqueMatches().size(), uniqueMatches().size())); + buf.append(String.format("%20s%8d%8d\n", "Ambiguously matched", numAmbiguousSource, numAmbiguousDest)); + buf.append(String.format("%20s%8d%8d\n", "Unmatched", unmatchedSourceClasses().size(), unmatchedDestClasses().size())); return buf.toString(); } } -- cgit v1.2.3