ClassStructMap (org.refcodes:refcodes-struct 2.1.0 API)

All Superinterfaces:

org.refcodes.mixin.AnnotatorAccessor, Containable, org.refcodes.mixin.DelimiterAccessor, Dictionary<String,T>, org.refcodes.mixin.Dumpable, Keys<String,T>, PathMap<Class<?>>, org.refcodes.mixin.TypeAccessor<Class<?>>, TypeModeAccessor

All Known Subinterfaces:

ClassStructMap.ClassStructMapBuilder, ClassStructMap.MutableClassStructMap

All Known Implementing Classes:

ClassStructMapBuilderImpl, ClassStructMapImpl
```
public interface ClassStructMap
extends PathMap<Class<?>>, TypeModeAccessor
```
The ClassStructMap disects a Class into its simple types (considering String and Enum types as well as primitive types).

Nested Class Summary

Nested Classes
Modifier and Type	Interface	Description
`static interface`	`ClassStructMap.ClassStructMapBuilder`	The Interface ClassStructMapBuilder.
`static interface`	`ClassStructMap.MutableClassStructMap`	The Interface MutableClassStructMap.

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.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>

Nested classes/interfaces inherited from interface org.refcodes.struct.TypeModeAccessor
TypeModeAccessor.TypeModeBuilder<B extends TypeModeAccessor.TypeModeBuilder<B>>, TypeModeAccessor.TypeModeMutator, TypeModeAccessor.TypeModeProperty

Field Summary

Fields
Modifier and Type Field Description

static String ARRAY_SELECTOR
- Fields inherited from interface org.refcodes.struct.PathMap
  ANNOTATOR, DELIMITER

