From 959cb5fd4f9586ec3bd265b452fe25fe1db82e3f Mon Sep 17 00:00:00 2001
From: jeff
Date: Tue, 13 Jan 2015 23:25:04 -0500
Subject: source format change don't hate me too much if you were planning a
 big merge. =P

---
 src/cuchaz/enigma/analysis/EntryRenamer.java | 173 +++++++++++----------------
 1 file changed, 67 insertions(+), 106 deletions(-)

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

diff --git a/src/cuchaz/enigma/analysis/EntryRenamer.java b/src/cuchaz/enigma/analysis/EntryRenamer.java
index 2d59fe9..b54489c 100644
--- a/src/cuchaz/enigma/analysis/EntryRenamer.java
+++ b/src/cuchaz/enigma/analysis/EntryRenamer.java
@@ -26,100 +26,83 @@ 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 )
-	{
+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 ) );
+		for (T val : set) {
+			entries.add(renameClassesInThing(renames, val));
 		}
 		set.clear();
-		set.addAll( entries );
+		set.addAll(entries);
 	}
 	
-	public static <Key,Val> void renameClassesInMap( Map<String,String> renames, Map<Key,Val> map )
-	{
+	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() )
-			) );
+		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() );
+		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 )
-	{
+	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() )
-			) );
+		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() );
+		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 )
-	{
+	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();
-		for( Map.Entry<Key,Val> entry : map.entries() )
-		{
-			entriesToAdd.add( new AbstractMap.SimpleEntry<Key,Val>(
-				renameMethodsInThing( renames, entry.getKey() ),
-				renameMethodsInThing( renames, entry.getValue() )
-			) );
+		for (Map.Entry<Key,Val> entry : map.entries()) {
+			entriesToAdd.add(new AbstractMap.SimpleEntry<Key,Val>(
+				renameMethodsInThing(renames, entry.getKey()),
+				renameMethodsInThing(renames, entry.getValue())
+			));
 		}
 		map.clear();
-		for( Map.Entry<Key,Val> entry : entriesToAdd )
-		{
-			map.put( entry.getKey(), entry.getValue() );
+		for (Map.Entry<Key,Val> entry : entriesToAdd) {
+			map.put(entry.getKey(), entry.getValue());
 		}
 	}
 	
-	public static <Key,Val> void renameMethodsInMap( Map<MethodEntry,MethodEntry> renames, Map<Key,Val> map )
-	{
+	public static <Key,Val> void renameMethodsInMap(Map<MethodEntry,MethodEntry> 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>(
-				renameMethodsInThing( renames, entry.getKey() ),
-				renameMethodsInThing( renames, entry.getValue() )
-			) );
+		for (Map.Entry<Key,Val> entry : map.entrySet()) {
+			entriesToAdd.add(new AbstractMap.SimpleEntry<Key,Val>(
+				renameMethodsInThing(renames, entry.getKey()),
+				renameMethodsInThing(renames, entry.getValue())
+			));
 		}
 		map.clear();
-		for( Map.Entry<Key,Val> entry : entriesToAdd )
-		{
-			map.put( entry.getKey(), 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 )
-		{
+	@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 )
-			{
+			MethodEntry newMethodEntry = renames.get(methodEntry);
+			if (newMethodEntry != null) {
 				return (T)new MethodEntry(
 					methodEntry.getClassEntry(),
 					newMethodEntry.getName(),
@@ -127,81 +110,59 @@ public class EntryRenamer
 				);
 			}
 			return thing;
-		}
-		else if( thing instanceof ArgumentEntry )
-		{
+		} else if (thing instanceof ArgumentEntry) {
 			ArgumentEntry argumentEntry = (ArgumentEntry)thing;
 			return (T)new ArgumentEntry(
-				renameMethodsInThing( renames, argumentEntry.getBehaviorEntry() ),
+				renameMethodsInThing(renames, argumentEntry.getBehaviorEntry()),
 				argumentEntry.getIndex(),
 				argumentEntry.getName()
 			);
-		}
-		else if( thing instanceof EntryReference )
-		{
+		} 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 );
+			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 )
-		{
+	
+	@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 );
+			if (renames.containsKey(stringEntry)) {
+				return (T)renames.get(stringEntry);
 			}
-		}
-		else if( thing instanceof ClassEntry )
-		{
+		} else if (thing instanceof ClassEntry) {
 			ClassEntry classEntry = (ClassEntry)thing;
-			return (T)new ClassEntry( renameClassesInThing( renames, classEntry.getClassName() ) );
-		}
-		else if( thing instanceof FieldEntry )
-		{
+			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 )
-		{
+			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() ),
+				renameClassesInThing(renames, constructorEntry.getClassEntry()),
 				constructorEntry.getSignature()
 			);
-		}
-		else if( thing instanceof MethodEntry )
-		{
+		} else if (thing instanceof MethodEntry) {
 			MethodEntry methodEntry = (MethodEntry)thing;
 			return (T)new MethodEntry(
-				renameClassesInThing( renames, methodEntry.getClassEntry() ),
+				renameClassesInThing(renames, methodEntry.getClassEntry()),
 				methodEntry.getName(),
 				methodEntry.getSignature()
 			);
-		}
-		else if( thing instanceof ArgumentEntry )
-		{
+		} else if (thing instanceof ArgumentEntry) {
 			ArgumentEntry argumentEntry = (ArgumentEntry)thing;
 			return (T)new ArgumentEntry(
-				renameClassesInThing( renames, argumentEntry.getBehaviorEntry() ),
+				renameClassesInThing(renames, argumentEntry.getBehaviorEntry()),
 				argumentEntry.getIndex(),
 				argumentEntry.getName()
 			);
-		}
-		else if( thing instanceof EntryReference )
-		{
+		} 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 );
+			reference.entry = renameClassesInThing(renames, reference.entry);
+			reference.context = renameClassesInThing(renames, reference.context);
 			return thing;
 		}
 		
-- 
cgit v1.2.3