io.protostuff.Input Java Examples

public void mergeFrom(Input input, DefaultFacets message) throws IOException {
    int number;
    while ((number = input.readFieldNumber(this)) != 0) {
        switch (number) {
            case 1:
                if (message.fields == null)
                    message.fields = new ArrayList<FieldCardinalityBase>();
                DefaultFieldCardinality f = input.mergeObject(null, DefaultFieldCardinality.getSchema());
                message.fields.add(f);
                break;
            default:
                input.handleUnknownField(number, this);
                break;
        }
    }
}
 

static ArrayWrapper newArrayWrapper(Input input, Schema<?> schema,
        boolean mapped, IdStrategy strategy) throws IOException
{
    final Class<?> componentType = strategy.resolveArrayComponentTypeFrom(
            input, mapped);

    if (input.readFieldNumber(schema) != ID_ARRAY_LEN)
        throw new ProtostuffException("Corrupt input.");
    final int len = input.readUInt32();

    if (input.readFieldNumber(schema) != ID_ARRAY_DIMENSION)
        throw new ProtostuffException("Corrupt input.");
    final int dimensions = input.readUInt32();

    if (dimensions == 1)
        return new ArrayWrapper(Array.newInstance(componentType, len));

    final int[] arg = new int[dimensions];
    arg[0] = len;
    return new ArrayWrapper(Array.newInstance(componentType, arg));
}
 

static void transferArray(Pipe pipe, Input input, Output output, int number,
        Pipe.Schema<?> pipeSchema, boolean mapped, IdStrategy strategy) throws IOException
{
    strategy.transferArrayId(input, output, number, mapped);

    if (input.readFieldNumber(pipeSchema.wrappedSchema) != ID_ARRAY_LEN)
        throw new ProtostuffException("Corrupt input.");

    output.writeUInt32(ID_ARRAY_LEN, input.readUInt32(), false);

    if (input.readFieldNumber(pipeSchema.wrappedSchema) != ID_ARRAY_DIMENSION)
        throw new ProtostuffException("Corrupt input.");

    output.writeUInt32(ID_ARRAY_DIMENSION, input.readUInt32(), false);

    if (output instanceof StatefulOutput)
    {
        // update using the derived schema.
        ((StatefulOutput) output).updateLast(strategy.ARRAY_PIPE_SCHEMA, pipeSchema);
    }

    Pipe.transferDirect(strategy.ARRAY_PIPE_SCHEMA, pipe, input, output);
}
 

static Object readObjectFrom(Input input, Schema<?> schema, Object owner,
        IdStrategy strategy, int number) throws IOException
{
    final Schema<Object> derivedSchema = strategy.resolvePojoFrom(input,
            number).getSchema();
    
    final Object pojo = derivedSchema.newMessage();
    
    if (input instanceof GraphInput)
    {
        // update the actual reference.
        ((GraphInput) input).updateLast(pojo, owner);
    }
    
    derivedSchema.mergeFrom(input, pojo);
    return pojo;
}
 

protected Object readPrimitiveFrom(Input input, Object owner, int len)
        throws IOException
{
    short[] array = new short[len];
    if (input instanceof GraphInput)
    {
        // update the actual reference.
        ((GraphInput) input).updateLast(array, owner);
    }

    for (int i = 0; i < len; i++)
    {
        if (ID_ARRAY_DATA != input.readFieldNumber(this))
            throw new ProtostuffException("Corrupt input.");

        array[i] = (short) input.readUInt32();
    }

    if (0 != input.readFieldNumber(this))
        throw new ProtostuffException("Corrupt input.");

    return array;
}
 

@Override
public void mergeFrom(final Input input, final OffsetDateTime message) throws IOException {
    while (true) {
        int number = input.readFieldNumber(this);
        switch (number) {
            case 0:
                return;
            case 1:
                LocalDateTime localDateTime = LocalDateTime.now();
                input.mergeObject(localDateTime, LocalDateTimeSchema.INSTANCE);
                setValue(FIELD_DATE_TIME, message, localDateTime);
                break;
            case 2:
                //不能使用0，0会缓存结果对象
                ZoneOffset offset = ZoneOffset.ofTotalSeconds(1);
                input.mergeObject(offset, ZoneOffsetSchema.INSTANCE);
                setValue(FIELD_ZONE_OFFSET, message, offset);
                break;
            default:
                input.handleUnknownField(number, this);
        }
    }
}
 

