JavaPropsSchema (Jackson-dataformat-Properties 2.8.0 API)

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 `#_indexStartMarker`, `#_indexEndMarker`) 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)

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 #_indexStartMarker and #_indexEndMarker.
    Default value is true, "plain" index segments are supported.
  - _writeIndexUsingMarkers
```
protected boolean _writeIndexUsingMarkers
```
    Whether array-element paths are written using start/end markers (see #_indexStartMarker, #_indexEndMarker) 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()
```

Class JavaPropsSchema

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_INDEX_MARKER

EMPTY

_splitter

_firstArrayOffset

_pathSeparator

_indexMarker

_parseSimpleIndexes

_writeIndexUsingMarkers

_lineIndentation

_keyValueSeparator

_lineEnding

_header

Constructor Detail

JavaPropsSchema

JavaPropsSchema

Method Detail

pathSplitter

withFirstArrayOffset

withPathSeparator

withoutPathSeparator

withIndexMarker

withoutIndexMarker

withParseSimpleIndexes

withWriteIndexUsingMarkers

withLineIndentation

withoutLineIndentation

withKeyValueSeparator

withLineEnding

withHeader

withoutHeader

getSchemaType

emptySchema

firstArrayOffset

header

indexMarker

lineEnding

lineIndentation

keyValueSeparator

parseSimpleIndexes

pathSeparator

writeIndexUsingMarkers