JavaPropsSchema (Jackson-dataformat-Properties 2.15.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 char`	`_pathSeparatorEscapeChar` Default escape character to use for single character path separators , enabling the pathSeparator to be included in a segment.
`protected String`	`_prefix` Optional prefix to strip and append to key names.
`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)

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

Method Summary

All Methods Static Methods Instance Methods Concrete 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()`
`char`	`pathSeparatorEscapeChar()`
`JPropPathSplitter`	`pathSplitter()` Accessor for getting a `JPropPathSplitter` instance that does splitting according to the settings of this instance.
`String`	`prefix()`
`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`	`withPathSeparatorEscapeChar(char v)` Mutant factory method for constructing a new instance with a different escape character to use for single character path separators , enabling the pathSeparator to be included in a segment.
`JavaPropsSchema`	`withPrefix(String v)` Mutant factory for constructing schema instance where specified prefix is prepended before logical path when generator writes output and removed by parser before binding back as properties.
`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).
  - _pathSeparatorEscapeChar
```
protected char _pathSeparatorEscapeChar
```
    Default escape character to use for single character path separators , enabling the pathSeparator to be included in a segment. Note that this is only used if the path separator is a single character. The default value is NULL ('\0') which effectively disables escape processing. The escape character is only used for escaping either the pathSeparator character or a sequence of escape characters immediately prior to the pathSeparator. i.e., if the pathSeparator is "." and the escape char is '#' then "a#.b" produces a segment called "a.b", but "a##.b" produces a segment called "a#" with a child called "b" and "a###.b" produces a segment called "a#.b". Finally, "a#b" produces a segment called "a#b" - the escape processing is only used immediately prior to the path separator. Any escape character may be used. Backslash ('\\') is the most obvious candidate but be aware that the JDK Properties loader has its own rules for escape processing (documented in the Javadoc for Properties.load ) that will remove ALL duplicated backslash characters (and also carry out other escape handling) before the JavaPropsMapper gets to see them.
    
    Since:
    
    2.14
  - _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.
  - _prefix
```
protected String _prefix
```
    Optional prefix to strip and append to key names. Useful when subset of properties need to be processed.
    
    Since:
    
    2.10
- 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().
  - withPathSeparatorEscapeChar
```
public JavaPropsSchema withPathSeparatorEscapeChar(char v)
```
    Mutant factory method for constructing a new instance with a different escape character to use for single character path separators , enabling the pathSeparator to be included in a segment. Note that this is only used if the path separator is a single character. The default value is NULL ('\0') which effectively disables escape processing. The escape character is only used for escaping either the pathSeparator character or a sequence of escape characters immediately prior to the pathSeparator. i.e., if the pathSeparator is "." and the escape char is '#' then "a#.b" produces a segment called "a.b", but "a##.b" produces a segment called "a#" with a child called "b" and "a###.b" produces a segment called "a#.b". Finally, "a#b" produces a segment called "a#b" - the escape processing is only used immediately prior to the path separator. Any escape character may be used. Backslash ('\\') is the most obvious candidate but be aware that the JDK Properties loader has its own rules for escape processing (documented in the Javadoc for Properties.load ) that will remove ALL duplicated backslash characters (and also carry out other escape handling) before the JavaPropsMapper gets to see them.
    
    Since:
    
    2.14
  - 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)
```
  - withPrefix
```
public JavaPropsSchema withPrefix(String v)
```
    Mutant factory for constructing schema instance where specified prefix is prepended before logical path when generator writes output and removed by parser before binding back as properties.
    
    Since:
    
    2.10
  - 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()
```
  - pathSeparatorEscapeChar
```
public char pathSeparatorEscapeChar()
```
    Since:
    
    2.14
  - prefix
```
public String prefix()
```
    Since:
    
    2.10
  - 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

_pathSeparatorEscapeChar

_indexMarker

_parseSimpleIndexes

_writeIndexUsingMarkers

_lineIndentation

_keyValueSeparator

_lineEnding

_header

_prefix

Constructor Detail

JavaPropsSchema

JavaPropsSchema

Method Detail

pathSplitter

withFirstArrayOffset

withPathSeparator

withPathSeparatorEscapeChar

withoutPathSeparator

withIndexMarker

withoutIndexMarker

withParseSimpleIndexes

withWriteIndexUsingMarkers

withLineIndentation

withoutLineIndentation

withKeyValueSeparator

withLineEnding

withPrefix

withHeader

withoutHeader

getSchemaType

emptySchema

firstArrayOffset

header

indexMarker

lineEnding

lineIndentation

keyValueSeparator

parseSimpleIndexes

pathSeparator

pathSeparatorEscapeChar

prefix

writeIndexUsingMarkers