ResolvingDecoder (Apache Avro Java 1.5.4 API)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.apache.avro.io
Class ResolvingDecoder

java.lang.Object
  org.apache.avro.io.Decoder
      org.apache.avro.io.ParsingDecoder
          org.apache.avro.io.ValidatingDecoder
              org.apache.avro.io.ResolvingDecoder

All Implemented Interfaces:: Parser.ActionHandler, SkipParser.SkipHandler

public class ResolvingDecoder
extends ValidatingDecoder
extends ValidatingDecoder

Decoder that performs type-resolution between the reader's and writer's schemas.

When resolving schemas, this class will return the values of fields in _writer's_ order, not the reader's order. (However, it returns _only_ the reader's fields, not any extra fields the writer may have written.) To help clients handle fields that appear to be coming out of order, this class defines the method readFieldOrder().

See the parser documentation for information on how this works.

Field Summary

Fields inherited from class org.apache.avro.io.ValidatingDecoder
`in`

Fields inherited from class org.apache.avro.io.ParsingDecoder
`parser`

Method Summary
`Symbol`	`doAction(Symbol input, Symbol top)` Handle the action symbol `top` when the `input` is sought to be taken off the stack.
`void`	`drain()` Consume any more data that has been written by the writer but not needed by the reader so that the the underlying decoder is in proper shape for the next record.
`double`	`readDouble()` Reads a double written by `Encoder.writeDouble(double)`.
`int`	`readEnum()` Reads an enumeration.
`Schema.Field[]`	`readFieldOrder()` Returns the actual order in which the reader's fields will be returned to the reader.
`float`	`readFloat()` Reads a float written by `Encoder.writeFloat(float)`.
`int`	`readIndex()` Reads the tag of a union written by `Encoder.writeIndex(int)`.
`long`	`readLong()` Reads a long written by `Encoder.writeLong(long)`.
`static Object`	`resolve(Schema writer, Schema reader)` Produces an opaque resolver that can be used to construct a new `ResolvingDecoder(Object, Decoder)`.
`void`	`skipAction()` Skips the action at the top of the stack.

Methods inherited from class org.apache.avro.io.ValidatingDecoder
`arrayNext, configure, mapNext, readArrayStart, readBoolean, readBytes, readFixed, readInt, readMapStart, readNull, readString, skipArray, skipBytes, skipFixed, skipFixed, skipMap, skipString`

Methods inherited from class org.apache.avro.io.ParsingDecoder
`skipTopSymbol`

Methods inherited from class org.apache.avro.io.Decoder
`readFixed`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Method Detail

resolve

public static Object resolve(Schema writer,
                             Schema reader)
                      throws IOException

Produces an opaque resolver that can be used to construct a new ResolvingDecoder(Object, Decoder). The returned Object is immutable and hence can be simultaneously used in many ResolvingDecoders. This method is reasonably expensive, the users are encouraged to cache the result.

Parameters:: writer - The writer's schema. Cannot be null.; reader - The reader's schema. Cannot be null.
Returns:: The opaque reolver.
Throws:: IOException

readFieldOrder

public final Schema.Field[] readFieldOrder()
                                    throws IOException

Returns the actual order in which the reader's fields will be returned to the reader. This method is useful because ResolvingDecoder returns values in the order written by the writer, rather than the order expected by the reader. This method allows readers to figure out what fields to expect. Let's say the reader is expecting a three-field record, the first field is a long, the second a string, and the third an array. In this case, a typical usage might be as follows:

   Schema.Fields[] fieldOrder = in.readFieldOrder();
   for (int i = 0; i < 3; i++) {
     switch (fieldOrder[i].pos()) {
     case 1:
       foo(in.readLong());
       break;
     case 2:
       someVariable = in.readString();
       break;
     case 3:
       bar(in); // The code of "bar" will read an array-of-int
       break;
     }

Note that ResolvingDecoder will return only the fields expected by the reader, not other fields that may have been written by the writer. Thus, the iteration-count of "3" in the above loop will always be correct. Throws a runtime exception if we're not just about to read the field of a record. Also, this method will consume the field information, and thus may only be called once before reading the field value. (However, if the client knows the order of incoming fields, then the client does not need to call this method but rather can just start reading the field values.)

Throws:: AvroTypeException - If we're not starting a new record; IOException

drain

public final void drain()
                 throws IOException

Consume any more data that has been written by the writer but not needed by the reader so that the the underlying decoder is in proper shape for the next record. This situation happens when, for example, the writer writes a record with two fields and the reader needs only the first field. This function should be called after completely decoding an object but before next object can be decoded from the same underlying decoder either directly or through another resolving decoder. If the same resolving decoder is used for the next object as well, calling this method is optional; the state of this resolving decoder ensures that any leftover portions are consumed before the next object is decoded.

Throws:: IOException