@Override
public void mergeFrom(final Input input, final LocalDateTime message) throws IOException {
    while (true) {
        int number = input.readFieldNumber(this);
        switch (number) {
            case 0:
                return;
            case 1:
                LocalDate localDate = LocalDate.now();
                input.mergeObject(localDate, LocalDateSchema.INSTANCE);
                setValue(FIELD_DATE, message, localDate);
                break;
            case 2:
                LocalTime localTime = LocalTime.now();
                input.mergeObject(localTime, LocalTimeSchema.INSTANCE);
                setValue(FIELD_TIME, message, localTime);
                break;
            default:
                input.handleUnknownField(number, this);
        }
    }
}
 

protected Object readPrimitiveFrom(Input input, Object owner, int len)
        throws IOException
{
    boolean[] array = new boolean[len];
    if (input instanceof GraphInput)
    {
        // update the actual reference.
        ((GraphInput) input).updateLast(array, owner);
    }

    for (int i = 0; i < len; i++)
    {
        if (ID_ARRAY_DATA != input.readFieldNumber(this))
            throw new ProtostuffException("Corrupt input.");

        array[i] = input.readBool();
    }

    if (0 != input.readFieldNumber(this))
        throw new ProtostuffException("Corrupt input.");

    return array;
}
 

@Override
public void mergeFrom(final Input input, final LocalDate message) throws IOException {
    while (true) {
        int number = input.readFieldNumber(this);
        switch (number) {
            case 0:
                return;
            case 1:
                setValue(FIELD_YEAR, message, input.readInt32());
                break;
            case 2:
                setValue(FIELD_MONTH, message, (short) input.readInt32());
                break;
            case 3:
                setValue(FIELD_DAY, message, (short) input.readInt32());
                break;
            default:
                input.handleUnknownField(number, this);
        }
    }
}
 

protected Object readPrimitiveFrom(Input input, Object owner, int len)
        throws IOException
{
    float[] array = new float[len];
    if (input instanceof GraphInput)
    {
        // update the actual reference.
        ((GraphInput) input).updateLast(array, owner);
    }

    for (int i = 0; i < len; i++)
    {
        if (ID_ARRAY_DATA != input.readFieldNumber(this))
            throw new ProtostuffException("Corrupt input.");

        array[i] = input.readFloat();
    }

    if (0 != input.readFieldNumber(this))
        throw new ProtostuffException("Corrupt input.");

    return array;
}
 

@Override
public <T> T readObject(InputBuf inputBuf, Class<T> clazz) {
    Schema<T> schema = RuntimeSchema.getSchema(clazz);
    T msg = schema.newMessage();

    Input input = Inputs.getInput(inputBuf);
    try {
        schema.mergeFrom(input, msg);
        Inputs.checkLastTagWas(input, 0);
    } catch (IOException e) {
        ThrowUtil.throwException(e);
    } finally {
        inputBuf.release();
    }

    return msg;
}
 

@Override
@SuppressWarnings("unchecked")
protected <T> HasSchema<T> transferPojoId(Input input, Output output, int fieldNumber)
        throws IOException
{
    final int id = input.readUInt32();

    final BaseHS<T> wrapper = id < pojos.size() ? (BaseHS<T>) pojos.get(id) : null;
    if (wrapper == null)
        throw new UnknownTypeException("unknown pojo id: " + id);

    output.writeUInt32(fieldNumber, id, false);

    return wrapper;
}
 

@Override
public Object readFrom(Input input, Object owner) throws IOException
{
    if (ID_ARRAY_LEN != input.readFieldNumber(this))
        throw new ProtostuffException("Corrupt input.");

    final int len = input.readInt32();

    Object[] array = (Object[])Array.newInstance(delegate.typeClass(), len);
    if (input instanceof GraphInput)
    {
        // update the actual reference.
        ((GraphInput) input).updateLast(array, owner);
    }

    for (int i = 0; i < len;)
    {
        switch (input.readFieldNumber(this))
        {
            case ID_ARRAY_DATA:
                array[i++] = delegate.readFrom(input);
                break;
            case ID_ARRAY_NULLCOUNT:
                i += input.readUInt32();
                break;
            default:
                throw new ProtostuffException("Corrupt input.");
        }
    }

    if (0 != input.readFieldNumber(this))
        throw new ProtostuffException("Corrupt input.");

    return array;
}
 

@Override
protected <T> HasSchema<T> resolvePojoFrom(Input input, int fieldNumber)
        throws IOException
{
    final String className = input.readString();

    final HasSchema<T> wrapper = getSchemaWrapper(className,
            0 != (AUTO_LOAD_POLYMORPHIC_CLASSES & flags));
    if (wrapper == null)
        throw new ProtostuffException("polymorphic pojo not registered: "
                + className);

    return wrapper;
}
 

@Override
protected Class<?> resolveArrayComponentTypeFrom(Input input, boolean mapped)
        throws IOException
{
    return mapped ? RuntimeEnv.loadClass(input.readString()) :
            resolveClass(input.readUInt32());
}
 

