Optimized Map/Set lookups in Structure

Reduced the number of Set lookups in Structure.read / Structure.write.
Introduced a new class to replace two entries of a HashMap with one.
This reduces the number of lookups and the initial capacity has been
reduced too.

Author: joerg1985

src/com/sun/jna/Structure.java

@@ -127,6 +127,17 @@ public interface ByValue { }
      */
     public interface ByReference { }
 
+    private static class PointerTracking {
+
+        private final Pointer pointer;
+        private final Object value;
+
+        PointerTracking(Pointer pointer, Object value) {
+            this.pointer = pointer;
+            this.value = value;
+        }
+    }
+
     /** Use the platform default alignment. */
     public static final int ALIGN_DEFAULT = 0;
     /** No alignment, place all fields on nearest 1-byte boundary */
@@ -157,7 +168,7 @@ public interface ByReference { }
     private Map<String, StructField> structFields;
     // Keep track of native C strings which have been allocated,
     // corresponding to String fields of this Structure
-    private final Map<String, Object> nativeStrings = new HashMap<String, Object>();
+    private final Map<String, PointerTracking> nativeStrings = new HashMap<String, PointerTracking>(8);
     private TypeMapper typeMapper;
     // This field is accessed by native code
     private long typeInfo;
@@ -343,14 +354,15 @@ void useMemory(Pointer m, int offset, boolean force) {
                 this.memory.write(0, buf, 0, buf.length);
             }
             else {
-                // Ensure our memory pointer is initialized, even if we can't
-                // yet figure out a proper size/layout
-                this.memory = m.share(offset);
                 if (size == CALCULATE_SIZE) {
                     size = calculateSize(false);
                 }
                 if (size != CALCULATE_SIZE) {
                     this.memory = m.share(offset, size);
+                } else {
+                    // Ensure our memory pointer is initialized, even if we can't
+                    // yet figure out a proper size/layout
+                    this.memory = m.share(offset);
                 }
             }
             this.array = null;
@@ -508,8 +520,9 @@ public boolean add(Structure o) {
             if (!contains(o)) {
                 ensureCapacity(count+1);
                 elements[count++] = o;
+                return true;
             }
-            return true;
+            return false;
         }
         private int indexOf(Structure s1) {
             for (int i=0;i < count;i++) {
@@ -579,10 +592,9 @@ public void read() {
         ensureAllocated();
 
         // Avoid redundant reads
-        if (busy().contains(this)) {
+        if (!busy().add(this)) {
             return;
         }
-        busy().add(this);
         if (this instanceof Structure.ByReference) {
             reading().put(getPointer(), this);
         }
@@ -593,7 +605,7 @@ public void read() {
         }
         finally {
             busy().remove(this);
-            if (reading().get(getPointer()) == this) {
+            if (this instanceof Structure.ByReference && reading().get(getPointer()) == this) {
                 reading().remove(getPointer());
             }
         }
@@ -740,8 +752,7 @@ protected Object readField(StructField structField) {
 
         if (fieldType.equals(String.class)
             || fieldType.equals(WString.class)) {
-            nativeStrings.put(structField.name + ".ptr", memory.getPointer(offset));
-            nativeStrings.put(structField.name + ".val", result);
+            nativeStrings.put(structField.name, new PointerTracking(memory.getPointer(offset), result));
         }
 
         // Update the value on the Java field
@@ -769,10 +780,9 @@ public void write() {
         }
 
         // Avoid redundant writes
-        if (busy().contains(this)) {
+        if (!busy().add(this)) {
             return;
         }
-        busy().add(this);
         try {
             // Write all fields, except those marked 'volatile'
             for (StructField sf : fields().values()) {
@@ -845,23 +855,21 @@ protected void writeField(StructField structField) {
             if (value != null) {
                 // If we've already allocated a native string here, and the
                 // string value is unchanged, leave it alone
-                if (nativeStrings.containsKey(structField.name + ".ptr")
-                    && value.equals(nativeStrings.get(structField.name + ".val"))) {
+                PointerTracking tracking = nativeStrings.get(structField.name);
+                if (tracking != null && value.equals(tracking.value)) {
                     return;
                 }
                 NativeString nativeString = wide
                     ? new NativeString(value.toString(), true)
                     : new NativeString(value.toString(), encoding);
                 // Keep track of allocated C strings to avoid
                 // premature garbage collection of the memory.
-                nativeStrings.put(structField.name, nativeString);
+                nativeStrings.put(structField.name, new PointerTracking(nativeString.getPointer(), nativeString));
                 value = nativeString.getPointer();
             }
             else {
                 nativeStrings.remove(structField.name);
             }
-            nativeStrings.remove(structField.name + ".ptr");
-            nativeStrings.remove(structField.name + ".val");
         }
 
         try {