com.fasterxml.jackson.dataformat.javaprop

## Class JavaPropsSchema

- java.lang.Object
- - com.fasterxml.jackson.dataformat.javaprop.JavaPropsSchema

- All Implemented Interfaces:
    com.fasterxml.jackson.core.FormatSchema, Serializable

      public class JavaPropsSchema
      extends Object
      implements com.fasterxml.jackson.core.FormatSchema, Serializable

  Simple `FormatSchema` sub-type that defines details of things like:
  - How are "flat" property names mapped to hierarchic POJO types, using separator-based naming convention.
  - What indentation (if any) is used before key values, and between key/value
  - If and how are Array values inferred from property names
  See Also:
    Serialized Form

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected int` | `_firstArrayOffset` Specifies index number used when writing the first array entry (which in Java has index of 0).
    `protected String` | `_header` Optional header to prepend before any other output: typically a comment section or so.
    `protected Markers` | `_indexMarker` Default start marker for index access, if any; empty String may be used to indicate no marker-based index detection should be made.
    `protected String` | `_keyValueSeparator` String added between key and value; needs to include the "equals character" (either '=' or ':', both allowed by Java Properties specification), may also include white before and/or after "equals character".
    `protected String` | `_lineEnding` String added after value, including at least one linefeed.
    `protected String` | `_lineIndentation` String prepended before key value, as possible indentation
    `protected boolean` | `_parseSimpleIndexes` Whether 'simple' index-notation is supported for path segments or not: simple meaning that if a path segment is a textual representation of a non-negative integer value with length of 9 or less (that is, up to but no including one billion), it will be considered index, not property name.
    `protected String` | `_pathSeparator` Default path separator to use for hierarchic paths, if any; empty String may be used to indicate that no hierarchy should be inferred using a simple separator (although index markers may still be used, if defined).
    `protected JPropPathSplitter` | `_splitter` Since splitter instances are slightly costly to build in some cases, we will lazily instantiate and cache them.
    `protected boolean` | `_writeIndexUsingMarkers` Whether array-element paths are written using start/end markers (see `_indexMarker` or "simple" index number: if set to `true` AND markers are specified as non-empty Strings, will use sequence of
    `protected static Markers` | `DEFAULT_INDEX_MARKER`
    `protected static JavaPropsSchema` | `EMPTY`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `JavaPropsSchema()`
    `JavaPropsSchema(JavaPropsSchema base)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static JavaPropsSchema` | `emptySchema()`
    `int` | `firstArrayOffset()`
    `String` | `getSchemaType()`
    `String` | `header()`
    `Markers` | `indexMarker()`
    `String` | `keyValueSeparator()`
    `String` | `lineEnding()`
    `String` | `lineIndentation()`
    `boolean` | `parseSimpleIndexes()`
    `String` | `pathSeparator()`
    `JPropPathSplitter` | `pathSplitter()` Accessor for getting a `JPropPathSplitter` instance that does splitting according to the settings of this instance.
    `JavaPropsSchema` | `withFirstArrayOffset(int v)`
    `JavaPropsSchema` | `withHeader(String v)` Mutant factory for constructing schema instance where specified header section (piece of text written out right before actual properties entries) will be used.
    `JavaPropsSchema` | `withIndexMarker(Markers v)`
    `JavaPropsSchema` | `withKeyValueSeparator(String v)`
    `JavaPropsSchema` | `withLineEnding(String v)`
    `JavaPropsSchema` | `withLineIndentation(String v)`
    `JavaPropsSchema` | `withoutHeader()` Convenience method, functionally equivalent to:
    `JavaPropsSchema` | `withoutIndexMarker()`
    `JavaPropsSchema` | `withoutLineIndentation()`
    `JavaPropsSchema` | `withoutPathSeparator()` Mutant factory method for constructing a new instance that specifies that no "path splitting" is to be done: this is similar to default behavior of `Properties` in which keys are full Strings and there is no nesting of values.
    `JavaPropsSchema` | `withParseSimpleIndexes(boolean v)`
    `JavaPropsSchema` | `withPathSeparator(String v)` Mutant factory method for constructing a new instance with specified path separator; default being comma (".").
    `JavaPropsSchema` | `withWriteIndexUsingMarkers(boolean v)`
    `boolean` | `writeIndexUsingMarkers()`

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

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

- - ### Field Detail

    - #### DEFAULT_INDEX_MARKER

          protected static final Markers DEFAULT_INDEX_MARKER

    - #### EMPTY

          protected static final JavaPropsSchema EMPTY

    - #### _splitter

          protected transient JPropPathSplitter _splitter

      Since splitter instances are slightly costly to build in some cases, we will lazily instantiate and cache them.

    - #### _firstArrayOffset

          protected int _firstArrayOffset

      Specifies index number used when writing the first array entry (which in Java has index of 0). After this initial value, additional elements will have consecutive values, incremented by 1. Note that this setting has no effect on reading: input indexes are only used for sorting values, and their exact values have no meaning.

      Default value is 1.

    - #### _pathSeparator

          protected String _pathSeparator

      Default path separator to use for hierarchic paths, if any; empty String may be used to indicate that no hierarchy should be inferred using a simple separator (although index markers may still be used, if defined).

    - #### _indexMarker

          protected Markers _indexMarker

      Default start marker for index access, if any; empty String may be used to indicate no marker-based index detection should be made.

      Default value of "[" is usually combined with end marker of "]" to allow C/Java-style bracket notation, like "settings.path[1]".

    - #### _parseSimpleIndexes

          protected boolean _parseSimpleIndexes

      Whether 'simple' index-notation is supported for path segments or not: simple meaning that if a path segment is a textual representation of a non-negative integer value with length of 9 or less (that is, up to but no including one billion), it will be considered index, not property name.

      Note that this settings does NOT control whether "start/end marker" indicated indexes are enabled or not; those depend on `_indexMarker`.

      Default value is `true`, "plain" index segments are supported.

    - #### _writeIndexUsingMarkers

          protected boolean _writeIndexUsingMarkers

      Whether array-element paths are written using start/end markers (see `_indexMarker` or "simple" index number: if set to `true` AND markers are specified as non-empty Strings, will use sequence of

             startMarker index endMarker

      to include index in path; otherwise will simply use textual representation of the index number as path segment, prefixed by path separator as necessary.

    - #### _lineIndentation

          protected String _lineIndentation

      String prepended before key value, as possible indentation

    - #### _keyValueSeparator

          protected String _keyValueSeparator

      String added between key and value; needs to include the "equals character" (either '=' or ':', both allowed by Java Properties specification), may also include white before and/or after "equals character". Default value is a single '=' character with no white spaces around

    - #### _lineEnding

          protected String _lineEnding

      String added after value, including at least one linefeed. Default value is the 'Unix linefeed'.

    - #### _header

          protected String _header

      Optional header to prepend before any other output: typically a comment section or so. Note that contents here are NOT modified in any way, meaning that any comment indicators (leading '#' or '!') and linefeeds MUST be specified by caller.

  - ### Constructor Detail

    - #### JavaPropsSchema

          public JavaPropsSchema()

    - #### JavaPropsSchema

          public JavaPropsSchema(JavaPropsSchema base)

  - ### Method Detail

    - #### pathSplitter

          public JPropPathSplitter pathSplitter()

      Accessor for getting a `JPropPathSplitter` instance that does splitting according to the settings of this instance.

      Note that instance is constructed lazily as needed, but reused afterwards for this instance (and for these specific settings).

    - #### withFirstArrayOffset

          public JavaPropsSchema withFirstArrayOffset(int v)

    - #### withPathSeparator

          public JavaPropsSchema withPathSeparator(String v)

      Mutant factory method for constructing a new instance with specified path separator; default being comma ("."). Note that setting separator to `null` or empty String will basically disable handling of nesting, similar to calling `withoutPathSeparator()`.

    - #### withoutPathSeparator

          public JavaPropsSchema withoutPathSeparator()

      Mutant factory method for constructing a new instance that specifies that no "path splitting" is to be done: this is similar to default behavior of `Properties` in which keys are full Strings and there is no nesting of values.

    - #### withIndexMarker

          public JavaPropsSchema withIndexMarker(Markers v)

    - #### withoutIndexMarker

          public JavaPropsSchema withoutIndexMarker()

    - #### withParseSimpleIndexes

          public JavaPropsSchema withParseSimpleIndexes(boolean v)

    - #### withWriteIndexUsingMarkers

          public JavaPropsSchema withWriteIndexUsingMarkers(boolean v)

    - #### withLineIndentation

          public JavaPropsSchema withLineIndentation(String v)

    - #### withoutLineIndentation

          public JavaPropsSchema withoutLineIndentation()

      Since:
        2.8

    - #### withKeyValueSeparator

          public JavaPropsSchema withKeyValueSeparator(String v)

    - #### withLineEnding

          public JavaPropsSchema withLineEnding(String v)

    - #### withHeader

          public JavaPropsSchema withHeader(String v)

      Mutant factory for constructing schema instance where specified header section (piece of text written out right before actual properties entries) will be used. Note that caller must specify any and all linefeeds to use: generator will NOT modify header String contents in any way, and will not append a linefeed after contents (if any).

    - #### withoutHeader

          public JavaPropsSchema withoutHeader()

      Convenience method, functionally equivalent to:

             withHeader("")

      used to ensure that no header is prepended before actual property values are output.
      Since:
        2.8

    - #### getSchemaType

          public String getSchemaType()

      Specified by:
        `getSchemaType` in interface `com.fasterxml.jackson.core.FormatSchema`

    - #### emptySchema

          public static JavaPropsSchema emptySchema()

    - #### firstArrayOffset

          public int firstArrayOffset()

    - #### header

          public String header()

    - #### indexMarker

          public Markers indexMarker()

    - #### lineEnding

          public String lineEnding()

    - #### lineIndentation

          public String lineIndentation()

    - #### keyValueSeparator

          public String keyValueSeparator()

    - #### parseSimpleIndexes

          public boolean parseSimpleIndexes()

    - #### pathSeparator

          public String pathSeparator()

    - #### writeIndexUsingMarkers

          public boolean writeIndexUsingMarkers()

Copyright © 2017 FasterXML. All rights reserved.