Fields
Modifier and Type	Field	Description
`static String`	`ARRAY_SELECTOR`

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method	Description
`default boolean`	`containsValue(Object value)`	This method is defined for the sake of `Map` conformity.
`default String`	`getArraySelector()`	Returns the array selector used in paths to identify an array type.
`default ClassStructMap`	`getCompositeArrayDir()`	Retrieves the directory of the composite type's array represented by the root path.
`default ClassStructMap`	`getCompositeArrayDir(Object aPath)`	Retrieves the directory of the composite type's array represented by the given path.
`default ClassStructMap`	`getCompositeArrayDir(Object... aPathElements)`	Retrieves the directory of the composite type's array represented by the given path.
`default ClassStructMap`	`getCompositeArrayDir(String aPath)`	Retrieves the directory of the composite type's array represented by the given path.
`default ClassStructMap`	`getCompositeArrayDir(String... aPathElements)`	Retrieves the directory of the composite type's array represented by the given path.
`default ClassStructMap`	`getCompositeArrayDir(Collection<?> aPathElements)`	Retrieves the directory of the composite type's array represented by the given path.
`default ClassStructMap`	`getCompositeDir()`	Retrieves the directory of the composite type represented by the root path.
`default ClassStructMap`	`getCompositeDir(Object aPath)`	Retrieves the directory of the composite type represented by the given path.
`default ClassStructMap`	`getCompositeDir(Object... aPathElements)`	Retrieves the directory of the composite type represented by the given path.
`default ClassStructMap`	`getCompositeDir(String aPath)`	Retrieves the directory of the composite type represented by the given path.
`default ClassStructMap`	`getCompositeDir(String... aPathElements)`	Retrieves the directory of the composite type represented by the given path.
`default ClassStructMap`	`getCompositeDir(Collection<?> aPathElements)`	Retrieves the directory of the composite type represented by the given path.
`default ClassStructMap`	`getDir(Object aPath)`	Gets the children elements of the provided parent's path, excluding the parent's path.
`default ClassStructMap`	`getDir(Object... aPathElements)`	Gets the children elements of the provided parent's path elements, excluding the parent's path.
`default ClassStructMap`	`getDir(String aPath)`	Extracts a new `PathMap` from the elements of this `PathMap` found below the "from-path".
`default ClassStructMap`	`getDir(String... aPathElements)`	Gets the children elements of the provided parent's path elements, excluding the parent's path.
`default ClassStructMap`	`getDir(Collection<?> aPathElements)`	Gets the children elements of the provided parent's path elements, excluding the parent's path.
`default ClassStructMap`	`getDirAt(int aIndex)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default ClassStructMap`	`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 ClassStructMap`	`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 ClassStructMap`	`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 ClassStructMap`	`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 ClassStructMap`	`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 Class<?>`	`getPrimitiveArrayType()`	Retrieves the primitive type of the array represented by the root path.
`default Class<?>`	`getPrimitiveArrayType(Object aPath)`	Retrieves the primitive type of the array represented by the given path.
`default Class<?>`	`getPrimitiveArrayType(Object... aPathElements)`	Retrieves the primitive type of the array represented by the given path.
`default Class<?>`	`getPrimitiveArrayType(String aPath)`	Retrieves the primitive type of the array represented by the given path.
`default Class<?>`	`getPrimitiveArrayType(String... aPathElements)`	Retrieves the primitive type of the array represented by the given path.
`default Class<?>`	`getPrimitiveArrayType(Collection<?> aPathElements)`	Retrieves the primitive type of the array represented by the given path.
`default Class<?>`	`getPrimitiveType()`	Retrieves the primitive type represented by the root path.
`default Class<?>`	`getPrimitiveType(Object aPath)`	Retrieves the primitive type represented by the given path.
`default Class<?>`	`getPrimitiveType(Object... aPathElements)`	Retrieves the primitive type represented by the given path.
`default Class<?>`	`getPrimitiveType(String aPath)`	Retrieves the primitive type represented by the given path.
`default Class<?>`	`getPrimitiveType(String... aPathElements)`	Retrieves the primitive type represented by the given path.
`default Class<?>`	`getPrimitiveType(Collection<?> aPathElements)`	Retrieves the primitive type represented by the given path.
`default Class<?>`	`getSimpleArrayType()`	Retrieves the simple type of the array represented by the root path.
`default Class<?>`	`getSimpleArrayType(Object aPath)`	Retrieves the simple type of the array represented by the given path.
`default Class<?>`	`getSimpleArrayType(Object... aPathElements)`	Retrieves the simple type of the array represented by the given path.
`default Class<?>`	`getSimpleArrayType(String aPath)`	Retrieves the simple type of the array represented by the given path.
`default Class<?>`	`getSimpleArrayType(String... aPathElements)`	Retrieves the simple type of the array represented by the given path.
`default Class<?>`	`getSimpleArrayType(Collection<?> aPathElements)`	Retrieves the simple type of the array represented by the given path.
`default Class<?>`	`getSimpleType()`	Retrieves the simple type represented by the root path.
`default Class<?>`	`getSimpleType(Object aPath)`	Retrieves the simple type represented by the given path.
`default Class<?>`	`getSimpleType(Object... aPathElements)`	Retrieves the simple type represented by the given path.
`default Class<?>`	`getSimpleType(String aPath)`	Retrieves the simple type represented by the given path.
`default Class<?>`	`getSimpleType(String... aPathElements)`	Retrieves the simple type represented by the given path.
`default Class<?>`	`getSimpleType(Collection<?> aPathElements)`	Retrieves the simple type represented by the given path.
`default Class<?>`	`getWrapperArrayType()`	Retrieves the wrapper type of the array represented by the root path.
`default Class<?>`	`getWrapperArrayType(Object aPath)`	Retrieves the wrapper type of the array represented by the given path.
`default Class<?>`	`getWrapperArrayType(Object... aPathElements)`	Retrieves the wrapper type of the array represented by the given path.
`default Class<?>`	`getWrapperArrayType(String aPath)`	Retrieves the wrapper type of the array represented by the given path.
`default Class<?>`	`getWrapperArrayType(String... aPathElements)`	Retrieves the wrapper type of the array represented by the given path.
`default Class<?>`	`getWrapperArrayType(Collection<?> aPathElements)`	Retrieves the wrapper type of the array represented by the given path.
`default Class<?>`	`getWrapperType()`	Retrieves the wrapper type represented by the root path.
`default Class<?>`	`getWrapperType(Object aPath)`	Retrieves the wrapper type represented by the given path.
`default Class<?>`	`getWrapperType(Object... aPathElements)`	Retrieves the wrapper type represented by the given path.
`default Class<?>`	`getWrapperType(String aPath)`	Retrieves the wrapper type represented by the given path.
`default Class<?>`	`getWrapperType(String... aPathElements)`	Retrieves the wrapper type represented by the given path.
`default Class<?>`	`getWrapperType(Collection<?> aPathElements)`	Retrieves the wrapper type represented by the given path.
`default boolean`	`isArrayType()`	Determines if the elements below the root path can be treated as an array.
`default boolean`	`isArrayType(Object aPath)`	Determines if the elements below the given path can be treated as an array.
`default boolean`	`isArrayType(Object... aPathElements)`	Determines if the elements below the given path elements can be treated as an array.
`default boolean`	`isArrayType(String aPath)`	Determines if the elements below the given path can be treated as an array.
`default boolean`	`isArrayType(String... aPathElements)`	Determines if the elements below the given path elements can be treated as an array.
`default boolean`	`isArrayType(Collection<?> aPathElements)`	Determines if the elements below the given path elements can be treated as an array.
`default boolean`	`isCompositeArrayDir()`	Determines if the elements below the root path can be treated as a composite type directory.
`default boolean`	`isCompositeArrayDir(Object aPath)`	Determines if the elements below the given path can be treated as a composite type directory.
`default boolean`	`isCompositeArrayDir(Object... aPathElements)`	Determines if the elements below the given path elements can be treated as a composite type directory.
`default boolean`	`isCompositeArrayDir(String aPath)`	Determines if the elements below the given path can be treated as a composite type directory.
`default boolean`	`isCompositeArrayDir(String... aPathElements)`	Determines if the elements below the given path elements can be treated as a composite type directory.
`default boolean`	`isCompositeArrayDir(Collection<?> aPathElements)`	Determines if the elements below the given path elements can be treated as a composite type directory.
`default boolean`	`isCompositeDir()`	Determines if the elements below the root path can be treated as a composite type directory.
`default boolean`	`isCompositeDir(Object aPath)`	Determines if the elements below the given path can be treated as a composite type directory.
`default boolean`	`isCompositeDir(Object... aPathElements)`	Determines if the elements below the given path elements can be treated as a composite type directory.
`default boolean`	`isCompositeDir(String aPath)`	Determines if the elements below the given path can be treated as a composite type directory.
`default boolean`	`isCompositeDir(String... aPathElements)`	Determines if the elements below the given path elements can be treated as a composite type directory.
`default boolean`	`isCompositeDir(Collection<?> aPathElements)`	Determines if the elements below the given path elements can be treated as a composite type directory.
`default boolean`	`isPrimitiveArrayType()`	Determines if the elements below the root path can be treated as a primitive type array.
`default boolean`	`isPrimitiveArrayType(Object aPath)`	Determines if the elements below the given path can be treated as a primitive type array.
`default boolean`	`isPrimitiveArrayType(Object... aPathElements)`	Determines if the elements below the given path elements can be treated as a primitive type array.
`default boolean`	`isPrimitiveArrayType(String aPath)`	Determines if the elements below the given path can be treated as a primitive type array.
`default boolean`	`isPrimitiveArrayType(String... aPathElements)`	Determines if the elements below the given path elements can be treated as a primitive type array.
`default boolean`	`isPrimitiveArrayType(Collection<?> aPathElements)`	Determines if the elements below the given path elements can be treated as a primitive type array.
`default boolean`	`isPrimitiveType()`	Determines if the elements below the root path can be treated as a primitive type.
`default boolean`	`isPrimitiveType(Object aPath)`	Determines if the elements below the given path can be treated as a primitive type.
`default boolean`	`isPrimitiveType(Object... aPathElements)`	Determines if the elements below the given path elements can be treated as a primitive type.
`default boolean`	`isPrimitiveType(String aPath)`	Determines if the elements below the given path can be treated as a primitive type.
`default boolean`	`isPrimitiveType(String... aPathElements)`	Determines if the elements below the given path elements can be treated as a primitive type.
`default boolean`	`isPrimitiveType(Collection<?> aPathElements)`	Determines if the elements below the given path elements can be treated as a primitive type.
`default boolean`	`isSimpleArrayType()`	Determines if the elements below the root path can be treated as a simple type array.
`default boolean`	`isSimpleArrayType(Object aPath)`	Determines if the elements below the given path can be treated as a simple type array.
`default boolean`	`isSimpleArrayType(Object... aPathElements)`	Determines if the elements below the given path elements can be treated as a simple type array.
`default boolean`	`isSimpleArrayType(String aPath)`	Determines if the elements below the given path can be treated as a simple type array.
`default boolean`	`isSimpleArrayType(String... aPathElements)`	Determines if the elements below the given path elements can be treated as a simple type array.
`default boolean`	`isSimpleArrayType(Collection<?> aPathElements)`	Determines if the elements below the given path elements can be treated as a simple type array.
`default boolean`	`isSimpleType()`	Determines if the elements below the root path can be treated as a simple type.
`default boolean`	`isSimpleType(Object aPath)`	Determines if the elements below the given path can be treated as a simple type.
`default boolean`	`isSimpleType(Object... aPathElements)`	Determines if the elements below the given path elements can be treated as a simple type.
`default boolean`	`isSimpleType(String aPath)`	Determines if the elements below the given path can be treated as a simple type.
`default boolean`	`isSimpleType(String... aPathElements)`	Determines if the elements below the given path elements can be treated as a simple type.
`default boolean`	`isSimpleType(Collection<?> aPathElements)`	Determines if the elements below the given path elements can be treated as a simple type.
`default boolean`	`isWrapperArrayType()`	Determines if the elements below the root path can be treated as a wrapper type array.
`default boolean`	`isWrapperArrayType(Object aPath)`	Determines if the elements below the given path can be treated as a wrapper type array.
`default boolean`	`isWrapperArrayType(Object... aPathElements)`	Determines if the elements below the given path elements can be treated as a wrapper type array.
`default boolean`	`isWrapperArrayType(String aPath)`	Determines if the elements below the given path can be treated as a wrapper type array.
`default boolean`	`isWrapperArrayType(String... aPathElements)`	Determines if the elements below the given path elements can be treated as a wrapper type array.
`default boolean`	`isWrapperArrayType(Collection<?> aPathElements)`	Determines if the elements below the given path elements can be treated as a wrapper type array.
`default boolean`	`isWrapperType()`	Determines if the elements below the root path can be treated as a wrapper type.
`default boolean`	`isWrapperType(Object aPath)`	Determines if the elements below the given path can be treated as a wrapper type.
`default boolean`	`isWrapperType(Object... aPathElements)`	Determines if the elements below the given path elements can be treated as a wrapper type.
`default boolean`	`isWrapperType(String aPath)`	Determines if the elements below the given path can be treated as a wrapper type.
`default boolean`	`isWrapperType(String... aPathElements)`	Determines if the elements below the given path elements can be treated as a wrapper type.
`default boolean`	`isWrapperType(Collection<?> aPathElements)`	Determines if the elements below the given path elements can be treated as a wrapper type.
`default ClassStructMap`	`query(Object... aQueryElements)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`query(String aPathQuery)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`query(String... aQueryElements)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`query(Collection<?> aQueryElements)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`query(Pattern aRegExp)`	Queries the keys of the instance using a regular expression as of the provided `Pattern` instance.
`default ClassStructMap`	`queryBetween(Object[] aFromPath, Object[] aPathQuery, Object[] aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`queryBetween(Object aFromPath, Object aPathQuery, Object aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`queryBetween(String[] aFromPath, String[] aPathQuery, String[] aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`queryBetween(String aFromPath, String aPathQuery, String aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`queryBetween(String aFromPath, Pattern aRegExp, String aToPath)`	Queries the keys of the instance using a regular expression as of the provided `Pattern`.
`default ClassStructMap`	`queryBetween(Collection<?> aFromPath, Collection<?> aPathQuery, Collection<?> aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`queryFrom(Object[] aPathQuery, Object[] aFromPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`queryFrom(Object aPathQuery, Object aFromPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`queryFrom(String[] aPathQuery, String[] aFromPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`queryFrom(String aPathQuery, String aFromPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`queryFrom(Collection<?> aPathQuery, Collection<?> aFromPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`queryFrom(Pattern aRegExp, String aFromPath)`	Queries the keys of the instance using a regular expression as of the provided `Pattern`.
`default ClassStructMap`	`queryTo(Object[] aPathQuery, String aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`queryTo(Object aPathQuery, String aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`queryTo(String[] aPathQuery, String aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`queryTo(String aPathQuery, String aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`queryTo(Collection<?> aPathQuery, String aToPath)`	Queries the keys of the instance using the `PathMatcher`' matching patterns, similar to the wildcards '*', '?'
`default ClassStructMap`	`queryTo(Pattern aRegExp, String aToPath)`	Queries the keys of the instance using a regular expression as of the provided `Pattern`.
`default ClassStructMap`	`retrieveBetween(Object[] aFromPath, Object[] aToPath)`	Extracts a new `PathMap` from the elements of this `PathMap` found below the "from-path".
`default ClassStructMap`	`retrieveBetween(Object aFromPath, Object aToPath)`	Extracts a new `PathMap` from the elements of this `PathMap` found below the "from-path".
`default ClassStructMap`	`retrieveBetween(String[] aFromPath, String[] aToPath)`	Extracts a new `PathMap` from the elements of this `PathMap` found below the "from-path".
`default ClassStructMap`	`retrieveBetween(String aFromPath, String aToPath)`	Extracts a new `PathMap` from the elements of this `PathMap` found below the "from-path".
`default ClassStructMap`	`retrieveBetween(Collection<?> aFromPath, Collection<?> aToPath)`	Extracts a new `PathMap` from the elements of this `PathMap` found below the "from-path".
`default ClassStructMap`	`retrieveFrom(Object aParentPath)`	Gets the children elements of the provided parent's path, excluding the parent's path.
`default ClassStructMap`	`retrieveFrom(Object... aPathElements)`	Gets the children elements of the provided parent's path elements, excluding the parent's path.
`ClassStructMap`	`retrieveFrom(String aFromPath)`	Extracts a new `PathMap` from the elements of this `PathMap` found below the "from-path".
`default ClassStructMap`	`retrieveFrom(String... aPathElements)`	Gets the children elements of the provided parent's path elements, excluding the parent's path.
`default ClassStructMap`	`retrieveFrom(Collection<?> aPathElements)`	Gets the children elements of the provided parent's path elements, excluding the parent's path.
`default ClassStructMap`	`retrieveTo(Object aToPath)`	Extracts a new `PathMap` from this `PathMap`'s elements with the paths relocated to the provided "to-path".
`default ClassStructMap`	`retrieveTo(Object... aToPathElements)`	Extracts a new `PathMap` from this `PathMap`'s elements with the paths relocated to the provided "to-path".
`ClassStructMap`	`retrieveTo(String aToPath)`	Extracts a new `PathMap` from this `PathMap`'s elements with the paths relocated to the provided "to-path".
`default ClassStructMap`	`retrieveTo(String... aToPathElements)`	Extracts a new `PathMap` from this `PathMap`'s elements with the paths relocated to the provided "to-path".
`default ClassStructMap`	`retrieveTo(Collection<?> aToPathElements)`	Extracts a new `PathMap` from this `PathMap`'s elements with the paths relocated to the provided "to-path".
`default Map<String,Class<?>>`	`toMap()`	This method creates a `Map` instance from this `ClassStructMap` 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
isEmpty, 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.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, 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, toPathElements, toPathList, toPathStack, toPropertyPath, toType, toType

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

Methods inherited from interface org.refcodes.struct.TypeModeAccessor
getTypeMode

- Field Detail
  - ARRAY_SELECTOR
```
static final String ARRAY_SELECTOR
```
- Method Detail
  - 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,T>
    
    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 ClassStructMap 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<Class<?>>
    
    Parameters:
    
    aIndex - The index which to use.
    
    Returns:
    
    The indexed elements without the indexed path "prefixes".
  - getDirAt
```
default ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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".
  - query
```
default ClassStructMap 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<Class<?>>
    
    Parameters:
    
    aQueryElements - The elements representing the path query including your wildcards.
    
    Returns:
    
    The result contains the matching paths with the according values.
  - query
```
default ClassStructMap 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<Class<?>>
    
    Parameters:
    
    aQueryElements - The elements representing the path query including your wildcards.
    
    Returns:
    
    The result contains the matching paths with the according values.
  - query
```
default ClassStructMap 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<Class<?>>
    
    Parameters:
    
    aRegExp - The regular expression to be used for the query.
    
    Returns:
    
    The matching properties.
  - query
```
default ClassStructMap 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<Class<?>>
    
    Parameters:
    
    aPathQuery - The path query including your wildcards.
    
    Returns:
    
    The result contains the matching paths with the according values.
  - query
```
default ClassStructMap 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<Class<?>>
    
    Parameters:
    
    aQueryElements - The elements representing the path query including your wildcards.
    
    Returns:
    
    The result contains the matching paths with the according values.
  - queryBetween
```
default ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    Parameters:
    
    aPathElements - The path elements from where to retrieve the children.
    
    Returns:
    
    The children of the given parent's path.
  - retrieveFrom
```
default ClassStructMap retrieveFrom(Object aParentPath)
```
    Gets the children elements of the provided parent's path, excluding the parent's path.
    
    Specified by:
    
    retrieveFrom in interface PathMap<Class<?>>
    
    Parameters:
    
    aParentPath - The path from where to retrieve the children.
    
    Returns:
    
    The children of the given parent's path.
  - retrieveFrom
```
default ClassStructMap 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<Class<?>>
    
    Parameters:
    
    aPathElements - The path elements from where to retrieve the children.
    
    Returns:
    
    The children of the given parent's path.
  - retrieveFrom
```
ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    Parameters:
    
    aPathElements - The path elements from where to retrieve the children.
    
    Returns:
    
    The children of the given parent's path.
  - getDir
```
default ClassStructMap 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<Class<?>>
    
    Parameters:
    
    aPathElements - The path elements from where to retrieve the children.
    
    Returns:
    
    The children of the given parent's path.
  - getDir
```
default ClassStructMap getDir(Object aPath)
```
    Gets the children elements of the provided parent's path, excluding the parent's path.
    
    Specified by:
    
    getDir in interface PathMap<Class<?>>
    
    Parameters:
    
    aPath - The path from where to retrieve the children.
    
    Returns:
    
    The children of the given parent's path.
  - getDir
```
default ClassStructMap 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<Class<?>>
    
    Parameters:
    
    aPathElements - The path elements from where to retrieve the children.
    
    Returns:
    
    The children of the given parent's path.
  - getDir
```
default ClassStructMap getDir(String aPath)
```
    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.getDir(String) with "/dog", then the resulting PathMap will contain the path "/cat" for that value.
    
    Specified by:
    
    getDir in interface PathMap<Class<?>>
    
    Parameters:
    
    aPath - 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.
  - getDir
```
default ClassStructMap 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<Class<?>>
    
    Parameters:
    
    aPathElements - The path elements from where to retrieve the children.
    
    Returns:
    
    The children of the given parent's path.
  - retrieveTo
```
default ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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
```
ClassStructMap 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<Class<?>>
    
    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 ClassStructMap 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<Class<?>>
    
    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.
  - toMap
```
default Map<String,Class<?>> toMap()
```
    This method creates a Map instance from this ClassStructMap instance's elements (key/value-pairs) as of interoperability reasons.
    
    Specified by:
    
    toMap in interface PathMap<Class<?>>
    
    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 .
  - getArraySelector
```
default String getArraySelector()
```
    Returns the array selector used in paths to identify an array type.
    
    Returns:
    
    The array selector denoting array types.
  - isArrayType
```
default boolean isArrayType()
```
    Determines if the elements below the root path can be treated as an array.
    
    Returns:
    
    True in case we have an array structure below the root path or not.
  - isArrayType
```
default boolean isArrayType(String... aPathElements)
```
    Determines if the elements below the given path elements can be treated as an array.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have an array structure below the path or not.
  - isArrayType
```
default boolean isArrayType(Collection<?> aPathElements)
```
    Determines if the elements below the given path elements can be treated as an array.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have an array structure below the path or not.
  - isArrayType
```
default boolean isArrayType(Object aPath)
```
    Determines if the elements below the given path can be treated as an array.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have an array structure below the path or not.
  - isArrayType
```
default boolean isArrayType(Object... aPathElements)
```
    Determines if the elements below the given path elements can be treated as an array.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have an array structure below the path or not.
  - isArrayType
```
default boolean isArrayType(String aPath)
```
    Determines if the elements below the given path can be treated as an array.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have an array structure below the path or not.
  - isSimpleArrayType
```
default boolean isSimpleArrayType()
```
    Determines if the elements below the root path can be treated as a simple type array.
    
    Returns:
    
    True in case we have a simple type types) array structure below the root path or not.
  - isSimpleArrayType
```
default boolean isSimpleArrayType(Object aPath)
```
    Determines if the elements below the given path can be treated as a simple type array.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have a simple type types) array structure below the path or not.
  - isSimpleArrayType
```
default boolean isSimpleArrayType(Object... aPathElements)
```
    Determines if the elements below the given path elements can be treated as a simple type array.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a simple type types) array structure below the path or not.
  - isSimpleArrayType
```
default boolean isSimpleArrayType(String... aPathElements)
```
    Determines if the elements below the given path elements can be treated as a simple type array.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a simple type types) array structure below the path or not.
  - isSimpleArrayType
```
default boolean isSimpleArrayType(Collection<?> aPathElements)
```
    Determines if the elements below the given path elements can be treated as a simple type array.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a simple type types) array structure below the path or not.
  - isSimpleArrayType
```
default boolean isSimpleArrayType(String aPath)
```
    Determines if the elements below the given path can be treated as a simple type array.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have a simple type types) array structure below the path or not.
  - getSimpleArrayType
```
default Class<?> getSimpleArrayType()
```
    Retrieves the simple type of the array represented by the root path.
    
    Returns:
    
    The array's simple type in case we have a simple type array structure below the root path, else null
  - getSimpleArrayType
```
default Class<?> getSimpleArrayType(Object aPath)
```
    Retrieves the simple type of the array represented by the given path.
    
    Parameters:
    
    aPath - the path representing an array of simple type.
    
    Returns:
    
    The array's simple type in case we have a simple type array structure below the path, else null.
  - getSimpleArrayType
```
default Class<?> getSimpleArrayType(Object... aPathElements)
```
    Retrieves the simple type of the array represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of simple type.
    
    Returns:
    
    The array's simple type in case we have a simple type array structure below the path, else null.
  - getSimpleArrayType
```
default Class<?> getSimpleArrayType(String... aPathElements)
```
    Retrieves the simple type of the array represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of simple type.
    
    Returns:
    
    The array's simple type in case we have a simple type array structure below the path, else null.
  - getSimpleArrayType
```
default Class<?> getSimpleArrayType(Collection<?> aPathElements)
```
    Retrieves the simple type of the array represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of simple type.
    
    Returns:
    
    The array's simple type in case we have a simple type array structure below the path, else null.
  - getSimpleArrayType
```
default Class<?> getSimpleArrayType(String aPath)
```
    Retrieves the simple type of the array represented by the given path.
    
    Parameters:
    
    aPath - the path representing an array of simple type.
    
    Returns:
    
    The array's simple type in case we have a simple type array structure below the path, else null.
  - isSimpleType
```
default boolean isSimpleType()
```
    Determines if the elements below the root path can be treated as a simple type.
    
    Returns:
    
    True in case we have a simple type types) below the root path or not.
  - isSimpleType
