serverscanning/capnproto-java-rpc
16
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

inheritance for lists

Browse source
This commit is contained in:
David Renshaw 2014-10-07 16:49:36 -04:00
parent 868cc5072d
commit 89ea97a401
14 changed files with 691 additions and 459 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
compiler/src/main/cpp/capnpc-java.c++
View file

@ -1089,7 +1089,7 @@ private:
spaces(indent), " }\n", spaces(indent), " }\n",
spaces(indent), " public final void set", titleCase, "(", readerClass, " value) {\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), " }\n",
spaces(indent), " public final ", builderClass, spaces(indent), " public final ", builderClass,
@ -1137,7 +1137,7 @@ private:
int indent) { int indent) {
return kj::strTree( return kj::strTree(
spaces(indent), "public static final class Reader extends org.capnproto.StructReader {\n", 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", "int dataSize, short pointerCount, byte bit0Offset, int nestingLimit){\n",
spaces(indent), " super(segment, data, pointers, dataSize, pointerCount, bit0Offset, nestingLimit);\n", spaces(indent), " super(segment, data, pointers, dataSize, pointerCount, bit0Offset, nestingLimit);\n",
spaces(indent), " }\n", spaces(indent), " }\n",
@ -1153,7 +1153,7 @@ private:
int indent) { int indent) {
return kj::strTree( return kj::strTree(
spaces(indent), "public static final class Builder extends org.capnproto.StructBuilder {\n", 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", "int dataSize, short pointerCount, byte bit0Offset){\n",
spaces(indent), " super(segment, data, pointers, dataSize, pointerCount, bit0Offset);\n", spaces(indent), " super(segment, data, pointers, dataSize, pointerCount, bit0Offset);\n",
spaces(indent), " }\n", spaces(indent), " }\n",

81
runtime/src/main/java/org/capnproto/DataList.java
View file

@ -2,36 +2,59 @@ package org.capnproto;
public final class DataList { public final class DataList {
public static final class Factory implements ListFactory<Builder, Reader> { public static final class Factory implements ListFactory<Builder, Reader> {
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) { 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) { 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) { public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) {
return new Builder(builder.initList(FieldSize.POINTER, size)); return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.POINTER);
} }
} }
public static final Factory factory = new Factory(); public static final Factory factory = new Factory();
public static final class Reader implements Iterable<Data.Reader> { public static final class Reader extends ListReader implements Iterable<Data.Reader> {
public final ListReader reader; public Reader(SegmentReader segment,
int ptr,
public Reader(ListReader reader) { int elementCount, int step,
this.reader = reader; int structDataSize, short structPointerCount,
} int nestingLimit) {
super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit);
public int size() {
return this.reader.size();
} }
public Data.Reader get(int index) { public Data.Reader get(int index) {
return this.reader.getPointerElement(index).getData(); return _getPointerElement(index).getData();
} }
public final class Iterator implements java.util.Iterator<Data.Reader> { public final class Iterator implements java.util.Iterator<Data.Reader> {
public Reader list; public Reader list;
public int idx = 0; public int idx = 0;
@ -40,7 +63,7 @@ public final class DataList {
} }
public Data.Reader next() { public Data.Reader next() {
return this.list.reader.getPointerElement(idx++).getData(); return this.list._getPointerElement(idx++).getData();
} }
public boolean hasNext() { public boolean hasNext() {
return idx < list.size(); return idx < list.size();
@ -53,32 +76,22 @@ public final class DataList {
public java.util.Iterator<Data.Reader> iterator() { public java.util.Iterator<Data.Reader> iterator() {
return new Iterator(this); return new Iterator(this);
} }
} }
public static final class Builder implements Iterable<Data.Builder> { public static final class Builder extends ListBuilder implements Iterable<Data.Builder> {
public final ListBuilder builder;
public Builder(ListBuilder builder) { public Builder(SegmentBuilder segment, int ptr,
this.builder = builder; int elementCount, int step,
} int structDataSize, short structPointerCount){
/* super(segment, ptr, elementCount, step, structDataSize, structPointerCount);
// init
Builder(PointerBuilder builder, int size) {
this.builder = builder.initStructList(size, factory.structSize());
}
*/
public int size() {
return this.builder.size();
} }
public final Data.Builder get(int index) { 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) { 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<Data.Builder> { public final class Iterator implements java.util.Iterator<Data.Builder> {
@ -89,7 +102,7 @@ public final class DataList {
} }
public Data.Builder next() { public Data.Builder next() {
return this.list.builder.getPointerElement(idx++).getData(); return this.list._getPointerElement(idx++).getData();
} }
public boolean hasNext() { public boolean hasNext() {
return this.idx < this.list.size(); return this.idx < this.list.size();

71
runtime/src/main/java/org/capnproto/EnumList.java
View file

@ -15,57 +15,82 @@ public class EnumList {
public Factory(T values[]) { public Factory(T values[]) {
this.values = values; this.values = values;
} }
public final Reader<T> constructReader(SegmentReader segment,
int ptr,
int elementCount, int step,
int structDataSize, short structPointerCount,
int nestingLimit) {
return new Reader<T>(values,
segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit);
}
public final Builder<T> constructBuilder(SegmentBuilder segment,
int ptr,
int elementCount, int step,
int structDataSize, short structPointerCount) {
return new Builder<T> (values, segment, ptr, elementCount, step, structDataSize, structPointerCount);
}
public final Reader<T> fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) { public final Reader<T> fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) {
return new Reader<T>(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<T> fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) { public final Builder<T> fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) {
return new Builder<T>(values, builder.getList(FieldSize.TWO_BYTES, defaultSegment, defaultOffset)); return WireHelpers.getWritableListPointer(this,
builder.pointer,
builder.segment,
FieldSize.TWO_BYTES,
defaultSegment,
defaultOffset);
} }
public final Builder<T> initFromPointerBuilder(PointerBuilder builder, int size) { public final Builder<T> initFromPointerBuilder(PointerBuilder builder, int elementCount) {
return new Builder<T>(values, builder.initList(FieldSize.TWO_BYTES, size)); return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.TWO_BYTES);
} }
} }
public static final class Reader<T extends java.lang.Enum> { public static final class Reader<T extends java.lang.Enum> extends ListReader {
public final ListReader reader;
public final T values[]; public final T values[];
public Reader(T values[], ListReader reader) { public Reader(T values[],
this.reader = reader; 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; this.values = values;
} }
public int size() {
return this.reader.size();
}
public T get(int index) { public T get(int index) {
return clampOrdinal(this.values, this.reader.getShortElement(index)); return clampOrdinal(this.values, _getShortElement(index));
} }
} }
public static final class Builder<T extends java.lang.Enum> { public static final class Builder<T extends java.lang.Enum> extends ListBuilder {
public final ListBuilder builder;
public final T values[]; public final T values[];
public Builder(T values[], ListBuilder builder) { public Builder(T values[],
this.builder = builder; SegmentBuilder segment,
int ptr,
int elementCount, int step,
int structDataSize, short structPointerCount) {
super(segment, ptr, elementCount, step, structDataSize, structPointerCount);
this.values = values; this.values = values;
} }
public int size() {
return this.builder.size();
}
public T get(int index) { 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) { public void set(int index, T value) {
this.builder.setShortElement(index, (short)value.ordinal()); _setShortElement(index, (short)value.ordinal());
} }
} }
} }

5
runtime/src/main/java/org/capnproto/FromPointerBuilder.java
View file

@ -1,6 +1,9 @@
package org.capnproto; package org.capnproto;
public interface FromPointerBuilder<T> { public interface FromPointerBuilder<T> {
T constructBuilder(SegmentBuilder segment, int ptr,
int elementCount, int step,
int structDataSize, short structPointerCount);
T fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset); T fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset);
T initFromPointerBuilder(PointerBuilder value, int size); T initFromPointerBuilder(PointerBuilder builder, int elementCount);
} }

5
runtime/src/main/java/org/capnproto/FromPointerReader.java
View file

@ -1,5 +1,10 @@
package org.capnproto; package org.capnproto;
public interface FromPointerReader<T> { public interface FromPointerReader<T> {
T constructReader(SegmentReader segment,
int ptr,
int elementCount, int step,
int structDataSize, short structPointerCount,
int nestingLimit);
T fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset); T fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset);
} }

34
runtime/src/main/java/org/capnproto/ListBuilder.java
View file

@ -1,6 +1,6 @@
package org.capnproto; package org.capnproto;
public final class ListBuilder { public class ListBuilder {
final SegmentBuilder segment; final SegmentBuilder segment;
final int ptr; // byte offset to front of list final int ptr; // byte offset to front of list
final int elementCount; final int elementCount;
@ -23,36 +23,36 @@ public final class ListBuilder {
return this.elementCount; return this.elementCount;
} }
public boolean getBooleanElement(int index) { protected boolean _getBooleanElement(int index) {
byte b = this.segment.buffer.get(this.ptr + index / 8); byte b = this.segment.buffer.get(this.ptr + index / 8);
return (b & (1 << (index % 8))) != 0; return (b & (1 << (index % 8))) != 0;
} }
public byte getByteElement(int index) { protected byte _getByteElement(int index) {
return this.segment.buffer.get(this.ptr + 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); 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); 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); 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); 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); 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; int bitOffset = index;
byte bitnum = (byte)(bitOffset % 8); byte bitnum = (byte)(bitOffset % 8);
int position = this.ptr + (bitOffset / 8); int position = this.ptr + (bitOffset / 8);
@ -61,31 +61,31 @@ public final class ListBuilder {
(byte)((oldValue & (~(1 << bitnum))) | (( value ? 1 : 0) << bitnum))); (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); 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); 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); 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); 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); 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); this.segment.buffer.putDouble(this.ptr + index * 8, value);
} }
public final <T> T getStructElement(FromStructBuilder<T> factory, int index) { protected final <T> T _getStructElement(FromStructBuilder<T> factory, int index) {
int indexBit = index * this.step; int indexBit = index * this.step;
int structData = this.ptr + indexBit / 8 ; int structData = this.ptr + indexBit / 8 ;
int structPointers = (structData + (this.structDataSize / 8)) / 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( return new PointerBuilder(
this.segment, this.segment,
(this.ptr + (index * this.step / Constants.BITS_PER_BYTE)) / Constants.BYTES_PER_WORD); (this.ptr + (index * this.step / Constants.BITS_PER_BYTE)) / Constants.BYTES_PER_WORD);

72
runtime/src/main/java/org/capnproto/ListList.java
View file

@ -10,58 +10,82 @@ public final class ListList {
this.factory = factory; this.factory = factory;
} }
public final Reader<ElementReader> constructReader(SegmentReader segment,
int ptr,
int elementCount, int step,
int structDataSize, short structPointerCount,
int nestingLimit) {
return new Reader<ElementReader>(factory, segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit);
}
public final Builder<ElementBuilder> constructBuilder(SegmentBuilder segment,
int ptr,
int elementCount, int step,
int structDataSize, short structPointerCount) {
return new Builder<ElementBuilder>(factory, segment, ptr, elementCount, step, structDataSize, structPointerCount);
}
public final Reader<ElementReader> fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) { public final Reader<ElementReader> fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) {
return new Reader<ElementReader>(factory, reader.getList(FieldSize.POINTER, defaultSegment, defaultOffset)); return WireHelpers.readListPointer(this,
reader.segment,
reader.pointer,
defaultSegment,
defaultOffset,
FieldSize.POINTER,
reader.nestingLimit);
} }
public final Builder<ElementBuilder> fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) { public final Builder<ElementBuilder> fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) {
return new Builder<ElementBuilder>(factory, builder.getList(FieldSize.POINTER, defaultSegment, defaultOffset)); return WireHelpers.getWritableListPointer(this,
builder.pointer,
builder.segment,
FieldSize.POINTER,
defaultSegment,
defaultOffset);
} }
public final Builder<ElementBuilder> initFromPointerBuilder(PointerBuilder builder, int size) { public final Builder<ElementBuilder> initFromPointerBuilder(PointerBuilder builder,
return new Builder<ElementBuilder>(factory, builder.initList(FieldSize.POINTER, size)); int elementCount) {
return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.POINTER);
} }
} }
public static final class Reader<T> extends ListReader {
public static final class Reader<T> {
public final ListReader reader;
private final FromPointerReader<T> factory; private final FromPointerReader<T> factory;
public Reader(FromPointerReader<T> factory, ListReader reader) { public Reader(FromPointerReader<T> 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.factory = factory;
this.reader = reader;
}
public final int size() {
return this.reader.size();
} }
public T get(int index) { 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<T> { public static final class Builder<T> extends ListBuilder {
public final ListBuilder builder;
private final FromPointerBuilder<T> factory; private final FromPointerBuilder<T> factory;
public Builder(FromPointerBuilder<T> factory, ListBuilder builder) { public Builder(FromPointerBuilder<T> factory,
SegmentBuilder segment, int ptr,
int elementCount, int step,
int structDataSize, short structPointerCount){
super(segment, ptr, elementCount, step, structDataSize, structPointerCount);
this.factory = factory; this.factory = factory;
this.builder = builder;
}
public final int size() {
return this.builder.size();
} }
public final T init(int index, int 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) { public final T get(int index) {
return this.factory.fromPointerBuilder(this.builder.getPointerElement(index), null, 0); return this.factory.fromPointerBuilder(_getPointerElement(index), null, 0);
} }
} }
} }

20
runtime/src/main/java/org/capnproto/ListReader.java
View file

@ -1,6 +1,6 @@
package org.capnproto; package org.capnproto;
public final class ListReader { public class ListReader {
final SegmentReader segment; final SegmentReader segment;
final int ptr; // byte offset to front of list final int ptr; // byte offset to front of list
final int elementCount; final int elementCount;
@ -37,36 +37,36 @@ public final class ListReader {
return this.elementCount; return this.elementCount;
} }
public boolean getBooleanElement(int index) { protected boolean _getBooleanElement(int index) {
byte b = this.segment.buffer.get(this.ptr + index / 8); byte b = this.segment.buffer.get(this.ptr + index / 8);
return (b & (1 << (index % 8))) != 0; return (b & (1 << (index % 8))) != 0;
} }
public byte getByteElement(int index) { protected byte _getByteElement(int index) {
return this.segment.buffer.get(this.ptr + 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); 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); 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); 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); 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); return this.segment.buffer.getDouble(this.ptr + index * 8);
} }
public <T> T getStructElement(FromStructReader<T> factory, int index) { protected <T> T _getStructElement(FromStructReader<T> factory, int index) {
// TODO check nesting limit // TODO check nesting limit
int indexBit = index * this.step; int indexBit = index * this.step;
@ -78,7 +78,7 @@ public final class ListReader {
this.structPointerCount, (byte) (indexBit % 8), this.nestingLimit - 1); this.structPointerCount, (byte) (indexBit % 8), this.nestingLimit - 1);
} }
public PointerReader getPointerElement(int index) { protected PointerReader _getPointerElement(int index) {
return new PointerReader(this.segment, return new PointerReader(this.segment,
(this.ptr + (index * this.step / Constants.BITS_PER_BYTE)) / Constants.BYTES_PER_WORD, (this.ptr + (index * this.step / Constants.BITS_PER_BYTE)) / Constants.BYTES_PER_WORD,
this.nestingLimit); this.nestingLimit);

16
runtime/src/main/java/org/capnproto/PointerBuilder.java
View file

@ -27,14 +27,6 @@ public final class PointerBuilder {
defaultReader, defaultOffset); 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() { public final Text.Builder getText() {
return WireHelpers.getWritableTextPointer( return WireHelpers.getWritableTextPointer(
this.pointer, this.segment, null, 0, 0); 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()); 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) { public final Text.Builder initText(int size) {
return WireHelpers.initTextPointer(this.pointer, this.segment, size); return WireHelpers.initTextPointer(this.pointer, this.segment, size);
} }

18
runtime/src/main/java/org/capnproto/PointerReader.java
View file

@ -44,24 +44,6 @@ public final class PointerReader {
this.nestingLimit); 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() { public Text.Reader getText() {
return WireHelpers.readTextPointer(this.segment, this.pointer, null, 0, 0); return WireHelpers.readTextPointer(this.segment, this.pointer, null, 0, 0);
} }

558
runtime/src/main/java/org/capnproto/PrimitiveList.java
View file

@ -3,29 +3,53 @@ package org.capnproto;
public class PrimitiveList { public class PrimitiveList {
public static class Void { public static class Void {
public static final class Factory implements ListFactory<Builder, Reader> { public static final class Factory implements ListFactory<Builder, Reader> {
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) { 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) { 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) { public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) {
return new Builder(builder.initList(FieldSize.VOID, size)); return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.VOID);
} }
} }
public static final Factory factory = new Factory(); public static final Factory factory = new Factory();
public static final class Reader { public static final class Reader extends ListReader {
public final ListReader reader; public Reader(SegmentReader segment,
int ptr,
public Reader(ListReader reader) { int elementCount, int step,
this.reader = reader; int structDataSize, short structPointerCount,
} int nestingLimit) {
super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit);
public int size() {
return this.reader.size();
} }
public org.capnproto.Void get(int index) { public org.capnproto.Void get(int index) {
@ -33,123 +57,157 @@ public class PrimitiveList {
} }
} }
public static final class Builder { public static final class Builder extends ListBuilder {
public final ListBuilder builder; public Builder(SegmentBuilder segment, int ptr,
int elementCount, int step,
public Builder(ListBuilder builder) { int structDataSize, short structPointerCount){
this.builder = builder; super(segment, ptr, elementCount, step, structDataSize, structPointerCount);
} }
public int size() {
return this.builder.size();
}
} }
} }
public static class Boolean { public static class Boolean {
public static final class Factory implements ListFactory<Builder, Reader> { public static final class Factory implements ListFactory<Builder, Reader> {
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) { 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) { 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) { public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) {
return new Builder(builder.initList(FieldSize.BIT, size)); return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.BIT);
} }
} }
public static final Factory factory = new Factory(); public static final Factory factory = new Factory();
public static final class Reader { public static final class Reader extends ListReader {
public final ListReader reader; public Reader(SegmentReader segment,
int ptr,
public Reader(ListReader reader) { int elementCount, int step,
this.reader = reader; int structDataSize, short structPointerCount,
} int nestingLimit) {
super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit);
public int size() {
return this.reader.size();
} }
public boolean get(int index) { public boolean get(int index) {
return this.reader.getBooleanElement(index); return _getBooleanElement(index);
} }
} }
public static final class Builder { public static final class Builder extends ListBuilder {
public final ListBuilder builder; public Builder(SegmentBuilder segment, int ptr,
int elementCount, int step,
public Builder(ListBuilder builder) { int structDataSize, short structPointerCount){
this.builder = builder; super(segment, ptr, elementCount, step, structDataSize, structPointerCount);
}
public int size() {
return this.builder.size();
} }
public boolean get(int index) { public boolean get(int index) {
return this.builder.getBooleanElement(index); return _getBooleanElement(index);
} }
public void set(int index, boolean value) { public void set(int index, boolean value) {
this.builder.setBooleanElement(index, value); _setBooleanElement(index, value);
} }
} }
} }
public static class Byte { public static class Byte {
public static final class Factory implements ListFactory<Builder, Reader> { public static final class Factory implements ListFactory<Builder, Reader> {
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) { 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) { 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) { public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) {
return new Builder(builder.initList(FieldSize.BYTE, size)); return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.BYTE);
} }
} }
public static final Factory factory = new Factory(); public static final Factory factory = new Factory();
public static final class Reader { public static final class Reader extends ListReader {
public final ListReader reader; public Reader(SegmentReader segment,
int ptr,
public Reader(ListReader reader) { int elementCount, int step,
this.reader = reader; int structDataSize, short structPointerCount,
} int nestingLimit) {
super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit);
public int size() {
return this.reader.size();
} }
public byte get(int index) { public byte get(int index) {
return this.reader.getByteElement(index); return _getByteElement(index);
} }
} }
public static final class Builder { public static final class Builder extends ListBuilder {
public final ListBuilder builder; public Builder(SegmentBuilder segment, int ptr,
int elementCount, int step,
public Builder(ListBuilder builder) { int structDataSize, short structPointerCount){
this.builder = builder; super(segment, ptr, elementCount, step, structDataSize, structPointerCount);
}
public int size() {
return this.builder.size();
} }
public byte get(int index) { public byte get(int index) {
return this.builder.getByteElement(index); return _getByteElement(index);
} }
public void set(int index, byte value) { 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 class Short {
public static final class Factory implements ListFactory<Builder, Reader> { public static final class Factory implements ListFactory<Builder, Reader> {
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) { 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) { 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) { public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) {
return new Builder(builder.initList(FieldSize.TWO_BYTES, size)); return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.TWO_BYTES);
} }
} }
public static final Factory factory = new Factory(); public static final Factory factory = new Factory();
public static final class Reader { public static final class Reader extends ListReader {
public final ListReader reader; public Reader(SegmentReader segment,
int ptr,
public Reader(ListReader reader) { int elementCount, int step,
this.reader = reader; int structDataSize, short structPointerCount,
} int nestingLimit) {
super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit);
public int size() {
return this.reader.size();
} }
public short get(int index) { public short get(int index) {
return this.reader.getShortElement(index); return _getShortElement(index);
} }
} }
public static final class Builder { public static final class Builder extends ListBuilder {
public final ListBuilder builder; public Builder(SegmentBuilder segment, int ptr,
int elementCount, int step,
public Builder(ListBuilder builder) { int structDataSize, short structPointerCount){
this.builder = builder; super(segment, ptr, elementCount, step, structDataSize, structPointerCount);
}
public int size() {
return this.builder.size();
} }
public short get(int index) { public short get(int index) {
return this.builder.getShortElement(index); return _getShortElement(index);
} }
public void set(int index, short value) { 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 class Int {
public static final class Factory implements ListFactory<Builder, Reader> { public static final class Factory implements ListFactory<Builder, Reader> {
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) { 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) { 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) { public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) {
return new Builder(builder.initList(FieldSize.FOUR_BYTES, size)); return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.FOUR_BYTES);
} }
} }
public static final Factory factory = new Factory(); public static final Factory factory = new Factory();
public static final class Reader { public static final class Reader extends ListReader {
public final ListReader reader; public Reader(SegmentReader segment,
int ptr,
public Reader(ListReader reader) { int elementCount, int step,
this.reader = reader; int structDataSize, short structPointerCount,
} int nestingLimit) {
super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit);
public int size() {
return this.reader.size();
} }
public int get(int index) { public int get(int index) {
return this.reader.getIntElement(index); return _getIntElement(index);
} }
} }
public static final class Builder { public static final class Builder extends ListBuilder {
public final ListBuilder builder; public Builder(SegmentBuilder segment, int ptr,
int elementCount, int step,
public Builder(ListBuilder builder) { int structDataSize, short structPointerCount){
this.builder = builder; super(segment, ptr, elementCount, step, structDataSize, structPointerCount);
}
public int size() {
return this.builder.size();
} }
public int get(int index) { public int get(int index) {
return this.builder.getIntElement(index); return _getIntElement(index);
} }
public void set(int index, int value) { public void set(int index, int value) {
this.builder.setIntElement(index, value); _setIntElement(index, value);
} }
} }
} }
public static class Float { public static class Float {
public static final class Factory implements ListFactory<Builder, Reader> { public static final class Factory implements ListFactory<Builder, Reader> {
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) { 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) { 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) { public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) {
return new Builder(builder.initList(FieldSize.FOUR_BYTES, size)); return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.FOUR_BYTES);
} }
} }
public static final Factory factory = new Factory(); public static final Factory factory = new Factory();
public static final class Reader { public static final class Reader extends ListReader {
public final ListReader reader; public Reader(SegmentReader segment,
int ptr,
public Reader(ListReader reader) { int elementCount, int step,
this.reader = reader; int structDataSize, short structPointerCount,
} int nestingLimit) {
super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit);
public int size() {
return this.reader.size();
} }
public float get(int index) { public float get(int index) {
return this.reader.getFloatElement(index); return _getFloatElement(index);
} }
} }
public static final class Builder { public static final class Builder extends ListBuilder {
public final ListBuilder builder; public Builder(SegmentBuilder segment, int ptr,
int elementCount, int step,
public Builder(ListBuilder builder) { int structDataSize, short structPointerCount){
this.builder = builder; super(segment, ptr, elementCount, step, structDataSize, structPointerCount);
}
public int size() {
return this.builder.size();
} }
public float get(int index) { public float get(int index) {
return this.builder.getFloatElement(index); return _getFloatElement(index);
} }
public void set(int index, float value) { 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 class Long {
public static final class Factory implements ListFactory<Builder, Reader> { public static final class Factory implements ListFactory<Builder, Reader> {
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) { 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) { 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) { public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) {
return new Builder(builder.initList(FieldSize.EIGHT_BYTES, size)); return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.EIGHT_BYTES);
} }
} }
public static final Factory factory = new Factory(); public static final Factory factory = new Factory();
public static final class Reader { public static final class Reader extends ListReader {
public final ListReader reader; public Reader(SegmentReader segment,
int ptr,
public Reader(ListReader reader) { int elementCount, int step,
this.reader = reader; int structDataSize, short structPointerCount,
} int nestingLimit) {
super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit);
public int size() {
return this.reader.size();
} }
public long get(int index) { public long get(int index) {
return this.reader.getLongElement(index); return _getLongElement(index);
} }
} }
public static final class Builder { public static final class Builder extends ListBuilder {
public final ListBuilder builder; public Builder(SegmentBuilder segment, int ptr,
int elementCount, int step,
public Builder(ListBuilder builder) { int structDataSize, short structPointerCount){
this.builder = builder; super(segment, ptr, elementCount, step, structDataSize, structPointerCount);
}
public int size() {
return this.builder.size();
} }
public long get(int index) { public long get(int index) {
return this.builder.getLongElement(index); return _getLongElement(index);
} }
public void set(int index, long value) { public void set(int index, long value) {
this.builder.setLongElement(index, value); _setLongElement(index, value);
} }
} }
} }
public static class Double { public static class Double {
public static final class Factory implements ListFactory<Builder, Reader> { public static final class Factory implements ListFactory<Builder, Reader> {
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) { 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) { 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) { public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) {
return new Builder(builder.initList(FieldSize.EIGHT_BYTES, size)); return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.EIGHT_BYTES);
} }
} }
public static final Factory factory = new Factory(); public static final Factory factory = new Factory();
public static final class Reader { public static final class Reader extends ListReader {
public final ListReader reader; public Reader(SegmentReader segment,
int ptr,
public Reader(ListReader reader) { int elementCount, int step,
this.reader = reader; int structDataSize, short structPointerCount,
} int nestingLimit) {
super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit);
public int size() {
return this.reader.size();
} }
public double get(int index) { public double get(int index) {
return this.reader.getDoubleElement(index); return _getDoubleElement(index);
} }
} }
public static final class Builder { public static final class Builder extends ListBuilder {
public final ListBuilder builder; public Builder(SegmentBuilder segment, int ptr,
int elementCount, int step,
public Builder(ListBuilder builder) { int structDataSize, short structPointerCount){
this.builder = builder; super(segment, ptr, elementCount, step, structDataSize, structPointerCount);
}
public int size() {
return this.builder.size();
} }
public double get(int index) { public double get(int index) {
return this.builder.getDoubleElement(index); return _getDoubleElement(index);
} }
public void set(int index, double value) { public void set(int index, double value) {
this.builder.setDoubleElement(index, value); _setDoubleElement(index, value);
} }
} }
} }

