Port to java

Overall, this makes the library _much_ clear, and likely fixes
long-lasting bugs.

Author: Techcable

.gitignore

@@ -121,3 +121,6 @@ target/
 
 # A big file I use to test performance:
 joined.srg
+
+# Maven
+target

pom.xml

@@ -0,0 +1,44 @@
+<project>
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>net.techcable</groupId>
+    <artifactId>srglib</artifactId>
+    <version>0.1.0-alpha1-SNAPSHOT</version>
+    <properties>
+        <java.version>1.8</java.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>20.0</version>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.code.findbugs</groupId>
+            <artifactId>jsr305</artifactId>
+            <version>1.3.9</version>
+            <scope>provided</scope>
+            <optional>true</optional>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.5.1</version>
+                <configuration>
+                    <source>${java.version}</source>
+                    <target>${java.version}</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

profiling.py

@@ -0,0 +1,73 @@
+package net.techcable.srglib;
+
+import static java.util.Objects.*;
+
+/**
+ * An array type
+ */
+/* package */ final class ArrayType implements JavaType {
+    private final JavaType elementType;
+    public ArrayType(JavaType elementType) {
+        this.elementType = requireNonNull(elementType);
+    }
+
+    /**
+     * Return the element type of this array.
+     *
+     * @return the element type
+     */
+    @Override
+    public JavaType getElementType() {
+        return elementType;
+    }
+
+    @Override
+    public JavaTypeSort getSort() {
+        return JavaTypeSort.ARRAY_TYPE;
+    }
+
+    @Override
+    public String getInternalName() {
+        return elementType.getInternalName() + "[]";
+    }
+
+    @Override
+    public String getDescriptor() {
+        return "[" + elementType.getDescriptor();
+    }
+
+    @Override
+    public String getName() {
+        return elementType.getName() + "[]";
+    }
+
+    private JavaType innermostType;
+    private JavaType getInnermostType() {
+        if (innermostType == null) {
+            JavaType innermostType = this.elementType;
+            while (innermostType instanceof ArrayType) {
+                innermostType = ((ArrayType) innermostType).elementType;
+            }
+            this.innermostType = innermostType;
+        }
+        return innermostType;
+    }
+
+    @Override
+    public int hashCode() {
+        // Invert the bits to distribute it better
+        return ~getInnermostType().hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        return obj == this || obj != null
+                && obj.getClass() == ArrayType.class
+                && this.getInnermostType().equals(((ArrayType) obj).getInnermostType());
+    }
+
+    @Override
+    public String toString() {
+        return getName();
+    }
+}

setup.py

@@ -0,0 +1,99 @@
+package net.techcable.srglib;
+
+import java.util.function.UnaryOperator;
+
+import static com.google.common.base.Preconditions.*;
+import static java.util.Objects.*;
+
+/**
+ * A field's name and declaring type.
+ */
+public final class FieldData {
+    private final JavaType declaringType;
+    private final String name;
+
+    private FieldData(JavaType declaringType, String name) {
+        this.declaringType = requireNonNull(declaringType, "Null declaring type");
+        this.name = requireNonNull(name, "Null name");
+        checkArgument(SrgLib.isValidIdentifier(name), "Invalid name: %s", name);
+    }
+
+    /**
+     * Return the declaring type of this field
+     *
+     * @return the declaring type
+     */
+    public JavaType getDeclaringType() {
+        return declaringType;
+    }
+
+    /**
+     * Return the name of this field
+     *
+     * @return the name
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Return the internal name of this field.
+     * <p>
+     * Internal method names are in the format ${internal type name}/${field name}.
+     * </p>
+     *
+     * @return the internal name
+     */
+    public String getInternalName() {
+        return this.declaringType.getInternalName() + "/" + this.name;
+    }
+
+    public FieldData withName(String name) {
+        return new FieldData(declaringType, name);
+    }
+
+    public boolean hasSameTypes(FieldData other) {
+        requireNonNull(other, "Null other data!");
+        return this.declaringType.equals(other.declaringType);
+    }
+
+    public FieldData withDeclaringType(JavaType declaringType) {
+        return new FieldData(declaringType, name);
+    }
+
+    public FieldData mapTypes(UnaryOperator<JavaType> transformer) {
+        return new FieldData(transformer.apply(declaringType), name);
+    }
+
+
+    public static FieldData create(JavaType declaringType, String name) {
+        return new FieldData(declaringType, name);
+    }
+
+
+    @Override
+    public int hashCode() {
+        return declaringType.hashCode() ^ name.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        return obj == this || obj != null
+                && obj.getClass() == FieldData.class
+                && ((FieldData) obj).declaringType.equals(this.declaringType)
+                && ((FieldData) obj).name.equals(this.name);
+    }
+
+    @Override
+    public String toString() {
+        return getInternalName();
+    }
+
+    public static FieldData fromInternalName(String internalName) {
+        int index = internalName.lastIndexOf('/');
+        checkArgument(index >= 0 && index < internalName.length() - 1, "Invalid internal name: %s", internalName);
+        JavaType declaringType = JavaType.fromInternalName(internalName.substring(0, index));
+        String name = internalName.substring(index + 1);
+        return create(declaringType, name);
+    }
+}