Package org.apache.avro.io

# Class ValidatingEncoder

java.lang.Object
org.apache.avro.io.Encoder
org.apache.avro.io.ParsingEncoder
org.apache.avro.io.ValidatingEncoder

All Implemented Interfaces:
  `Flushable`, `Parser.ActionHandler`

public class ValidatingEncoder extends ParsingEncoder implements Parser.ActionHandler
An implementation of `Encoder` that wraps another Encoder and ensures that the sequence of operations conforms to the provided schema.

Use `EncoderFactory.validatingEncoder(Schema, Encoder)` to construct and configure.

ValidatingEncoder is not thread-safe.

See Also:
  - `Encoder`
  - `EncoderFactory`

## Field Summary

Fields
Modifier and Type
Field
Description
`protected Encoder`
`out`
`protected final Parser`
`parser`

### Fields inherited from class org.apache.avro.io.ParsingEncoder

`pos`

## Method Summary

Modifier and Type
Method
Description
`ValidatingEncoder`
`configure(Encoder encoder)`
Reconfigures this ValidatingEncoder to wrap the encoder provided.
`Symbol`
`doAction(Symbol input, Symbol top)`
Handle the action symbol `top` when the `input` is sought to be taken off the stack.
`void`
`flush()`
`void`
`setItemCount(long itemCount)`
Call this method before writing a batch of items in an array or a map.
`void`
`startItem()`
Start a new item of an array or map.
`void`
`writeArrayEnd()`
Call this method to finish writing an array.
`void`
`writeArrayStart()`
Call this method to start writing an array.
`void`
`writeBoolean(boolean b)`
Write a boolean value.
`void`
`writeBytes(byte[] bytes, int start, int len)`
Write a byte string.
`void`
`writeBytes(ByteBuffer bytes)`
Write a byte string.
`void`
`writeDouble(double d)`
Write a double.
`void`
`writeEnum(int e)`
Writes an enumeration.
`void`
`writeFixed(byte[] bytes, int start, int len)`
Writes a fixed size binary object.
`void`
`writeFloat(float f)`
Write a float.
`void`
`writeIndex(int unionIndex)`
Call this method to write the tag of a union.
`void`
`writeInt(int n)`
Writes a 32-bit integer.
`void`
`writeLong(long n)`
Write a 64-bit integer.
`void`
`writeMapEnd()`
Call this method to terminate the inner-most, currently-opened map.
`void`
`writeMapStart()`
Call this to start a new map.
`void`
`writeNull()`
"Writes" a null value.
`void`
`writeString(CharSequence charSequence)`
Write a Unicode character string.
`void`
`writeString(String str)`
Write a Unicode character string.
`void`
`writeString(Utf8 utf8)`
Write a Unicode character string.

### Methods inherited from class org.apache.avro.io.ParsingEncoder

`depth, pop, push`

### Methods inherited from class org.apache.avro.io.Encoder

`writeBytes, writeFixed, writeFixed`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Field Details

### out

protected Encoder out

### parser

protected final Parser parser

## Method Details

### flush

public void flush() throws IOException

Specified by:
  `flush` in interface `Flushable`
Throws:
  `IOException`

### configure

public ValidatingEncoder configure(Encoder encoder)
Reconfigures this ValidatingEncoder to wrap the encoder provided.

Parameters:
  `encoder` - The Encoder to wrap for validation.
Returns:
  This ValidatingEncoder.

### writeNull