@Override
protected void transfer(Pipe pipe, Input input, Output output)
        throws IOException
{
    transferObject(this, pipe, input, output, strategy,
            RuntimeFieldFactory.INT64);
}
 

@Override
public void mergeFrom(final Input input, final ZoneId message) throws IOException {
    while (true) {
        int number = input.readFieldNumber(this);
        switch (number) {
            case 0:
                return;
            case 1:
                setValue(FIELD_ID, message, input.readString());
                break;
            default:
                input.handleUnknownField(number, this);
        }
    }
}
 

@Override
public Object readFrom(Input input, Object owner) throws IOException
{
    if (ID_ARRAY_LEN != input.readFieldNumber(this))
        throw new ProtostuffException("Corrupt input.");

    final int len = input.readInt32();

    Object[] array = (Object[])Array.newInstance(eio.enumClass, len);
    if (input instanceof GraphInput)
    {
        // update the actual reference.
        ((GraphInput) input).updateLast(array, owner);
    }

    for (int i = 0; i < len;)
    {
        switch (input.readFieldNumber(this))
        {
            case ID_ARRAY_DATA:
                array[i++] = eio.readFrom(input);
                break;
            case ID_ARRAY_NULLCOUNT:
                i += input.readUInt32();
                break;
            default:
                throw new ProtostuffException("Corrupt input.");
        }
    }

    if (0 != input.readFieldNumber(this))
        throw new ProtostuffException("Corrupt input.");

    return array;
}
 

static Object readObjectFrom(Input input, Schema<?> schema, Object owner,
        IdStrategy strategy) throws IOException
{
    final int number = input.readFieldNumber(schema);
    if (number != ID_POJO)
        throw new ProtostuffException("Corrupt input.");
    
    return readObjectFrom(input, schema, owner, strategy, number);
}
 

@Override
public Object readFrom(Input input, Object owner) throws IOException
{
    if (ID_ARRAY_LEN != input.readFieldNumber(this))
        throw new ProtostuffException("Corrupt input.");

    final int len = input.readInt32();
    return primitive ? readPrimitiveFrom(input, owner, len) : 
            readBoxedFrom(input, owner, len);
}
 

@Override
protected void transfer(Pipe pipe, Input input, Output output)
        throws IOException
{
    transferObject(this, pipe, input, output, strategy,
            RuntimeFieldFactory.SHORT);
}
 

@Override
protected Class<?> resolveClassFrom(Input input, boolean mapped,
        boolean array) throws IOException
{
    return mapped ? RuntimeEnv.loadClass(input.readString()) :
            resolveClass(input.readUInt32());
}
 

private static Object readCheckedCollectionFrom(Input input,
        Schema<?> schema, Object owner, IdStrategy strategy, boolean graph,
        Object collection, boolean ss, boolean list) throws IOException
{
    if (graph)
    {
        // update the actual reference.
        ((GraphInput) input).updateLast(collection, owner);
    }

    final Wrapper wrapper = new Wrapper();
    Object c = input.mergeObject(wrapper,
            strategy.POLYMORPHIC_COLLECTION_SCHEMA);
    if (!graph || !((GraphInput) input).isCurrentMessageReference())
        c = wrapper.value;

    if (1 != input.readFieldNumber(schema))
        throw new ProtostuffException("Corrupt input.");

    Object type = input.mergeObject(wrapper, strategy.CLASS_SCHEMA);
    if (!graph || !((GraphInput) input).isCurrentMessageReference())
        type = wrapper.value;
    try
    {
        fCheckedCollection_c.set(collection, c);
        fCheckedCollection_type.set(collection, type);

        if (ss)
            fCheckedSortedSet_ss.set(collection, c);

        if (list)
            fCheckedList_list.set(collection, c);
    }
    catch (Exception e)
    {
        throw new RuntimeException(e);
    }

    return collection;
}
 

public void mergeFrom(Input input, MapReduceInfoResponseList message) throws IOException {
    List<MapReduceInfoResponse> responses = null;
    LinkedList<QueryExceptionType> exceptions = null;
    int number;
    while ((number = input.readFieldNumber(this)) != 0) {
        switch (number) {
            case 1:
                if (responses == null)
                    responses = new ArrayList<MapReduceInfoResponse>();
                responses.add(input.mergeObject(null, MapReduceInfoResponse.getSchema()));
                break;
            case 2:
                message.setOperationTimeMS(input.readUInt64());
                break;
            case 3:
                message.addMessage(input.readString());
                break;
            case 4:
                if (exceptions == null)
                    exceptions = new LinkedList<QueryExceptionType>();
                exceptions.add(input.mergeObject(null, QueryExceptionType.getSchema()));
                break;
            default:
                input.handleUnknownField(number, this);
                break;
        }
    }
    if (exceptions != null)
        message.setExceptions(exceptions);
    if (responses != null)
        message.setResults(responses);
}
 

