summaryrefslogtreecommitdiff
path: root/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java
diff options
context:
space:
mode:
Diffstat (limited to 'src/main/java/cuchaz/enigma/analysis/EntryRenamer.java')
-rw-r--r--src/main/java/cuchaz/enigma/analysis/EntryRenamer.java167
1 files changed, 0 insertions, 167 deletions
diff --git a/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java b/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java
deleted file mode 100644
index c474d68..0000000
--- a/src/main/java/cuchaz/enigma/analysis/EntryRenamer.java
+++ /dev/null
@@ -1,167 +0,0 @@
1/*******************************************************************************
2 * Copyright (c) 2015 Jeff Martin.
3 * All rights reserved. This program and the accompanying materials
4 * are made available under the terms of the GNU Lesser General Public
5 * License v3.0 which accompanies this distribution, and is available at
6 * http://www.gnu.org/licenses/lgpl.html
7 * <p>
8 * Contributors:
9 * Jeff Martin - initial API and implementation
10 ******************************************************************************/
11
12package cuchaz.enigma.analysis;
13
14import com.google.common.collect.Lists;
15import com.google.common.collect.Multimap;
16import com.google.common.collect.Sets;
17import cuchaz.enigma.mapping.*;
18import cuchaz.enigma.mapping.entry.*;
19
20import java.util.AbstractMap;
21import java.util.List;
22import java.util.Map;
23import java.util.Set;
24
25public class EntryRenamer {
26
27 public static <T> void renameClassesInSet(Map<String, String> renames, Set<T> set) {
28 List<T> entries = Lists.newArrayList();
29 for (T val : set) {
30 entries.add(renameClassesInThing(renames, val));
31 }
32 set.clear();
33 set.addAll(entries);
34 }
35
36 public static <Key, Val> void renameClassesInMap(Map<String, String> renames, Map<Key, Val> map) {
37 // for each key/value pair...
38 Set<Map.Entry<Key, Val>> entriesToAdd = Sets.newHashSet();
39 for (Map.Entry<Key, Val> entry : map.entrySet()) {
40 entriesToAdd.add(new AbstractMap.SimpleEntry<>(renameClassesInThing(renames, entry.getKey()), renameClassesInThing(renames, entry.getValue())));
41 }
42 map.clear();
43 for (Map.Entry<Key, Val> entry : entriesToAdd) {
44 map.put(entry.getKey(), entry.getValue());
45 }
46 }
47
48 public static <Key, Val> void renameClassesInMultimap(Map<String, String> renames, Multimap<Key, Val> map) {
49 // for each key/value pair...
50 Set<Map.Entry<Key, Val>> entriesToAdd = Sets.newHashSet();
51 for (Map.Entry<Key, Val> entry : map.entries()) {
52 entriesToAdd.add(new AbstractMap.SimpleEntry<>(renameClassesInThing(renames, entry.getKey()), renameClassesInThing(renames, entry.getValue())));
53 }
54 map.clear();
55 for (Map.Entry<Key, Val> entry : entriesToAdd) {
56 map.put(entry.getKey(), entry.getValue());
57 }
58 }
59
60 public static <Key, Val> void renameMethodsInMultimap(Map<MethodEntry, MethodEntry> renames, Multimap<Key, Val> map) {
61 // for each key/value pair...
62 Set<Map.Entry<Key, Val>> entriesToAdd = Sets.newHashSet();
63 for (Map.Entry<Key, Val> entry : map.entries()) {
64 entriesToAdd.add(new AbstractMap.SimpleEntry<>(renameMethodsInThing(renames, entry.getKey()), renameMethodsInThing(renames, entry.getValue())));
65 }
66 map.clear();
67 for (Map.Entry<Key, Val> entry : entriesToAdd) {
68 map.put(entry.getKey(), entry.getValue());
69 }
70 }
71
72 public static <Key, Val> void renameMethodsInMap(Map<MethodEntry, MethodEntry> renames, Map<Key, Val> map) {
73 // for each key/value pair...
74 Set<Map.Entry<Key, Val>> entriesToAdd = Sets.newHashSet();
75 for (Map.Entry<Key, Val> entry : map.entrySet()) {
76 entriesToAdd.add(new AbstractMap.SimpleEntry<>(renameMethodsInThing(renames, entry.getKey()), renameMethodsInThing(renames, entry.getValue())));
77 }
78 map.clear();
79 for (Map.Entry<Key, Val> entry : entriesToAdd) {
80 map.put(entry.getKey(), entry.getValue());
81 }
82 }
83
84 @SuppressWarnings("unchecked")
85 public static <T> T renameMethodsInThing(Map<MethodEntry, MethodEntry> renames, T thing) {
86 if (thing instanceof MethodEntry) {
87 MethodEntry methodEntry = (MethodEntry) thing;
88 MethodEntry newMethodEntry = renames.get(methodEntry);
89 if (newMethodEntry != null) {
90 return (T) new MethodEntry(
91 methodEntry.getOwnerClassEntry(),
92 newMethodEntry.getName(),
93 methodEntry.getDesc()
94 );
95 }
96 return thing;
97 } else if (thing instanceof LocalVariableEntry) {
98 LocalVariableEntry variableEntry = (LocalVariableEntry) thing;
99 return (T) new LocalVariableEntry(
100 renameMethodsInThing(renames, variableEntry.getOwnerEntry()),
101 variableEntry.getIndex(),
102 variableEntry.getName(),
103 variableEntry.isParameter()
104 );
105 } else if (thing instanceof EntryReference) {
106 EntryReference<Entry, Entry> reference = (EntryReference<Entry, Entry>) thing;
107 reference.entry = renameMethodsInThing(renames, reference.entry);
108 reference.context = renameMethodsInThing(renames, reference.context);
109 return thing;
110 }
111 return thing;
112 }
113
114 @SuppressWarnings("unchecked")
115 public static <T> T renameClassesInThing(final Map<String, String> renames, T thing) {
116 if (thing instanceof String) {
117 String stringEntry = (String) thing;
118 if (renames.containsKey(stringEntry)) {
119 return (T) renames.get(stringEntry);
120 }
121 } else if (thing instanceof ClassEntry) {
122 ClassEntry classEntry = (ClassEntry) thing;
123 return (T) new ClassEntry(renameClassesInThing(renames, classEntry.getClassName()));
124 } else if (thing instanceof FieldDefEntry) {
125 FieldDefEntry fieldEntry = (FieldDefEntry) thing;
126 return (T) new FieldDefEntry(
127 renameClassesInThing(renames, fieldEntry.getOwnerClassEntry()),
128 fieldEntry.getName(),
129 renameClassesInThing(renames, fieldEntry.getDesc()),
130 renameClassesInThing(renames, fieldEntry.getSignature()),
131 fieldEntry.getAccess()
132 );
133 } else if (thing instanceof MethodDefEntry) {
134 MethodDefEntry methodEntry = (MethodDefEntry) thing;
135 return (T) new MethodDefEntry(
136 renameClassesInThing(renames, methodEntry.getOwnerClassEntry()),
137 methodEntry.getName(),
138 renameClassesInThing(renames, methodEntry.getDesc()),
139 renameClassesInThing(renames, methodEntry.getSignature()),
140 methodEntry.getAccess()
141 );
142 } else if (thing instanceof MethodEntry) {
143 MethodEntry methodEntry = (MethodEntry) thing;
144 return (T) new MethodEntry(
145 renameClassesInThing(renames, methodEntry.getOwnerClassEntry()),
146 methodEntry.getName(),
147 renameClassesInThing(renames, methodEntry.getDesc())
148 );
149 } else if (thing instanceof LocalVariableEntry) {
150 LocalVariableEntry argumentEntry = (LocalVariableEntry) thing;
151 return (T) new LocalVariableEntry(renameClassesInThing(renames, argumentEntry.getOwnerEntry()), argumentEntry.getIndex(), argumentEntry.getName(), argumentEntry.isParameter());
152 } else if (thing instanceof EntryReference) {
153 EntryReference<Entry, Entry> reference = (EntryReference<Entry, Entry>) thing;
154 reference.entry = renameClassesInThing(renames, reference.entry);
155 reference.context = renameClassesInThing(renames, reference.context);
156 return thing;
157 } else if (thing instanceof MethodDescriptor) {
158 return (T) ((MethodDescriptor) thing).remap(className -> renameClassesInThing(renames, className));
159 } else if (thing instanceof TypeDescriptor) {
160 return (T) ((TypeDescriptor) thing).remap(className -> renameClassesInThing(renames, className));
161 } else if (thing instanceof Signature) {
162 return (T) ((Signature) thing).remap(className -> renameClassesInThing(renames, className));
163 }
164
165 return thing;
166 }
167}
HIC SVNT DRACONES