JsonGeneratorBase (Jackson JSON Processor)
Date: 2013-07-14

org.codehaus.jackson.impl

## Class JsonGeneratorBase

- java.lang.Object
- - org.codehaus.jackson.JsonGenerator
  - - org.codehaus.jackson.impl.JsonGeneratorBase

- All Implemented Interfaces:
    Closeable, AutoCloseable, Versioned
  Direct Known Subclasses:
    SmileGenerator, Utf8Generator, WriterBasedGenerator

      public abstract class JsonGeneratorBase
      extends JsonGenerator

  This base class implements part of API that a JSON generator exposes to applications, adds shared internal methods that sub-classes can use and adds some abstract methods sub-classes must implement.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class org.codehaus.jackson.JsonGenerator

      `JsonGenerator.Feature`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected boolean` | `_cfgNumbersAsStrings` Flag set to indicate that implicit conversion from number to JSON String is needed (as per `JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS`).
    `protected boolean` | `_closed` Flag that indicates whether generator is closed or not.
    `protected int` | `_features` Bit flag composed of bits that indicate which `JsonGenerator.Feature`s are enabled.
    `protected ObjectCodec` | `_objectCodec`
    `protected JsonWriteContext` | `_writeContext` Object that keeps track of the current contextual state of the generator.

    - ### Fields inherited from class org.codehaus.jackson.JsonGenerator

      `_cfgPrettyPrinter`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `JsonGeneratorBase(int features, ObjectCodec codec)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `_cantHappen()`
    `protected abstract void` | `_releaseBuffers()`
    `protected void` | `_reportError(String msg)`
    `protected void` | `_reportUnsupportedOperation()`
    `protected void` | `_throwInternal()`
    `protected abstract void` | `_verifyValueWrite(String typeMsg)`
    `protected void` | `_writeEndArray()` Deprecated. since 1.7, should just override `writeEndArray()` instead of defining this method
    `protected void` | `_writeEndObject()` Deprecated. since 1.7, should just override `writeEndObject()` instead of defining this method
    `protected void` | `_writeSimpleObject(Object value)` Helper method to try to call appropriate write method for given untyped Object.
    `protected void` | `_writeStartArray()` Deprecated. since 1.7, should just override `writeStartArray()` instead of defining this method
    `protected void` | `_writeStartObject()` Deprecated. since 1.7, should just override `writeStartObject()` instead of defining this method
    `void` | `close()` Method called to close this generator, so that no more content can be written.
    `void` | `copyCurrentEvent(JsonParser jp)` Method for copying contents of the current event that the given parser instance points to.
    `void` | `copyCurrentStructure(JsonParser jp)` Method for copying contents of the current event and following events that it encloses the given parser instance points to.
    `JsonGenerator` | `disable(JsonGenerator.Feature f)` Method for disabling specified features (check `JsonGenerator.Feature` for list of features)
    `JsonGenerator` | `enable(JsonGenerator.Feature f)` Method for enabling specified parser features: check `JsonGenerator.Feature` for list of available features.
    `abstract void` | `flush()` Method called to flush any buffered content to the underlying target (output stream, writer), and to flush the target itself as well.
    `ObjectCodec` | `getCodec()` Method for accessing the object used for writing Java object as Json content (using method `JsonGenerator.writeObject(java.lang.Object)`).
    `JsonWriteContext` | `getOutputContext()` Note: co-variant return type.
    `boolean` | `isClosed()` Method that can be called to determine whether this generator is closed or not.
    `boolean` | `isEnabled(JsonGenerator.Feature f)` Method for checking whether given feature is enabled.
    `JsonGenerator` | `setCodec(ObjectCodec oc)` Method that can be called to set or reset the object to use for writing Java objects as JsonContent (using method `JsonGenerator.writeObject(java.lang.Object)`).
    `JsonGenerator` | `useDefaultPrettyPrinter()` Convenience method for enabling pretty-printing using the default pretty printer (`DefaultPrettyPrinter`).
    `Version` | `version()` Method called to detect version of the component that implements this interface; returned version should never be null, but may return specific "not available" instance (see `Version` for details).
    `void` | `writeEndArray()` Method for writing closing marker of a JSON Array value (character ']'; plus possible white space decoration if pretty-printing is enabled).
    `void` | `writeEndObject()` Method for writing closing marker of a JSON Object value (character '}'; plus possible white space decoration if pretty-printing is enabled).
    `void` | `writeObject(Object value)` Method for writing given Java object (POJO) as Json.
    `void` | `writeRawValue(char[] text, int offset, int len)`
    `void` | `writeRawValue(String text)` Method that will force generator to copy input text verbatim without any modifications, but assuming it must constitute a single legal JSON value (number, string, boolean, null, Array or List).
    `void` | `writeRawValue(String text, int offset, int len)`
    `void` | `writeStartArray()` Method for writing starting marker of a JSON Array value (character '['; plus possible white space decoration if pretty-printing is enabled).
    `void` | `writeStartObject()` Method for writing starting marker of a JSON Object value (character '{'; plus possible white space decoration if pretty-printing is enabled).
    `void` | `writeTree(JsonNode rootNode)` Method for writing given JSON tree (expressed as a tree where given JsonNode is the root) using this generator.

    - ### Methods inherited from class org.codehaus.jackson.JsonGenerator

      `canUseSchema, configure, disableFeature, enableFeature, getCharacterEscapes, getHighestEscapedChar, getOutputTarget, isFeatureEnabled, setCharacterEscapes, setFeature, setHighestNonEscapedChar, setPrettyPrinter, setSchema, writeArrayFieldStart, writeBinary, writeBinary, writeBinary, writeBinaryField, writeBoolean, writeBooleanField, writeFieldName, writeFieldName, writeFieldName, writeNull, writeNullField, writeNumber, writeNumber, writeNumber, writeNumber, writeNumber, writeNumber, writeNumber, writeNumberField, writeNumberField, writeNumberField, writeNumberField, writeNumberField, writeObjectField, writeObjectFieldStart, writeRaw, writeRaw, writeRaw, writeRaw, writeRawUTF8String, writeString, writeString, writeString, writeStringField, writeUTF8String`

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

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

