switched to line-by-line mergable, human-readable file format for mappings

1 files changed, 84 insertions, 26 deletions

diff --git a/src/cuchaz/enigma/mapping/ClassIndex.java b/src/cuchaz/enigma/mapping/ClassMapping.java
index 699807b..3ba3569 100644
--- a/src/cuchaz/enigma/mapping/ClassIndex.java
+++ b/src/cuchaz/enigma/mapping/ClassMapping.java
@@ -14,24 +14,25 @@ import java.io.Serializable;
 import java.util.Map;
 
 import com.beust.jcommander.internal.Maps;
-import com.google.common.collect.BiMap;
-import com.google.common.collect.HashBiMap;
 
-public class ClassIndex implements Serializable
+public class ClassMapping implements Serializable
 {
         private static final long serialVersionUID = -5148491146902340107L;
         
         private String m_obfName;
         private String m_deobfName;
-        private BiMap<String,String> m_fieldsObfToDeobf;
-        private Map<String,MethodIndex> m_methodsByObf;
-        private Map<String,MethodIndex> m_methodsByDeobf;
+        private Map<String,FieldMapping> m_fieldsByObf;
+        private Map<String,FieldMapping> m_fieldsByDeobf;
+        private Map<String,MethodMapping> m_methodsByObf;
+        private Map<String,MethodMapping> m_methodsByDeobf;
         
-        public ClassIndex( String obfName, String deobfName )
+        // NOTE: this argument order is important for the MethodReader/MethodWriter
+        public ClassMapping( String obfName, String deobfName )
         {
                 m_obfName = obfName;
                 m_deobfName = deobfName;
-                m_fieldsObfToDeobf = HashBiMap.create();
+                m_fieldsByObf = Maps.newHashMap();
+                m_fieldsByDeobf = Maps.newHashMap();
                 m_methodsByObf = Maps.newHashMap();
                 m_methodsByDeobf = Maps.newHashMap();
         }
@@ -49,34 +50,91 @@ public class ClassIndex implements Serializable
         {
                 m_deobfName = val;
         }
+        
+        public Iterable<FieldMapping> fields( )
+        {
+                assert( m_fieldsByObf.size() == m_fieldsByDeobf.size() );
+                return m_fieldsByObf.values();
+        }
+        
+        protected void addFieldMapping( FieldMapping fieldMapping )
+        {
+                m_fieldsByObf.put( fieldMapping.getObfName(), fieldMapping );
+                m_fieldsByDeobf.put( fieldMapping.getDeobfName(), fieldMapping );
+        }
+
+        public Iterable<MethodMapping> methods( )
+        {
+                assert( m_methodsByObf.size() == m_methodsByDeobf.size() );
+                return m_methodsByObf.values();
+        }
+        
+        protected void addMethodMapping( MethodMapping methodMapping )
+        {
+                m_methodsByObf.put( getMethodKey( methodMapping.getObfName(), methodMapping.getObfSignature() ), methodMapping );
+                m_methodsByDeobf.put( getMethodKey( methodMapping.getDeobfName(), methodMapping.getDeobfSignature() ), methodMapping );
+        }
 
         public String getObfFieldName( String deobfName )
         {
-                return m_fieldsObfToDeobf.inverse().get( deobfName );
+                FieldMapping fieldMapping = m_fieldsByDeobf.get( deobfName );
+                if( fieldMapping != null )
+                {
+                        return fieldMapping.getObfName();
+                }
+                return null;
         }
         
         public String getDeobfFieldName( String obfName )
         {
-                return m_fieldsObfToDeobf.get( obfName );
+                FieldMapping fieldMapping = m_fieldsByObf.get( obfName );
+                if( fieldMapping != null )
+                {
+                        return fieldMapping.getDeobfName();
+                }
+                return null;
         }
         
         public void setFieldName( String obfName, String deobfName )
         {
-                m_fieldsObfToDeobf.put( obfName, deobfName );
+                if( deobfName == null )
+                {
+                        throw new IllegalArgumentException( "deobf name cannot be null!" );
+                }
+                
+                FieldMapping fieldMapping = m_fieldsByObf.get( obfName );
+                if( fieldMapping == null )
+                {
+                        fieldMapping = new FieldMapping( obfName, deobfName );
+                        m_fieldsByObf.put( obfName, fieldMapping );
+                        m_fieldsByDeobf.put( deobfName, fieldMapping );
+                }
+                
+                m_fieldsByDeobf.remove( fieldMapping.getDeobfName() );
+                fieldMapping.setDeobfName( deobfName );
+                m_fieldsByDeobf.put( deobfName, fieldMapping );
         }
         
-        public MethodIndex getMethodByObf( String obfName, String signature )
+        public MethodMapping getMethodByObf( String obfName, String signature )
         {
                 return m_methodsByObf.get( getMethodKey( obfName, signature ) );
         }
         
-        public MethodIndex getMethodByDeobf( String deobfName, String signature )
+        public MethodMapping getMethodByDeobf( String deobfName, String signature )
         {
                 return m_methodsByDeobf.get( getMethodKey( deobfName, signature ) );
         }
         
         private String getMethodKey( String name, String signature )
         {
+                if( name == null )
+                {
+                        throw new IllegalArgumentException( "name cannot be null!" );
+                }
+                if( signature == null )
+                {
+                        throw new IllegalArgumentException( "signature cannot be null!" );
+                }
                 return name + signature;
         }
         
@@ -87,7 +145,7 @@ public class ClassIndex implements Serializable
                         throw new IllegalArgumentException( "deobf name cannot be null!" );
                 }
                 
