com.fasterxml.jackson.databind.node

## Class BaseJsonNode

- java.lang.Object
- - com.fasterxml.jackson.databind.JsonSerializable.Base
  - - com.fasterxml.jackson.databind.JsonNode
    - - com.fasterxml.jackson.databind.node.BaseJsonNode

- All Implemented Interfaces:
    TreeNode, JsonSerializable, Serializable, Iterable<JsonNode>
  Direct Known Subclasses:
    ContainerNode, ValueNode

      public abstract class BaseJsonNode
      extends JsonNode
      implements Serializable

  Abstract base class common to all standard `JsonNode` implementations. The main addition here is that we declare that sub-classes must implement `JsonSerializable`. This simplifies object mapping aspects a bit, as no external serializers are needed.

  Since 2.10, all implements have been `Serializable`.

  See Also:
    Serialized Form

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface com.fasterxml.jackson.databind.JsonSerializable

      `JsonSerializable.Base`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `BaseJsonNode()`

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `abstract JsonToken` | `asToken()` Method that can be used for efficient type detection when using stream abstraction for traversing nodes.
    `JsonNode` | `findPath(String fieldName)` Method similar to `JsonNode.findValue(java.lang.String)`, but that will return a "missing node" instead of null if no field is found.
    `abstract int` | `hashCode()`
    `JsonParser.NumberType` | `numberType()` Returns code that identifies type of underlying numeric value, if (and only if) node is a number node.
    `JsonNode` | `required(int index)` Method is functionally equivalent to `path(index).required()` and can be used to check that this node is an `ArrayNode` (that is, represents JSON Array value) and has value for specified `index` (but note that value may be explicit JSON null value).
    `JsonNode` | `required(String fieldName)` Method is functionally equivalent to `path(fieldName).required()` and can be used to check that this node is an `ObjectNode` (that is, represents JSON Object value) and has value for specified property with key `fieldName` (but note that value may be explicit JSON null value).
    `abstract void` | `serialize(JsonGenerator jgen, SerializerProvider provider)` Method called to serialize node instances using given generator.
    `abstract void` | `serializeWithType(JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)` Type information is needed, even if JsonNode instances are "plain" JSON, since they may be mixed with other types.
    `String` | `toPrettyString()` Alternative to `JsonNode.toString()` that will serialize this node using Jackson default pretty-printer.
    `String` | `toString()` Method that will produce (as of Jackson 2.10) valid JSON using default settings of databind, as String.
    `JsonParser` | `traverse()`
    `JsonParser` | `traverse(ObjectCodec codec)`

    - ### Methods inherited from class com.fasterxml.jackson.databind.JsonNode

      `_at, _reportRequiredViolation, _this, asBoolean, asBoolean, asDouble, asDouble, asInt, asInt, asLong, asLong, asText, asText, at, at, bigIntegerValue, binaryValue, booleanValue, canConvertToExactIntegral, canConvertToInt, canConvertToLong, decimalValue, deepCopy, doubleValue, elements, equals, equals, fieldNames, fields, findParent, findParents, findParents, findValue, findValues, findValues, findValuesAsText, findValuesAsText, floatValue, get, get, getNodeType, has, has, hasNonNull, hasNonNull, intValue, isArray, isBigDecimal, isBigInteger, isBinary, isBoolean, isContainerNode, isDouble, isEmpty, isFloat, isFloatingPointNumber, isInt, isIntegralNumber, isLong, isMissingNode, isNull, isNumber, isObject, isPojo, isShort, isTextual, isValueNode, iterator, longValue, numberValue, path, path, require, requiredAt, requiredAt, requireNonNull, shortValue, size, textValue, with, withArray`

    - ### Methods inherited from class com.fasterxml.jackson.databind.JsonSerializable.Base

      `isEmpty`

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

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface java.lang.Iterable

      `forEach, spliterator`