public void mergeFrom(Input input, DefaultEdgeQueryResponse message) throws IOException {
    LinkedList<QueryExceptionType> exceptions = null;
    int number;
    while ((number = input.readFieldNumber(this)) != 0) {
        switch (number) {
            case 1:
                message.setQueryId(input.readString());
                break;
            case 2:
                message.setLogicName(input.readString());
                break;
            case 3:
                message.setOperationTimeMS(input.readUInt64());
                break;
            case 4:
                message.addMessage(input.readString());
                break;
            case 5:
                if (exceptions == null)
                    exceptions = new LinkedList<QueryExceptionType>();
                exceptions.add(input.mergeObject(null, QueryExceptionType.getSchema()));
                break;
            case 6:
                message.securityMarkings = input.readString();
                break;
            case 7:
                if (message.edges == null)
                    message.edges = new ArrayList<DefaultEdge>();
                message.edges.add(input.mergeObject(null, DefaultEdge.getSchema()));
                break;
            default:
                input.handleUnknownField(number, this);
                break;
        }
    }
    if (exceptions != null)
        message.setExceptions(exceptions);
}
 

static void transferObject(Pipe.Schema<Object> pipeSchema, Pipe pipe,
        Input input, Output output, IdStrategy strategy,
        Delegate<?> delegate) throws IOException
{
    if (ID_ARRAY_LEN != input.readFieldNumber(pipeSchema.wrappedSchema))
        throw new ProtostuffException("Corrupt input.");

    int len = input.readInt32();
    // write it back
    output.writeInt32(ID_ARRAY_LEN, len, false);
    
    // if from derived schema and the array is boxed, the length written
    // during serialization is: -(len + 1)
    if (len < 0)
        len = -len - 1;

    for (int i = 0, nullCount = 0; i < len;)
    {
        switch (input.readFieldNumber(pipeSchema.wrappedSchema))
        {
            case ID_ARRAY_DATA:
                i++;
                delegate.transfer(pipe, input, output, ID_ARRAY_DATA, true);
                break;
            case ID_ARRAY_NULLCOUNT:
                nullCount = input.readUInt32();
                i += nullCount;
                output.writeUInt32(ID_ARRAY_NULLCOUNT, nullCount, false);
                break;
            default:
                throw new ProtostuffException("Corrupt input.");
        }
    }

    if (0 != input.readFieldNumber(pipeSchema.wrappedSchema))
        throw new ProtostuffException("Corrupt input.");
}
 

@Override
protected EnumIO<?> resolveEnumFrom(Input input) throws IOException
{
    final int id = input.readUInt32();

    final RegisteredEnumIO reio = id < enums.size() ? enums.get(id) : null;
    if (reio == null)
        throw new UnknownTypeException("enum id: " + id + " (Outdated registry)");

    return reio.eio;
}
 

/**
 * Transfers the {@link Enum} from the input to the output.
 */
public static void transfer(Pipe pipe, Input input, Output output,
        int number, boolean repeated, IdStrategy strategy) throws IOException
{
    if (0 == (IdStrategy.ENUMS_BY_NAME & strategy.flags))
        output.writeEnum(number, input.readEnum(), repeated);
    else
        input.transferByteRangeTo(output, true, number, repeated);
}
 

@Override
public Object readFrom(Input input, Object owner) throws IOException
{
    if (ID_ARRAY_LEN != input.readFieldNumber(this))
        throw new ProtostuffException("Corrupt input.");

    final int len = input.readInt32();
    return primitive ? readPrimitiveFrom(input, owner, len) : 
            readBoxedFrom(input, owner, len);
}
 

protected Object readBoxedFrom(Input input, Object owner, int len)
        throws IOException
{
    final Long[] array = new Long[len];
    if (input instanceof GraphInput)
    {
        // update the actual reference.
        ((GraphInput) input).updateLast(array, owner);
    }

    for (int i = 0; i < len;)
    {
        switch (input.readFieldNumber(this))
        {
            case ID_ARRAY_DATA:
                array[i++] = input.readInt64();
                break;
            case ID_ARRAY_NULLCOUNT:
                i += input.readUInt32();
                break;
            default:
                throw new ProtostuffException("Corrupt input.");
        }
    }

    if (0 != input.readFieldNumber(this))
        throw new ProtostuffException("Corrupt input.");

    return array;
}