```
default boolean isSimpleType(Object aPath)
```
    Determines if the elements below the given path can be treated as a simple type.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have a simple type types) below the path or not.
  - isSimpleType
```
default boolean isSimpleType(Object... aPathElements)
```
    Determines if the elements below the given path elements can be treated as a simple type.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a simple type types) below the path or not.
  - isSimpleType
```
default boolean isSimpleType(String... aPathElements)
```
    Determines if the elements below the given path elements can be treated as a simple type.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a simple type types) below the path or not.
  - isSimpleType
```
default boolean isSimpleType(Collection<?> aPathElements)
```
    Determines if the elements below the given path elements can be treated as a simple type.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a simple type types) below the path or not.
  - isSimpleType
```
default boolean isSimpleType(String aPath)
```
    Determines if the elements below the given path can be treated as a simple type.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have a simple type types) below the path or not.
  - getSimpleType
```
default Class<?> getSimpleType()
```
    Retrieves the simple type represented by the root path.
    
    Returns:
    
    The simple type in case we have a simple type types) structure below the root path, else null
  - getSimpleType
```
default Class<?> getSimpleType(Object aPath)
```
    Retrieves the simple type represented by the given path.
    
    Parameters:
    
    aPath - the path representing an array of simple type.
    
    Returns:
    
    The simple type in case we have a simple type types) below the path, else null.
  - getSimpleType
