All Superinterfaces:

org.refcodes.mixin.AnnotatorAccessor, Containable, org.refcodes.mixin.DelimiterAccessor, Dictionary<String,String>, org.refcodes.mixin.Dumpable, org.refcodes.mixin.EmptyAccessor, InterOperableMap<String>, Keys<String,String>, PathMap<String>, org.refcodes.mixin.TypeAccessor<String>

All Known Subinterfaces:

CanonicalMap.CanonicalMapBuilder, CanonicalMap.MutableCanonicalMap

All Known Implementing Classes:

CanonicalMapBuilderImpl, CanonicalMapImpl
```
public interface CanonicalMap
extends InterOperableMap<String>
```
The CanonicalMap is an "intermediate" type adding type and Data-Structure related functionality to any implementing class.

Nested Class Summary

Nested Classes
Modifier and Type	Interface	Description
`static interface`	`CanonicalMap.CanonicalMapBuilder`	The Interface CanonicalMapBuilder.
`static interface`	`CanonicalMap.MutableCanonicalMap`	The Interface MutableCanonicalMap.

Nested classes/interfaces inherited from interface org.refcodes.mixin.AnnotatorAccessor
org.refcodes.mixin.AnnotatorAccessor.AnnotatorBuilder<B extends org.refcodes.mixin.AnnotatorAccessor.AnnotatorBuilder<B>>, org.refcodes.mixin.AnnotatorAccessor.AnnotatorMutator, org.refcodes.mixin.AnnotatorAccessor.AnnotatorProperty

Nested classes/interfaces inherited from interface org.refcodes.mixin.DelimiterAccessor
org.refcodes.mixin.DelimiterAccessor.DelimiterBuilder<B extends org.refcodes.mixin.DelimiterAccessor.DelimiterBuilder<B>>, org.refcodes.mixin.DelimiterAccessor.DelimiterMutator, org.refcodes.mixin.DelimiterAccessor.DelimiterProperty

Nested classes/interfaces inherited from interface org.refcodes.struct.Dictionary
Dictionary.MutableDictionary<K,V>

Nested classes/interfaces inherited from interface org.refcodes.mixin.EmptyAccessor
org.refcodes.mixin.EmptyAccessor.EmptyMutator, org.refcodes.mixin.EmptyAccessor.EmptyProperty

Nested classes/interfaces inherited from interface org.refcodes.struct.InterOperableMap
InterOperableMap.InterOperableMapBuilder<T>, InterOperableMap.MutableInterOperableMap<T>

Nested classes/interfaces inherited from interface org.refcodes.struct.Keys
Keys.MutableKeys<K,V>, Keys.MutableValues<K,V>

Nested classes/interfaces inherited from interface org.refcodes.struct.PathMap
PathMap.MutablePathMap<T>, PathMap.PathMapBuilder<T>

Nested classes/interfaces inherited from interface org.refcodes.mixin.TypeAccessor
org.refcodes.mixin.TypeAccessor.TypeBuilder<T extends Object,B extends org.refcodes.mixin.TypeAccessor.TypeBuilder<T,B>>, org.refcodes.mixin.TypeAccessor.TypeMutator<T extends Object>, org.refcodes.mixin.TypeAccessor.TypeProperty<T extends Object>

