Json format (#2)

* Added new format

* Fixed bug

* Updated Version

1 files changed, 184 insertions, 0 deletions

diff --git a/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java b/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java
new file mode 100644
index 0000000..b99537c
--- /dev/null
+++ b/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java
@@ -0,0 +1,184 @@
+/*******************************************************************************
+ * Copyright (c) 2015 Jeff Martin.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Lesser General Public
+ * License v3.0 which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/lgpl.html
+ * <p>
+ * 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 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 <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();
+        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());
+        }
+    }
+
+    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())
+            ));
+        }
+        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 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, new ClassNameReplacer() {
+                @Override
+                public String replace(String className) {
+                    return renameClassesInThing(renames, className);
+                }
+            });
+        } else if (thing instanceof Type) {
+            return (T) new Type((Type) thing, new ClassNameReplacer() {
+                @Override
+                public String replace(String className) {
+                    return renameClassesInThing(renames, className);
+                }
+            });
+        }
+
+        return thing;
+    }
+}