-                MethodIndex methodIndex = m_methodsByObf.get( getMethodKey( obfName, obfSignature ) );
+                MethodMapping methodIndex = m_methodsByObf.get( getMethodKey( obfName, obfSignature ) );
                 if( methodIndex == null )
                 {
                         methodIndex = createMethodIndex( obfName, obfSignature );
@@ -101,30 +159,30 @@ public class ClassIndex implements Serializable
         
         public void updateDeobfMethodSignatures( Translator translator )
         {
-                for( MethodIndex methodIndex : m_methodsByObf.values() )
+                for( MethodMapping methodIndex : m_methodsByObf.values() )
                 {
                         methodIndex.setDeobfSignature( translator.translateSignature( methodIndex.getObfSignature() ) );
                 }
         }
 
-        public void setArgumentName( String obfMethodName, String obfMethodSignature, int index, String obfName, String deobfName )
+        public void setArgumentName( String obfMethodName, String obfMethodSignature, int argumentIndex, String argumentName )
         {
-                if( deobfName == null )
+                if( argumentName == null )
                 {
-                        throw new IllegalArgumentException( "deobf name cannot be null!" );
+                        throw new IllegalArgumentException( "argument name cannot be null!" );
                 }
                 
-                MethodIndex methodIndex = m_methodsByObf.get( getMethodKey( obfMethodName, obfMethodSignature ) );
+                MethodMapping methodIndex = m_methodsByObf.get( getMethodKey( obfMethodName, obfMethodSignature ) );
                 if( methodIndex == null )
                 {
                         methodIndex = createMethodIndex( obfMethodName, obfMethodSignature );
                 }
-                methodIndex.setArgumentName( index, obfName, deobfName );
+                methodIndex.setArgumentName( argumentIndex, argumentName );
         }
 
-        private MethodIndex createMethodIndex( String obfName, String obfSignature )
+        private MethodMapping createMethodIndex( String obfName, String obfSignature )
         {
-                MethodIndex methodIndex = new MethodIndex( obfName, obfSignature, obfName, obfSignature );
+                MethodMapping methodIndex = new MethodMapping( obfName, obfName, obfSignature, obfSignature );
                 String key = getMethodKey( obfName, obfSignature );
                 m_methodsByObf.put( key, methodIndex );
                 m_methodsByDeobf.put( key, methodIndex );
@@ -140,16 +198,16 @@ public class ClassIndex implements Serializable
                 buf.append( m_deobfName );
                 buf.append( "\n" );
                 buf.append( "Fields:\n" );
-                for( Map.Entry<String,String> entry : m_fieldsObfToDeobf.entrySet() )
+                for( FieldMapping fieldMapping : fields() )
                 {
                         buf.append( "\t" );
-                        buf.append( entry.getKey() );
+                        buf.append( fieldMapping.getObfName() );
                         buf.append( " <-> " );
-                        buf.append( entry.getValue() );
+                        buf.append( fieldMapping.getDeobfName() );
                         buf.append( "\n" );
                 }
                 buf.append( "Methods:\n" );
-                for( MethodIndex methodIndex : m_methodsByObf.values() )
+                for( MethodMapping methodIndex : m_methodsByObf.values() )
                 {
                         buf.append( methodIndex.toString() );
                         buf.append( "\n" );