From 360bbd1c2fca8cbd575907b7d930a8072fccb0c2 Mon Sep 17 00:00:00 2001
From: jeff
Date: Mon, 1 Sep 2014 22:52:07 -0400
Subject: refactored jar,translation index. fixed bug with field renaming when
 fields are shadowed by subclasses

---
 src/cuchaz/enigma/analysis/EntryRenamer.java | 199 +++++++++++++++++++++++++++
 1 file changed, 199 insertions(+)
 create mode 100644 src/cuchaz/enigma/analysis/EntryRenamer.java

(limited to 'src/cuchaz/enigma/analysis/EntryRenamer.java')

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;
+	}
+}
-- 
cgit v1.2.3