1 files changed, 43 insertions, 37 deletions

diff --git a/src/main/java/ftbsc/lll/mapper/impl/SRGMapper.java b/src/main/java/ftbsc/lll/mapper/impl/SRGMapper.java
index e47ca38..c92dba7 100644
--- a/src/main/java/ftbsc/lll/mapper/impl/SRGMapper.java
+++ b/src/main/java/ftbsc/lll/mapper/impl/SRGMapper.java
@@ -2,27 +2,17 @@ package ftbsc.lll.mapper.impl;
 
 import com.google.auto.service.AutoService;
 import ftbsc.lll.exceptions.MalformedMappingsException;
-import ftbsc.lll.mapper.AbstractMapper;
-import ftbsc.lll.mapper.IMapper;
+import ftbsc.lll.mapper.IMappingFormat;
+import ftbsc.lll.mapper.tools.Mapper;
 import ftbsc.lll.mapper.tools.data.ClassData;
 
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 
 /**
- * A {@link IMapper} capable of parsing SRG mappings.
+ * A {@link IMappingFormat} capable of parsing SRG mappings.
  */
-@AutoService(IMapper.class)
-public class SRGMapper extends AbstractMapper {
-
-	/**
-	 * A {@link Map} tying each obfuscated name to its class data.
-	 * Done this way because SRG files provide mapped descriptors in advance,
-	 * so we can populate this right a way in a less expensive way.
-	 */
-	private final Map<String, ClassData> mappingsInverted = new HashMap<>();
-
+@AutoService(IMappingFormat.class)
+public class SRGMapper implements IMappingFormat {
 
 	@Override
 	public boolean claim(List<String> lines) {
@@ -33,33 +23,47 @@ public class SRGMapper extends AbstractMapper {
 				|| firstLineTokens[0].equals("FD:"));
 	}
 
-	@Override
-	public void populate(List<String> lines, boolean ignoreErrors) throws MalformedMappingsException {
+	/**
+	 * Builds the two mappers, and returns one of the two depending on the flag.
+	 * Since the SRG format contains descriptor mappings, it's possible to process
+	 * this right away.
+	 * @param lines the lines to read
+	 * @param ignoreErrors try to ignore errors and keep going
+	 * @param inverted whether it should return the inverted one
+	 * @return the {@link Mapper}, inverted depending on the flag
+	 * @throws MalformedMappingsException if an error is encountered and ignoreErrors is false
+	 */
+	protected Mapper buildMapper(List<String> lines, boolean ignoreErrors, boolean inverted) throws MalformedMappingsException {
+		Mapper mapper = new Mapper();
+		Mapper invertedMapper = new Mapper();
 		for(int i = 0; i < lines.size(); i++) {
 			String[] tokens = lines.get(i).trim().split(" ");
 			switch(tokens[0]) {
 				case "CL:":
 					if(tokens.length != 3)
 						break;
-					this.registerClass(tokens[1], tokens[2]);
+					this.registerClass(mapper, invertedMapper, tokens[1], tokens[2]);
 					continue;
 				case "MD:":
 				case "FD:":
-					if(this.processMemberTokens(tokens))
+					if(this.processMemberTokens(mapper, invertedMapper, tokens))
 						continue;
 					break;
 			}
 			if(!ignoreErrors)
 				throw new MalformedMappingsException(i, "wrong number of space-separated tokens");
 		}
+		return inverted ? invertedMapper : mapper;
 	}
 
 	/**
 	 * Processes a line, broken up into tokens.
+	 * @param mapper the {@link Mapper} with normal mappings
+	 * @param invertedMapper the {@link Mapper} with inverted mappings
 	 * @param tokens the tokens
 	 * @return whether it was a valid mapping
 	 */
-	private boolean processMemberTokens(String[] tokens) {
+	private boolean processMemberTokens(Mapper mapper, Mapper invertedMapper, String[] tokens) {
 		boolean field;
 		if(tokens[0].equals("MD:")) {
 			if(tokens.length != 5)
@@ -78,25 +82,29 @@ public class SRGMapper extends AbstractMapper {
 		split = tokens[obfPosition].split("/");
 		String memberNameObf = split[split.length - 1];
 		String parentObf = tokens[obfPosition].substring(0, tokens[obfPosition].length() - split[split.length - 1].length() - 1);
-		if(field) this.registerMember(parent, parentObf, memberName, memberNameObf, null, null);
-		else this.registerMember(parent, parentObf, memberName, memberNameObf, tokens[2], tokens[4]);
+		this.registerMember(mapper, invertedMapper, parent, parentObf, memberName, memberNameObf,
+			field ? null : tokens[2], field ? null : tokens[4]);
 		return true;
 	}
 
 	/**
 	 * Registers a class in the mapper, if it isn't already.
+	 * @param mapper the {@link Mapper} with normal mappings
+	 * @param invertedMapper the {@link Mapper} with inverted mappings
 	 * @param name the name
 	 * @param nameMapped the mapped name
 	 */
-	private void registerClass(String name, String nameMapped) {
-		if(this.mappings.containsKey(name))
+	private void registerClass(Mapper mapper, Mapper invertedMapper, String name, String nameMapped) {
+		if(mapper.getRawMappings().containsKey(name))
 			return;
-		this.mappings.put(name, new ClassData(name, nameMapped));
-		this.mappingsInverted.put(nameMapped, new ClassData(nameMapped, name));
+		mapper.getRawMappings().put(name, new ClassData(name, nameMapped));
+		invertedMapper.getRawMappings().put(nameMapped, new ClassData(nameMapped, name));
 	}
 
 	/**
 	 * Registers a class member. The descriptors should be null for fields.
+	 * @param mapper the {@link Mapper} with normal mappings
+	 * @param invertedMapper the {@link Mapper} with inverted mappings
 	 * @param parent the parent's plain internal name
 	 * @param parentMapped the parent's mapped internal name
 	 * @param name the member's plain name
@@ -104,11 +112,12 @@ public class SRGMapper extends AbstractMapper {
 	 * @param descriptor the member's plain descriptor, may be null
 	 * @param descriptorMapped the member's mapped descriptor, may be null
 	 */
-	private void registerMember(String parent, String parentMapped, String name, String nameMapped,
+	private void registerMember(Mapper mapper, Mapper invertedMapper, String parent,
+															String parentMapped, String name, String nameMapped,
 															String descriptor, String descriptorMapped) {
-		this.registerClass(parent, parentMapped);
-		ClassData data = this.mappings.get(parent);
-		ClassData dataReverse = this.mappings.get(data.nameMapped);
+		this.registerClass(mapper, invertedMapper, parent, parentMapped);
+		ClassData data = mapper.getClassData(parent);
+		ClassData dataReverse = invertedMapper.getClassData(data.nameMapped);
 		if(descriptor == null || descriptorMapped == null) {
 			//field
 			data.addField(name, nameMapped);
@@ -121,15 +130,12 @@ public class SRGMapper extends AbstractMapper {
 	}
 
 	@Override
-	public IMapper getInverted() {
-		SRGMapper inverted = new SRGMapper();
-		inverted.mappings.putAll(this.mappingsInverted);
-		inverted.mappingsInverted.putAll(this.mappings); //in case some weirdo calls getInverted() twice
-		return inverted;
+	public Mapper getMapper(List<String> lines, boolean ignoreErrors) throws MalformedMappingsException {
+		return this.buildMapper(lines, ignoreErrors, false);
 	}
 
 	@Override
-	protected AbstractMapper newInstance() { //not really used but whatever
-		return new SRGMapper();
+	public Mapper getInvertedMapper(List<String> lines, boolean ignoreErrors) {
+		return this.buildMapper(lines, ignoreErrors, true);
 	}
 }
\ No newline at end of file