From 89ea97a401d575e2df610a24905227f5efe9ef1d Mon Sep 17 00:00:00 2001 From: David Renshaw Date: Tue, 7 Oct 2014 16:49:36 -0400 Subject: [PATCH] inheritance for lists --- compiler/src/main/cpp/capnpc-java.c++ | 6 +- .../src/main/java/org/capnproto/DataList.java | 81 +-- .../src/main/java/org/capnproto/EnumList.java | 71 ++- .../org/capnproto/FromPointerBuilder.java | 5 +- .../java/org/capnproto/FromPointerReader.java | 5 + .../main/java/org/capnproto/ListBuilder.java | 34 +- .../src/main/java/org/capnproto/ListList.java | 72 ++- .../main/java/org/capnproto/ListReader.java | 20 +- .../java/org/capnproto/PointerBuilder.java | 16 - .../java/org/capnproto/PointerReader.java | 18 - .../java/org/capnproto/PrimitiveList.java | 558 +++++++++++------- .../main/java/org/capnproto/StructList.java | 87 +-- .../src/main/java/org/capnproto/TextList.java | 85 +-- .../main/java/org/capnproto/WireHelpers.java | 92 +-- 14 files changed, 691 insertions(+), 459 deletions(-) diff --git a/compiler/src/main/cpp/capnpc-java.c++ b/compiler/src/main/cpp/capnpc-java.c++ index b870e1c..f20b183 100644 --- a/compiler/src/main/cpp/capnpc-java.c++ +++ b/compiler/src/main/cpp/capnpc-java.c++ @@ -1089,7 +1089,7 @@ private: spaces(indent), " }\n", spaces(indent), " public final void set", titleCase, "(", readerClass, " value) {\n", - spaces(indent), " _getPointerField(", offset, ").setList(value.reader);\n", + spaces(indent), " _getPointerField(", offset, ").setList(value);\n", spaces(indent), " }\n", spaces(indent), " public final ", builderClass, @@ -1137,7 +1137,7 @@ private: int indent) { return kj::strTree( spaces(indent), "public static final class Reader extends org.capnproto.StructReader {\n", - spaces(indent), " public Reader(org.capnproto.SegmentReader segment, int data, int pointers,", + spaces(indent), " Reader(org.capnproto.SegmentReader segment, int data, int pointers,", "int dataSize, short pointerCount, byte bit0Offset, int nestingLimit){\n", spaces(indent), " super(segment, data, pointers, dataSize, pointerCount, bit0Offset, nestingLimit);\n", spaces(indent), " }\n", @@ -1153,7 +1153,7 @@ private: int indent) { return kj::strTree( spaces(indent), "public static final class Builder extends org.capnproto.StructBuilder {\n", - spaces(indent), " public Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,", + spaces(indent), " Builder(org.capnproto.SegmentBuilder segment, int data, int pointers,", "int dataSize, short pointerCount, byte bit0Offset){\n", spaces(indent), " super(segment, data, pointers, dataSize, pointerCount, bit0Offset);\n", spaces(indent), " }\n", diff --git a/runtime/src/main/java/org/capnproto/DataList.java b/runtime/src/main/java/org/capnproto/DataList.java index d8ee63f..7224502 100644 --- a/runtime/src/main/java/org/capnproto/DataList.java +++ b/runtime/src/main/java/org/capnproto/DataList.java @@ -2,36 +2,59 @@ package org.capnproto; public final class DataList { public static final class Factory implements ListFactory { + public final Reader constructReader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + return new Reader(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); + } + + public final Builder constructBuilder(SegmentBuilder segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount) { + return new Builder(segment, ptr, elementCount, step, structDataSize, structPointerCount); + } + public final Reader fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) { - return new Reader(reader.getList(FieldSize.POINTER, defaultSegment, defaultOffset)); + return WireHelpers.readListPointer(this, + reader.segment, + reader.pointer, + defaultSegment, + defaultOffset, + FieldSize.POINTER, + reader.nestingLimit); } public final Builder fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) { - return new Builder(builder.getList(FieldSize.POINTER, defaultSegment, defaultOffset)); + return WireHelpers.getWritableListPointer(this, + builder.pointer, + builder.segment, + FieldSize.POINTER, + defaultSegment, + defaultOffset); } - public final Builder initFromPointerBuilder(PointerBuilder builder, int size) { - return new Builder(builder.initList(FieldSize.POINTER, size)); + public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) { + return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.POINTER); } } public static final Factory factory = new Factory(); - public static final class Reader implements Iterable { - public final ListReader reader; - - public Reader(ListReader reader) { - this.reader = reader; - } - - public int size() { - return this.reader.size(); + public static final class Reader extends ListReader implements Iterable { + public Reader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); } public Data.Reader get(int index) { - return this.reader.getPointerElement(index).getData(); + return _getPointerElement(index).getData(); } - public final class Iterator implements java.util.Iterator { public Reader list; public int idx = 0; @@ -40,7 +63,7 @@ public final class DataList { } public Data.Reader next() { - return this.list.reader.getPointerElement(idx++).getData(); + return this.list._getPointerElement(idx++).getData(); } public boolean hasNext() { return idx < list.size(); @@ -53,32 +76,22 @@ public final class DataList { public java.util.Iterator iterator() { return new Iterator(this); } - } - public static final class Builder implements Iterable { - public final ListBuilder builder; + public static final class Builder extends ListBuilder implements Iterable { - public Builder(ListBuilder builder) { - this.builder = builder; - } -/* - // init - Builder(PointerBuilder builder, int size) { - this.builder = builder.initStructList(size, factory.structSize()); - } -*/ - public int size() { - return this.builder.size(); + public Builder(SegmentBuilder segment, int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount){ + super(segment, ptr, elementCount, step, structDataSize, structPointerCount); } public final Data.Builder get(int index) { - return this.builder.getPointerElement(index).getData(); + return _getPointerElement(index).getData(); } - public final void set(int index, Data.Reader value) { - this.builder.getPointerElement(index).setData(value); + _getPointerElement(index).setData(value); } public final class Iterator implements java.util.Iterator { @@ -89,7 +102,7 @@ public final class DataList { } public Data.Builder next() { - return this.list.builder.getPointerElement(idx++).getData(); + return this.list._getPointerElement(idx++).getData(); } public boolean hasNext() { return this.idx < this.list.size(); diff --git a/runtime/src/main/java/org/capnproto/EnumList.java b/runtime/src/main/java/org/capnproto/EnumList.java index edd7e70..18f8e2b 100644 --- a/runtime/src/main/java/org/capnproto/EnumList.java +++ b/runtime/src/main/java/org/capnproto/EnumList.java @@ -15,57 +15,82 @@ public class EnumList { public Factory(T values[]) { this.values = values; } + public final Reader constructReader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + return new Reader(values, + segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); + } + + public final Builder constructBuilder(SegmentBuilder segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount) { + return new Builder (values, segment, ptr, elementCount, step, structDataSize, structPointerCount); + } public final Reader fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) { - return new Reader(values, reader.getList(FieldSize.TWO_BYTES, defaultSegment, defaultOffset)); + return WireHelpers.readListPointer(this, + reader.segment, + reader.pointer, + defaultSegment, + defaultOffset, + FieldSize.TWO_BYTES, + reader.nestingLimit); } public final Builder fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) { - return new Builder(values, builder.getList(FieldSize.TWO_BYTES, defaultSegment, defaultOffset)); + return WireHelpers.getWritableListPointer(this, + builder.pointer, + builder.segment, + FieldSize.TWO_BYTES, + defaultSegment, + defaultOffset); } - public final Builder initFromPointerBuilder(PointerBuilder builder, int size) { - return new Builder(values, builder.initList(FieldSize.TWO_BYTES, size)); + public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) { + return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.TWO_BYTES); } } - public static final class Reader { - public final ListReader reader; + public static final class Reader extends ListReader { public final T values[]; - public Reader(T values[], ListReader reader) { - this.reader = reader; + public Reader(T values[], + SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); this.values = values; } - public int size() { - return this.reader.size(); - } - public T get(int index) { - return clampOrdinal(this.values, this.reader.getShortElement(index)); + return clampOrdinal(this.values, _getShortElement(index)); } } - public static final class Builder { - public final ListBuilder builder; + public static final class Builder extends ListBuilder { public final T values[]; - public Builder(T values[], ListBuilder builder) { - this.builder = builder; + public Builder(T values[], + SegmentBuilder segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount) { + super(segment, ptr, elementCount, step, structDataSize, structPointerCount); this.values = values; } - public int size() { - return this.builder.size(); - } - public T get(int index) { - return clampOrdinal(this.values, this.builder.getShortElement(index)); + return clampOrdinal(this.values, _getShortElement(index)); } public void set(int index, T value) { - this.builder.setShortElement(index, (short)value.ordinal()); + _setShortElement(index, (short)value.ordinal()); } } } diff --git a/runtime/src/main/java/org/capnproto/FromPointerBuilder.java b/runtime/src/main/java/org/capnproto/FromPointerBuilder.java index 37f19e5..be4b382 100644 --- a/runtime/src/main/java/org/capnproto/FromPointerBuilder.java +++ b/runtime/src/main/java/org/capnproto/FromPointerBuilder.java @@ -1,6 +1,9 @@ package org.capnproto; public interface FromPointerBuilder { + T constructBuilder(SegmentBuilder segment, int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount); T fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset); - T initFromPointerBuilder(PointerBuilder value, int size); + T initFromPointerBuilder(PointerBuilder builder, int elementCount); } diff --git a/runtime/src/main/java/org/capnproto/FromPointerReader.java b/runtime/src/main/java/org/capnproto/FromPointerReader.java index 27cde66..44fca8d 100644 --- a/runtime/src/main/java/org/capnproto/FromPointerReader.java +++ b/runtime/src/main/java/org/capnproto/FromPointerReader.java @@ -1,5 +1,10 @@ package org.capnproto; public interface FromPointerReader { + T constructReader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit); T fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset); } diff --git a/runtime/src/main/java/org/capnproto/ListBuilder.java b/runtime/src/main/java/org/capnproto/ListBuilder.java index b1cb92b..582130b 100644 --- a/runtime/src/main/java/org/capnproto/ListBuilder.java +++ b/runtime/src/main/java/org/capnproto/ListBuilder.java @@ -1,6 +1,6 @@ package org.capnproto; -public final class ListBuilder { +public class ListBuilder { final SegmentBuilder segment; final int ptr; // byte offset to front of list final int elementCount; @@ -23,36 +23,36 @@ public final class ListBuilder { return this.elementCount; } - public boolean getBooleanElement(int index) { + protected boolean _getBooleanElement(int index) { byte b = this.segment.buffer.get(this.ptr + index / 8); return (b & (1 << (index % 8))) != 0; } - public byte getByteElement(int index) { + protected byte _getByteElement(int index) { return this.segment.buffer.get(this.ptr + index); } - public short getShortElement(int index) { + protected short _getShortElement(int index) { return this.segment.buffer.getShort(this.ptr + index * 2); } - public int getIntElement(int index) { + protected int _getIntElement(int index) { return this.segment.buffer.getInt(this.ptr + index * 4); } - public long getLongElement(int index) { + protected long _getLongElement(int index) { return this.segment.buffer.getLong(this.ptr + index * 8); } - public float getFloatElement(int index) { + protected float _getFloatElement(int index) { return this.segment.buffer.getFloat(this.ptr + index * 4); } - public double getDoubleElement(int index) { + protected double _getDoubleElement(int index) { return this.segment.buffer.getDouble(this.ptr + index * 8); } - public void setBooleanElement(int index, boolean value) { + protected void _setBooleanElement(int index, boolean value) { int bitOffset = index; byte bitnum = (byte)(bitOffset % 8); int position = this.ptr + (bitOffset / 8); @@ -61,31 +61,31 @@ public final class ListBuilder { (byte)((oldValue & (~(1 << bitnum))) | (( value ? 1 : 0) << bitnum))); } - public void setByteElement(int index, byte value) { + protected void _setByteElement(int index, byte value) { this.segment.buffer.put(this.ptr + index, value); } - public void setShortElement(int index, short value) { + protected void _setShortElement(int index, short value) { this.segment.buffer.putShort(this.ptr + index * 2, value); } - public void setIntElement(int index, int value) { + protected void _setIntElement(int index, int value) { this.segment.buffer.putInt(this.ptr + index * 4, value); } - public void setLongElement(int index, long value) { + protected void _setLongElement(int index, long value) { this.segment.buffer.putLong(this.ptr + index * 8, value); } - public void setFloatElement(int index, float value) { + protected void _setFloatElement(int index, float value) { this.segment.buffer.putFloat(this.ptr + index * 4, value); } - public void setDoubleElement(int index, double value) { + protected void _setDoubleElement(int index, double value) { this.segment.buffer.putDouble(this.ptr + index * 8, value); } - public final T getStructElement(FromStructBuilder factory, int index) { + protected final T _getStructElement(FromStructBuilder factory, int index) { int indexBit = index * this.step; int structData = this.ptr + indexBit / 8 ; int structPointers = (structData + (this.structDataSize / 8)) / 8; @@ -99,7 +99,7 @@ public final class ListBuilder { } - public final PointerBuilder getPointerElement(int index) { + protected final PointerBuilder _getPointerElement(int index) { return new PointerBuilder( this.segment, (this.ptr + (index * this.step / Constants.BITS_PER_BYTE)) / Constants.BYTES_PER_WORD); diff --git a/runtime/src/main/java/org/capnproto/ListList.java b/runtime/src/main/java/org/capnproto/ListList.java index d65a864..7c9ace8 100644 --- a/runtime/src/main/java/org/capnproto/ListList.java +++ b/runtime/src/main/java/org/capnproto/ListList.java @@ -10,58 +10,82 @@ public final class ListList { this.factory = factory; } + public final Reader constructReader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + return new Reader(factory, segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); + } + + public final Builder constructBuilder(SegmentBuilder segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount) { + return new Builder(factory, segment, ptr, elementCount, step, structDataSize, structPointerCount); + } + public final Reader fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) { - return new Reader(factory, reader.getList(FieldSize.POINTER, defaultSegment, defaultOffset)); + return WireHelpers.readListPointer(this, + reader.segment, + reader.pointer, + defaultSegment, + defaultOffset, + FieldSize.POINTER, + reader.nestingLimit); } public final Builder fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) { - return new Builder(factory, builder.getList(FieldSize.POINTER, defaultSegment, defaultOffset)); + return WireHelpers.getWritableListPointer(this, + builder.pointer, + builder.segment, + FieldSize.POINTER, + defaultSegment, + defaultOffset); } - public final Builder initFromPointerBuilder(PointerBuilder builder, int size) { - return new Builder(factory, builder.initList(FieldSize.POINTER, size)); + public final Builder initFromPointerBuilder(PointerBuilder builder, + int elementCount) { + return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.POINTER); } } - - public static final class Reader { - public final ListReader reader; + public static final class Reader extends ListReader { private final FromPointerReader factory; - public Reader(FromPointerReader factory, ListReader reader) { + public Reader(FromPointerReader factory, + SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); this.factory = factory; - this.reader = reader; - } - - public final int size() { - return this.reader.size(); } public T get(int index) { - return this.factory.fromPointerReader(this.reader.getPointerElement(index), null, 0); + return this.factory.fromPointerReader(_getPointerElement(index), null, 0); } } - public static final class Builder { - public final ListBuilder builder; + public static final class Builder extends ListBuilder { private final FromPointerBuilder factory; - public Builder(FromPointerBuilder factory, ListBuilder builder) { + public Builder(FromPointerBuilder factory, + SegmentBuilder segment, int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount){ + super(segment, ptr, elementCount, step, structDataSize, structPointerCount); this.factory = factory; - this.builder = builder; - } - - public final int size() { - return this.builder.size(); } public final T init(int index, int size) { - return this.factory.initFromPointerBuilder(this.builder.getPointerElement(index), size); + return this.factory.initFromPointerBuilder(_getPointerElement(index), size); } public final T get(int index) { - return this.factory.fromPointerBuilder(this.builder.getPointerElement(index), null, 0); + return this.factory.fromPointerBuilder(_getPointerElement(index), null, 0); } } } diff --git a/runtime/src/main/java/org/capnproto/ListReader.java b/runtime/src/main/java/org/capnproto/ListReader.java index 8ed48ba..58be227 100644 --- a/runtime/src/main/java/org/capnproto/ListReader.java +++ b/runtime/src/main/java/org/capnproto/ListReader.java @@ -1,6 +1,6 @@ package org.capnproto; -public final class ListReader { +public class ListReader { final SegmentReader segment; final int ptr; // byte offset to front of list final int elementCount; @@ -37,36 +37,36 @@ public final class ListReader { return this.elementCount; } - public boolean getBooleanElement(int index) { + protected boolean _getBooleanElement(int index) { byte b = this.segment.buffer.get(this.ptr + index / 8); return (b & (1 << (index % 8))) != 0; } - public byte getByteElement(int index) { + protected byte _getByteElement(int index) { return this.segment.buffer.get(this.ptr + index); } - public short getShortElement(int index) { + protected short _getShortElement(int index) { return this.segment.buffer.getShort(this.ptr + index * 2); } - public int getIntElement(int index) { + protected int _getIntElement(int index) { return this.segment.buffer.getInt(this.ptr + index * 4); } - public long getLongElement(int index) { + protected long _getLongElement(int index) { return this.segment.buffer.getLong(this.ptr + index * 8); } - public float getFloatElement(int index) { + protected float _getFloatElement(int index) { return this.segment.buffer.getFloat(this.ptr + index * 4); } - public double getDoubleElement(int index) { + protected double _getDoubleElement(int index) { return this.segment.buffer.getDouble(this.ptr + index * 8); } - public T getStructElement(FromStructReader factory, int index) { + protected T _getStructElement(FromStructReader factory, int index) { // TODO check nesting limit int indexBit = index * this.step; @@ -78,7 +78,7 @@ public final class ListReader { this.structPointerCount, (byte) (indexBit % 8), this.nestingLimit - 1); } - public PointerReader getPointerElement(int index) { + protected PointerReader _getPointerElement(int index) { return new PointerReader(this.segment, (this.ptr + (index * this.step / Constants.BITS_PER_BYTE)) / Constants.BYTES_PER_WORD, this.nestingLimit); diff --git a/runtime/src/main/java/org/capnproto/PointerBuilder.java b/runtime/src/main/java/org/capnproto/PointerBuilder.java index 77b1101..68dd117 100644 --- a/runtime/src/main/java/org/capnproto/PointerBuilder.java +++ b/runtime/src/main/java/org/capnproto/PointerBuilder.java @@ -27,14 +27,6 @@ public final class PointerBuilder { defaultReader, defaultOffset); } - public final ListBuilder getList(byte elementSize, SegmentReader defaultBuffer, int defaultOffset) { - return WireHelpers.getWritableListPointer(this.pointer, this.segment, elementSize); - } - - public final ListBuilder getStructList(StructSize elementSize, SegmentReader defaultSegment, int defaultOffset) { - throw new Error("unimplemented"); - } - public final Text.Builder getText() { return WireHelpers.getWritableTextPointer( this.pointer, this.segment, null, 0, 0); @@ -66,14 +58,6 @@ public final class PointerBuilder { return WireHelpers.initStructPointer(factory, this.pointer, this.segment, factory.structSize()); } - public final ListBuilder initList(byte elementSize, int elementCount) { - return WireHelpers.initListPointer(this.pointer, this.segment, elementCount, elementSize); - } - - public final ListBuilder initStructList(int elementCount, StructSize elementSize) { - return WireHelpers.initStructListPointer(this.pointer, this.segment, elementCount, elementSize); - } - public final Text.Builder initText(int size) { return WireHelpers.initTextPointer(this.pointer, this.segment, size); } diff --git a/runtime/src/main/java/org/capnproto/PointerReader.java b/runtime/src/main/java/org/capnproto/PointerReader.java index 98c4723..d0b3d2e 100644 --- a/runtime/src/main/java/org/capnproto/PointerReader.java +++ b/runtime/src/main/java/org/capnproto/PointerReader.java @@ -44,24 +44,6 @@ public final class PointerReader { this.nestingLimit); } - public ListReader getList(byte expectedElementSize) { - return WireHelpers.readListPointer(this.segment, - this.pointer, - null, 0, - expectedElementSize, - this.nestingLimit); - } - - - public ListReader getList(byte expectedElementSize, SegmentReader defaultSegment, int defaultOffset) { - return WireHelpers.readListPointer(this.segment, - this.pointer, - defaultSegment, - defaultOffset, - expectedElementSize, - this.nestingLimit); - } - public Text.Reader getText() { return WireHelpers.readTextPointer(this.segment, this.pointer, null, 0, 0); } diff --git a/runtime/src/main/java/org/capnproto/PrimitiveList.java b/runtime/src/main/java/org/capnproto/PrimitiveList.java index 30bc723..90b33ef 100644 --- a/runtime/src/main/java/org/capnproto/PrimitiveList.java +++ b/runtime/src/main/java/org/capnproto/PrimitiveList.java @@ -3,29 +3,53 @@ package org.capnproto; public class PrimitiveList { public static class Void { public static final class Factory implements ListFactory { + public final Reader constructReader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + return new Reader(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); + } + + public final Builder constructBuilder(SegmentBuilder segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount) { + return new Builder(segment, ptr, elementCount, step, structDataSize, structPointerCount); + } + public final Reader fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) { - return new Reader(reader.getList(FieldSize.VOID, defaultSegment, defaultOffset)); + return WireHelpers.readListPointer(this, + reader.segment, + reader.pointer, + defaultSegment, + defaultOffset, + FieldSize.VOID, + reader.nestingLimit); } public final Builder fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) { - return new Builder(builder.getList(FieldSize.VOID, defaultSegment, defaultOffset)); + return WireHelpers.getWritableListPointer(this, + builder.pointer, + builder.segment, + FieldSize.VOID, + defaultSegment, + defaultOffset); } - public final Builder initFromPointerBuilder(PointerBuilder builder, int size) { - return new Builder(builder.initList(FieldSize.VOID, size)); + public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) { + return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.VOID); } } public static final Factory factory = new Factory(); - public static final class Reader { - public final ListReader reader; - - public Reader(ListReader reader) { - this.reader = reader; - } - - public int size() { - return this.reader.size(); + public static final class Reader extends ListReader { + public Reader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); } public org.capnproto.Void get(int index) { @@ -33,123 +57,157 @@ public class PrimitiveList { } } - public static final class Builder { - public final ListBuilder builder; - - public Builder(ListBuilder builder) { - this.builder = builder; + public static final class Builder extends ListBuilder { + public Builder(SegmentBuilder segment, int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount){ + super(segment, ptr, elementCount, step, structDataSize, structPointerCount); } - - - public int size() { - return this.builder.size(); - } - } } public static class Boolean { public static final class Factory implements ListFactory { + public final Reader constructReader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + return new Reader(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); + } + + public final Builder constructBuilder(SegmentBuilder segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount) { + return new Builder(segment, ptr, elementCount, step, structDataSize, structPointerCount); + } + public final Reader fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) { - return new Reader(reader.getList(FieldSize.BIT, defaultSegment, defaultOffset)); + return WireHelpers.readListPointer(this, + reader.segment, + reader.pointer, + defaultSegment, + defaultOffset, + FieldSize.BIT, + reader.nestingLimit); } public final Builder fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) { - return new Builder(builder.getList(FieldSize.BIT, defaultSegment, defaultOffset)); + return WireHelpers.getWritableListPointer(this, + builder.pointer, + builder.segment, + FieldSize.BIT, + defaultSegment, + defaultOffset); } - public final Builder initFromPointerBuilder(PointerBuilder builder, int size) { - return new Builder(builder.initList(FieldSize.BIT, size)); + public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) { + return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.BIT); } } public static final Factory factory = new Factory(); - public static final class Reader { - public final ListReader reader; - - public Reader(ListReader reader) { - this.reader = reader; - } - - public int size() { - return this.reader.size(); + public static final class Reader extends ListReader { + public Reader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); } public boolean get(int index) { - return this.reader.getBooleanElement(index); + return _getBooleanElement(index); } } - public static final class Builder { - public final ListBuilder builder; - - public Builder(ListBuilder builder) { - this.builder = builder; - } - - public int size() { - return this.builder.size(); + public static final class Builder extends ListBuilder { + public Builder(SegmentBuilder segment, int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount){ + super(segment, ptr, elementCount, step, structDataSize, structPointerCount); } public boolean get(int index) { - return this.builder.getBooleanElement(index); + return _getBooleanElement(index); } public void set(int index, boolean value) { - this.builder.setBooleanElement(index, value); + _setBooleanElement(index, value); } } } public static class Byte { public static final class Factory implements ListFactory { + public final Reader constructReader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + return new Reader(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); + } + + public final Builder constructBuilder(SegmentBuilder segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount) { + return new Builder(segment, ptr, elementCount, step, structDataSize, structPointerCount); + } + public final Reader fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) { - return new Reader(reader.getList(FieldSize.BYTE, defaultSegment, defaultOffset)); + return WireHelpers.readListPointer(this, + reader.segment, + reader.pointer, + defaultSegment, + defaultOffset, + FieldSize.BYTE, + reader.nestingLimit); } public final Builder fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) { - return new Builder(builder.getList(FieldSize.BYTE, defaultSegment, defaultOffset)); + return WireHelpers.getWritableListPointer(this, + builder.pointer, + builder.segment, + FieldSize.BYTE, + defaultSegment, + defaultOffset); } - public final Builder initFromPointerBuilder(PointerBuilder builder, int size) { - return new Builder(builder.initList(FieldSize.BYTE, size)); + public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) { + return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.BYTE); } } public static final Factory factory = new Factory(); - public static final class Reader { - public final ListReader reader; - - public Reader(ListReader reader) { - this.reader = reader; - } - - public int size() { - return this.reader.size(); + public static final class Reader extends ListReader { + public Reader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); } public byte get(int index) { - return this.reader.getByteElement(index); + return _getByteElement(index); } } - public static final class Builder { - public final ListBuilder builder; - - public Builder(ListBuilder builder) { - this.builder = builder; - } - - public int size() { - return this.builder.size(); + public static final class Builder extends ListBuilder { + public Builder(SegmentBuilder segment, int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount){ + super(segment, ptr, elementCount, step, structDataSize, structPointerCount); } public byte get(int index) { - return this.builder.getByteElement(index); + return _getByteElement(index); } public void set(int index, byte value) { - this.builder.setByteElement(index, value); + _setByteElement(index, value); } } @@ -157,53 +215,73 @@ public class PrimitiveList { public static class Short { public static final class Factory implements ListFactory { + public final Reader constructReader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + return new Reader(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); + } + + public final Builder constructBuilder(SegmentBuilder segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount) { + return new Builder(segment, ptr, elementCount, step, structDataSize, structPointerCount); + } + public final Reader fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) { - return new Reader(reader.getList(FieldSize.TWO_BYTES, defaultSegment, defaultOffset)); + return WireHelpers.readListPointer(this, + reader.segment, + reader.pointer, + defaultSegment, + defaultOffset, + FieldSize.TWO_BYTES, + reader.nestingLimit); } public final Builder fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) { - return new Builder(builder.getList(FieldSize.TWO_BYTES, defaultSegment, defaultOffset)); + return WireHelpers.getWritableListPointer(this, + builder.pointer, + builder.segment, + FieldSize.TWO_BYTES, + defaultSegment, + defaultOffset); } - public final Builder initFromPointerBuilder(PointerBuilder builder, int size) { - return new Builder(builder.initList(FieldSize.TWO_BYTES, size)); + public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) { + return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.TWO_BYTES); } } public static final Factory factory = new Factory(); - public static final class Reader { - public final ListReader reader; - - public Reader(ListReader reader) { - this.reader = reader; - } - - public int size() { - return this.reader.size(); + public static final class Reader extends ListReader { + public Reader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); } public short get(int index) { - return this.reader.getShortElement(index); + return _getShortElement(index); } } - public static final class Builder { - public final ListBuilder builder; - - public Builder(ListBuilder builder) { - this.builder = builder; - } - - public int size() { - return this.builder.size(); + public static final class Builder extends ListBuilder { + public Builder(SegmentBuilder segment, int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount){ + super(segment, ptr, elementCount, step, structDataSize, structPointerCount); } public short get(int index) { - return this.builder.getShortElement(index); + return _getShortElement(index); } public void set(int index, short value) { - this.builder.setShortElement(index, value); + _setShortElement(index, value); } } @@ -211,106 +289,148 @@ public class PrimitiveList { public static class Int { public static final class Factory implements ListFactory { + public final Reader constructReader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + return new Reader(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); + } + + public final Builder constructBuilder(SegmentBuilder segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount) { + return new Builder(segment, ptr, elementCount, step, structDataSize, structPointerCount); + } + public final Reader fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) { - return new Reader(reader.getList(FieldSize.FOUR_BYTES, defaultSegment, defaultOffset)); + return WireHelpers.readListPointer(this, + reader.segment, + reader.pointer, + defaultSegment, + defaultOffset, + FieldSize.FOUR_BYTES, + reader.nestingLimit); } public final Builder fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) { - return new Builder(builder.getList(FieldSize.FOUR_BYTES, defaultSegment, defaultOffset)); + return WireHelpers.getWritableListPointer(this, + builder.pointer, + builder.segment, + FieldSize.FOUR_BYTES, + defaultSegment, + defaultOffset); } - public final Builder initFromPointerBuilder(PointerBuilder builder, int size) { - return new Builder(builder.initList(FieldSize.FOUR_BYTES, size)); + public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) { + return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.FOUR_BYTES); } } public static final Factory factory = new Factory(); - public static final class Reader { - public final ListReader reader; - - public Reader(ListReader reader) { - this.reader = reader; - } - - public int size() { - return this.reader.size(); + public static final class Reader extends ListReader { + public Reader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); } public int get(int index) { - return this.reader.getIntElement(index); + return _getIntElement(index); } } - public static final class Builder { - public final ListBuilder builder; - - public Builder(ListBuilder builder) { - this.builder = builder; - } - - public int size() { - return this.builder.size(); + public static final class Builder extends ListBuilder { + public Builder(SegmentBuilder segment, int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount){ + super(segment, ptr, elementCount, step, structDataSize, structPointerCount); } public int get(int index) { - return this.builder.getIntElement(index); + return _getIntElement(index); } public void set(int index, int value) { - this.builder.setIntElement(index, value); + _setIntElement(index, value); } } } public static class Float { public static final class Factory implements ListFactory { + public final Reader constructReader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + return new Reader(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); + } + + public final Builder constructBuilder(SegmentBuilder segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount) { + return new Builder(segment, ptr, elementCount, step, structDataSize, structPointerCount); + } + + public final Reader fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) { - return new Reader(reader.getList(FieldSize.FOUR_BYTES, defaultSegment, defaultOffset)); + return WireHelpers.readListPointer(this, + reader.segment, + reader.pointer, + defaultSegment, + defaultOffset, + FieldSize.FOUR_BYTES, + reader.nestingLimit); } public final Builder fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) { - return new Builder(builder.getList(FieldSize.FOUR_BYTES, defaultSegment, defaultOffset)); + return WireHelpers.getWritableListPointer(this, + builder.pointer, + builder.segment, + FieldSize.FOUR_BYTES, + defaultSegment, + defaultOffset); } - public final Builder initFromPointerBuilder(PointerBuilder builder, int size) { - return new Builder(builder.initList(FieldSize.FOUR_BYTES, size)); + public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) { + return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.FOUR_BYTES); } + } public static final Factory factory = new Factory(); - public static final class Reader { - public final ListReader reader; - - public Reader(ListReader reader) { - this.reader = reader; - } - - public int size() { - return this.reader.size(); + public static final class Reader extends ListReader { + public Reader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); } public float get(int index) { - return this.reader.getFloatElement(index); + return _getFloatElement(index); } } - public static final class Builder { - public final ListBuilder builder; - - public Builder(ListBuilder builder) { - this.builder = builder; - } - - public int size() { - return this.builder.size(); + public static final class Builder extends ListBuilder { + public Builder(SegmentBuilder segment, int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount){ + super(segment, ptr, elementCount, step, structDataSize, structPointerCount); } public float get(int index) { - return this.builder.getFloatElement(index); + return _getFloatElement(index); } public void set(int index, float value) { - this.builder.setFloatElement(index, value); + _setFloatElement(index, value); } } } @@ -318,106 +438,146 @@ public class PrimitiveList { public static class Long { public static final class Factory implements ListFactory { + public final Reader constructReader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + return new Reader(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); + } + + public final Builder constructBuilder(SegmentBuilder segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount) { + return new Builder(segment, ptr, elementCount, step, structDataSize, structPointerCount); + } + public final Reader fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) { - return new Reader(reader.getList(FieldSize.EIGHT_BYTES, defaultSegment, defaultOffset)); + return WireHelpers.readListPointer(this, + reader.segment, + reader.pointer, + defaultSegment, + defaultOffset, + FieldSize.EIGHT_BYTES, + reader.nestingLimit); } public final Builder fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) { - return new Builder(builder.getList(FieldSize.EIGHT_BYTES, defaultSegment, defaultOffset)); + return WireHelpers.getWritableListPointer(this, + builder.pointer, + builder.segment, + FieldSize.EIGHT_BYTES, + defaultSegment, + defaultOffset); } - public final Builder initFromPointerBuilder(PointerBuilder builder, int size) { - return new Builder(builder.initList(FieldSize.EIGHT_BYTES, size)); + public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) { + return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.EIGHT_BYTES); } } public static final Factory factory = new Factory(); - public static final class Reader { - public final ListReader reader; - - public Reader(ListReader reader) { - this.reader = reader; - } - - public int size() { - return this.reader.size(); + public static final class Reader extends ListReader { + public Reader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); } public long get(int index) { - return this.reader.getLongElement(index); + return _getLongElement(index); } } - public static final class Builder { - public final ListBuilder builder; - - public Builder(ListBuilder builder) { - this.builder = builder; - } - - public int size() { - return this.builder.size(); + public static final class Builder extends ListBuilder { + public Builder(SegmentBuilder segment, int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount){ + super(segment, ptr, elementCount, step, structDataSize, structPointerCount); } public long get(int index) { - return this.builder.getLongElement(index); + return _getLongElement(index); } public void set(int index, long value) { - this.builder.setLongElement(index, value); + _setLongElement(index, value); } } } public static class Double { public static final class Factory implements ListFactory { + public final Reader constructReader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + return new Reader(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); + } + + public final Builder constructBuilder(SegmentBuilder segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount) { + return new Builder(segment, ptr, elementCount, step, structDataSize, structPointerCount); + } + public final Reader fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) { - return new Reader(reader.getList(FieldSize.EIGHT_BYTES, defaultSegment, defaultOffset)); + return WireHelpers.readListPointer(this, + reader.segment, + reader.pointer, + defaultSegment, + defaultOffset, + FieldSize.EIGHT_BYTES, + reader.nestingLimit); } public final Builder fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) { - return new Builder(builder.getList(FieldSize.EIGHT_BYTES, defaultSegment, defaultOffset)); + return WireHelpers.getWritableListPointer(this, + builder.pointer, + builder.segment, + FieldSize.EIGHT_BYTES, + defaultSegment, + defaultOffset); } - public final Builder initFromPointerBuilder(PointerBuilder builder, int size) { - return new Builder(builder.initList(FieldSize.EIGHT_BYTES, size)); + public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) { + return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.EIGHT_BYTES); } } public static final Factory factory = new Factory(); - public static final class Reader { - public final ListReader reader; - - public Reader(ListReader reader) { - this.reader = reader; - } - - public int size() { - return this.reader.size(); + public static final class Reader extends ListReader { + public Reader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); } public double get(int index) { - return this.reader.getDoubleElement(index); + return _getDoubleElement(index); } } - public static final class Builder { - public final ListBuilder builder; - - public Builder(ListBuilder builder) { - this.builder = builder; - } - - public int size() { - return this.builder.size(); + public static final class Builder extends ListBuilder { + public Builder(SegmentBuilder segment, int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount){ + super(segment, ptr, elementCount, step, structDataSize, structPointerCount); } public double get(int index) { - return this.builder.getDoubleElement(index); + return _getDoubleElement(index); } public void set(int index, double value) { - this.builder.setDoubleElement(index, value); + _setDoubleElement(index, value); } } } diff --git a/runtime/src/main/java/org/capnproto/StructList.java b/runtime/src/main/java/org/capnproto/StructList.java index cef591a..5a6c336 100644 --- a/runtime/src/main/java/org/capnproto/StructList.java +++ b/runtime/src/main/java/org/capnproto/StructList.java @@ -10,34 +10,65 @@ public final class StructList { this.factory = factory; } + public final Reader constructReader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + return new Reader(factory, + segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); + } + + public final Builder constructBuilder(SegmentBuilder segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount) { + return new Builder (factory, segment, ptr, elementCount, step, structDataSize, structPointerCount); + } + public final Reader fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) { - return new Reader(factory, reader.getList(FieldSize.INLINE_COMPOSITE, defaultSegment, defaultOffset)); + return WireHelpers.readListPointer(this, + reader.segment, + reader.pointer, + defaultSegment, + defaultOffset, + FieldSize.INLINE_COMPOSITE, + reader.nestingLimit); } public final Builder fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) { - return new Builder(factory, builder.getStructList(this.factory.structSize(), defaultSegment, defaultOffset)); + throw new Error(); + /* return WireHelpers.getWritableStructListPointer(this, + builder.pointer, + builder.segment, + FieldSize.POINTER, + defaultSegment, + defaultOffset,0); */ } - public final Builder initFromPointerBuilder(PointerBuilder builder, int size) { - return new Builder(factory, builder.initStructList(size, this.factory.structSize())); + public final Builder initFromPointerBuilder(PointerBuilder builder, + int elementCount) { + return WireHelpers.initStructListPointer(this, builder.pointer, builder.segment, elementCount, factory.structSize()); } + + } - public static final class Reader implements Iterable { - public final ListReader reader; + public static final class Reader extends ListReader implements Iterable { public final FromStructReader factory; - public Reader(FromStructReader factory, ListReader reader) { - this.reader = reader; + public Reader(FromStructReader factory, + SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); this.factory = factory; } - public int size() { - return this.reader.size(); - } - public T get(int index) { - return this.reader.getStructElement(factory, index); + return _getStructElement(factory, index); } @@ -49,7 +80,7 @@ public final class StructList { } public T next() { - return list.reader.getStructElement(factory, idx++); + return list._getStructElement(factory, idx++); } public boolean hasNext() { return idx < list.size(); @@ -64,30 +95,21 @@ public final class StructList { } } - public static final class Builder implements Iterable { - public final ListBuilder builder; + public static final class Builder extends ListBuilder implements Iterable { public final FromStructBuilder factory; - public Builder(FromStructBuilder factory, ListBuilder builder) { - this.builder = builder; + public Builder(FromStructBuilder factory, + SegmentBuilder segment, int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount){ + super(segment, ptr, elementCount, step, structDataSize, structPointerCount); this.factory = factory; } - // init - Builder(FromStructBuilder factory, PointerBuilder builder, int size) { - this.builder = builder.initStructList(size, factory.structSize()); - this.factory = factory; - } - - public int size() { - return this.builder.size(); - } - public final T get(int index) { - return this.builder.getStructElement(factory, index); + return _getStructElement(factory, index); } - public final class Iterator implements java.util.Iterator { public Builder list; public int idx = 0; @@ -96,7 +118,7 @@ public final class StructList { } public T next() { - return list.builder.getStructElement(factory, idx++); + return list._getStructElement(factory, idx++); } public boolean hasNext() { return idx < list.size(); @@ -109,8 +131,5 @@ public final class StructList { public java.util.Iterator iterator() { return new Iterator(this); } - - } - } diff --git a/runtime/src/main/java/org/capnproto/TextList.java b/runtime/src/main/java/org/capnproto/TextList.java index 811d7e9..0e25bd2 100644 --- a/runtime/src/main/java/org/capnproto/TextList.java +++ b/runtime/src/main/java/org/capnproto/TextList.java @@ -2,36 +2,60 @@ package org.capnproto; public final class TextList { public static final class Factory implements ListFactory { + public final Reader constructReader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + return new Reader(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); + } + + public final Builder constructBuilder(SegmentBuilder segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount) { + return new Builder(segment, ptr, elementCount, step, structDataSize, structPointerCount); + } + public final Reader fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) { - return new Reader(reader.getList(FieldSize.POINTER, defaultSegment, defaultOffset)); + return WireHelpers.readListPointer(this, + reader.segment, + reader.pointer, + defaultSegment, + defaultOffset, + FieldSize.POINTER, + reader.nestingLimit); } public final Builder fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) { - return new Builder(builder.getList(FieldSize.POINTER, defaultSegment, defaultOffset)); + return WireHelpers.getWritableListPointer(this, + builder.pointer, + builder.segment, + FieldSize.POINTER, + defaultSegment, + defaultOffset); } - public final Builder initFromPointerBuilder(PointerBuilder builder, int size) { - return new Builder(builder.initList(FieldSize.POINTER, size)); + public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) { + return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.POINTER); } + } public static final Factory factory = new Factory(); - public static final class Reader implements Iterable { - public final ListReader reader; - - public Reader(ListReader reader) { - this.reader = reader; - } - - public int size() { - return this.reader.size(); + public static final class Reader extends ListReader implements Iterable { + public Reader(SegmentReader segment, + int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount, + int nestingLimit) { + super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit); } public Text.Reader get(int index) { - return this.reader.getPointerElement(index).getText(); + return _getPointerElement(index).getText(); } - public final class Iterator implements java.util.Iterator { public Reader list; public int idx = 0; @@ -40,7 +64,7 @@ public final class TextList { } public Text.Reader next() { - return this.list.reader.getPointerElement(idx++).getText(); + return this.list._getPointerElement(idx++).getText(); } public boolean hasNext() { return idx < list.size(); @@ -56,29 +80,19 @@ public final class TextList { } - public static final class Builder implements Iterable { - public final ListBuilder builder; - - public Builder(ListBuilder builder) { - this.builder = builder; - } -/* - // init - Builder(PointerBuilder builder, int size) { - this.builder = builder.initStructList(size, factory.structSize()); - } -*/ - public int size() { - return this.builder.size(); + public static final class Builder extends ListBuilder implements Iterable { + public Builder(SegmentBuilder segment, int ptr, + int elementCount, int step, + int structDataSize, short structPointerCount){ + super(segment, ptr, elementCount, step, structDataSize, structPointerCount); } public final Text.Builder get(int index) { - return this.builder.getPointerElement(index).getText(); + return _getPointerElement(index).getText(); } - public final void set(int index, Text.Reader value) { - this.builder.getPointerElement(index).setText(value); + _getPointerElement(index).setText(value); } public final class Iterator implements java.util.Iterator { @@ -89,7 +103,7 @@ public final class TextList { } public Text.Builder next() { - return this.list.builder.getPointerElement(idx++).getText(); + return this.list._getPointerElement(idx++).getText(); } public boolean hasNext() { return this.idx < this.list.size(); @@ -102,8 +116,5 @@ public final class TextList { public java.util.Iterator iterator() { return new Iterator(this); } - - } - } diff --git a/runtime/src/main/java/org/capnproto/WireHelpers.java b/runtime/src/main/java/org/capnproto/WireHelpers.java index 33b292b..cfb7c44 100644 --- a/runtime/src/main/java/org/capnproto/WireHelpers.java +++ b/runtime/src/main/java/org/capnproto/WireHelpers.java @@ -188,10 +188,11 @@ final class WireHelpers { } - static ListBuilder initListPointer(int refOffset, - SegmentBuilder segment, - int elementCount, - byte elementSize) { + static T initListPointer(FromPointerBuilder factory, + int refOffset, + SegmentBuilder segment, + int elementCount, + byte elementSize) { assert elementSize != FieldSize.INLINE_COMPOSITE : "Should have called initStructListPointer instead"; int dataSize = FieldSize.dataBitsPerElement(elementSize); @@ -202,18 +203,19 @@ final class WireHelpers { ListPointer.set(allocation.segment.buffer, allocation.refOffset, elementSize, elementCount); - return new ListBuilder(allocation.segment, - allocation.ptr * Constants.BYTES_PER_WORD, - elementCount, step, dataSize, (short)pointerCount); + return factory.constructBuilder(allocation.segment, + allocation.ptr * Constants.BYTES_PER_WORD, + elementCount, step, dataSize, (short)pointerCount); } - static ListBuilder initStructListPointer(int refOffset, - SegmentBuilder segment, - int elementCount, - StructSize elementSize) { + static T initStructListPointer(FromPointerBuilder factory, + int refOffset, + SegmentBuilder segment, + int elementCount, + StructSize elementSize) { if (elementSize.preferredListEncoding != FieldSize.INLINE_COMPOSITE) { //# Small data-only struct. Allocate a list of primitives instead. - return initListPointer(refOffset, segment, elementCount, + return initListPointer(factory, refOffset, segment, elementCount, elementSize.preferredListEncoding); } @@ -230,15 +232,18 @@ final class WireHelpers { WirePointer.STRUCT, elementCount); StructPointer.setFromStructSize(allocation.segment.buffer, allocation.ptr, elementSize); - return new ListBuilder(allocation.segment, - (allocation.ptr + 1) * Constants.BYTES_PER_WORD, - elementCount, wordsPerElement * Constants.BITS_PER_WORD, - elementSize.data * Constants.BITS_PER_WORD, elementSize.pointers); + return factory.constructBuilder(allocation.segment, + (allocation.ptr + 1) * Constants.BYTES_PER_WORD, + elementCount, wordsPerElement * Constants.BITS_PER_WORD, + elementSize.data * Constants.BITS_PER_WORD, elementSize.pointers); } - static ListBuilder getWritableListPointer(int origRefOffset, - SegmentBuilder origSegment, - byte elementSize) { + static T getWritableListPointer(FromPointerBuilder factory, + int origRefOffset, + SegmentBuilder origSegment, + byte elementSize, + SegmentReader defaultSegment, + int defaultOffset) { assert elementSize != FieldSize.INLINE_COMPOSITE : "Use getStructList{Element,Field} for structs"; long origRef = WirePointer.get(origSegment.buffer, origRefOffset); @@ -285,9 +290,9 @@ final class WireHelpers { int step = dataSize + pointerCount * Constants.BITS_PER_POINTER; - return new ListBuilder(resolved.segment, resolved.ptr * Constants.BYTES_PER_WORD, - ListPointer.elementCount(resolved.ref), - step, dataSize, (short) pointerCount); + return factory.constructBuilder(resolved.segment, resolved.ptr * Constants.BYTES_PER_WORD, + ListPointer.elementCount(resolved.ref), + step, dataSize, (short) pointerCount); } } @@ -498,18 +503,19 @@ final class WireHelpers { throw new Error("copyPointer is unimplemented"); } - static ListReader readListPointer(SegmentReader segment, - int refOffset, - SegmentReader defaultSegment, - int defaultOffset, - byte expectedElementSize, - int nestingLimit) { + static T readListPointer(FromPointerReader factory, + SegmentReader segment, + int refOffset, + SegmentReader defaultSegment, + int defaultOffset, + byte expectedElementSize, + int nestingLimit) { long ref = WirePointer.get(segment.buffer, refOffset); if (WirePointer.isNull(ref)) { if (defaultSegment == null) { - return new ListReader(); + factory.constructReader(SegmentReader.EMPTY, 0, 0, 0, 0, (short) 0, 0x7fffffff); } else { segment = defaultSegment; refOffset = defaultOffset; @@ -542,13 +548,13 @@ final class WireHelpers { // TODO check whether the size is compatible - return new ListReader(resolved.segment, - ptr * Constants.BYTES_PER_WORD, - size, - wordsPerElement * Constants.BITS_PER_WORD, - StructPointer.dataSize(tag) * Constants.BITS_PER_WORD, - StructPointer.ptrCount(tag), - nestingLimit - 1); + return factory.constructReader(resolved.segment, + ptr * Constants.BYTES_PER_WORD, + size, + wordsPerElement * Constants.BITS_PER_WORD, + StructPointer.dataSize(tag) * Constants.BITS_PER_WORD, + StructPointer.ptrCount(tag), + nestingLimit - 1); } default : { //# This is a primitive or pointer list, but all such @@ -580,13 +586,13 @@ final class WireHelpers { throw new DecodeException("Message contains list with incompatible element type."); } - return new ListReader(resolved.segment, - resolved.ptr * Constants.BYTES_PER_WORD, - ListPointer.elementCount(resolved.ref), - step, - dataSize, - (short)pointerCount, - nestingLimit - 1); + return factory.constructReader(resolved.segment, + resolved.ptr * Constants.BYTES_PER_WORD, + ListPointer.elementCount(resolved.ref), + step, + dataSize, + (short)pointerCount, + nestingLimit - 1); } } }