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:
  • Field Details

    • serialVersionUID

      private static final long serialVersionUID
      See Also:
    • 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 Details

    • JavaPropsSchema

      public JavaPropsSchema()
    • JavaPropsSchema

      public JavaPropsSchema(JavaPropsSchema base)
  • Method Details

    • 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()
    • _equals

      private <V> boolean _equals(V a, V b)