```
default Class<?> getSimpleType(Object... aPathElements)
```
    Retrieves the simple type represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of simple type.
    
    Returns:
    
    The simple type in case we have a simple type types) below the path, else null.
  - getSimpleType
```
default Class<?> getSimpleType(String... aPathElements)
```
    Retrieves the simple type represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of simple type.
    
    Returns:
    
    The simple type in case we have a simple type types) below the path, else null.
  - getSimpleType
```
default Class<?> getSimpleType(Collection<?> aPathElements)
```
    Retrieves the simple type represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of simple type.
    
    Returns:
    
    The simple type in case we have a simple type types) below the path, else null.
  - getSimpleType
```
default Class<?> getSimpleType(String aPath)
```
    Retrieves the simple type represented by the given path.
    
    Parameters:
    
    aPath - the path representing an array of simple type.
    
    Returns:
    
    The simple type in case we have a simple type types) below the path, else null.
  - isPrimitiveArrayType
```
default boolean isPrimitiveArrayType()
```
    Determines if the elements below the root path can be treated as a primitive type array.
    
    Returns:
    
    True in case we have a primitive type types) array structure below the root path or not.
  - isPrimitiveArrayType
```
default boolean isPrimitiveArrayType(Object aPath)
```
    Determines if the elements below the given path can be treated as a primitive type array.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have a primitive type types) array structure below the path or not.
  - isPrimitiveArrayType
