io.protostuff.WireFormat.FieldType Java Examples

public void testRawLittleEndian64Bytes() throws Exception
{
    String n1 = "double1", n2 = "double2";
    for (int i = 0; i < doubleValues.length;)
    {
        double[] inner = doubleValues[i++];
        int num = i;
        for (int j = 0; j < inner.length; j++)
        {
            long value = Double.doubleToRawLongBits(inner[j]);
            int tag = WireFormat.makeTag(num, FieldType.DOUBLE.wireType);
            int tagSize = CodedOutput.computeRawVarint32Size(tag);
            int expect = tagSize + CodedOutput.LITTLE_ENDIAN_64_SIZE;

            assertSize(n1, CodedOutput.computeDoubleSize(num, inner[j]), expect);
            assertSize(n2, CodedOutput.getTagAndRawLittleEndian64Bytes(tag, value).length, expect);
        }
    }
}
 

public void testRawLittleEndian32Bytes() throws Exception
{
    String n1 = "float1", n2 = "float2";
    for (int i = 0; i < floatValues.length;)
    {
        float[] inner = floatValues[i++];
        int num = i;
        for (int j = 0; j < inner.length; j++)
        {
            int value = Float.floatToRawIntBits(inner[j]);
            int valueSize = CodedOutput.LITTLE_ENDIAN_32_SIZE;
            int tag = WireFormat.makeTag(num, FieldType.FLOAT.wireType);
            int tagSize = CodedOutput.computeRawVarint32Size(tag);
            int expect = tagSize + valueSize;

            assertSize(n1, CodedOutput.computeFloatSize(num, inner[j]), expect);
            assertSize(n2, CodedOutput.getTagAndRawLittleEndian32Bytes(tag, value).length, expect);
        }
    }
}
 

public void testRawVarInt64Bytes() throws Exception
{
    String n1 = "long1", n2 = "long2";
    for (int i = 0; i < int64values.length;)
    {
        long[] inner = int64values[i++];
        int num = i;
        for (int j = 0; j < inner.length; j++)
        {
            long value = inner[j];
            int valueSize = CodedOutput.computeRawVarint64Size(value);
            int tag = WireFormat.makeTag(num, FieldType.INT64.wireType);
            int tagSize = CodedOutput.computeRawVarint32Size(tag);
            int expect = tagSize + valueSize;

            assertSize(n1, CodedOutput.computeInt64Size(num, value), expect);
            assertSize(n2, CodedOutput.getTagAndRawVarInt64Bytes(tag, value).length, expect);
        }
    }
}
 

public void testRawVarInt32Bytes() throws Exception
{
    String n1 = "int1", n2 = "int2";
    for (int i = 0; i < int32values.length;)
    {
        int[] inner = int32values[i++];
        int num = i;
        for (int j = 0; j < inner.length; j++)
        {
            int value = inner[j];
            int valueSize = CodedOutput.computeRawVarint32Size(value);
            int tag = WireFormat.makeTag(num, FieldType.INT32.wireType);
            int tagSize = CodedOutput.computeRawVarint32Size(tag);
            int expect = tagSize + valueSize;

            assertSize(n1, CodedOutput.computeInt32Size(num, value), expect);
            assertSize(n2, CodedOutput.getTagAndRawVarInt32Bytes(tag, value).length, expect);
        }
    }

}
 

public RuntimeDerivativeField(Class<Object> typeClass, FieldType type,
        int number, String name, boolean repeated, Tag tag,
        IdStrategy strategy)
{
    super(type, number, name, repeated, tag);
    this.typeClass = typeClass;

    schema = new DerivativeSchema(strategy)
    {
        @Override
        protected void doMergeFrom(Input input,
                Schema<Object> derivedSchema, Object owner)
                throws IOException
        {
            RuntimeDerivativeField.this.doMergeFrom(input, derivedSchema,
                    owner);
        }
    };
}
 