Field Summary
- Fields inherited from interface org.refcodes.struct.PathMap
  ANNOTATOR, DELIMITER

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method	Description
`default String[]`	`asArray(Object aKey)`	Same as `asArray(String, char)` using a comma (',') as delimiter.
`default String[]`	`asArray(Object aKey, char aDelimiter)`	Treats the value associated with the given key as an array with its elements being the elements of the value separated by the given delimiter char.
`default String[]`	`asArray(String aKey)`	Same as `asArray(String, char)` using a comma (',') as delimiter.
`default String[]`	`asArray(String aKey, char aDelimiter)`	Treats the value associated with the given key as an array with its elements being the elements of the value separated by the given delimiter char.
`default boolean[]`	`asBooleanArray(Object aKey)`	Same as `asBooleanArray(String, char)` using a comma (',') as delimiter.
`default boolean[]`	`asBooleanArray(Object aKey, char aDelimiter)`	Treats the value associated with the given key as a boolean array with its elements being the elements of the value separated by the given delimiter char.
`default boolean[]`	`asBooleanArray(String aKey)`	Same as `asBooleanArray(String, char)` using a comma (',') as delimiter.
`default boolean[]`	`asBooleanArray(String aKey, char aDelimiter)`	Treats the value associated with the given key as a boolean array with its elements being the elements of the value separated by the given delimiter char.
`default byte[]`	`asByteArray(Object aKey)`	Same as `asByteArray(String, char)` using a comma (',') as delimiter.
`default byte[]`	`asByteArray(Object aKey, char aDelimiter)`	Treats the value associated with the given key as a byte array with its elements being the elements of the value separated by the given delimiter char.
`default byte[]`	`asByteArray(String aKey)`	Same as `asByteArray(String, char)` using a comma (',') as delimiter.
`default byte[]`	`asByteArray(String aKey, char aDelimiter)`	Treats the value associated with the given key as a byte array with its elements being the elements of the value separated by the given delimiter char.
`default char[]`	`asCharArray(Object aKey)`	Same as `asCharArray(String, char)` using a comma (',') as delimiter.
`default char[]`	`asCharArray(Object aKey, char aDelimiter)`	Treats the value associated with the given key as a char array with its elements being the elements of the value separated by the given delimiter char.
`default char[]`	`asCharArray(String aKey)`	Same as `asCharArray(String, char)` using a comma (',') as delimiter.
`default char[]`	`asCharArray(String aKey, char aDelimiter)`	Treats the value associated with the given key as a char array with its elements being the elements of the value separated by the given delimiter char.
`default double[]`	`asDoubleArray(Object aKey)`	Same as `asDoubleArray(String, char)` using a comma (',') as delimiter.
`default double[]`	`asDoubleArray(Object aKey, char aDelimiter)`	Treats the value associated with the given key as a double array with its elements being the elements of the value separated by the given delimiter double.
`default double[]`	`asDoubleArray(String aKey)`	Same as `asDoubleArray(String, char)` using a comma (',') as delimiter.
`default double[]`	`asDoubleArray(String aKey, char aDelimiter)`	Treats the value associated with the given key as a double array with its elements being the elements of the value separated by the given delimiter double.
`default float[]`	`asFloatArray(Object aKey)`	Same as `asFloatArray(String, char)` using a comma (',') as delimiter.
`default float[]`	`asFloatArray(Object aKey, char aDelimiter)`	Treats the value associated with the given key as a float array with its elements being the elements of the value separated by the given delimiter float.
`default float[]`	`asFloatArray(String aKey)`	Same as `asFloatArray(String, char)` using a comma (',') as delimiter.
`default float[]`	`asFloatArray(String aKey, char aDelimiter)`	Treats the value associated with the given key as a float array with its elements being the elements of the value separated by the given delimiter float.
`default int[]`	`asIntArray(Object aKey)`	Same as `asIntArray(String, char)` using a comma (',') as delimiter.
`default int[]`	`asIntArray(Object aKey, char aDelimiter)`	Treats the value associated with the given key as a integer array with its elements being the elements of the value separated by the given delimiter char.
`default int[]`	`asIntArray(String aKey)`	Same as `asIntArray(String, char)` using a comma (',') as delimiter.
`default int[]`	`asIntArray(String aKey, char aDelimiter)`	Treats the value associated with the given key as a integer array with its elements being the elements of the value separated by the given delimiter char.
`default long[]`	`asLongArray(Object aKey)`	Same as `asLongArray(String, char)` using a comma (',') as delimiter.
`default long[]`	`asLongArray(Object aKey, char aDelimiter)`	Treats the value associated with the given key as a longeger array with its elements being the elements of the value separated by the given delimiter char.
`default long[]`	`asLongArray(String aKey)`	Same as `asLongArray(String, char)` using a comma (',') as delimiter.
`default long[]`	`asLongArray(String aKey, char aDelimiter)`	Treats the value associated with the given key as a longeger array with its elements being the elements of the value separated by the given delimiter char.
`default short[]`	`asShortArray(Object aKey)`	Same as `asShortArray(String, char)` using a comma (',') as delimiter.
`default short[]`	`asShortArray(Object aKey, char aDelimiter)`	Treats the value associated with the given key as a shorteger array with its elements being the elements of the value separated by the given delimiter char.
`default short[]`	`asShortArray(String aKey)`	Same as `asShortArray(String, char)` using a comma (',') as delimiter.
`default short[]`	`asShortArray(String aKey, char aDelimiter)`	Treats the value associated with the given key as a shorteger array with its elements being the elements of the value separated by the given delimiter char.
`default boolean`	`containsValue(Object value)`	This method is defined for the sake of `Map` conformity.
`default CanonicalMap`	`getDir(Object aPath)`	Gets the children elements of the provided parent's path, excluding the parent's path.
`default CanonicalMap`	`getDir(Object... aPathElements)`	Gets the children elements of the provided parent's path elements, excluding the parent's path.
`default CanonicalMap`	`getDir(String aPath)`	Gets the children elements of the provided parent's path elements, excluding the parent's path.
`default CanonicalMap`	`getDir(String... aPathElements)`	Gets the children elements of the provided parent's path elements, excluding the parent's path.
`default CanonicalMap`	`getDir(Collection<?> aPathElements)`	Gets the children elements of the provided parent's path elements, excluding the parent's path.
`default CanonicalMap`	`getDirAt(int aIndex)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default CanonicalMap`	`getDirAt(Object[] aPathElements, int aIndex)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default CanonicalMap`	`getDirAt(Object aPath, int aIndex)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default CanonicalMap`	`getDirAt(String[] aPathElements, int aIndex)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default CanonicalMap`	`getDirAt(String aPath, int aIndex)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default CanonicalMap`	`getDirAt(Collection<?> aPathElements, int aIndex)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default CanonicalMap[]`	`getDirs(Object aPath)`	Gets the children elements of the provided parent's path, excluding the parent's path.
`default CanonicalMap[]`	`getDirs(Object... aPathElements)`	Gets the children elements of the provided parent's path elements, excluding the parent's path.
`default CanonicalMap[]`	`getDirs(String aPath)`	Gets the children elements of the provided parent's path elements, excluding the parent's path.
`default CanonicalMap[]`	`getDirs(String... aPathElements)`	Gets the children elements of the provided parent's path elements, excluding the parent's path.
`default CanonicalMap[]`	`getDirs(Collection<?> aPathElements)`	Gets the children elements of the provided parent's path, excluding the parent's path.
`default CanonicalMap`	`query(Object... aQueryElements)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`query(String aPathQuery)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`query(String... aQueryElements)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`query(Collection<?> aQueryElements)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`query(Pattern aRegExp)`	Queries the keys of the instance using a regular expression as of the provided `Pattern` instance.
`default CanonicalMap`	`queryBetween(Object[] aFromPath, Object[] aPathQuery, Object[] aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`queryBetween(Object aFromPath, Object aPathQuery, Object aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`queryBetween(String[] aFromPath, String[] aPathQuery, String[] aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`queryBetween(String aFromPath, String aPathQuery, String aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`queryBetween(String aFromPath, Pattern aRegExp, String aToPath)`	Queries the keys of the instance using a regular expression as of the provided `Pattern`.
`default CanonicalMap`	`queryBetween(Collection<?> aFromPath, Collection<?> aPathQuery, Collection<?> aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`queryFrom(Object[] aPathQuery, Object[] aFromPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`queryFrom(Object aPathQuery, Object aFromPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`queryFrom(String[] aPathQuery, String[] aFromPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`queryFrom(String aPathQuery, String aFromPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`queryFrom(Collection<?> aPathQuery, Collection<?> aFromPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`queryFrom(Pattern aRegExp, String aFromPath)`	Queries the keys of the instance using a regular expression as of the provided `Pattern`.
`default CanonicalMap`	`queryTo(Object[] aPathQuery, String aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`queryTo(Object aPathQuery, String aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`queryTo(String[] aPathQuery, String aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`queryTo(String aPathQuery, String aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`queryTo(Collection<?> aPathQuery, String aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default CanonicalMap`	`queryTo(Pattern aRegExp, String aToPath)`	Queries the keys of the instance using a regular expression as of the provided `Pattern`.
`default CanonicalMap`	`retrieveBetween(Object[] aFromPath, Object[] aToPath)`	Extracts a new `PathMap` from the elements of this `PathMap` found below the "from-path".
`default CanonicalMap`	`retrieveBetween(Object aFromPath, Object aToPath)`	Extracts a new `PathMap` from the elements of this `PathMap` found below the "from-path".
`default CanonicalMap`	`retrieveBetween(String[] aFromPath, String[] aToPath)`	Extracts a new `PathMap` from the elements of this `PathMap` found below the "from-path".
`default CanonicalMap`	`retrieveBetween(String aFromPath, String aToPath)`	Extracts a new `PathMap` from the elements of this `PathMap` found below the "from-path".
`default CanonicalMap`	`retrieveBetween(Collection<?> aFromPath, Collection<?> aToPath)`	Extracts a new `PathMap` from the elements of this `PathMap` found below the "from-path".
`default CanonicalMap`	`retrieveFrom(Object aParentPath)`	Gets the children elements of the provided parent's path, excluding the parent's path.
`default CanonicalMap`	`retrieveFrom(Object... aPathElements)`	Gets the children elements of the provided parent's path elements, excluding the parent's path.
`CanonicalMap`	`retrieveFrom(String aFromPath)`	Extracts a new `PathMap` from the elements of this `PathMap` found below the "from-path".
`default CanonicalMap`	`retrieveFrom(String... aPathElements)`	Gets the children elements of the provided parent's path elements, excluding the parent's path.
`default CanonicalMap`	`retrieveFrom(Collection<?> aPathElements)`	Gets the children elements of the provided parent's path elements, excluding the parent's path.
`default CanonicalMap`	`retrieveTo(Object aToPath)`	Extracts a new `PathMap` from this `PathMap`'s elements with the paths relocated to the provided "to-path".
`default CanonicalMap`	`retrieveTo(Object... aToPathElements)`	Extracts a new `PathMap` from this `PathMap`'s elements with the paths relocated to the provided "to-path".
`CanonicalMap`	`retrieveTo(String aToPath)`	Extracts a new `PathMap` from this `PathMap`'s elements with the paths relocated to the provided "to-path".
`default CanonicalMap`	`retrieveTo(String... aToPathElements)`	Extracts a new `PathMap` from this `PathMap`'s elements with the paths relocated to the provided "to-path".
`default CanonicalMap`	`retrieveTo(Collection<?> aToPathElements)`	Extracts a new `PathMap` from this `PathMap`'s elements with the paths relocated to the provided "to-path".
`default Map<String,String>`	`toMap()`	This method creates a `Map` instance from this `CanonicalMap` instance's elements (key/value-pairs) as of interoperability reasons.
`default Properties`	`toProperties()`	This method creates a `Properties` instance from this `Properties` instance's elements (key/value-pairs) as of interoperability reasons.

Methods inherited from interface org.refcodes.mixin.AnnotatorAccessor
getAnnotator

Methods inherited from interface org.refcodes.struct.Containable
size

Methods inherited from interface org.refcodes.mixin.DelimiterAccessor
getDelimiter

Methods inherited from interface org.refcodes.mixin.Dumpable
toDump, toDump, toPrintable

Methods inherited from interface org.refcodes.mixin.EmptyAccessor
isEmpty

Methods inherited from interface org.refcodes.struct.InterOperableMap
getBoolean, getBoolean, getBoolean, getBoolean, getBoolean, getBooleanOr, getBooleanOr, getBooleanOr, getBooleanOr, getBooleanOr, getByte, getByte, getByte, getByte, getByte, getByteOr, getByteOr, getByteOr, getByteOr, getByteOr, getChar, getChar, getChar, getChar, getChar, getCharOr, getCharOr, getCharOr, getCharOr, getCharOr, getClass, getClass, getClass, getClass, getClass, getClassOr, getClassOr, getClassOr, getClassOr, getClassOr, getDouble, getDouble, getDouble, getDouble, getDouble, getDoubleOr, getDoubleOr, getDoubleOr, getDoubleOr, getDoubleOr, getEnum, getEnum, getEnum, getEnum, getEnum, getEnumOr, getEnumOr, getEnumOr, getEnumOr, getEnumOr, getEnumOr, getEnumOr, getEnumOr, getEnumOr, getEnumOr, getFloat, getFloat, getFloat, getFloat, getFloat, getFloatOr, getFloatOr, getFloatOr, getFloatOr, getFloatOr, getInt, getInt, getInt, getInt, getInt, getIntOr, getIntOr, getIntOr, getIntOr, getIntOr, getLong, getLong, getLong, getLong, getLong, getLongOr, getLongOr, getLongOr, getLongOr, getLongOr, getShort, getShort, getShort, getShort, getShort, getShortOr, getShortOr, getShortOr, getShortOr, getShortOr, getString, getString, getString, getString, getString, getStringOr, getStringOr, getStringOr, getStringOr, getStringOr

Methods inherited from interface org.refcodes.struct.Keys
containsKey, get, getOr, keySet, use, values

Methods inherited from interface org.refcodes.struct.PathMap
children, children, children, children, children, children, containsKey, containsKey, containsKey, dirs, dirs, dirs, dirs, dirs, dirs, findPaths, fromExternalPath, get, get, get, getArray, getArray, getArray, getArray, getArray, getArrayIndexes, getArrayIndexes, getArrayIndexes, getArrayIndexes, getArrayIndexes, getArrayOr, getArrayOr, getArrayOr, getArrayOr, getArrayOr, getDirIndexes, getDirIndexes, getDirIndexes, getDirIndexes, getDirIndexes, getRootPath, getValueAt, getValueAt, getValueAt, getValueAt, getValueAt, getValueAt, hasChildren, hasChildren, hasChildren, hasChildren, hasChildren, hasDirAt, hasDirAt, hasDirAt, hasDirAt, hasDirAt, hasDirAt, hasDirAt, hasDirAt, hasDirAt, hasDirAt, hasDirAt, hasParentPath, hasPath, hasPath, hasPath, hasPath, hasSubDirs, hasSubDirs, hasSubDirs, hasSubDirs, hasValue, hasValue, hasValue, hasValue, hasValue, hasValueAt, hasValueAt, hasValueAt, hasValueAt, hasValueAt, hasValueAt, hasValueAt, hasValueAt, isArray, isArray, isArray, isArray, isArray, isArray, isChild, isChild, isChild, isChild, isDir, isDir, isDir, isDir, isDir, isEqualTo, isIndexDir, isIndexDir, isIndexDir, isIndexDir, isIndexDir, isLeaf, isLeaf, isLeaf, isLeaf, isLeaf, isRootPath, keySet, keySet, keySet, keySet, keySet, lastArrayIndex, lastArrayIndex, lastArrayIndex, lastArrayIndex, lastArrayIndex, lastArrayIndex, lastDirIndex, lastDirIndex, lastDirIndex, lastDirIndex, lastDirIndex, lastDirIndex, leaves, leaves, leaves, leaves, leaves, leaves, nextArrayIndex, nextArrayIndex, nextArrayIndex, nextArrayIndex, nextArrayIndex, nextArrayIndex, nextDirIndex, nextDirIndex, nextDirIndex, nextDirIndex, nextDirIndex, nextDirIndex, paths, paths, paths, paths, paths, paths, queryPaths, queryPaths, queryPaths, queryPaths, queryPaths, queryPaths, sortedKeys, sortedKeys, sortedKeys, sortedKeys, sortedKeys, sortedKeys, sortedKeys, sortedKeys, sortedKeys, sortedKeys, sortedKeys, sortedKeys, sortedKeys, sortedKeys, sortedKeys, sortedKeys, sortedKeys, sortedKeys, toDataStructure, toDataStructure, toExternalPath, toInstance, toInstance, toLeaf, toMap, toNormalizedPath, toParentPath, toPath, toPath, toPath, toPath, toPathElements, toPathList, toPathStack, toPropertyPath, toType, toType, toType, toType, toType, toType, toType, toType

Methods inherited from interface org.refcodes.mixin.TypeAccessor
getType

- Method Detail
  - asArray
```
default String[] asArray(Object aKey)
```
    Same as asArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
  - asArray
```
default String[] asArray(Object aKey,
                         char aDelimiter)
```
    Treats the value associated with the given key as an array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "1, 2, 3, 4, 5", then the corresponding array, when using the comma (',') char as delimiter, will be { "1", "2", "3", "4", "5" }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
  - asArray
```
default String[] asArray(String aKey)
```
    Same as asArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
  - asArray
```
default String[] asArray(String aKey,
                         char aDelimiter)
```
    Treats the value associated with the given key as an array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "1, 2, 3, 4, 5", then the corresponding array, when using the comma (',') char as delimiter, will be { "1", "2", "3", "4", "5" }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
  - asBooleanArray
```
default boolean[] asBooleanArray(Object aKey)
                          throws NumberFormatException
```
    Same as asBooleanArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException
  - asBooleanArray
```
default boolean[] asBooleanArray(Object aKey,
                                 char aDelimiter)
                          throws NumberFormatException
```
    Treats the value associated with the given key as a boolean array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException - thrown in case conversion fails.
  - asBooleanArray
```
default boolean[] asBooleanArray(String aKey)
                          throws NumberFormatException
```
    Same as asBooleanArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException
  - asBooleanArray
```
default boolean[] asBooleanArray(String aKey,
                                 char aDelimiter)
                          throws NumberFormatException
```
    Treats the value associated with the given key as a boolean array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException - thrown in case conversion fails.
  - asByteArray
```
default byte[] asByteArray(Object aKey)
                    throws NumberFormatException
```
    Same as asByteArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException
  - asByteArray
```
default byte[] asByteArray(Object aKey,
                           char aDelimiter)
                    throws NumberFormatException
```
    Treats the value associated with the given key as a byte array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException - thrown in case conversion fails.
  - asByteArray
```
default byte[] asByteArray(String aKey)
                    throws NumberFormatException
```
    Same as asByteArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException
  - asByteArray
```
default byte[] asByteArray(String aKey,
                           char aDelimiter)
                    throws NumberFormatException
```
    Treats the value associated with the given key as a byte array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException - thrown in case conversion fails.
  - asCharArray
```
default char[] asCharArray(Object aKey)
                    throws NumberFormatException
```
    Same as asCharArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException
  - asCharArray
```
default char[] asCharArray(Object aKey,
                           char aDelimiter)
                    throws NumberFormatException
```
    Treats the value associated with the given key as a char array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException - thrown in case conversion fails.
  - asCharArray
```
default char[] asCharArray(String aKey)
                    throws NumberFormatException
```
    Same as asCharArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException
  - asCharArray
```
default char[] asCharArray(String aKey,
                           char aDelimiter)
                    throws NumberFormatException
```
    Treats the value associated with the given key as a char array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException - thrown in case conversion fails.
  - asDoubleArray
```
default double[] asDoubleArray(Object aKey)
                        throws NumberFormatException
```
    Same as asDoubleArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException
  - asDoubleArray
```
default double[] asDoubleArray(Object aKey,
                               char aDelimiter)
                        throws NumberFormatException
```
    Treats the value associated with the given key as a double array with its elements being the elements of the value separated by the given delimiter double. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') double as delimiter, will be { true, false, true, false, true }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException - thrown in case conversion fails.
  - asDoubleArray
```
default double[] asDoubleArray(String aKey)
                        throws NumberFormatException
```
    Same as asDoubleArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException
  - asDoubleArray
```
default double[] asDoubleArray(String aKey,
                               char aDelimiter)
                        throws NumberFormatException
```
    Treats the value associated with the given key as a double array with its elements being the elements of the value separated by the given delimiter double. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') double as delimiter, will be { true, false, true, false, true }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException - thrown in case conversion fails.
  - asFloatArray
```
default float[] asFloatArray(Object aKey)
                      throws NumberFormatException
```
    Same as asFloatArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException
  - asFloatArray
```
default float[] asFloatArray(Object aKey,
                             char aDelimiter)
                      throws NumberFormatException
```
    Treats the value associated with the given key as a float array with its elements being the elements of the value separated by the given delimiter float. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') float as delimiter, will be { true, false, true, false, true }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException - thrown in case conversion fails.
  - asFloatArray
```
default float[] asFloatArray(String aKey)
                      throws NumberFormatException
```
    Same as asFloatArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException
  - asFloatArray
```
default float[] asFloatArray(String aKey,
                             char aDelimiter)
                      throws NumberFormatException
```
    Treats the value associated with the given key as a float array with its elements being the elements of the value separated by the given delimiter float. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') float as delimiter, will be { true, false, true, false, true }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException - thrown in case conversion fails.
  - asIntArray
```
default int[] asIntArray(Object aKey)
                  throws NumberFormatException
```
    Same as asIntArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException
  - asIntArray
```
default int[] asIntArray(Object aKey,
                         char aDelimiter)
                  throws NumberFormatException
```
    Treats the value associated with the given key as a integer array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException - thrown in case conversion fails.
  - asIntArray
```
default int[] asIntArray(String aKey)
                  throws NumberFormatException
```
    Same as asIntArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException
  - asIntArray
```
default int[] asIntArray(String aKey,
                         char aDelimiter)
                  throws NumberFormatException
```
    Treats the value associated with the given key as a integer array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException - thrown in case conversion fails.
  - asLongArray
```
default long[] asLongArray(Object aKey)
                    throws NumberFormatException
```
    Same as asLongArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException
  - asLongArray
```
default long[] asLongArray(Object aKey,
                           char aDelimiter)
                    throws NumberFormatException
```
    Treats the value associated with the given key as a longeger array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException - thrown in case conversion fails.
  - asLongArray
```
default long[] asLongArray(String aKey)
                    throws NumberFormatException
```
    Same as asLongArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException
  - asLongArray
```
default long[] asLongArray(String aKey,
                           char aDelimiter)
                    throws NumberFormatException
```
    Treats the value associated with the given key as a longeger array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException - thrown in case conversion fails.
  - asShortArray
```
default short[] asShortArray(Object aKey)
                      throws NumberFormatException
```
    Same as asShortArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException
  - asShortArray
```
default short[] asShortArray(Object aKey,
                             char aDelimiter)
                      throws NumberFormatException
```
    Treats the value associated with the given key as a shorteger array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException - thrown in case conversion fails.
  - asShortArray
```
default short[] asShortArray(String aKey)
                      throws NumberFormatException
```
    Same as asShortArray(String, char) using a comma (',') as delimiter.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException
  - asShortArray
```
default short[] asShortArray(String aKey,
                             char aDelimiter)
                      throws NumberFormatException
```
    Treats the value associated with the given key as a shorteger array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
    
    Parameters:
    
    aKey - The key, which's value is to be converted to an array.
    
    aDelimiter - The delimiter to be used to identify the elements of the future array.
    
    Returns:
    
    The according array or null if no (or a null) value has been associated to the key.
    
    Throws:
    
    NumberFormatException - thrown in case conversion fails.
  - containsValue
```
default boolean containsValue(Object value)
```
    This method is defined for the sake of Map conformity. Tests whether the provided value has a key assigned.
    
    Specified by:
    
    containsValue in interface Keys<String,String>
    
    Parameters:
    
    value - The value to test if a key references this value.
    
    Returns:
    
    True in case the given value is referenced by a key.
  - getDirAt
```
default CanonicalMap getDirAt(String[] aPathElements,
                              int aIndex)
```
    An indexed directory represents all elements which begin with a path which's last path element represents an index. There may by many sub-paths for the same indexed path which are all are included by the according directory. Returns the elements of the given index below the path of the path "array" path. Given the following paths and index = 1 with a queried path "/root/child": /root/child/0/0aaa /root/child/0/0bbb /root/child/0/0bbb /root/child/1/1aaa /root/child/1/1bbb /root/child/1/1bbb You will get a result containing all the elements which's keys begin with "/root/child/1/".The keys of the result will exclude the path "prefix" "/root/child/1".
    
    Specified by:
    
    getDirAt in interface PathMap<String>
    
    Parameters:
    
    aPathElements - The elements of the path from which to get the indexed elements.
    
    aIndex - The index which to use.
    
    Returns:
    
    The indexed elements without the indexed path "prefixes".
  - getDirAt
```
default CanonicalMap getDirAt(int aIndex)
```
    An indexed directory represents all elements which begin with a path which's last path element represents an index. There may by many sub-paths for the same indexed path which are all are included by the according directory. Returns the elements of the given index below the path of the root "array" path. Given the following paths and index = 1: /0/0aaa /0/0bbb /0/0bbb /1/1aaa /1/1bbb /1/1bbb You will get a result containing all the elements which's keys begin with "/1/". The keys of the result will exclude the path "prefix" "/1".
    
    Specified by:
    
    getDirAt in interface PathMap<String>
    
    Parameters:
    
    aIndex - The index which to use.
    
    Returns:
    
    The indexed elements without the indexed path "prefixes".
  - getDirAt
```
default CanonicalMap getDirAt(String aPath,
                              int aIndex)
```
    An indexed directory represents all elements which begin with a path which's last path element represents an index. There may by many sub-paths for the same indexed path which are all are included by the according directory. Returns the elements of the given index below the path of the path "array" path. Given the following paths and index = 1 with a queried path "/root/child": /root/child/0/0aaa /root/child/0/0bbb /root/child/0/0bbb /root/child/1/1aaa /root/child/1/1bbb /root/child/1/1bbb You will get a result containing all the elements which's keys begin with "/root/child/1/".The keys of the result will exclude the path "prefix" "/root/child/1".
    
    Specified by:
    
    getDirAt in interface PathMap<String>
    
    Parameters:
    
    aPath - The path from which to get the indexed elements.
    
    aIndex - The index which to use.
    
    Returns:
    
    The indexed elements without the indexed path "prefixes".
  - getDirAt
```
default CanonicalMap getDirAt(Collection<?> aPathElements,
                              int aIndex)
```
    An indexed directory represents all elements which begin with a path which's last path element represents an index. There may by many sub-paths for the same indexed path which are all are included by the according directory. Returns the elements of the given index below the path of the path "array" path. Given the following paths and index = 1 with a queried path "/root/child": /root/child/0/0aaa /root/child/0/0bbb /root/child/0/0bbb /root/child/1/1aaa /root/child/1/1bbb /root/child/1/1bbb You will get a result containing all the elements which's keys begin with "/root/child/1/".The keys of the result will exclude the path "prefix" "/root/child/1".
    
    Specified by:
    
    getDirAt in interface PathMap<String>
    
    Parameters:
    
    aPathElements - The elements of the path from which to get the indexed elements.
    
    aIndex - The index which to use.
    
    Returns:
    
    The indexed elements without the indexed path "prefixes".
  - getDirAt
```
default CanonicalMap getDirAt(Object aPath,
                              int aIndex)
```
    An indexed directory represents all elements which begin with a path which's last path element represents an index. There may by many sub-paths for the same indexed path which are all are included by the according directory. Returns the elements of the given index below the path of the path "array" path. Given the following paths and index = 1 with a queried path "/root/child": /root/child/0/0aaa /root/child/0/0bbb /root/child/0/0bbb /root/child/1/1aaa /root/child/1/1bbb /root/child/1/1bbb You will get a result containing all the elements which's keys begin with "/root/child/1/". The keys of the result will exclude the path "prefix" "/root/child/1".
    
    Specified by:
    
    getDirAt in interface PathMap<String>
    
    Parameters:
    
    aPath - The path from which to get the indexed elements.
    
    aIndex - The index which to use.
    
    Returns:
    
    The indexed elements without the indexed path "prefixes".
  - getDirAt
```
default CanonicalMap getDirAt(Object[] aPathElements,
                              int aIndex)
```
    An indexed directory represents all elements which begin with a path which's last path element represents an index. There may by many sub-paths for the same indexed path which are all are included by the according directory. Returns the elements of the given index below the path of the path "array" path. Given the following paths and index = 1 with a queried path "/root/child": /root/child/0/0aaa /root/child/0/0bbb /root/child/0/0bbb /root/child/1/1aaa /root/child/1/1bbb /root/child/1/1bbb You will get a result containing all the elements which's keys begin with "/root/child/1/".The keys of the result will exclude the path "prefix" "/root/child/1".
    
    Specified by:
    
    getDirAt in interface PathMap<String>
    
    Parameters:
    
    aPathElements - The elements of the path from which to get the indexed elements.
    
    aIndex - The index which to use.
    
    Returns:
    
    The indexed elements without the indexed path "prefixes".
  - query
```
default CanonicalMap query(Collection<?> aQueryElements)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    query in interface PathMap<String>
    
    Parameters:
    
    aQueryElements - The elements representing the path query including your wildcards.
    
    Returns:
    
    The result contains the matching paths with the according values.
  - query
```
default CanonicalMap query(Object... aQueryElements)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    query in interface PathMap<String>
    
    Parameters:
    
    aQueryElements - The elements representing the path query including your wildcards.
    
    Returns:
    
    The result contains the matching paths with the according values.
  - query
```
default CanonicalMap query(Pattern aRegExp)
```
    Queries the keys of the instance using a regular expression as of the provided Pattern instance.
    
    Specified by:
    
    query in interface PathMap<String>
    
    Parameters:
    
    aRegExp - The regular expression to be used for the query.
    
    Returns:
    
    The matching properties.
  - query
```
default CanonicalMap query(String aPathQuery)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    query in interface PathMap<String>
    
    Parameters:
    
    aPathQuery - The path query including your wildcards.
    
    Returns:
    
    The result contains the matching paths with the according values.
  - query
```
default CanonicalMap query(String... aQueryElements)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    query in interface PathMap<String>
    
    Parameters:
    
    aQueryElements - The elements representing the path query including your wildcards.
    
    Returns:
    
    The result contains the matching paths with the according values.
  - queryBetween
```
default CanonicalMap queryBetween(Collection<?> aFromPath,
                                  Collection<?> aPathQuery,
                                  Collection<?> aToPath)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    queryBetween in interface PathMap<String>
    
    Parameters:
    
    aFromPath - The path from where to start querying and extracting the paths.
    
    aPathQuery - The path query including your wildcards.
    
    aToPath - The path where to relocate the result to.
    
    Returns:
    
    The result contains the matching paths (with respect to the from-path and the to-path) with the according values.
  - queryBetween
```
default CanonicalMap queryBetween(Object aFromPath,
                                  Object aPathQuery,
                                  Object aToPath)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    queryBetween in interface PathMap<String>
    
    Parameters:
    
    aFromPath - The path from where to start querying and extracting the paths.
    
    aPathQuery - The path query including your wildcards.
    
    aToPath - The path where to relocate the result to.
    
    Returns:
    
    The result contains the matching paths (with respect to the from-path and the to-path) with the according values.
  - queryBetween
```
default CanonicalMap queryBetween(Object[] aFromPath,
                                  Object[] aPathQuery,
                                  Object[] aToPath)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    queryBetween in interface PathMap<String>
    
    Parameters:
    
    aFromPath - The path from where to start querying and extracting the paths.
    
    aPathQuery - The path query including your wildcards.
    
    aToPath - The path where to relocate the result to.
    
    Returns:
    
    The result contains the matching paths (with respect to the from-path and the to-path) with the according values.
  - queryBetween
```
default CanonicalMap queryBetween(String aFromPath,
                                  Pattern aRegExp,
                                  String aToPath)
```
    Queries the keys of the instance using a regular expression as of the provided Pattern.
    
    Specified by:
    
    queryBetween in interface PathMap<String>
    
    Parameters:
    
    aFromPath - The path from where to start querying and extracting the paths.
    
    aRegExp - The regular expression to be used for the query.
    
    aToPath - The path where to relocate the result to.
    
    Returns:
    
    The result contains the matching paths (with respect to the from-path and the to-path) with the according values.
  - queryBetween
```
default CanonicalMap queryBetween(String aFromPath,
                                  String aPathQuery,
                                  String aToPath)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    queryBetween in interface PathMap<String>
    
    Parameters:
    
    aFromPath - The path from where to start querying and extracting the paths.
    
    aPathQuery - The path query including your wildcards.
    
    aToPath - The path where to relocate the result to.
    
    Returns:
    
    The result contains the matching paths (with respect to the from-path and the to-path) with the according values.
  - queryBetween
```
default CanonicalMap queryBetween(String[] aFromPath,
                                  String[] aPathQuery,
                                  String[] aToPath)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    queryBetween in interface PathMap<String>
    
    Parameters:
    
    aFromPath - The path from where to start querying and extracting the paths.
    
    aPathQuery - The path query including your wildcards.
    
    aToPath - The path where to relocate the result to.
    
    Returns:
    
    The result contains the matching paths (with respect to the from-path and the to-path) with the according values.
  - queryFrom
```
default CanonicalMap queryFrom(Collection<?> aPathQuery,
                               Collection<?> aFromPath)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    queryFrom in interface PathMap<String>
    
    Parameters:
    
    aPathQuery - The path query including your wildcards.
    
    aFromPath - The path from where to start querying and extracting the paths.
    
    Returns:
    
    The result contains the matching paths (with respect to the from-path) with the according values.
  - queryFrom
```
default CanonicalMap queryFrom(Object aPathQuery,
                               Object aFromPath)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    queryFrom in interface PathMap<String>
    
    Parameters:
    
    aPathQuery - The path query including your wildcards.
    
    aFromPath - The path from where to start querying and extracting the paths.
    
    Returns:
    
    The result contains the matching paths (with respect to the from-path) with the according values.
  - queryFrom
```
default CanonicalMap queryFrom(Object[] aPathQuery,
                               Object[] aFromPath)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    queryFrom in interface PathMap<String>
    
    Parameters:
    
    aPathQuery - The path query including your wildcards.
    
    aFromPath - The path from where to start querying and extracting the paths.
    
    Returns:
    
    The result contains the matching paths (with respect to the from-path) with the according values.
  - queryFrom
```
default CanonicalMap queryFrom(Pattern aRegExp,
                               String aFromPath)
```
    Queries the keys of the instance using a regular expression as of the provided Pattern.
    
    Specified by:
    
    queryFrom in interface PathMap<String>
    
    Parameters:
    
    aRegExp - The regular expression to be used for the query.
    
    aFromPath - The path from where to start querying and extracting the paths.
    
    Returns:
    
    The result contains the matching paths (with respect to the from-path) with the according values.
  - queryFrom
```
default CanonicalMap queryFrom(String aPathQuery,
                               String aFromPath)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    queryFrom in interface PathMap<String>
    
    Parameters:
    
    aPathQuery - The path query including your wildcards.
    
    aFromPath - The path from where to start querying and extracting the paths.
    
    Returns:
    
    The result contains the matching paths (with respect to the from-path) with the according values.
  - queryFrom
```
default CanonicalMap queryFrom(String[] aPathQuery,
                               String[] aFromPath)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    queryFrom in interface PathMap<String>
    
    Parameters:
    
    aPathQuery - The path query including your wildcards.
    
    aFromPath - The path from where to start querying and extracting the paths.
    
    Returns:
    
    The result contains the matching paths (with respect to the from-path) with the according values.
  - queryTo
```
default CanonicalMap queryTo(Collection<?> aPathQuery,
                             String aToPath)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    queryTo in interface PathMap<String>
    
    Parameters:
    
    aPathQuery - The path query including your wildcards.
    
    aToPath - The path where to relocate the result to.
    
    Returns:
    
    The result contains the matching paths (with respect to the to-path) with the according values.
  - queryTo
```
default CanonicalMap queryTo(Object aPathQuery,
                             String aToPath)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    queryTo in interface PathMap<String>
    
    Parameters:
    
    aPathQuery - The path query including your wildcards.
    
    aToPath - The path where to relocate the result to.
    
    Returns:
    
    The result contains the matching paths (with respect to the to-path) with the according values.
  - queryTo
```
default CanonicalMap queryTo(Object[] aPathQuery,
                             String aToPath)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    queryTo in interface PathMap<String>
    
    Parameters:
    
    aPathQuery - The path query including your wildcards.
    
    aToPath - The path where to relocate the result to.
    
    Returns:
    
    The result contains the matching paths (with respect to the to-path) with the according values.
  - queryTo
```
default CanonicalMap queryTo(Pattern aRegExp,
                             String aToPath)
```
    Queries the keys of the instance using a regular expression as of the provided Pattern.
    
    Specified by:
    
    queryTo in interface PathMap<String>
    
    Parameters:
    
    aRegExp - The regular expression to be used for the query.
    
    aToPath - The path where to relocate the result to.
    
    Returns:
    
    The result contains the matching paths (with respect to the to-path) with the according values.
  - queryTo
```
default CanonicalMap queryTo(String aPathQuery,
                             String aToPath)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    queryTo in interface PathMap<String>
    
    Parameters:
    
    aPathQuery - The path query including your wildcards.
    
    aToPath - The path where to relocate the result to.
    
    Returns:
    
    The result contains the matching paths (with respect to the to-path) with the according values.
  - queryTo
```
default CanonicalMap queryTo(String[] aPathQuery,
                             String aToPath)
```
    Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
    
    Specified by:
    
    queryTo in interface PathMap<String>
    
    Parameters:
    
    aPathQuery - The path query including your wildcards.
    
    aToPath - The path where to relocate the result to.
    
    Returns:
    
    The result contains the matching paths (with respect to the to-path) with the according values.
  - retrieveBetween
```
default CanonicalMap retrieveBetween(Collection<?> aFromPath,
                                     Collection<?> aToPath)
```
    Extracts a new PathMap from the elements of this PathMap found below the "from-path". The sub-paths will be relocated to the provided "to-path".
    
    Specified by:
    
    retrieveBetween in interface PathMap<String>
    
    Parameters:
    
    aFromPath - The path from where to start extracting the paths.
    
    aToPath - The path where to relocate the extracted paths to.
    
    Returns:
    
    The PathMap with the elements below the provided path "from-path" relocated to the given "to-path".
  - retrieveBetween
```
default CanonicalMap retrieveBetween(Object aFromPath,
                                     Object aToPath)
```
    Extracts a new PathMap from the elements of this PathMap found below the "from-path". The sub-paths will be relocated to the provided "to-path".
    
    Specified by:
    
    retrieveBetween in interface PathMap<String>
    
    Parameters:
    
    aFromPath - The path from where to start extracting the paths.
    
    aToPath - The path where to relocate the extracted paths to.
    
    Returns:
    
    The PathMap with the elements below the provided path "from-path" relocated to the given "to-path".
  - retrieveBetween
```
default CanonicalMap retrieveBetween(Object[] aFromPath,
                                     Object[] aToPath)
```
    Extracts a new PathMap from the elements of this PathMap found below the "from-path". The sub-paths will be relocated to the provided "to-path".
    
    Specified by:
    
    retrieveBetween in interface PathMap<String>
    
    Parameters:
    
    aFromPath - The path from where to start extracting the paths.
    
    aToPath - The path where to relocate the extracted paths to.
    
    Returns:
    
    The PathMap with the elements below the provided path "from-path" relocated to the given "to-path".
  - retrieveBetween
```
default CanonicalMap retrieveBetween(String aFromPath,
                                     String aToPath)
```
    Extracts a new PathMap from the elements of this PathMap found below the "from-path". The sub-paths will be relocated to the provided "to-path".
    
    Specified by:
    
    retrieveBetween in interface PathMap<String>
    
    Parameters:
    
    aFromPath - The path from where to start extracting the paths.
    
    aToPath - The path where to relocate the extracted paths to.
    
    Returns:
    
    The PathMap with the elements below the provided path "from-path" relocated to the given "to-path".
  - retrieveBetween
```
default CanonicalMap retrieveBetween(String[] aFromPath,
                                     String[] aToPath)
```
    Extracts a new PathMap from the elements of this PathMap found below the "from-path". The sub-paths will be relocated to the provided "to-path".
    
    Specified by:
    
    retrieveBetween in interface PathMap<String>
    
    Parameters:
    
    aFromPath - The path from where to start extracting the paths.
    
    aToPath - The path where to relocate the extracted paths to.
    
    Returns:
    
    The PathMap with the elements below the provided path "from-path" relocated to the given "to-path".
  - retrieveFrom
```
default CanonicalMap retrieveFrom(Collection<?> aPathElements)
```
    Gets the children elements of the provided parent's path elements, excluding the parent's path.
    
    Specified by:
    
    retrieveFrom in interface PathMap<String>
    
    Parameters:
    
    aPathElements - The path elements from where to retrieve the children.
    
    Returns:
    
    The children of the given parent's path.
  - retrieveFrom
```
default CanonicalMap retrieveFrom(Object aParentPath)
```
    Gets the children elements of the provided parent's path, excluding the parent's path.
    
    Specified by:
    
    retrieveFrom in interface PathMap<String>
    
    Parameters:
    
    aParentPath - The path from where to retrieve the children.
    
    Returns:
    
    The children of the given parent's path.
  - retrieveFrom
```
default CanonicalMap retrieveFrom(Object... aPathElements)
```
    Gets the children elements of the provided parent's path elements, excluding the parent's path.
    
    Specified by:
    
    retrieveFrom in interface PathMap<String>
    
    Parameters:
    
    aPathElements - The path elements from where to retrieve the children.
    
    Returns:
    
    The children of the given parent's path.
  - retrieveFrom
```
CanonicalMap retrieveFrom(String aFromPath)
```
    Extracts a new PathMap from the elements of this PathMap found below the "from-path". The sub-paths will be the root paths for the new PathMap. Given we have a value for path "/dog/cat" in the PathMap and we call PathMap.retrieveFrom(String) with "/dog", then the resulting PathMap will contain the path "/cat" for that value.
    
    Specified by:
    
    retrieveFrom in interface PathMap<String>
    
    Parameters:
    
    aFromPath - The path from where to start extracting the paths.
    
    Returns:
    
    The PathMap with the elements below the provided path which are root elements in the new PathMap.
  - retrieveFrom
```
default CanonicalMap retrieveFrom(String... aPathElements)
```
    Gets the children elements of the provided parent's path elements, excluding the parent's path.
    
    Specified by:
    
    retrieveFrom in interface PathMap<String>
    
    Parameters:
    
    aPathElements - The path elements from where to retrieve the children.
    
    Returns:
    
    The children of the given parent's path.
  - retrieveTo
```
default CanonicalMap retrieveTo(Collection<?> aToPathElements)
```
    Extracts a new PathMap from this PathMap's elements with the paths relocated to the provided "to-path". Given we have a value for path "/dog/cat" in the PathMap and we call PathMap.retrieveTo(String) with "/animals", then the resulting PathMap will contain the path "/animals/dog/cat" for that value.
    
    Specified by:
    
    retrieveTo in interface PathMap<String>
    
    Parameters:
    
    aToPathElements - The path elements representing the path where to relocate the paths of this PathMap to.
    
    Returns:
    
    The PathMap with the elements from the provided PathMap with accordingly relocated paths.
  - retrieveTo
```
default CanonicalMap retrieveTo(Object aToPath)
```
    Extracts a new PathMap from this PathMap's elements with the paths relocated to the provided "to-path". Given we have a value for path "/dog/cat" in the PathMap and we call PathMap.retrieveTo(String) with "/animals", then the resulting PathMap will contain the path "/animals/dog/cat" for that value.
    
    Specified by:
    
    retrieveTo in interface PathMap<String>
    
    Parameters:
    
    aToPath - The path where to relocate the paths of this PathMap to.
    
    Returns:
    
    The PathMap with the elements from the provided PathMap with accordingly relocated paths.
  - retrieveTo
```
default CanonicalMap retrieveTo(Object... aToPathElements)
```
    Extracts a new PathMap from this PathMap's elements with the paths relocated to the provided "to-path". Given we have a value for path "/dog/cat" in the PathMap and we call PathMap.retrieveTo(String) with "/animals", then the resulting PathMap will contain the path "/animals/dog/cat" for that value.
    
    Specified by:
    
    retrieveTo in interface PathMap<String>
    
    Parameters:
    
    aToPathElements - The path elements representing the path where to relocate the paths of this PathMap to.
    
    Returns:
    
    The PathMap with the elements from the provided PathMap with accordingly relocated paths.
  - retrieveTo
```
CanonicalMap retrieveTo(String aToPath)
```
    Extracts a new PathMap from this PathMap's elements with the paths relocated to the provided "to-path". Given we have a value for path "/dog/cat" in the PathMap and we call PathMap.retrieveTo(String) with "/animals", then the resulting PathMap will contain the path "/animals/dog/cat" for that value.
    
    Specified by:
    
    retrieveTo in interface PathMap<String>
    
    Parameters:
    
    aToPath - The path where to relocate the paths of this PathMap to.
    
    Returns:
    
    The PathMap with the elements from the provided PathMap with accordingly relocated paths.
  - retrieveTo
```
default CanonicalMap retrieveTo(String... aToPathElements)
```
    Extracts a new PathMap from this PathMap's elements with the paths relocated to the provided "to-path". Given we have a value for path "/dog/cat" in the PathMap and we call PathMap.retrieveTo(String) with "/animals", then the resulting PathMap will contain the path "/animals/dog/cat" for that value.
    
    Specified by:
    
    retrieveTo in interface PathMap<String>
    
    Parameters:
    
    aToPathElements - The path elements representing the path where to relocate the paths of this PathMap to.
    
    Returns:
    
    The PathMap with the elements from the provided PathMap with accordingly relocated paths.
  - getDir
```
default CanonicalMap getDir(Collection<?> aPathElements)
```
    Gets the children elements of the provided parent's path elements, excluding the parent's path.
    
    Specified by:
    
    getDir in interface PathMap<String>
    
    Parameters:
    
    aPathElements - The path elements from where to retrieve the children.
    
    Returns:
    
    The children of the given parent's path.
  - getDir
```
default CanonicalMap getDir(Object aPath)
```
    Gets the children elements of the provided parent's path, excluding the parent's path.
    
    Specified by:
    
    getDir in interface PathMap<String>
    
    Parameters:
    
    aPath - The path from where to retrieve the children.
    
    Returns:
    
    The children of the given parent's path.
  - getDir
```
default CanonicalMap getDir(Object... aPathElements)
```
    Gets the children elements of the provided parent's path elements, excluding the parent's path.
    
    Specified by:
    
    getDir in interface PathMap<String>
    
    Parameters:
    
    aPathElements - The path elements from where to retrieve the children.
    
    Returns:
    
    The children of the given parent's path.
  - getDir
```
default CanonicalMap getDir(String aPath)
```
    Gets the children elements of the provided parent's path elements, excluding the parent's path.
    
    Specified by:
    
    getDir in interface PathMap<String>
    
    Parameters:
    
    aPath - The path from where to retrieve the children.
    
    Returns:
    
    The children of the given parent's path.
  - getDir
```
default CanonicalMap getDir(String... aPathElements)
```
    Gets the children elements of the provided parent's path elements, excluding the parent's path.
    
    Specified by:
    
    getDir in interface PathMap<String>
    
    Parameters:
    
    aPathElements - The path elements from where to retrieve the children.
    
    Returns:
    
    The children of the given parent's path.
  - getDirs
```
default CanonicalMap[] getDirs(Collection<?> aPathElements)
```
    Gets the children elements of the provided parent's path, excluding the parent's path. If the parent pointes to a directory index (as of PathMap.isIndexDir() and the like methods), then the indexed directories are returned with their directory index corresponding to the returned array's index. parent's path.
    
    Specified by:
    
    getDirs in interface PathMap<String>
    
    Parameters:
    
    aPathElements - The path elements from where to retrieve the children.
    
    Returns:
    
    An array with the children directories of the given parent's path: Ff the path points to an indexed directory (as of PathMap.isIndexDir() or the like), then each indexed directory is represented by an element of the array at the according index. If the path does not point to an indexed directory, then the directory itself is returned as the only element in the returned array.
  - getDirs
```
default CanonicalMap[] getDirs(Object aPath)
```
    Gets the children elements of the provided parent's path, excluding the parent's path. If the parent pointes to a directory index (as of PathMap.isIndexDir() and the like methods), then the indexed directories are returned with their directory index corresponding to the returned array's index. parent's path.
    
    Specified by:
    
    getDirs in interface PathMap<String>
    
    Parameters:
    
    aPath - The path from where to retrieve the children.
    
    Returns:
    
    An array with the children directories of the given parent's path: Ff the path points to an indexed directory (as of PathMap.isIndexDir() or the like), then each indexed directory is represented by an element of the array at the according index. If the path does not point to an indexed directory, then the directory itself is returned as the only element in the returned array.
  - getDirs
```
default CanonicalMap[] getDirs(Object... aPathElements)
```
    Gets the children elements of the provided parent's path elements, excluding the parent's path. If the parent pointes to a directory index (as of PathMap.isIndexDir() and the like methods), then the indexed directories are returned with their directory index corresponding to the returned array's index. parent's path.
    
    Specified by:
    
    getDirs in interface PathMap<String>
    
    Parameters:
    
    aPathElements - The path elements from where to retrieve the children.
    
    Returns:
    
    An array with the children directories of the given parent's path: Ff the path points to an indexed directory (as of PathMap.isIndexDir() or the like), then each indexed directory is represented by an element of the array at the according index. If the path does not point to an indexed directory, then the directory itself is returned as the only element in the returned array.
  - getDirs
```
default CanonicalMap[] getDirs(String aPath)
```
    Gets the children elements of the provided parent's path elements, excluding the parent's path. If the parent pointes to a directory index (as of PathMap.isIndexDir() and the like methods), then the indexed directories are returned with their directory index corresponding to the returned array's index. parent's path.
    
    Specified by:
    
    getDirs in interface PathMap<String>
    
    Parameters:
    
    aPath - The path from where to retrieve the children.
    
    Returns:
    
    An array with the children directories of the given parent's path: Ff the path points to an indexed directory (as of PathMap.isIndexDir() or the like), then each indexed directory is represented by an element of the array at the according index. If the path does not point to an indexed directory, then the directory itself is returned as the only element in the returned array.
  - getDirs
```
default CanonicalMap[] getDirs(String... aPathElements)
```
    Gets the children elements of the provided parent's path elements, excluding the parent's path. If the parent pointes to a directory index (as of PathMap.isIndexDir() and the like methods), then the indexed directories are returned with their directory index corresponding to the returned array's index. parent's path.
    
    Specified by:
    
    getDirs in interface PathMap<String>
    
    Parameters:
    
    aPathElements - The path elements from where to retrieve the children.
    
    Returns:
    
    An array with the children directories of the given parent's path: Ff the path points to an indexed directory (as of PathMap.isIndexDir() or the like), then each indexed directory is represented by an element of the array at the according index. If the path does not point to an indexed directory, then the array. directory itself is returned as the only element in the returned
  - toMap
```
default Map<String,String> toMap()
```
    This method creates a Map instance from this CanonicalMap instance's elements (key/value-pairs) as of interoperability reasons.
    
    Specified by:
    
    toMap in interface PathMap<String>
    
    Returns:
    
    A Map object from the herein contained key/value-pairs .
  - toProperties
```
default Properties toProperties()
```
    This method creates a Properties instance from this Properties instance's elements (key/value-pairs) as of interoperability reasons.
    
    Returns:
    
    A Properties object from the herein contained key/value-pairs .

Interface CanonicalMap

Nested Class Summary

Nested classes/interfaces inherited from interface org.refcodes.mixin.AnnotatorAccessor

Nested classes/interfaces inherited from interface org.refcodes.mixin.DelimiterAccessor

Nested classes/interfaces inherited from interface org.refcodes.struct.Dictionary

Nested classes/interfaces inherited from interface org.refcodes.mixin.EmptyAccessor

Nested classes/interfaces inherited from interface org.refcodes.struct.InterOperableMap

Nested classes/interfaces inherited from interface org.refcodes.struct.Keys

Nested classes/interfaces inherited from interface org.refcodes.struct.PathMap

Nested classes/interfaces inherited from interface org.refcodes.mixin.TypeAccessor

Field Summary

Fields inherited from interface org.refcodes.struct.PathMap

Method Summary

Methods inherited from interface org.refcodes.mixin.AnnotatorAccessor

Methods inherited from interface org.refcodes.struct.Containable

Methods inherited from interface org.refcodes.mixin.DelimiterAccessor

Methods inherited from interface org.refcodes.mixin.Dumpable

Methods inherited from interface org.refcodes.mixin.EmptyAccessor

Methods inherited from interface org.refcodes.struct.InterOperableMap

Methods inherited from interface org.refcodes.struct.Keys

Methods inherited from interface org.refcodes.struct.PathMap

Methods inherited from interface org.refcodes.mixin.TypeAccessor

Method Detail

asArray

asArray

asArray

asArray

asBooleanArray

asBooleanArray

asBooleanArray

asBooleanArray

asByteArray

asByteArray

asByteArray

asByteArray

asCharArray

asCharArray

asCharArray

asCharArray

asDoubleArray

asDoubleArray

asDoubleArray

asDoubleArray

asFloatArray

asFloatArray

asFloatArray

asFloatArray

asIntArray

asIntArray

asIntArray

asIntArray

asLongArray

asLongArray

asLongArray

asLongArray

asShortArray

asShortArray

asShortArray

asShortArray

containsValue

getDirAt

getDirAt

getDirAt

getDirAt

getDirAt

getDirAt

query

query

query

query

query

queryBetween

queryBetween

queryBetween

queryBetween

queryBetween

queryBetween

queryFrom

queryFrom

queryFrom