```
default boolean isPrimitiveArrayType(Object... aPathElements)
```
    Determines if the elements below the given path elements can be treated as a primitive type array.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a primitive type types) array structure below the path or not.
  - isPrimitiveArrayType
```
default boolean isPrimitiveArrayType(String... aPathElements)
```
    Determines if the elements below the given path elements can be treated as a primitive type array.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a primitive type types) array structure below the path or not.
  - isPrimitiveArrayType
```
default boolean isPrimitiveArrayType(Collection<?> aPathElements)
```
    Determines if the elements below the given path elements can be treated as a primitive type array.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a primitive type types) array structure below the path or not.
  - isPrimitiveArrayType
```
default boolean isPrimitiveArrayType(String aPath)
```
    Determines if the elements below the given path can be treated as a primitive type array.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have a primitive type types) array structure below the path or not.
  - getPrimitiveArrayType
```
default Class<?> getPrimitiveArrayType()
```
    Retrieves the primitive type of the array represented by the root path.
    
    Returns:
    
    The array's primitive type in case we have a primitive type array structure below the root path, else null
  - getPrimitiveArrayType
```
default Class<?> getPrimitiveArrayType(Object aPath)
```
    Retrieves the primitive type of the array represented by the given path.
    
    Parameters:
    
    aPath - the path representing an array of primitive type.
    
    Returns:
    
    The array's primitive type in case we have a primitive type array structure below the path, else null.
  - getPrimitiveArrayType
