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 and Description
    --- | ---
    `protected Encoder` | `out`
    `protected Parser` | `parser`

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

      `pos`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and 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 Detail

    - #### out

          protected Encoder out

    - #### parser

          protected final Parser parser

  - ### Method Detail

    - #### 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`
      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 an 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 an Long field and a Boolean field. Your code would look something like this:

           out.writeMapStart();
           out.setItemCount(list.size());
           for (Map.Entry 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 an 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`

Copyright © 2009–2024 The Apache Software Foundation. All rights reserved.