public void writeNull() throws IOException
Description copied from class: `Encoder`
"Writes" a null value. (Doesn't actually write anything, but advances the state of the parser if this class is stateful.)

Specified by:
  `writeNull` in class `Encoder`
Throws:
  `IOException`

### writeBoolean

public void writeBoolean(boolean b) throws IOException
Description copied from class: `Encoder`
Write a boolean value.

Specified by:
  `writeBoolean` in class `Encoder`
Throws:
  `IOException`

### writeInt

public void writeInt(int n) throws IOException
Description copied from class: `Encoder`
Writes a 32-bit integer.

Specified by:
  `writeInt` in class `Encoder`
Throws:
  `IOException`

### writeLong

public void writeLong(long n) throws IOException
Description copied from class: `Encoder`
Write a 64-bit integer.

Specified by:
  `writeLong` in class `Encoder`
Throws:
  `IOException`

### writeFloat

public void writeFloat(float f) throws IOException
Description copied from class: `Encoder`
Write a float.

Specified by:
  `writeFloat` in class `Encoder`
Throws:
  `IOException`

### writeDouble

public void writeDouble(double d) throws IOException
Description copied from class: `Encoder`
Write a double.

Specified by:
  `writeDouble` in class `Encoder`
Throws:
  `IOException`

### writeString

public void writeString(Utf8 utf8) throws IOException
Description copied from class: `Encoder`
Write a Unicode character string.

Specified by:
  `writeString` in class `Encoder`
Throws:
  `IOException`

### writeString

public void writeString(String str) throws IOException
Description copied from class: `Encoder`
Write a Unicode character string. The default implementation converts the String to a `Utf8`. Some Encoder implementations may want to do something different as a performance optimization.

Overrides:
  `writeString` in class `Encoder`
Throws:
  `IOException`

### writeString

public void writeString(CharSequence charSequence) throws IOException
Description copied from class: `Encoder`
Write a Unicode character string. If the CharSequence is an `Utf8` it writes this directly, otherwise the CharSequence is converted to a String via toString() and written.

Overrides:
  `writeString` in class `Encoder`
Throws:
  `IOException`

### writeBytes

public void writeBytes(ByteBuffer bytes) throws IOException
Description copied from class: `Encoder`
Write a byte string.

Specified by:
  `writeBytes` in class `Encoder`
Throws:
  `IOException`

### writeBytes

public void writeBytes(byte[] bytes, int start, int len) throws IOException
Description copied from class: `Encoder`
Write a byte string.

Specified by:
  `writeBytes` in class `Encoder`
Throws:
  `IOException`

### writeFixed

public void writeFixed(byte[] bytes, int start, int len) throws IOException
Description copied from class: `Encoder`
Writes a fixed size binary object.

Specified by:
  `writeFixed` in class `Encoder`
Parameters:
  `bytes` - The contents to write
  `start` - The position within `bytes` where the contents start.
  `len` - The number of bytes to write.
Throws:
  `IOException`

### writeEnum

public void writeEnum(int e) throws IOException
Description copied from class: `Encoder`
Writes an enumeration.

Specified by:
  `writeEnum` in class `Encoder`
Parameters:
  `e` - the enumeration to write
Throws:
  `IOException`

### writeArrayStart

public void writeArrayStart() throws IOException
Description copied from class: `Encoder`
Call this method to start writing an array. When starting to serialize an array, call `Encoder.writeArrayStart()`. Then, before writing any data for any item call `Encoder.setItemCount(long)` followed by a sequence of `Encoder.startItem()` and the item itself. The number of `Encoder.startItem()` should match the number specified in `Encoder.setItemCount(long)`. When actually writing the data of the item, you can call any `Encoder` method (e.g., `Encoder.writeLong(long)`). When all items of the array have been written, call `Encoder.writeArrayEnd()`. As an example, let's say you want to write an array of records, the record consisting of a Long field and a Boolean field. Your code would look something like this:

     out.writeArrayStart();
     out.setItemCount(list.size());
     for (Record r : list) {
       out.startItem();
       out.writeLong(r.longField);
       out.writeBoolean(r.boolField);
     }
     out.writeArrayEnd();

Specified by:
  `writeArrayStart` in class `Encoder`
Throws:
  `IOException`

### writeArrayEnd

public void writeArrayEnd() throws IOException
Description copied from class: `Encoder`
Call this method to finish writing an array. See `Encoder.writeArrayStart()` for usage information.

Specified by:
  `writeArrayEnd` in class `Encoder`
Throws:
  `IOException`

### writeMapStart

public void writeMapStart() throws IOException
Description copied from class: `Encoder`
Call this to start a new map. See `Encoder.writeArrayStart()` for details on usage. As an example of usage, let's say you want to write a map of records, the record consisting of a Long field and a Boolean field. Your code would look something like this:

     out.writeMapStart();
     out.setItemCount(list.size());
     for (Map.Entryinvalid input: '<'String, Record> entry : map.entrySet()) {
       out.startItem();
       out.writeString(entry.getKey());
       out.writeLong(entry.getValue().longField);
       out.writeBoolean(entry.getValue().boolField);
     }
     out.writeMapEnd();

Specified by:
  `writeMapStart` in class `Encoder`
Throws:
  `IOException`

### writeMapEnd

public void writeMapEnd() throws IOException
Description copied from class: `Encoder`
Call this method to terminate the inner-most, currently-opened map. See `Encoder.writeArrayStart()` for more details.

Specified by:
  `writeMapEnd` in class `Encoder`
Throws:
  `IOException`

### setItemCount

public void setItemCount(long itemCount) throws IOException
Description copied from class: `Encoder`
Call this method before writing a batch of items in an array or a map. Then for each item, call `Encoder.startItem()` followed by any of the other write methods of `Encoder`. The number of calls to `Encoder.startItem()` must be equal to the count specified in `Encoder.setItemCount(long)`. Once a batch is completed you can start another batch with `Encoder.setItemCount(long)`.

Overrides:
  `setItemCount` in class `ParsingEncoder`
Parameters:
  `itemCount` - The number of `Encoder.startItem()` calls to follow.
Throws:
  `IOException`

### startItem

public void startItem() throws IOException
Description copied from class: `Encoder`
Start a new item of an array or map. See `Encoder.writeArrayStart()` for usage information.

Overrides:
  `startItem` in class `ParsingEncoder`
Throws:
  `IOException`

### writeIndex

public void writeIndex(int unionIndex) throws IOException
Description copied from class: `Encoder`
Call this method to write the tag of a union. As an example of usage, let's say you want to write a union, whose second branch is a record consisting of a Long field and a Boolean field. Your code would look something like this:

     out.writeIndex(1);
     out.writeLong(record.longField);
     out.writeBoolean(record.boolField);

Specified by:
  `writeIndex` in class `Encoder`
Throws:
  `IOException`

### doAction

public Symbol doAction(Symbol input, Symbol top) throws IOException
Description copied from interface: `Parser.ActionHandler`
Handle the action symbol `top` when the `input` is sought to be taken off the stack.

Specified by:
  `doAction` in interface `Parser.ActionHandler`
Parameters:
  `input` - The input symbol from the caller of advance
  `top` - The symbol at the top the stack.
Returns:
  `null` if advance() is to continue processing the stack. If not `null` the return value will be returned by advance().
Throws:
  `IOException`