```
default Class<?> getPrimitiveArrayType(Object... aPathElements)
```
    Retrieves the primitive type of the array represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of primitive type.
    
    Returns:
    
    The array's primitive type in case we have a primitive type array structure below the path, else null.
  - getPrimitiveArrayType
```
default Class<?> getPrimitiveArrayType(String... aPathElements)
```
    Retrieves the primitive type of the array represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of primitive type.
    
    Returns:
    
    The array's primitive type in case we have a primitive type array structure below the path, else null.
  - getPrimitiveArrayType
```
default Class<?> getPrimitiveArrayType(Collection<?> aPathElements)
```
    Retrieves the primitive type of the array represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of primitive type.
    
    Returns:
    
    The array's primitive type in case we have a primitive type array structure below the path, else null.
  - getPrimitiveArrayType
```
default Class<?> getPrimitiveArrayType(String aPath)
```
    Retrieves the primitive type of the array represented by the given path.
    
    Parameters:
    
    aPath - the path representing an array of primitive type.
    
    Returns:
    
    The array's primitive type in case we have a primitive type array structure below the path, else null.
  - isPrimitiveType
```
default boolean isPrimitiveType()
```
    Determines if the elements below the root path can be treated as a primitive type.
    
    Returns:
    
    True in case we have a primitive type types) below the root path or not.
  - isPrimitiveType
```
default boolean isPrimitiveType(Object aPath)
```
    Determines if the elements below the given path can be treated as a primitive type.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have a primitive type types) below the path or not.
  - isPrimitiveType
```
default boolean isPrimitiveType(Object... aPathElements)
```
    Determines if the elements below the given path elements can be treated as a primitive type.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a primitive type types) below the path or not.
  - isPrimitiveType
```
default boolean isPrimitiveType(String... aPathElements)
```
    Determines if the elements below the given path elements can be treated as a primitive type.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a primitive type types) below the path or not.
  - isPrimitiveType
```
default boolean isPrimitiveType(Collection<?> aPathElements)
```
    Determines if the elements below the given path elements can be treated as a primitive type.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a primitive type types) below the path or not.
  - isPrimitiveType
```
default boolean isPrimitiveType(String aPath)
```
    Determines if the elements below the given path can be treated as a primitive type.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have a primitive type types) below the path or not.
  - getPrimitiveType
```
default Class<?> getPrimitiveType()
```
    Retrieves the primitive type represented by the root path.
    
    Returns:
    
    The primitive type in case we have a primitive type types) structure below the root path, else null
  - getPrimitiveType
```
default Class<?> getPrimitiveType(Object aPath)
```
    Retrieves the primitive type represented by the given path.
    
    Parameters:
    
    aPath - the path representing an array of primitive type.
    
    Returns:
    
    The primitive type in case we have a primitive type types) below the path, else null.
  - getPrimitiveType
```
default Class<?> getPrimitiveType(Object... aPathElements)
```
    Retrieves the primitive type represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of primitive type.
    
    Returns:
    
    The primitive type in case we have a primitive type types) below the path, else null.
  - getPrimitiveType
```
default Class<?> getPrimitiveType(String... aPathElements)
```
    Retrieves the primitive type represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of primitive type.
    
    Returns:
    
    The primitive type in case we have a primitive type types) below the path, else null.
  - getPrimitiveType
```
default Class<?> getPrimitiveType(Collection<?> aPathElements)
```
    Retrieves the primitive type represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of primitive type.
    
    Returns:
    
    The primitive type in case we have a primitive type types) below the path, else null.
  - getPrimitiveType
```
default Class<?> getPrimitiveType(String aPath)
```
    Retrieves the primitive type represented by the given path.
    
    Parameters:
    
    aPath - the path representing an array of primitive type.
    
    Returns:
    
    The primitive type in case we have a primitive type types) below the path, else null.
  - isWrapperArrayType
```
default boolean isWrapperArrayType()
```
    Determines if the elements below the root path can be treated as a wrapper type array.
    
    Returns:
    
    True in case we have a wrapper type array structure below the root path or not.
  - isWrapperArrayType
```
default boolean isWrapperArrayType(Object aPath)
```
    Determines if the elements below the given path can be treated as a wrapper type array.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have a wrapper type array structure below the path or not.
  - isWrapperArrayType