public RuntimeCollectionField(FieldType type, int number, String name,
        Tag tag, MessageFactory messageFactory, boolean allowNullElement)
{
    super(type, number, name, false, tag);
    schema = new CollectionSchema<V>(messageFactory, allowNullElement)
    {
        @Override
        protected void addValueFrom(Input input, Collection<V> collection)
                throws IOException
        {
            RuntimeCollectionField.this.addValueFrom(input, collection);
        }

        @Override
        protected void writeValueTo(Output output, int fieldNumber,
                V value, boolean repeated) throws IOException
        {
            RuntimeCollectionField.this.writeValueTo(output, fieldNumber,
                    value, repeated);
        }

        @Override
        protected void transferValue(Pipe pipe, Input input, Output output,
                int number, boolean repeated) throws IOException
        {
            RuntimeCollectionField.this.transferValue(pipe, input, output,
                    number, repeated);
        }
    };
}
 

public RuntimeMessageField(Class<P> typeClass, HasSchema<P> hasSchema,
        FieldType type, int number, String name, boolean repeated, Tag tag)
{
    super(type, number, name, repeated, tag);
    this.typeClass = typeClass;
    this.hasSchema = hasSchema;
}
 

public RuntimeObjectField(Class<?> typeClass, FieldType type, int number,
        String name, boolean repeated, Tag tag,
        PolymorphicSchema.Factory factory, IdStrategy strategy)
{
    super(type, number, name, repeated, tag);

    schema = factory.newSchema(typeClass, strategy, this);
}
 

public void testBool() throws Exception
{
    int num = 1;
    boolean value = true;
    int valueSize = 1;
    int tag = WireFormat.makeTag(num, FieldType.BOOL.wireType);
    int tagSize = CodedOutput.computeRawVarint32Size(tag);
    int expect = tagSize + valueSize;

    assertSize("boolean1", CodedOutput.computeBoolSize(num, value), expect);
    assertSize("boolean2", CodedOutput.getTagAndRawVarInt32Bytes(tag, 1).length, expect);
}
 

@Override
public FieldType getFieldType()
{
    return FieldType.DOUBLE;
}
 

@Override
public FieldType getFieldType()
{
    return FieldType.FLOAT;
}
 

@Override
public FieldType getFieldType()
{
    return FieldType.INT64;
}
 

@Override
public FieldType getFieldType()
{
    return FieldType.INT32;
}
 

@Override
public FieldType getFieldType()
{
    return FieldType.BOOL;
}
 

@Override
public FieldType getFieldType()
{
    return FieldType.STRING;
}
 

@Override
public FieldType getFieldType()
{
    return FieldType.BYTES;
}
 

@Override
public FieldType getFieldType()
{
    return FieldType.BYTES;
}
 

@Override
public FieldType getFieldType()
{
    throw new UnsupportedOperationException();
}
 

@Override
public FieldType getFieldType()
{
    throw new UnsupportedOperationException();
}
 

@Override
public FieldType getFieldType()
{
    throw new UnsupportedOperationException();
}
 

@Override
public FieldType getFieldType()
{
    return FieldType.MESSAGE;
}
 

@Override
public FieldType getFieldType()
{
    return FieldType.STRING;
}
 

@Override
public FieldType getFieldType()
{
    return FieldType.BYTES;
}
 

@Override
public FieldType getFieldType()
{
    return FieldType.FIXED64;
}
 

@Override
public FieldType getFieldType()
{
    throw new UnsupportedOperationException();
}
 

@Override
public FieldType getFieldType()
{
    throw new UnsupportedOperationException();
}
 

@Override
public FieldType getFieldType()
{
    throw new UnsupportedOperationException();
}
 

@Override
public FieldType getFieldType()
{
    return FieldType.BYTES;
}
 

@Override
public FieldType getFieldType()
{
    return FieldType.UINT32;
}
 

@Override
public FieldType getFieldType()
{
    throw new UnsupportedOperationException();
}