87
runtime/src/main/java/org/capnproto/StructList.java
View file

@ -10,34 +10,65 @@ public final class StructList {
this.factory = factory; this.factory = factory;
} }
public final Reader<ElementReader> constructReader(SegmentReader segment,
int ptr,
int elementCount, int step,
int structDataSize, short structPointerCount,
int nestingLimit) {
return new Reader<ElementReader>(factory,
segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit);
}
public final Builder<ElementBuilder> constructBuilder(SegmentBuilder segment,
int ptr,
int elementCount, int step,
int structDataSize, short structPointerCount) {
return new Builder<ElementBuilder> (factory, segment, ptr, elementCount, step, structDataSize, structPointerCount);
}
public final Reader<ElementReader> fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) { public final Reader<ElementReader> fromPointerReader(PointerReader reader, SegmentReader defaultSegment, int defaultOffset) {
return new Reader<ElementReader>(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<ElementBuilder> fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) { public final Builder<ElementBuilder> fromPointerBuilder(PointerBuilder builder, SegmentReader defaultSegment, int defaultOffset) {
return new Builder<ElementBuilder>(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<ElementBuilder> initFromPointerBuilder(PointerBuilder builder, int size) { public final Builder<ElementBuilder> initFromPointerBuilder(PointerBuilder builder,
return new Builder<ElementBuilder>(factory, builder.initStructList(size, this.factory.structSize())); int elementCount) {
return WireHelpers.initStructListPointer(this, builder.pointer, builder.segment, elementCount, factory.structSize());
} }
} }
public static final class Reader<T> implements Iterable<T> { public static final class Reader<T> extends ListReader implements Iterable<T> {
public final ListReader reader;
public final FromStructReader<T> factory; public final FromStructReader<T> factory;
public Reader(FromStructReader<T> factory, ListReader reader) { public Reader(FromStructReader<T> factory,
this.reader = reader; 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.factory = factory;
} }
public int size() {
return this.reader.size();
}
public T get(int index) { 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() { public T next() {
return list.reader.getStructElement(factory, idx++); return list._getStructElement(factory, idx++);
} }
public boolean hasNext() { public boolean hasNext() {
return idx < list.size(); return idx < list.size();
@ -64,30 +95,21 @@ public final class StructList {
} }
} }
public static final class Builder<T> implements Iterable<T> { public static final class Builder<T> extends ListBuilder implements Iterable<T> {
public final ListBuilder builder;
public final FromStructBuilder<T> factory; public final FromStructBuilder<T> factory;
public Builder(FromStructBuilder<T> factory, ListBuilder builder) { public Builder(FromStructBuilder<T> factory,
this.builder = builder; SegmentBuilder segment, int ptr,
int elementCount, int step,
int structDataSize, short structPointerCount){
super(segment, ptr, elementCount, step, structDataSize, structPointerCount);
this.factory = factory; this.factory = factory;
} }
// init
Builder(FromStructBuilder<T> 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) { public final T get(int index) {
return this.builder.getStructElement(factory, index); return _getStructElement(factory, index);
} }
public final class Iterator implements java.util.Iterator<T> { public final class Iterator implements java.util.Iterator<T> {
public Builder<T> list; public Builder<T> list;
public int idx = 0; public int idx = 0;
@ -96,7 +118,7 @@ public final class StructList {
} }
public T next() { public T next() {
return list.builder.getStructElement(factory, idx++); return list._getStructElement(factory, idx++);
} }
public boolean hasNext() { public boolean hasNext() {
return idx < list.size(); return idx < list.size();
@ -109,8 +131,5 @@ public final class StructList {
public java.util.Iterator<T> iterator() { public java.util.Iterator<T> iterator() {
return new Iterator(this); return new Iterator(this);
} }
} }
} }

85
runtime/src/main/java/org/capnproto/TextList.java
View file

@ -2,36 +2,60 @@ package org.capnproto;
public final class TextList { public final class TextList {
public static final class Factory implements ListFactory<Builder, Reader> { public static final class Factory implements ListFactory<Builder, Reader> {
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) { 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) { 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) { public final Builder initFromPointerBuilder(PointerBuilder builder, int elementCount) {
return new Builder(builder.initList(FieldSize.POINTER, size)); return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.POINTER);
} }
} }
public static final Factory factory = new Factory(); public static final Factory factory = new Factory();
public static final class Reader implements Iterable<Text.Reader> { public static final class Reader extends ListReader implements Iterable<Text.Reader> {
public final ListReader reader; public Reader(SegmentReader segment,
int ptr,
public Reader(ListReader reader) { int elementCount, int step,
this.reader = reader; int structDataSize, short structPointerCount,
} int nestingLimit) {
super(segment, ptr, elementCount, step, structDataSize, structPointerCount, nestingLimit);
public int size() {
return this.reader.size();
} }
public Text.Reader get(int index) { public Text.Reader get(int index) {
return this.reader.getPointerElement(index).getText(); return _getPointerElement(index).getText();
} }
public final class Iterator implements java.util.Iterator<Text.Reader> { public final class Iterator implements java.util.Iterator<Text.Reader> {
public Reader list; public Reader list;
public int idx = 0; public int idx = 0;
@ -40,7 +64,7 @@ public final class TextList {
} }
public Text.Reader next() { public Text.Reader next() {
return this.list.reader.getPointerElement(idx++).getText(); return this.list._getPointerElement(idx++).getText();
} }
public boolean hasNext() { public boolean hasNext() {
return idx < list.size(); return idx < list.size();
@ -56,29 +80,19 @@ public final class TextList {
} }
public static final class Builder implements Iterable<Text.Builder> { public static final class Builder extends ListBuilder implements Iterable<Text.Builder> {
public final ListBuilder builder; public Builder(SegmentBuilder segment, int ptr,
int elementCount, int step,
public Builder(ListBuilder builder) { int structDataSize, short structPointerCount){
this.builder = builder; super(segment, ptr, elementCount, step, structDataSize, structPointerCount);
}
/*
// init
Builder(PointerBuilder builder, int size) {
this.builder = builder.initStructList(size, factory.structSize());
}
*/
public int size() {
return this.builder.size();
} }
public final Text.Builder get(int index) { 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) { 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<Text.Builder> { public final class Iterator implements java.util.Iterator<Text.Builder> {
@ -89,7 +103,7 @@ public final class TextList {
} }
public Text.Builder next() { public Text.Builder next() {
return this.list.builder.getPointerElement(idx++).getText(); return this.list._getPointerElement(idx++).getText();
} }
public boolean hasNext() { public boolean hasNext() {
return this.idx < this.list.size(); return this.idx < this.list.size();
@ -102,8 +116,5 @@ public final class TextList {
public java.util.Iterator<Text.Builder> iterator() { public java.util.Iterator<Text.Builder> iterator() {
return new Iterator(this); return new Iterator(this);
} }
} }
} }

92
runtime/src/main/java/org/capnproto/WireHelpers.java
View file

@ -188,10 +188,11 @@ final class WireHelpers {
} }
static ListBuilder initListPointer(int refOffset, static <T> T initListPointer(FromPointerBuilder<T> factory,
SegmentBuilder segment, int refOffset,
int elementCount, SegmentBuilder segment,
byte elementSize) { int elementCount,
byte elementSize) {
assert elementSize != FieldSize.INLINE_COMPOSITE : "Should have called initStructListPointer instead"; assert elementSize != FieldSize.INLINE_COMPOSITE : "Should have called initStructListPointer instead";
int dataSize = FieldSize.dataBitsPerElement(elementSize); int dataSize = FieldSize.dataBitsPerElement(elementSize);
@ -202,18 +203,19 @@ final class WireHelpers {
ListPointer.set(allocation.segment.buffer, allocation.refOffset, elementSize, elementCount); ListPointer.set(allocation.segment.buffer, allocation.refOffset, elementSize, elementCount);
return new ListBuilder(allocation.segment, return factory.constructBuilder(allocation.segment,
allocation.ptr * Constants.BYTES_PER_WORD, allocation.ptr * Constants.BYTES_PER_WORD,
elementCount, step, dataSize, (short)pointerCount); elementCount, step, dataSize, (short)pointerCount);
} }
static ListBuilder initStructListPointer(int refOffset, static <T> T initStructListPointer(FromPointerBuilder<T> factory,
SegmentBuilder segment, int refOffset,
int elementCount, SegmentBuilder segment,
StructSize elementSize) { int elementCount,
StructSize elementSize) {
if (elementSize.preferredListEncoding != FieldSize.INLINE_COMPOSITE) { if (elementSize.preferredListEncoding != FieldSize.INLINE_COMPOSITE) {
//# Small data-only struct. Allocate a list of primitives instead. //# Small data-only struct. Allocate a list of primitives instead.
return initListPointer(refOffset, segment, elementCount, return initListPointer(factory, refOffset, segment, elementCount,
elementSize.preferredListEncoding); elementSize.preferredListEncoding);
} }
@ -230,15 +232,18 @@ final class WireHelpers {
WirePointer.STRUCT, elementCount); WirePointer.STRUCT, elementCount);
StructPointer.setFromStructSize(allocation.segment.buffer, allocation.ptr, elementSize); StructPointer.setFromStructSize(allocation.segment.buffer, allocation.ptr, elementSize);
return new ListBuilder(allocation.segment, return factory.constructBuilder(allocation.segment,
(allocation.ptr + 1) * Constants.BYTES_PER_WORD, (allocation.ptr + 1) * Constants.BYTES_PER_WORD,
elementCount, wordsPerElement * Constants.BITS_PER_WORD, elementCount, wordsPerElement * Constants.BITS_PER_WORD,
elementSize.data * Constants.BITS_PER_WORD, elementSize.pointers); elementSize.data * Constants.BITS_PER_WORD, elementSize.pointers);
} }
static ListBuilder getWritableListPointer(int origRefOffset, static <T> T getWritableListPointer(FromPointerBuilder<T> factory,
SegmentBuilder origSegment, int origRefOffset,
byte elementSize) { SegmentBuilder origSegment,
byte elementSize,
SegmentReader defaultSegment,
int defaultOffset) {
assert elementSize != FieldSize.INLINE_COMPOSITE : "Use getStructList{Element,Field} for structs"; assert elementSize != FieldSize.INLINE_COMPOSITE : "Use getStructList{Element,Field} for structs";
long origRef = WirePointer.get(origSegment.buffer, origRefOffset); long origRef = WirePointer.get(origSegment.buffer, origRefOffset);
@ -285,9 +290,9 @@ final class WireHelpers {
int step = dataSize + pointerCount * Constants.BITS_PER_POINTER; int step = dataSize + pointerCount * Constants.BITS_PER_POINTER;
return new ListBuilder(resolved.segment, resolved.ptr * Constants.BYTES_PER_WORD, return factory.constructBuilder(resolved.segment, resolved.ptr * Constants.BYTES_PER_WORD,
ListPointer.elementCount(resolved.ref), ListPointer.elementCount(resolved.ref),
step, dataSize, (short) pointerCount); step, dataSize, (short) pointerCount);
} }
} }
@ -498,18 +503,19 @@ final class WireHelpers {
throw new Error("copyPointer is unimplemented"); throw new Error("copyPointer is unimplemented");
} }
static ListReader readListPointer(SegmentReader segment, static <T> T readListPointer(FromPointerReader<T> factory,
int refOffset, SegmentReader segment,
SegmentReader defaultSegment, int refOffset,
int defaultOffset, SegmentReader defaultSegment,
byte expectedElementSize, int defaultOffset,
int nestingLimit) { byte expectedElementSize,
int nestingLimit) {
long ref = WirePointer.get(segment.buffer, refOffset); long ref = WirePointer.get(segment.buffer, refOffset);
if (WirePointer.isNull(ref)) { if (WirePointer.isNull(ref)) {
if (defaultSegment == null) { if (defaultSegment == null) {
return new ListReader(); factory.constructReader(SegmentReader.EMPTY, 0, 0, 0, 0, (short) 0, 0x7fffffff);
} else { } else {
segment = defaultSegment; segment = defaultSegment;
refOffset = defaultOffset; refOffset = defaultOffset;
@ -542,13 +548,13 @@ final class WireHelpers {
// TODO check whether the size is compatible // TODO check whether the size is compatible
return new ListReader(resolved.segment, return factory.constructReader(resolved.segment,
ptr * Constants.BYTES_PER_WORD, ptr * Constants.BYTES_PER_WORD,
size, size,
wordsPerElement * Constants.BITS_PER_WORD, wordsPerElement * Constants.BITS_PER_WORD,
StructPointer.dataSize(tag) * Constants.BITS_PER_WORD, StructPointer.dataSize(tag) * Constants.BITS_PER_WORD,
StructPointer.ptrCount(tag), StructPointer.ptrCount(tag),
nestingLimit - 1); nestingLimit - 1);
} }
default : { default : {
//# This is a primitive or pointer list, but all such //# 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."); throw new DecodeException("Message contains list with incompatible element type.");
} }
return new ListReader(resolved.segment, return factory.constructReader(resolved.segment,
resolved.ptr * Constants.BYTES_PER_WORD, resolved.ptr * Constants.BYTES_PER_WORD,
ListPointer.elementCount(resolved.ref), ListPointer.elementCount(resolved.ref),
step, step,
dataSize, dataSize,
(short)pointerCount, (short)pointerCount,
nestingLimit - 1); nestingLimit - 1);
} }
} }
} }