```
default boolean isWrapperArrayType(Object... aPathElements)
```
    Determines if the elements below the given path elements can be treated as a wrapper type array.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a wrapper type array structure below the path or not.
  - isWrapperArrayType
```
default boolean isWrapperArrayType(String... aPathElements)
```
    Determines if the elements below the given path elements can be treated as a wrapper type array.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a wrapper type array structure below the path or not.
  - isWrapperArrayType
```
default boolean isWrapperArrayType(Collection<?> aPathElements)
```
    Determines if the elements below the given path elements can be treated as a wrapper type array.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a wrapper type array structure below the path or not.
  - isWrapperArrayType
```
default boolean isWrapperArrayType(String aPath)
```
    Determines if the elements below the given path can be treated as a wrapper type array.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have a wrapper type array structure below the path or not.
  - getWrapperArrayType
```
default Class<?> getWrapperArrayType()
```
    Retrieves the wrapper type of the array represented by the root path.
    
    Returns:
    
    The array's wrapper type in case we have a wrapper type array structure below the root path, else null
  - getWrapperArrayType
```
default Class<?> getWrapperArrayType(Object aPath)
```
    Retrieves the wrapper type of the array represented by the given path.
    
    Parameters:
    
    aPath - the path representing an array of wrapper type.
    
    Returns:
    
    The array's wrapper type in case we have a wrapper type array structure below the path, else null.
  - getWrapperArrayType
```
default Class<?> getWrapperArrayType(Object... aPathElements)
```
    Retrieves the wrapper type of the array represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of wrapper type.
    
    Returns:
    
    The array's wrapper type in case we have a wrapper type array structure below the path, else null.
  - getWrapperArrayType
```
default Class<?> getWrapperArrayType(String... aPathElements)
```
    Retrieves the wrapper type of the array represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of wrapper type.
    
    Returns:
    
    The array's wrapper type in case we have a wrapper type array structure below the path, else null.
  - getWrapperArrayType
```
default Class<?> getWrapperArrayType(Collection<?> aPathElements)
```
    Retrieves the wrapper type of the array represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of wrapper type.
    
    Returns:
    
    The array's wrapper type in case we have a wrapper type array structure below the path, else null.
  - getWrapperArrayType
```
default Class<?> getWrapperArrayType(String aPath)
```
    Retrieves the wrapper type of the array represented by the given path.
    
    Parameters:
    
    aPath - the path representing an array of wrapper type.
    
    Returns:
    
    The array's wrapper type in case we have a wrapper type array structure below the path, else null.
  - isWrapperType
```
default boolean isWrapperType()
```
    Determines if the elements below the root path can be treated as a wrapper type.
    
    Returns:
    
    True in case we have a wrapper type below the root path or not.
  - isWrapperType
```
default boolean isWrapperType(Object aPath)
```
    Determines if the elements below the given path can be treated as a wrapper type.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have a wrapper type below the path or not.
  - isWrapperType
```
default boolean isWrapperType(Object... aPathElements)
```
    Determines if the elements below the given path elements can be treated as a wrapper type.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a wrapper type below the path or not.
  - isWrapperType
```
default boolean isWrapperType(String... aPathElements)
```
    Determines if the elements below the given path elements can be treated as a wrapper type.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a wrapper type below the path or not.
  - isWrapperType
```
default boolean isWrapperType(Collection<?> aPathElements)
```
    Determines if the elements below the given path elements can be treated as a wrapper type.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a wrapper type below the path or not.
  - isWrapperType
```
default boolean isWrapperType(String aPath)
```
    Determines if the elements below the given path can be treated as a wrapper type.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have a wrapper type below the path or not.
  - getWrapperType
```
default Class<?> getWrapperType()
```
    Retrieves the wrapper type represented by the root path.
    
    Returns:
    
    The wrapper type in case we have a wrapper type types) structure below the root path, else null
  - getWrapperType
```
default Class<?> getWrapperType(Object aPath)
```
    Retrieves the wrapper type represented by the given path.
    
    Parameters:
    
    aPath - the path representing an array of wrapper type.
    
    Returns:
    
    The wrapper type in case we have a wrapper type types) below the path, else null.
  - getWrapperType
```
default Class<?> getWrapperType(Object... aPathElements)
```
    Retrieves the wrapper type represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of wrapper type.
    
    Returns:
    
    The wrapper type in case we have a wrapper type types) below the path, else null.
  - getWrapperType
```
default Class<?> getWrapperType(String... aPathElements)
```
    Retrieves the wrapper type represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of wrapper type.
    
    Returns:
    
    The wrapper type in case we have a wrapper type types) below the path, else null.
  - getWrapperType
```
default Class<?> getWrapperType(Collection<?> aPathElements)
```
    Retrieves the wrapper type represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of wrapper type.
    
    Returns:
    
    The wrapper type in case we have a wrapper type types) below the path, else null.
  - getWrapperType
```
default Class<?> getWrapperType(String aPath)
```
    Retrieves the wrapper type represented by the given path.
    
    Parameters:
    
    aPath - the path representing an array of wrapper type.
    
    Returns:
    
    The wrapper type in case we have a wrapper type types) below the path, else null.
  - isCompositeArrayDir
```
default boolean isCompositeArrayDir()
```
    Determines if the elements below the root path can be treated as a composite type directory.
    
    Returns:
    
    True in case we have a composite type directory structure below the root path or not.
  - isCompositeArrayDir
```
default boolean isCompositeArrayDir(Object aPath)
```
    Determines if the elements below the given path can be treated as a composite type directory.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have a composite type directory structure below the path or not.
  - isCompositeArrayDir
```
default boolean isCompositeArrayDir(Object... aPathElements)
```
    Determines if the elements below the given path elements can be treated as a composite type directory.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a composite type directory structure below the path or not.
  - isCompositeArrayDir
```
default boolean isCompositeArrayDir(String... aPathElements)
```
    Determines if the elements below the given path elements can be treated as a composite type directory.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a composite type directory structure below the path or not.
  - isCompositeArrayDir
```
default boolean isCompositeArrayDir(Collection<?> aPathElements)
```
    Determines if the elements below the given path elements can be treated as a composite type directory.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a composite type directory structure below the path or not.
  - isCompositeArrayDir
