add some more builder classes; rename ptr -> buffer

Makefile

@@ -3,11 +3,13 @@ CXX=g++ -std=c++11
 CAPNP_SOURCES=\
 	src/capnp/AnyPointer.java\
 	src/capnp/FieldSize.java\
+	src/capnp/FromStructBuilder.java\
 	src/capnp/FromStructReader.java\
 	src/capnp/InputStreamMessageReader.java\
 	src/capnp/ListPointer.java\
 	src/capnp/ListBuilder.java\
 	src/capnp/ListReader.java\
+	src/capnp/MessageBuilder.java\
 	src/capnp/MessageReader.java\
 	src/capnp/PointerBuilder.java\
 	src/capnp/PointerReader.java\

src/capnp/FromStructBuilder.java

@@ -0,0 +1,5 @@
+package org.capnproto;
+
+public interface FromStructBuilder<T> {
+    public abstract T fromStructBuilder(StructBuilder builder);
+}

src/capnp/MessageBuilder.java

@@ -0,0 +1,5 @@
+package org.capnproto;
+
+public final class MessageBuilder {
+    
+}

src/capnp/PointerReader.java

@@ -25,7 +25,7 @@ public class PointerReader {
     }
 
     public boolean isNull() {
-        return this.segment.ptr.getLong(this.pointer) == 0;
+        return this.segment.buffer.getLong(this.pointer) == 0;
     }
 
     public StructReader getStruct() {

src/capnp/SegmentReader.java

@@ -3,9 +3,9 @@ package org.capnproto;
 import java.nio.ByteBuffer;
 
 public class SegmentReader {
-    ByteBuffer ptr;
+    ByteBuffer buffer;
 
-    public SegmentReader(ByteBuffer ptr) {
-        this.ptr = ptr;
+    public SegmentReader(ByteBuffer buffer) {
+        this.buffer = buffer;
     }
 }

src/capnp/StructBuilder.java

@@ -19,13 +19,20 @@ public final class StructBuilder {
         this.bit0Offset = bit0Offset;
     }
 
-
-    public int getIntField(int offset) {
-        return this.segment.ptr.getInt(this.data + offset * 4);
+    public final int getShortField(int offset) {
+        return this.segment.buffer.getShort(this.data + offset * 2);
     }
 
-    public void setIntField(int offset, int value) {
-        this.segment.ptr.putInt(this.data + offset * 4, value);
+    public final void setShortField(int offset, short value) {
+        this.segment.buffer.putShort(this.data + offset * 2, value);
+    }
+
+    public final int getIntField(int offset) {
+        return this.segment.buffer.getInt(this.data + offset * 4);
+    }
+
+    public final void setIntField(int offset, int value) {
+        this.segment.buffer.putInt(this.data + offset * 4, value);
     }
 
 }

src/capnp/StructReader.java

@@ -1,6 +1,6 @@
 package org.capnproto;
 
-public class StructReader {
+public final class StructReader {
     public SegmentReader segment;
     public int data; //byte offset to data section
     public int pointers; // word offset of pointer section
@@ -22,44 +22,44 @@ public class StructReader {
         this.nestingLimit = nestingLimit;
     }
 
-    public boolean getBoolField(int offset) {
+    public final boolean getBoolField(int offset) {
         // XXX should use unsigned operations
         if (offset < this.dataSize) {
             if (offset == 0) {
                 offset = this.bit0Offset;
             }
-            byte b = this.segment.ptr.get(offset / 8);
+            byte b = this.segment.buffer.get(offset / 8);
             return (b & (1 << (offset % 8))) != 0;
         } else {
             return false;
         }
     }
 
-    public byte getByteField(int offset) {
+    public final byte getByteField(int offset) {
         if ((offset + 1) * 8 <= this.dataSize) {
-            return this.segment.ptr.get(this.data + offset);
+            return this.segment.buffer.get(this.data + offset);
         } else {
             return 0;
         }
     }
 
-    public byte getShortField(int offset) {
+    public final byte getShortField(int offset) {
         if ((offset + 1) * 16 <= this.dataSize) {
-            return this.segment.ptr.get(this.data + offset * 2);
+            return this.segment.buffer.get(this.data + offset * 2);
         } else {
             return 0;
         }
     }
 
-    public int getIntField(int offset) {
+    public final int getIntField(int offset) {
         if ((offset + 1) * 32 <= this.dataSize) {
-            return this.segment.ptr.getInt(this.data + offset * 4);
+            return this.segment.buffer.getInt(this.data + offset * 4);
         } else {
             return 0;
         }
     }
 
-    public PointerReader getPointerField(int ptrIndex) {
+    public final PointerReader getPointerField(int ptrIndex) {
         if (ptrIndex < this.pointerCount) {
             return new PointerReader(this.segment,
                                      this.pointers + ptrIndex,

src/capnp/WireHelpers.java

@@ -8,7 +8,7 @@ final class WireHelpers {
 
         // TODO error handling
 
-        long ref = WirePointer.get(segment.ptr, refOffset);
+        long ref = WirePointer.get(segment.buffer, refOffset);
         int ptrOffset = WirePointer.target(refOffset, ref);
         int structPtr = WirePointer.structPointer(ref);
         int dataSizeWords = StructPointer.dataSize(structPtr);
@@ -29,7 +29,7 @@ final class WireHelpers {
                                              byte expectedElementSize,
                                              int nestingLimit) {
 
-        long ref = WirePointer.get(segment.ptr, refOffset);
+        long ref = WirePointer.get(segment.buffer, refOffset);
 
         // TODO check for null, follow fars, nestingLimit
         if (WirePointer.isNull(ref)) {
@@ -39,7 +39,7 @@ final class WireHelpers {
         int listPtr = WirePointer.listPointer(ref);
 
         int ptrOffset = WirePointer.target(refOffset, ref);
-        long ptr = WirePointer.get(segment.ptr, ptrOffset);
+        long ptr = WirePointer.get(segment.buffer, ptrOffset);
 
         switch (ListPointer.elementSize(listPtr)) {
         case FieldSize.INLINE_COMPOSITE : {
@@ -77,10 +77,10 @@ final class WireHelpers {
 
     public static Text.Reader readTextPointer(SegmentReader segment,
                                               int refOffset) {
-        long ref = WirePointer.get(segment.ptr, refOffset);
+        long ref = WirePointer.get(segment.buffer, refOffset);
         int ptrOffset = WirePointer.target(refOffset, ref);
         int listPtr = WirePointer.listPointer(ref);
         int size = ListPointer.elementCount(listPtr);
-        return new Text.Reader(segment.ptr, ptrOffset, size);
+        return new Text.Reader(segment.buffer, ptrOffset, size);
     }
 }