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), " 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",

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

@ -2,36 +2,59 @@ package org.capnproto;
public final class DataList {
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) {
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<Data.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 implements Iterable<Data.Reader> {
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<Data.Reader> {
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<Data.Reader> iterator() {
return new Iterator(this);
}
}
public static final class Builder implements Iterable<Data.Builder> {
public final ListBuilder builder;
public static final class Builder extends ListBuilder implements Iterable<Data.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 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<Data.Builder> {
@ -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();

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

@ -15,57 +15,82 @@ public class EnumList {
public Factory(T 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) {
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) {
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) {
return new Builder<T>(values, builder.initList(FieldSize.TWO_BYTES, size));
public final Builder<T> initFromPointerBuilder(PointerBuilder builder, int elementCount) {
return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.TWO_BYTES);
}
}
public static final class Reader<T extends java.lang.Enum> {
public final ListReader reader;
public static final class Reader<T extends java.lang.Enum> 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<T extends java.lang.Enum> {
public final ListBuilder builder;
public static final class Builder<T extends java.lang.Enum> 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());
}
}
}

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

@ -1,6 +1,9 @@
package org.capnproto;
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 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;
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);
}

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

@ -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> T getStructElement(FromStructBuilder<T> factory, int index) {
protected final <T> T _getStructElement(FromStructBuilder<T> 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);

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

@ -10,58 +10,82 @@ public final class ListList {
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) {
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) {
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) {
return new Builder<ElementBuilder>(factory, builder.initList(FieldSize.POINTER, size));
public final Builder<ElementBuilder> initFromPointerBuilder(PointerBuilder builder,
int elementCount) {
return WireHelpers.initListPointer(this, builder.pointer, builder.segment, elementCount, FieldSize.POINTER);
}
}
public static final class Reader<T> {
public final ListReader reader;
public static final class Reader<T> extends ListReader {
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.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<T> {
public final ListBuilder builder;
public static final class Builder<T> extends ListBuilder {
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.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);
}
}
}

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

@ -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> T getStructElement(FromStructReader<T> factory, int index) {
protected <T> T _getStructElement(FromStructReader<T> 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);

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

@ -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);
}

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

@ -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);
}

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

@ -3,29 +3,53 @@ package org.capnproto;
public class PrimitiveList {
public static class Void {
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) {
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<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) {
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<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) {
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<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) {
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<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) {
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<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) {
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<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) {
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<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) {
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);
}
}
}

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

@ -10,34 +10,65 @@ public final class StructList {
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) {
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) {
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) {
return new Builder<ElementBuilder>(factory, builder.initStructList(size, this.factory.structSize()));
public final Builder<ElementBuilder> initFromPointerBuilder(PointerBuilder builder,
int elementCount) {
return WireHelpers.initStructListPointer(this, builder.pointer, builder.segment, elementCount, factory.structSize());
}
}
public static final class Reader<T> implements Iterable<T> {
public final ListReader reader;
public static final class Reader<T> extends ListReader implements Iterable<T> {
public final FromStructReader<T> factory;
public Reader(FromStructReader<T> factory, ListReader reader) {
this.reader = reader;
public Reader(FromStructReader<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;
}
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<T> implements Iterable<T> {
public final ListBuilder builder;
public static final class Builder<T> extends ListBuilder implements Iterable<T> {
public final FromStructBuilder<T> factory;
public Builder(FromStructBuilder<T> factory, ListBuilder builder) {
this.builder = builder;
public Builder(FromStructBuilder<T> 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<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) {
return this.builder.getStructElement(factory, index);
return _getStructElement(factory, index);
}
public final class Iterator implements java.util.Iterator<T> {
public Builder<T> 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<T> iterator() {
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 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) {
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<Text.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 implements Iterable<Text.Reader> {
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<Text.Reader> {
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<Text.Builder> {
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<Text.Builder> {
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<Text.Builder> {
@ -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<Text.Builder> iterator() {
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,
SegmentBuilder segment,
int elementCount,
byte elementSize) {
static <T> T initListPointer(FromPointerBuilder<T> 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> T initStructListPointer(FromPointerBuilder<T> 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> T getWritableListPointer(FromPointerBuilder<T> 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> T readListPointer(FromPointerReader<T> 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);
}
}
}