- - ### Constructor Detail

    - #### BaseJsonNode

          protected BaseJsonNode()

  - ### Method Detail

    - #### findPath

          public final JsonNode findPath(String fieldName)

      Description copied from class: `JsonNode`
      Method similar to `JsonNode.findValue(java.lang.String)`, but that will return a "missing node" instead of null if no field is found. Missing node is a specific kind of node for which `JsonNode.isMissingNode()` returns true; and all value access methods return empty or missing value.
      Specified by:
        `findPath` in class `JsonNode`
      Parameters:
        `fieldName` - Name of field to look for
      Returns:
        Value of first matching node found; or if not found, a "missing node" (non-null instance that has no value)

    - #### hashCode

          public abstract int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### required

          public JsonNode required(String fieldName)

      Description copied from class: `JsonNode`
      Method is functionally equivalent to `path(fieldName).required()` and can be used to check that this node is an `ObjectNode` (that is, represents JSON Object value) and has value for specified property with key `fieldName` (but note that value may be explicit JSON null value). If this node is Object Node and has value for specified property, `this` is returned to allow chaining; otherwise `IllegalArgumentException` is thrown.
      Overrides:
        `required` in class `JsonNode`
      Returns:
        `this` node to allow chaining

    - #### required

          public JsonNode required(int index)

      Description copied from class: `JsonNode`
      Method is functionally equivalent to `path(index).required()` and can be used to check that this node is an `ArrayNode` (that is, represents JSON Array value) and has value for specified `index` (but note that value may be explicit JSON null value). If this node is Array Node and has value for specified index, `this` is returned to allow chaining; otherwise `IllegalArgumentException` is thrown.
      Overrides:
        `required` in class `JsonNode`
      Returns:
        `this` node to allow chaining

    - #### traverse

          public JsonParser traverse()

      Specified by:
        `traverse` in interface `TreeNode`

    - #### traverse

          public JsonParser traverse(ObjectCodec codec)

      Specified by:
        `traverse` in interface `TreeNode`

    - #### asToken

          public abstract JsonToken asToken()

      Method that can be used for efficient type detection when using stream abstraction for traversing nodes. Will return the first `JsonToken` that equivalent stream event would produce (for most nodes there is just one token but for structured/container types multiple)
      Specified by:
        `asToken` in interface `TreeNode`

    - #### numberType

          public JsonParser.NumberType numberType()

      Returns code that identifies type of underlying numeric value, if (and only if) node is a number node.
      Specified by:
        `numberType` in interface `TreeNode`

    - #### serialize

          public abstract void serialize(JsonGenerator jgen,
                                         SerializerProvider provider)
                                  throws IOException,
                                         JsonProcessingException

      Method called to serialize node instances using given generator.
      Specified by:
        `serialize` in interface `JsonSerializable`
      Throws:
        `IOException`
        `JsonProcessingException`

    - #### serializeWithType

          public abstract void serializeWithType(JsonGenerator jgen,
                                                 SerializerProvider provider,
                                                 TypeSerializer typeSer)
                                          throws IOException,
                                                 JsonProcessingException

      Type information is needed, even if JsonNode instances are "plain" JSON, since they may be mixed with other types.
      Specified by:
        `serializeWithType` in interface `JsonSerializable`
      Throws:
        `IOException`
        `JsonProcessingException`

    - #### toString

          public String toString()

      Description copied from class: `JsonNode`
      Method that will produce (as of Jackson 2.10) valid JSON using default settings of databind, as String. If you want other kinds of JSON output (or output formatted using one of other Jackson-supported data formats) make sure to use `ObjectMapper` or `ObjectWriter` to serialize an instance, for example:

             String json = objectMapper.writeValueAsString(rootNode);

      Note: method defined as abstract to ensure all implementation classes explicitly implement method, instead of relying on `Object.toString()` definition.

      Specified by:
        `toString` in class `JsonNode`

    - #### toPrettyString

          public String toPrettyString()

      Description copied from class: `JsonNode`
      Alternative to `JsonNode.toString()` that will serialize this node using Jackson default pretty-printer.
      Overrides:
        `toPrettyString` in class `JsonNode`

Copyright © 2008–2020 FasterXML. All rights reserved.