Follow Fabric guidelines

1 files changed, 116 insertions, 116 deletions

diff --git a/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java b/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java
index 7233fcf..75806c3 100644
--- a/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java
+++ b/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java
@@ -8,140 +8,140 @@
  * Contributors:
  * Jeff Martin - initial API and implementation
  ******************************************************************************/
+
 package cuchaz.enigma.analysis;
 
 import com.google.common.collect.Lists;
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Sets;
+import cuchaz.enigma.mapping.*;
 
 import java.util.AbstractMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-import cuchaz.enigma.mapping.*;
-
 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 <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<>(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 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<>(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<>(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<>(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();
-        for (Map.Entry<Key, Val> entry : map.entries()) {
-            entriesToAdd.add(new AbstractMap.SimpleEntry<>(renameMethodsInThing(renames, entry.getKey()), renameMethodsInThing(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();
+                for (Map.Entry<Key, Val> entry : map.entries()) {
+                        entriesToAdd.add(new AbstractMap.SimpleEntry<>(renameMethodsInThing(renames, entry.getKey()), renameMethodsInThing(renames, entry.getValue())));
+                }
+                map.clear();
+                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) {
-        // 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<>(renameMethodsInThing(renames, entry.getKey()), renameMethodsInThing(renames, entry.getValue())));
-        }
-        map.clear();
-        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) {
+                // 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<>(renameMethodsInThing(renames, entry.getKey()), renameMethodsInThing(renames, entry.getValue())));
+                }
+                map.clear();
+                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.getBehaviorEntry()),
-                    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 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.getBehaviorEntry()),
+                                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(final 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(), renameClassesInThing(renames, fieldEntry.getType()));
-        } else if (thing instanceof ConstructorEntry) {
-            ConstructorEntry constructorEntry = (ConstructorEntry) thing;
-            return (T) new ConstructorEntry(renameClassesInThing(renames, constructorEntry.getClassEntry()), renameClassesInThing(renames, constructorEntry.getSignature()));
-        } else if (thing instanceof MethodEntry) {
-            MethodEntry methodEntry = (MethodEntry) thing;
-            return (T) new MethodEntry(renameClassesInThing(renames, methodEntry.getClassEntry()), methodEntry.getName(), renameClassesInThing(renames, methodEntry.getSignature()));
-        } else if (thing instanceof ArgumentEntry) {
-            ArgumentEntry argumentEntry = (ArgumentEntry) thing;
-            return (T) new ArgumentEntry(renameClassesInThing(renames, argumentEntry.getBehaviorEntry()), 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 if (thing instanceof Signature) {
-            return (T) new Signature((Signature) thing, className -> renameClassesInThing(renames, className));
-        } else if (thing instanceof Type) {
-            return (T) new Type((Type) thing, className -> renameClassesInThing(renames, className));
-        }
+        @SuppressWarnings("unchecked")
+        public static <T> T renameClassesInThing(final 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(), renameClassesInThing(renames, fieldEntry.getType()));
+                } else if (thing instanceof ConstructorEntry) {
+                        ConstructorEntry constructorEntry = (ConstructorEntry) thing;
+                        return (T) new ConstructorEntry(renameClassesInThing(renames, constructorEntry.getClassEntry()), renameClassesInThing(renames, constructorEntry.getSignature()));
+                } else if (thing instanceof MethodEntry) {
+                        MethodEntry methodEntry = (MethodEntry) thing;
+                        return (T) new MethodEntry(renameClassesInThing(renames, methodEntry.getClassEntry()), methodEntry.getName(), renameClassesInThing(renames, methodEntry.getSignature()));
+                } else if (thing instanceof ArgumentEntry) {
+                        ArgumentEntry argumentEntry = (ArgumentEntry) thing;
+                        return (T) new ArgumentEntry(renameClassesInThing(renames, argumentEntry.getBehaviorEntry()), 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 if (thing instanceof Signature) {
+                        return (T) new Signature((Signature) thing, className -> renameClassesInThing(renames, className));
+                } else if (thing instanceof Type) {
+                        return (T) new Type((Type) thing, className -> renameClassesInThing(renames, className));
+                }
 
-        return thing;
-    }
+                return thing;
+        }
 }