refactored jar,translation index. fixed bug with field renaming when fields are shadowed by subclasses

1 files changed, 199 insertions, 0 deletions

diff --git a/src/cuchaz/enigma/analysis/EntryRenamer.java b/src/cuchaz/enigma/analysis/EntryRenamer.java
new file mode 100644
index 0000000..4b2c0b7
--- /dev/null
+++ b/src/cuchaz/enigma/analysis/EntryRenamer.java
@@ -0,0 +1,199 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ * 
+ * Contributors:
+ *     Jeff Martin - initial API and implementation
+ ******************************************************************************/
+package cuchaz.enigma.analysis;
+
+import java.util.AbstractMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.beust.jcommander.internal.Lists;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Sets;
+
+import cuchaz.enigma.mapping.ArgumentEntry;
+import cuchaz.enigma.mapping.ClassEntry;
+import cuchaz.enigma.mapping.ConstructorEntry;
+import cuchaz.enigma.mapping.Entry;
+import cuchaz.enigma.mapping.FieldEntry;
+import cuchaz.enigma.mapping.MethodEntry;
+
+public class EntryRenamer
+{
+        public static <T> void renameClassesInSet( Map<String,String> renames, Set<T> set )
+        {
+                List<T> entries = Lists.newArrayList();
+                for( T val : set )
+                {
+                        entries.add( renameClassesInThing( renames, val ) );
+                }
+                set.clear();
+                set.addAll( entries );
+        }
+        
+        public static <Key,Val> void renameClassesInMap( Map<String,String> renames, Map<Key,Val> map )
+        {
+                // for each key/value pair...
+                Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet();
+                for( Map.Entry<Key,Val> entry : map.entrySet() )
+                {
+                        entriesToAdd.add( new AbstractMap.SimpleEntry<Key,Val>(
+                                renameClassesInThing( renames, entry.getKey() ),
+                                renameClassesInThing( renames, entry.getValue() )
+                        ) );
+                }
+                map.clear();
+                for( Map.Entry<Key,Val> entry : entriesToAdd )
+                {
+                        map.put( entry.getKey(), entry.getValue() );
+                }
+        }
+        
+        public static <Key,Val> void renameClassesInMultimap( Map<String,String> renames, Multimap<Key,Val> map )
+        {
+                // for each key/value pair...
+                Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet();
+                for( Map.Entry<Key,Val> entry : map.entries() )
+                {
+                        entriesToAdd.add( new AbstractMap.SimpleEntry<Key,Val>(
+                                renameClassesInThing( renames, entry.getKey() ),
+                                renameClassesInThing( renames, entry.getValue() )
+                        ) );
+                }
+                map.clear();
+                for( Map.Entry<Key,Val> entry : entriesToAdd )
+                {
+                        map.put( entry.getKey(), entry.getValue() );
+                }
+        }
+        
+        public static <Key,Val> void renameMethodsInMultimap( Map<MethodEntry,MethodEntry> renames, Multimap<Key,Val> map )
+        {
+                // for each key/value pair...
+                Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet();
+                Iterator<Map.Entry<Key,Val>> iter = map.entries().iterator();
+                while( iter.hasNext() )
+                {
+                        Map.Entry<Key,Val> entry = iter.next();
+                        iter.remove();
+                        entriesToAdd.add( new AbstractMap.SimpleEntry<Key,Val>(
+                                renameMethodsInThing( renames, entry.getKey() ),
+                                renameMethodsInThing( renames, entry.getValue() )
+                        ) );
+                }
+                for( Map.Entry<Key,Val> entry : entriesToAdd )
+                {
+                        map.put( entry.getKey(), entry.getValue() );
+                }
+        }
+        
+        @SuppressWarnings( "unchecked" )
+        public static <T> T renameMethodsInThing( Map<MethodEntry,MethodEntry> renames, T thing )
+        {
+                if( thing instanceof MethodEntry )
+                {
+                        MethodEntry methodEntry = (MethodEntry)thing;
+                        MethodEntry newMethodEntry = renames.get( methodEntry );
+                        if( newMethodEntry != null )
+                        {
+                                return (T)new MethodEntry(
+                                        methodEntry.getClassEntry(),
+                                        newMethodEntry.getName(),
+                                        methodEntry.getSignature()
+                                );
+                        }
+                        return thing;
+                }
+                else if( thing instanceof ArgumentEntry )
+                {
+                        ArgumentEntry argumentEntry = (ArgumentEntry)thing;
+                        return (T)new ArgumentEntry(
+                                renameMethodsInThing( renames, argumentEntry.getMethodEntry() ),
+                                argumentEntry.getIndex(),
+                                argumentEntry.getName()
+                        );
+                }
+                else if( thing instanceof EntryReference )
+                {
+                        EntryReference<Entry,Entry> reference = (EntryReference<Entry,Entry>)thing;
+                        reference.entry = renameMethodsInThing( renames, reference.entry );
+                        reference.context = renameMethodsInThing( renames, reference.context );
+                        return thing;
+                }
+                return thing;
+        }
+
+        @SuppressWarnings( "unchecked" )
+        public static <T> T renameClassesInThing( Map<String,String> renames, T thing )
+        {
+                if( thing instanceof String )
+                {
+                        String stringEntry = (String)thing;
+                        if( renames.containsKey( stringEntry ) )
+                        {
+                                return (T)renames.get( stringEntry );
+                        }
+                }
+                else if( thing instanceof ClassEntry )
+                {
+                        ClassEntry classEntry = (ClassEntry)thing;
+                        return (T)new ClassEntry( renameClassesInThing( renames, classEntry.getClassName() ) );
+                }
+                else if( thing instanceof FieldEntry )
+                {
+                        FieldEntry fieldEntry = (FieldEntry)thing;
+                        return (T)new FieldEntry(
+                                renameClassesInThing( renames, fieldEntry.getClassEntry() ),
+                                fieldEntry.getName()
+                        );
+                }
+                else if( thing instanceof ConstructorEntry )
+                {
+                        ConstructorEntry constructorEntry = (ConstructorEntry)thing;
+                        return (T)new ConstructorEntry(
+                                renameClassesInThing( renames, constructorEntry.getClassEntry() ),
+                                constructorEntry.getSignature()
+                        );
+                }
+                else if( thing instanceof MethodEntry )
+                {
+                        MethodEntry methodEntry = (MethodEntry)thing;
+                        return (T)new MethodEntry(
+                                renameClassesInThing( renames, methodEntry.getClassEntry() ),
+                                methodEntry.getName(),
+                                methodEntry.getSignature()
+                        );
+                }
+                else if( thing instanceof ArgumentEntry )
+                {
+                        ArgumentEntry argumentEntry = (ArgumentEntry)thing;
+                        return (T)new ArgumentEntry(
+                                renameClassesInThing( renames, argumentEntry.getMethodEntry() ),
+                                argumentEntry.getIndex(),
+                                argumentEntry.getName()
+                        );
+                }
+                else if( thing instanceof EntryReference )
+                {
+                        EntryReference<Entry,Entry> reference = (EntryReference<Entry,Entry>)thing;
+                        reference.entry = renameClassesInThing( renames, reference.entry );
+                        reference.context = renameClassesInThing( renames, reference.context );
+                        return thing;
+                }
+                else
+                {
+                        throw new Error( "Not an entry: " + thing );
+                }
+                
+                return thing;
+        }
+}