summaryrefslogtreecommitdiff
path: root/src/cuchaz/enigma/analysis/EntryRenamer.java
diff options
context:
space:
mode:
authorGravatar jeff2015-01-13 23:25:04 -0500
committerGravatar jeff2015-01-13 23:25:04 -0500
commit959cb5fd4f9586ec3bd265b452fe25fe1db82e3f (patch)
treebdd8a2c52c2fe053ba3460614bde8542e5378dbe /src/cuchaz/enigma/analysis/EntryRenamer.java
parentgot rid of gradle in favor of ivy+ssjb (diff)
downloadenigma-fork-959cb5fd4f9586ec3bd265b452fe25fe1db82e3f.tar.gz
enigma-fork-959cb5fd4f9586ec3bd265b452fe25fe1db82e3f.tar.xz
enigma-fork-959cb5fd4f9586ec3bd265b452fe25fe1db82e3f.zip
source format change
don't hate me too much if you were planning a big merge. =P
Diffstat (limited to 'src/cuchaz/enigma/analysis/EntryRenamer.java')
-rw-r--r--src/cuchaz/enigma/analysis/EntryRenamer.java173
1 files changed, 67 insertions, 106 deletions
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;
26import cuchaz.enigma.mapping.FieldEntry; 26import cuchaz.enigma.mapping.FieldEntry;
27import cuchaz.enigma.mapping.MethodEntry; 27import cuchaz.enigma.mapping.MethodEntry;
28 28
29public class EntryRenamer 29public class EntryRenamer {
30{ 30
31 public static <T> void renameClassesInSet( Map<String,String> renames, Set<T> set ) 31 public static <T> void renameClassesInSet(Map<String,String> renames, Set<T> set) {
32 {
33 List<T> entries = Lists.newArrayList(); 32 List<T> entries = Lists.newArrayList();
34 for( T val : set ) 33 for (T val : set) {
35 { 34 entries.add(renameClassesInThing(renames, val));
36 entries.add( renameClassesInThing( renames, val ) );
37 } 35 }
38 set.clear(); 36 set.clear();
39 set.addAll( entries ); 37 set.addAll(entries);
40 } 38 }
41 39
42 public static <Key,Val> void renameClassesInMap( Map<String,String> renames, Map<Key,Val> map ) 40 public static <Key,Val> void renameClassesInMap(Map<String,String> renames, Map<Key,Val> map) {
43 {
44 // for each key/value pair... 41 // for each key/value pair...
45 Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet(); 42 Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet();
46 for( Map.Entry<Key,Val> entry : map.entrySet() ) 43 for (Map.Entry<Key,Val> entry : map.entrySet()) {
47 { 44 entriesToAdd.add(new AbstractMap.SimpleEntry<Key,Val>(
48 entriesToAdd.add( new AbstractMap.SimpleEntry<Key,Val>( 45 renameClassesInThing(renames, entry.getKey()),
49 renameClassesInThing( renames, entry.getKey() ), 46 renameClassesInThing(renames, entry.getValue())
50 renameClassesInThing( renames, entry.getValue() ) 47 ));
51 ) );
52 } 48 }
53 map.clear(); 49 map.clear();
54 for( Map.Entry<Key,Val> entry : entriesToAdd ) 50 for (Map.Entry<Key,Val> entry : entriesToAdd) {
55 { 51 map.put(entry.getKey(), entry.getValue());
56 map.put( entry.getKey(), entry.getValue() );
57 } 52 }
58 } 53 }
59 54
60 public static <Key,Val> void renameClassesInMultimap( Map<String,String> renames, Multimap<Key,Val> map ) 55 public static <Key,Val> void renameClassesInMultimap(Map<String,String> renames, Multimap<Key,Val> map) {
61 {
62 // for each key/value pair... 56 // for each key/value pair...
63 Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet(); 57 Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet();
64 for( Map.Entry<Key,Val> entry : map.entries() ) 58 for (Map.Entry<Key,Val> entry : map.entries()) {
65 { 59 entriesToAdd.add(new AbstractMap.SimpleEntry<Key,Val>(
66 entriesToAdd.add( new AbstractMap.SimpleEntry<Key,Val>( 60 renameClassesInThing(renames, entry.getKey()),
67 renameClassesInThing( renames, entry.getKey() ), 61 renameClassesInThing(renames, entry.getValue())
68 renameClassesInThing( renames, entry.getValue() ) 62 ));
69 ) );
70 } 63 }
71 map.clear(); 64 map.clear();
72 for( Map.Entry<Key,Val> entry : entriesToAdd ) 65 for (Map.Entry<Key,Val> entry : entriesToAdd) {
73 { 66 map.put(entry.getKey(), entry.getValue());
74 map.put( entry.getKey(), entry.getValue() );
75 } 67 }
76 } 68 }
77 69
78 public static <Key,Val> void renameMethodsInMultimap( Map<MethodEntry,MethodEntry> renames, Multimap<Key,Val> map ) 70 public static <Key,Val> void renameMethodsInMultimap(Map<MethodEntry,MethodEntry> renames, Multimap<Key,Val> map) {
79 {
80 // for each key/value pair... 71 // for each key/value pair...
81 Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet(); 72 Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet();
82 for( Map.Entry<Key,Val> entry : map.entries() ) 73 for (Map.Entry<Key,Val> entry : map.entries()) {
83 { 74 entriesToAdd.add(new AbstractMap.SimpleEntry<Key,Val>(
84 entriesToAdd.add( new AbstractMap.SimpleEntry<Key,Val>( 75 renameMethodsInThing(renames, entry.getKey()),
85 renameMethodsInThing( renames, entry.getKey() ), 76 renameMethodsInThing(renames, entry.getValue())
86 renameMethodsInThing( renames, entry.getValue() ) 77 ));
87 ) );
88 } 78 }
89 map.clear(); 79 map.clear();
90 for( Map.Entry<Key,Val> entry : entriesToAdd ) 80 for (Map.Entry<Key,Val> entry : entriesToAdd) {
91 { 81 map.put(entry.getKey(), entry.getValue());
92 map.put( entry.getKey(), entry.getValue() );
93 } 82 }
94 } 83 }
95 84
96 public static <Key,Val> void renameMethodsInMap( Map<MethodEntry,MethodEntry> renames, Map<Key,Val> map ) 85 public static <Key,Val> void renameMethodsInMap(Map<MethodEntry,MethodEntry> renames, Map<Key,Val> map) {
97 {
98 // for each key/value pair... 86 // for each key/value pair...
99 Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet(); 87 Set<Map.Entry<Key,Val>> entriesToAdd = Sets.newHashSet();
100 for( Map.Entry<Key,Val> entry : map.entrySet() ) 88 for (Map.Entry<Key,Val> entry : map.entrySet()) {
101 { 89 entriesToAdd.add(new AbstractMap.SimpleEntry<Key,Val>(
102 entriesToAdd.add( new AbstractMap.SimpleEntry<Key,Val>( 90 renameMethodsInThing(renames, entry.getKey()),
103 renameMethodsInThing( renames, entry.getKey() ), 91 renameMethodsInThing(renames, entry.getValue())
104 renameMethodsInThing( renames, entry.getValue() ) 92 ));
105 ) );
106 } 93 }
107 map.clear(); 94 map.clear();
108 for( Map.Entry<Key,Val> entry : entriesToAdd ) 95 for (Map.Entry<Key,Val> entry : entriesToAdd) {
109 { 96 map.put(entry.getKey(), entry.getValue());
110 map.put( entry.getKey(), entry.getValue() );
111 } 97 }
112 } 98 }
113 99
114 @SuppressWarnings( "unchecked" ) 100 @SuppressWarnings("unchecked")
115 public static <T> T renameMethodsInThing( Map<MethodEntry,MethodEntry> renames, T thing ) 101 public static <T> T renameMethodsInThing(Map<MethodEntry,MethodEntry> renames, T thing) {
116 { 102 if (thing instanceof MethodEntry) {
117 if( thing instanceof MethodEntry )
118 {
119 MethodEntry methodEntry = (MethodEntry)thing; 103 MethodEntry methodEntry = (MethodEntry)thing;
120 MethodEntry newMethodEntry = renames.get( methodEntry ); 104 MethodEntry newMethodEntry = renames.get(methodEntry);
121 if( newMethodEntry != null ) 105 if (newMethodEntry != null) {
122 {
123 return (T)new MethodEntry( 106 return (T)new MethodEntry(
124 methodEntry.getClassEntry(), 107 methodEntry.getClassEntry(),
125 newMethodEntry.getName(), 108 newMethodEntry.getName(),
@@ -127,81 +110,59 @@ public class EntryRenamer
127 ); 110 );
128 } 111 }
129 return thing; 112 return thing;
130 } 113 } else if (thing instanceof ArgumentEntry) {
131 else if( thing instanceof ArgumentEntry )
132 {
133 ArgumentEntry argumentEntry = (ArgumentEntry)thing; 114 ArgumentEntry argumentEntry = (ArgumentEntry)thing;
134 return (T)new ArgumentEntry( 115 return (T)new ArgumentEntry(
135 renameMethodsInThing( renames, argumentEntry.getBehaviorEntry() ), 116 renameMethodsInThing(renames, argumentEntry.getBehaviorEntry()),
136 argumentEntry.getIndex(), 117 argumentEntry.getIndex(),
137 argumentEntry.getName() 118 argumentEntry.getName()
138 ); 119 );
139 } 120 } else if (thing instanceof EntryReference) {
140 else if( thing instanceof EntryReference )
141 {
142 EntryReference<Entry,Entry> reference = (EntryReference<Entry,Entry>)thing; 121 EntryReference<Entry,Entry> reference = (EntryReference<Entry,Entry>)thing;
143 reference.entry = renameMethodsInThing( renames, reference.entry ); 122 reference.entry = renameMethodsInThing(renames, reference.entry);
144 reference.context = renameMethodsInThing( renames, reference.context ); 123 reference.context = renameMethodsInThing(renames, reference.context);
145 return thing; 124 return thing;
146 } 125 }
147 return thing; 126 return thing;
148 } 127 }
149 128
150 @SuppressWarnings( "unchecked" ) 129 @SuppressWarnings("unchecked")
151 public static <T> T renameClassesInThing( Map<String,String> renames, T thing ) 130 public static <T> T renameClassesInThing(Map<String,String> renames, T thing) {
152 { 131 if (thing instanceof String) {
153 if( thing instanceof String )
154 {
155 String stringEntry = (String)thing; 132 String stringEntry = (String)thing;
156 if( renames.containsKey( stringEntry ) ) 133 if (renames.containsKey(stringEntry)) {
157 { 134 return (T)renames.get(stringEntry);
158 return (T)renames.get( stringEntry );
159 } 135 }
160 } 136 } else if (thing instanceof ClassEntry) {
161 else if( thing instanceof ClassEntry )
162 {
163 ClassEntry classEntry = (ClassEntry)thing; 137 ClassEntry classEntry = (ClassEntry)thing;
164 return (T)new ClassEntry( renameClassesInThing( renames, classEntry.getClassName() ) ); 138 return (T)new ClassEntry(renameClassesInThing(renames, classEntry.getClassName()));
165 } 139 } else if (thing instanceof FieldEntry) {
166 else if( thing instanceof FieldEntry )
167 {
168 FieldEntry fieldEntry = (FieldEntry)thing; 140 FieldEntry fieldEntry = (FieldEntry)thing;
169 return (T)new FieldEntry( 141 return (T)new FieldEntry(renameClassesInThing(renames, fieldEntry.getClassEntry()), fieldEntry.getName());
170 renameClassesInThing( renames, fieldEntry.getClassEntry() ), 142 } else if (thing instanceof ConstructorEntry) {
171 fieldEntry.getName()
172 );
173 }
174 else if( thing instanceof ConstructorEntry )
175 {
176 ConstructorEntry constructorEntry = (ConstructorEntry)thing; 143 ConstructorEntry constructorEntry = (ConstructorEntry)thing;
177 return (T)new ConstructorEntry( 144 return (T)new ConstructorEntry(
178 renameClassesInThing( renames, constructorEntry.getClassEntry() ), 145 renameClassesInThing(renames, constructorEntry.getClassEntry()),
179 constructorEntry.getSignature() 146 constructorEntry.getSignature()
180 ); 147 );
181 } 148 } else if (thing instanceof MethodEntry) {
182 else if( thing instanceof MethodEntry )
183 {
184 MethodEntry methodEntry = (MethodEntry)thing; 149 MethodEntry methodEntry = (MethodEntry)thing;
185 return (T)new MethodEntry( 150 return (T)new MethodEntry(
186 renameClassesInThing( renames, methodEntry.getClassEntry() ), 151 renameClassesInThing(renames, methodEntry.getClassEntry()),
187 methodEntry.getName(), 152 methodEntry.getName(),
188 methodEntry.getSignature() 153 methodEntry.getSignature()
189 ); 154 );
190 } 155 } else if (thing instanceof ArgumentEntry) {
191 else if( thing instanceof ArgumentEntry )
192 {
193 ArgumentEntry argumentEntry = (ArgumentEntry)thing; 156 ArgumentEntry argumentEntry = (ArgumentEntry)thing;
194 return (T)new ArgumentEntry( 157 return (T)new ArgumentEntry(
195 renameClassesInThing( renames, argumentEntry.getBehaviorEntry() ), 158 renameClassesInThing(renames, argumentEntry.getBehaviorEntry()),
196 argumentEntry.getIndex(), 159 argumentEntry.getIndex(),
197 argumentEntry.getName() 160 argumentEntry.getName()
198 ); 161 );
199 } 162 } else if (thing instanceof EntryReference) {
200 else if( thing instanceof EntryReference )
201 {
202 EntryReference<Entry,Entry> reference = (EntryReference<Entry,Entry>)thing; 163 EntryReference<Entry,Entry> reference = (EntryReference<Entry,Entry>)thing;
203 reference.entry = renameClassesInThing( renames, reference.entry ); 164 reference.entry = renameClassesInThing(renames, reference.entry);
204 reference.context = renameClassesInThing( renames, reference.context ); 165 reference.context = renameClassesInThing(renames, reference.context);
205 return thing; 166 return thing;
206 } 167 }
207 168
HIC SVNT DRACONES