- - ### Field Detail

    - #### _objectCodec

          protected ObjectCodec _objectCodec

    - #### _features

          protected int _features

      Bit flag composed of bits that indicate which `JsonGenerator.Feature`s are enabled.

    - #### _cfgNumbersAsStrings

          protected boolean _cfgNumbersAsStrings

      Flag set to indicate that implicit conversion from number to JSON String is needed (as per `JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS`).

    - #### _writeContext

          protected JsonWriteContext _writeContext

      Object that keeps track of the current contextual state of the generator.

    - #### _closed

          protected boolean _closed

      Flag that indicates whether generator is closed or not. Gets set when it is closed by an explicit call (`close()`).

  - ### Constructor Detail

    - #### JsonGeneratorBase

          protected JsonGeneratorBase(int features,
                           ObjectCodec codec)

  - ### Method Detail

    - #### version

          public Version version()

      Description copied from interface: `Versioned`
      Method called to detect version of the component that implements this interface; returned version should never be null, but may return specific "not available" instance (see `Version` for details).
      Specified by:
        `version` in interface `Versioned`
      Overrides:
        `version` in class `JsonGenerator`

    - #### enable

          public JsonGenerator enable(JsonGenerator.Feature f)

      Description copied from class: `JsonGenerator`
      Method for enabling specified parser features: check `JsonGenerator.Feature` for list of available features.
      Specified by:
        `enable` in class `JsonGenerator`
      Returns:
        Generator itself (this), to allow chaining

    - #### disable

          public JsonGenerator disable(JsonGenerator.Feature f)

      Description copied from class: `JsonGenerator`
      Method for disabling specified features (check `JsonGenerator.Feature` for list of features)
      Specified by:
        `disable` in class `JsonGenerator`
      Returns:
        Generator itself (this), to allow chaining

    - #### isEnabled

          public final boolean isEnabled(JsonGenerator.Feature f)

      Description copied from class: `JsonGenerator`
      Method for checking whether given feature is enabled. Check `JsonGenerator.Feature` for list of available features.
      Specified by:
        `isEnabled` in class `JsonGenerator`

    - #### useDefaultPrettyPrinter

          public JsonGenerator useDefaultPrettyPrinter()

      Description copied from class: `JsonGenerator`
      Convenience method for enabling pretty-printing using the default pretty printer (`DefaultPrettyPrinter`).
      Specified by:
        `useDefaultPrettyPrinter` in class `JsonGenerator`
      Returns:
        Generator itself (this), to allow chaining

    - #### setCodec

          public JsonGenerator setCodec(ObjectCodec oc)

      Description copied from class: `JsonGenerator`
      Method that can be called to set or reset the object to use for writing Java objects as JsonContent (using method `JsonGenerator.writeObject(java.lang.Object)`).
      Specified by:
        `setCodec` in class `JsonGenerator`
      Returns:
        Generator itself (this), to allow chaining

    - #### getCodec

          public final ObjectCodec getCodec()

      Description copied from class: `JsonGenerator`
      Method for accessing the object used for writing Java object as Json content (using method `JsonGenerator.writeObject(java.lang.Object)`).
      Specified by:
        `getCodec` in class `JsonGenerator`

    - #### getOutputContext

          public final JsonWriteContext getOutputContext()

      Note: co-variant return type.
      Specified by:
        `getOutputContext` in class `JsonGenerator`
      Returns:
        Context object that can give information about logical position within generated json content.

    - #### writeStartArray

          public void writeStartArray()
                               throws IOException,
                                      JsonGenerationException

      Description copied from class: `JsonGenerator`
      Method for writing starting marker of a JSON Array value (character '['; plus possible white space decoration if pretty-printing is enabled).

      Array values can be written in any context where values are allowed: meaning everywhere except for when a field name is expected.

      Specified by:
        `writeStartArray` in class `JsonGenerator`
      Throws:
        `IOException`
        `JsonGenerationException`

    - #### _writeStartArray

          @Deprecated
          protected void _writeStartArray()
                                   throws IOException,
                                          JsonGenerationException

      Deprecated. since 1.7, should just override `writeStartArray()` instead of defining this method
      Throws:
        `IOException`
        `JsonGenerationException`

    - #### writeEndArray

          public void writeEndArray()
                             throws IOException,
                                    JsonGenerationException

      Description copied from class: `JsonGenerator`
      Method for writing closing marker of a JSON Array value (character ']'; plus possible white space decoration if pretty-printing is enabled).

      Marker can be written if the innermost structured type is Array.

      Specified by:
        `writeEndArray` in class `JsonGenerator`
      Throws:
        `IOException`
        `JsonGenerationException`

    - #### _writeEndArray

          @Deprecated
          protected void _writeEndArray()
                                 throws IOException,
                                        JsonGenerationException

      Deprecated. since 1.7, should just override `writeEndArray()` instead of defining this method
      Throws:
        `IOException`
        `JsonGenerationException`

    - #### writeStartObject

          public void writeStartObject()
                                throws IOException,
                                       JsonGenerationException

      Description copied from class: `JsonGenerator`
      Method for writing starting marker of a JSON Object value (character '{'; plus possible white space decoration if pretty-printing is enabled).

      Object values can be written in any context where values are allowed: meaning everywhere except for when a field name is expected.

      Specified by:
        `writeStartObject` in class `JsonGenerator`
      Throws:
        `IOException`
        `JsonGenerationException`

    - #### _writeStartObject

          @Deprecated
          protected void _writeStartObject()
                                    throws IOException,
                                           JsonGenerationException

      Deprecated. since 1.7, should just override `writeStartObject()` instead of defining this method
      Throws:
        `IOException`
        `JsonGenerationException`

    - #### writeEndObject

          public void writeEndObject()
                              throws IOException,
                                     JsonGenerationException

      Description copied from class: `JsonGenerator`
      Method for writing closing marker of a JSON Object value (character '}'; plus possible white space decoration if pretty-printing is enabled).

      Marker can be written if the innermost structured type is Object, and the last written event was either a complete value, or START-OBJECT marker (see JSON specification for more details).

      Specified by:
        `writeEndObject` in class `JsonGenerator`
      Throws:
        `IOException`
        `JsonGenerationException`

    - #### _writeEndObject

          @Deprecated
          protected void _writeEndObject()
                                  throws IOException,
                                         JsonGenerationException

      Deprecated. since 1.7, should just override `writeEndObject()` instead of defining this method
      Throws:
        `IOException`
        `JsonGenerationException`

    - #### writeRawValue

          public void writeRawValue(String text)
                             throws IOException,
                                    JsonGenerationException

      Description copied from class: `JsonGenerator`
      Method that will force generator to copy input text verbatim without any modifications, but assuming it must constitute a single legal JSON value (number, string, boolean, null, Array or List). Assuming this, proper separators are added if and as needed (comma or colon), and generator state updated to reflect this.
      Specified by:
        `writeRawValue` in class `JsonGenerator`
      Throws:
        `IOException`
        `JsonGenerationException`

    - #### writeRawValue

          public void writeRawValue(String text,
                           int offset,
                           int len)
                             throws IOException,
                                    JsonGenerationException

      Specified by:
        `writeRawValue` in class `JsonGenerator`
      Throws:
        `IOException`
        `JsonGenerationException`

    - #### writeRawValue

          public void writeRawValue(char[] text,
                           int offset,
                           int len)
                             throws IOException,
                                    JsonGenerationException

      Specified by:
        `writeRawValue` in class `JsonGenerator`
      Throws:
        `IOException`
        `JsonGenerationException`

    - #### writeObject

          public void writeObject(Object value)
                           throws IOException,
                                  JsonProcessingException

      Description copied from class: `JsonGenerator`
      Method for writing given Java object (POJO) as Json. Exactly how the object gets written depends on object in question (ad on codec, its configuration); for most beans it will result in Json object, but for others Json array, or String or numeric value (and for nulls, Json null literal. NOTE: generator must have its object codec set to non-null value; for generators created by a mapping factory this is the case, for others not.
      Specified by:
        `writeObject` in class `JsonGenerator`
      Throws:
        `IOException`
        `JsonProcessingException`

    - #### writeTree

          public void writeTree(JsonNode rootNode)
                         throws IOException,
                                JsonProcessingException

      Description copied from class: `JsonGenerator`
      Method for writing given JSON tree (expressed as a tree where given JsonNode is the root) using this generator. This will generally just call `JsonGenerator.writeObject(java.lang.Object)` with given node, but is added for convenience and to make code more explicit in cases where it deals specifically with trees.
      Specified by:
        `writeTree` in class `JsonGenerator`
      Throws:
        `IOException`
        `JsonProcessingException`

    - #### flush

          public abstract void flush()
                              throws IOException

      Description copied from class: `JsonGenerator`
      Method called to flush any buffered content to the underlying target (output stream, writer), and to flush the target itself as well.
      Specified by:
        `flush` in class `JsonGenerator`
      Throws:
        `IOException`

    - #### close

          public void close()
                     throws IOException

      Description copied from class: `JsonGenerator`
      Method called to close this generator, so that no more content can be written.

      Whether the underlying target (stream, writer) gets closed depends on whether this generator either manages the target (i.e. is the only one with access to the target -- case if caller passes a reference to the resource such as File, but not stream); or has feature `JsonGenerator.Feature.AUTO_CLOSE_TARGET` enabled. If either of above is true, the target is also closed. Otherwise (not managing, feature not enabled), target is not closed.

      Specified by:
        `close` in interface `Closeable`
      Specified by:
        `close` in interface `AutoCloseable`
      Specified by:
        `close` in class `JsonGenerator`
      Throws:
        `IOException`

    - #### isClosed

          public boolean isClosed()

      Description copied from class: `JsonGenerator`
      Method that can be called to determine whether this generator is closed or not. If it is closed, no more output can be done.
      Specified by:
        `isClosed` in class `JsonGenerator`

    - #### copyCurrentEvent

          public final void copyCurrentEvent(JsonParser jp)
                                      throws IOException,
                                             JsonProcessingException

      Description copied from class: `JsonGenerator`
      Method for copying contents of the current event that the given parser instance points to. Note that the method will not copy any other events, such as events contained within Json Array or Object structures.

      Calling this method will not advance the given parser, although it may cause parser to internally process more data (if it lazy loads contents of value events, for example)

      Specified by:
        `copyCurrentEvent` in class `JsonGenerator`
      Throws:
        `IOException`
        `JsonProcessingException`

    - #### copyCurrentStructure

          public final void copyCurrentStructure(JsonParser jp)
                                          throws IOException,
                                                 JsonProcessingException

      Description copied from class: `JsonGenerator`
      Method for copying contents of the current event and following events that it encloses the given parser instance points to.

      So what constitutes enclosing? Here is the list of events that have associated enclosed events that will get copied:

      - `JsonToken.START_OBJECT`: all events up to and including matching (closing) `JsonToken.END_OBJECT` will be copied
      - `JsonToken.START_ARRAY` all events up to and including matching (closing) `JsonToken.END_ARRAY` will be copied
      - `JsonToken.FIELD_NAME` the logical value (which can consist of a single scalar value; or a sequence of related events for structured types (Json Arrays, Objects)) will be copied along with the name itself. So essentially the whole field entry (name and value) will be copied.

      After calling this method, parser will point to the last event that was copied. This will either be the event parser already pointed to (if there were no enclosed events), or the last enclosed event copied.

      Specified by:
        `copyCurrentStructure` in class `JsonGenerator`
      Throws:
        `IOException`
        `JsonProcessingException`

    - #### _releaseBuffers

          protected abstract void _releaseBuffers()

    - #### _verifyValueWrite

          protected abstract void _verifyValueWrite(String typeMsg)
                                             throws IOException,
                                                    JsonGenerationException

      Throws:
        `IOException`
        `JsonGenerationException`

    - #### _reportError

          protected void _reportError(String msg)
                               throws JsonGenerationException

      Throws:
        `JsonGenerationException`

    - #### _cantHappen

          protected void _cantHappen()

    - #### _writeSimpleObject

          protected void _writeSimpleObject(Object value)
                                     throws IOException,
                                            JsonGenerationException

      Helper method to try to call appropriate write method for given untyped Object. At this point, no structural conversions should be done, only simple basic types are to be coerced as necessary.
      Parameters:
        `value` - Non-null value to write
      Throws:
        `IOException`
        `JsonGenerationException`

    - #### _throwInternal

          protected final void _throwInternal()

    - #### _reportUnsupportedOperation

          protected void _reportUnsupportedOperation()

      Since:
        1.7