```
default boolean isCompositeArrayDir(String aPath)
```
    Determines if the elements below the given path can be treated as a composite type directory.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have a composite type directory structure below the path or not.
  - getCompositeArrayDir
```
default ClassStructMap getCompositeArrayDir()
```
    Retrieves the directory of the composite type's array represented by the root path.
    
    Returns:
    
    The array's composite type in case we have a composite type array structure below the root path, else null
  - getCompositeArrayDir
```
default ClassStructMap getCompositeArrayDir(Object aPath)
```
    Retrieves the directory of the composite type's array represented by the given path.
    
    Parameters:
    
    aPath - the path representing an array of composite types.
    
    Returns:
    
    The array's composite type in case we have a composite type array structure below the path, else null.
  - getCompositeArrayDir
```
default ClassStructMap getCompositeArrayDir(Object... aPathElements)
```
    Retrieves the directory of the composite type's array represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of composite types.
    
    Returns:
    
    The array's composite type in case we have a composite type array structure below the path, else null.
  - getCompositeArrayDir
```
default ClassStructMap getCompositeArrayDir(String... aPathElements)
```
    Retrieves the directory of the composite type's array represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of composite types.
    
    Returns:
    
    The array's composite type in case we have a composite type array structure below the path, else null.
  - getCompositeArrayDir
```
default ClassStructMap getCompositeArrayDir(Collection<?> aPathElements)
```
    Retrieves the directory of the composite type's array represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an array of composite types.
    
    Returns:
    
    The array's composite type in case we have a composite type array structure below the path, else null.
  - getCompositeArrayDir
```
default ClassStructMap getCompositeArrayDir(String aPath)
```
    Retrieves the directory of the composite type's array represented by the given path.
    
    Parameters:
    
    aPath - the path representing an array of composite types.
    
    Returns:
    
    The array's composite type in case we have a composite type array structure below the path, else null.
  - isCompositeDir
```
default boolean isCompositeDir()
```
    Determines if the elements below the root path can be treated as a composite type directory.
    
    Returns:
    
    True in case we have a composite type directory structure below the root path or not.
  - isCompositeDir
```
default boolean isCompositeDir(Object aPath)
```
    Determines if the elements below the given path can be treated as a composite type directory.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have a composite type directory structure below the path or not.
  - isCompositeDir
```
default boolean isCompositeDir(Object... aPathElements)
```
    Determines if the elements below the given path elements can be treated as a composite type directory.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a composite type directory structure below the path or not.
  - isCompositeDir
```
default boolean isCompositeDir(String... aPathElements)
```
    Determines if the elements below the given path elements can be treated as a composite type directory.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a composite type directory structure below the path or not.
  - isCompositeDir
```
default boolean isCompositeDir(Collection<?> aPathElements)
```
    Determines if the elements below the given path elements can be treated as a composite type directory.
    
    Parameters:
    
    aPathElements - the path elements of the path which to test.
    
    Returns:
    
    True in case we have a composite type directory structure below the path or not.
  - isCompositeDir
```
default boolean isCompositeDir(String aPath)
```
    Determines if the elements below the given path can be treated as a composite type directory.
    
    Parameters:
    
    aPath - the path which to test.
    
    Returns:
    
    True in case we have a composite type directory structure below the path or not.
  - getCompositeDir
```
default ClassStructMap getCompositeDir()
```
    Retrieves the directory of the composite type represented by the root path.
    
    Returns:
    
    The 's composite type in case we have a composite type structure below the root path, else null
  - getCompositeDir
```
default ClassStructMap getCompositeDir(Object aPath)
```
    Retrieves the directory of the composite type represented by the given path.
    
    Parameters:
    
    aPath - the path representing an of composite types.
    
    Returns:
    
    The 's composite type in case we have a composite type structure below the path, else null.
  - getCompositeDir
```
default ClassStructMap getCompositeDir(Object... aPathElements)
```
    Retrieves the directory of the composite type represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an of composite types.
    
    Returns:
    
    The 's composite type in case we have a composite type structure below the path, else null.
  - getCompositeDir
```
default ClassStructMap getCompositeDir(String... aPathElements)
```
    Retrieves the directory of the composite type represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an of composite types.
    
    Returns:
    
    The 's composite type in case we have a composite type structure below the path, else null.
  - getCompositeDir
```
default ClassStructMap getCompositeDir(Collection<?> aPathElements)
```
    Retrieves the directory of the composite type represented by the given path.
    
    Parameters:
    
    aPathElements - the path elements of the path representing an of composite types.
    
    Returns:
    
    The 's composite type in case we have a composite type structure below the path, else null.
  - getCompositeDir
```
default ClassStructMap getCompositeDir(String aPath)
```
    Retrieves the directory of the composite type represented by the given path.
    
    Parameters:
    
    aPath - the path representing an of composite types.
    
    Returns:
    
    The 's composite type in case we have a composite type structure below the path, else null.

Interface ClassStructMap

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.struct.Keys

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

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

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

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.struct.Keys

Methods inherited from interface org.refcodes.struct.PathMap

Methods inherited from interface org.refcodes.mixin.TypeAccessor

Methods inherited from interface org.refcodes.struct.TypeModeAccessor

Field Detail

ARRAY_SELECTOR

Method Detail

containsValue

getDirAt

getDirAt

getDirAt

getDirAt

getDirAt

getDirAt

query

query

query

query

query

queryBetween

queryBetween

queryBetween

queryBetween

queryBetween

queryBetween

queryFrom

queryFrom

queryFrom

queryFrom

queryFrom

queryFrom

queryTo

queryTo

queryTo

queryTo

queryTo

queryTo

retrieveBetween

retrieveBetween

retrieveBetween

retrieveBetween

retrieveBetween

retrieveFrom

retrieveFrom

retrieveFrom

retrieveFrom

retrieveFrom

getDir

getDir

getDir

getDir

getDir

retrieveTo

retrieveTo

retrieveTo

retrieveTo

retrieveTo

toMap

toProperties

getArraySelector

isArrayType

isArrayType

isArrayType

isArrayType