Type Parameters:

T - The type of the terminating elements.

All Superinterfaces:

org.refcodes.mixin.AnnotatorAccessor, org.refcodes.mixin.Clearable, Containable, org.refcodes.mixin.DelimiterAccessor, Dictionary<String,T>, Dictionary.MutableDictionary<String,T>, org.refcodes.mixin.Dumpable, org.refcodes.mixin.EmptyAccessor, Keys<String,T>, Keys.MutableKeys<String,T>, Keys.MutableValues<String,T>, Map<String,T>, PathMap<T>, org.refcodes.mixin.TypeAccessor<T>

All Known Subinterfaces:

CanonicalMap.CanonicalMapBuilder, CanonicalMap.MutableCanonicalMap, ClassStructMap.ClassStructMapBuilder, ClassStructMap.MutableClassStructMap, InterOperableMap.InterOperableMapBuilder<T>, InterOperableMap.MutableInterOperableMap<T>, PathMap.PathMapBuilder<T>, SimpleTypeMap.MutableSimpleTypeMap, SimpleTypeMap.SimpleTypeMapBuilder

All Known Implementing Classes:

CanonicalMapBuilderImpl, ClassStructMapBuilderImpl, PathMapBuilderImpl, SimpleTypeMapBuilderImpl

Enclosing interface:

PathMap<T>
```
public static interface PathMap.MutablePathMap<T>
extends PathMap<T>, Dictionary.MutableDictionary<String,T>, Map<String,T>
```
The PathMap.MutablePathMap adds mutable functionality to the PathMap.

Nested Class Summary
- 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.Dictionary.MutableDictionary
  Dictionary.MutableDictionary.DictionaryBuilder<K,V,B extends Dictionary.MutableDictionary.DictionaryBuilder<K,V,B>>
- Nested classes/interfaces inherited from interface org.refcodes.mixin.EmptyAccessor
  org.refcodes.mixin.EmptyAccessor.EmptyMutator, org.refcodes.mixin.EmptyAccessor.EmptyProperty
- Nested classes/interfaces inherited from interface org.refcodes.struct.Keys
  Keys.MutableKeys<K,V>, Keys.MutableValues<K,V>
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K extends Object,V extends Object>
- Nested classes/interfaces inherited from interface org.refcodes.struct.PathMap
  PathMap.MutablePathMap<T>, PathMap.PathMapBuilder<T>
- Nested classes/interfaces inherited from interface org.refcodes.mixin.TypeAccessor
  org.refcodes.mixin.TypeAccessor.TypeBuilder<T extends Object,B extends org.refcodes.mixin.TypeAccessor.TypeBuilder<T,B>>, org.refcodes.mixin.TypeAccessor.TypeMutator<T extends Object>, org.refcodes.mixin.TypeAccessor.TypeProperty<T extends Object>

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

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method	Description
`default void`	`add(Object[] aPathElements, T aValue)`	Adds the given value to the path not overwriting any existing values: If the path points to a single value (and not to an array), then that value's path is converted to an array representation and the given value is appended to that array.
`default void`	`add(Object aPath, T aValue)`	Adds the given value to the path not overwriting any existing values: If the path points to a single value (and not to an array), then that value's path is converted to an array representation and the given value is appended to that array.
`default void`	`add(String[] aPathElements, T aValue)`	Adds the given value to the path not overwriting any existing values: If the path points to a single value (and not to an array), then that value's path is converted to an array representation and the given value is appended to that array.
`default void`	`add(String aPath, T aValue)`	Adds the given value to the path not overwriting any existing values: If the path points to a single value (and not to an array), then that value's path is converted to an array representation and the given value is appended to that array.
`default void`	`add(Collection<?> aPathElements, T aValue)`	Adds the given value to the path not overwriting any existing values: If the path points to a single value (and not to an array), then that value's path is converted to an array representation and the given value is appended to that array.
`default void`	`add(T aValue)`	Adds an element to the next index as of `PathMap.nextArrayIndex(String[])`.
`default void`	`appendDirTo(Object aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default void`	`appendDirTo(Object[] aPathElements, Object aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default void`	`appendDirTo(Object[] aPathElements, PathMap<T> aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default void`	`appendDirTo(Object aPath, Object aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default void`	`appendDirTo(Object aPath, PathMap<T> aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default void`	`appendDirTo(String[] aPathElements, Object aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default void`	`appendDirTo(String[] aPathElements, PathMap<T> aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default void`	`appendDirTo(String aPath, Object aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default void`	`appendDirTo(String aPath, PathMap<T> aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default void`	`appendDirTo(Collection<?> aPathElements, Object aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default void`	`appendDirTo(Collection<?> aPathElements, PathMap<T> aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default void`	`appendDirTo(PathMap<T> aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default void`	`appendValueTo(Object[] aPathElements, T aValue)`	Adds an element to the next index as of `PathMap.nextArrayIndex(String[])`.
`default void`	`appendValueTo(Object aPath, T aValue)`	Adds an element to the next index as of `PathMap.nextArrayIndex(String[])`.
`default void`	`appendValueTo(String[] aPathElements, T aValue)`	Adds an element to the next index as of `PathMap.nextArrayIndex(String)`.
`default void`	`appendValueTo(String aPath, T aValue)`	Adds an element to the next index as of `PathMap.nextArrayIndex(String)`.
`default void`	`appendValueTo(Collection<?> aPathElements, T aValue)`	Adds an element to the next index as of `PathMap.nextArrayIndex(String[])`.
`default void`	`appendValueTo(T aValue)`	Adds an element to the next index as of `PathMap.nextArrayIndex()`.
`default T`	`delete(Object aPath)`	Removes an element identified by the given key.
`default T`	`delete(Object[] aPathElements)`	Removes an element identified by the given key.
`default T`	`delete(String aPath)`	Removes an element identified by the given key.
`default T`	`delete(String[] aPathElements)`	Removes an element identified by the given key.
`default T`	`delete(Collection<?> aPathElements)`	Removes an element identified by the given key.
`void`	`insert(Object aFrom)`	Inspects the given object and adds all elements found in the given object.
`default void`	`insert(PathMap<T> aFrom)`	Method to semantically emphasize that we support our own types.
`default void`	`insertBetween(Object[] aToPathElements, Object aFrom, Object[] aFromPathElements)`	Same as `insert(Object)` though starting insertion of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`insertBetween(Object[] aToPathElements, PathMap<T> aFrom, Object[] aFromPathElements)`	Method to semantically emphasize that we support our own types.
`default void`	`insertBetween(Object aToPath, Object aFrom, Object aFromPath)`	Same as `insert(Object)` though starting insertion of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`insertBetween(Object aToPath, PathMap<T> aFrom, Object aFromPath)`	Method to semantically emphasize that we support our own types.
`default void`	`insertBetween(String[] aToPathElements, Object aFrom, String[] aFromPathElements)`	Same as `insert(Object)` though starting insertion of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`insertBetween(String[] aToPathElements, PathMap<T> aFrom, String[] aFromPathElements)`	Method to semantically emphasize that we support our own types.
`void`	`insertBetween(String aToPath, Object aFrom, String aFromPath)`	Same as `insert(Object)` though starting insertion of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`insertBetween(String aToPath, PathMap<T> aFrom, String aFromPath)`	Method to semantically emphasize that we support our own types.
`default void`	`insertBetween(Collection<?> aToPathElements, Object aFrom, Collection<?> aFromPathElements)`	Same as `insert(Object)` though starting insertion of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`insertBetween(Collection<?> aToPathElements, PathMap<T> aFrom, Collection<?> aFromPathElements)`	Method to semantically emphasize that we support our own types.
`default void`	`insertFrom(Object aFrom, Object aFromPath)`	Same as `insert(Object)` though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`insertFrom(Object aFrom, Object... aFromPathElements)`	Same as `insert(Object)` though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process.
`void`	`insertFrom(Object aFrom, String aFromPath)`	Same as `insert(Object)` though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`insertFrom(Object aFrom, String... aFromPathElements)`	Same as `insert(Object)` though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`insertFrom(Object aFrom, Collection<?> aFromPathElements)`	Same as `insert(Object)` though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`insertFrom(PathMap<T> aFrom, Object aFromPath)`	Method to semantically emphasize that we support our own types.
`default void`	`insertFrom(PathMap<T> aFrom, Object... aFromPathElements)`	Method to semantically emphasize that we support our own types.
`default void`	`insertFrom(PathMap<T> aFrom, String aFromPath)`	Method to semantically emphasize that we support our own types.
`default void`	`insertFrom(PathMap<T> aFrom, String... aFromPathElements)`	Method to semantically emphasize that we support our own types.
`default void`	`insertFrom(PathMap<T> aFrom, Collection<?> aFromPathElements)`	Method to semantically emphasize that we support our own types.
`default void`	`insertTo(Object[] aToPathElements, Object aFrom)`	Same as `insert(Object)` though starting insertion of object's introspected values at the given "path".
`default void`	`insertTo(Object[] aToPathElements, PathMap<T> aFrom)`	Method to semantically emphasize that we support our own types.
`default void`	`insertTo(Object aToPath, Object aFrom)`	Same as `insert(Object)` though starting insertion of object's introspected values at the given "path".
`default void`	`insertTo(Object aToPath, PathMap<T> aFrom)`	Method to semantically emphasize that we support our own types.
`default void`	`insertTo(String[] aToPathElements, Object aFrom)`	Same as `insert(Object)` though starting insertion of object's introspected values at the given "path".
`default void`	`insertTo(String[] aToPathElements, PathMap<T> aFrom)`	Method to semantically emphasize that we support our own types.
`void`	`insertTo(String aToPath, Object aFrom)`	Same as `insert(Object)` though starting insertion of object's introspected values at the given "path".
`default void`	`insertTo(String aToPath, PathMap<T> aFrom)`	Method to semantically emphasize that we support our own types.
`default void`	`insertTo(Collection<?> aToPathElements, Object aFrom)`	Same as `insert(Object)` though starting insertion of object's introspected values at the given "path".
`default void`	`insertTo(Collection<?> aToPathElements, PathMap<T> aFrom)`	Method to semantically emphasize that we support our own types.
`void`	`merge(Object aFrom)`	Inspects the given object and adds all elements found in the given object in case the targeted path does not exist or points to a null value.
`default void`	`merge(PathMap<T> aFrom)`	Method to semantically emphasize that we support our own types.
`default void`	`mergeBetween(Object[] aToPathElements, Object aFrom, Object[] aFromPathElements)`	Same as `merge(Object)` though starting merging of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`mergeBetween(Object[] aToPathElements, PathMap<T> aFrom, Object[] aFromPathElements)`	Method to semantically emphasize that we support our own types.
`default void`	`mergeBetween(Object aToPath, Object aFrom, Object aFromPath)`	Same as `merge(Object)` though starting merging of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`mergeBetween(Object aToPath, PathMap<T> aFrom, Object aFromPath)`	Method to semantically emphasize that we support our own types.
`default void`	`mergeBetween(String[] aToPathElements, Object aFrom, String[] aFromPathElements)`	Same as `merge(Object)` though starting merging of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`mergeBetween(String[] aToPathElements, PathMap<T> aFrom, String[] aFromPathElements)`	Method to semantically emphasize that we support our own types.
`void`	`mergeBetween(String aToPath, Object aFrom, String aFromPath)`	Same as `merge(Object)` though starting merging of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`mergeBetween(String aToPath, PathMap<T> aFrom, String aFromPath)`	Method to semantically emphasize that we support our own types.
`default void`	`mergeBetween(Collection<?> aToPathElements, Object aFrom, Collection<?> aFromPathElements)`	Same as `merge(Object)` though starting merging of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`mergeBetween(Collection<?> aToPathElements, PathMap<T> aFrom, Collection<?> aFromPathElements)`	Method to semantically emphasize that we support our own types.
`default void`	`mergeFrom(Object aFrom, Object aFromPath)`	Same as `merge(Object)` though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`mergeFrom(Object aFrom, Object... aFromPathElements)`	Same as `merge(Object)` though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process.
`void`	`mergeFrom(Object aFrom, String aFromPath)`	Same as `merge(Object)` though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`mergeFrom(Object aFrom, String... aFromPathElements)`	Same as `merge(Object)` though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`mergeFrom(Object aFrom, Collection<?> aFromPathElements)`	Same as `merge(Object)` though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process.
`default void`	`mergeFrom(PathMap<T> aFrom, Object aFromPath)`	Method to semantically emphasize that we support our own types.
`default void`	`mergeFrom(PathMap<T> aFrom, Object... aFromPathElements)`	Method to semantically emphasize that we support our own types.
`default void`	`mergeFrom(PathMap<T> aFrom, String aFromPath)`	Method to semantically emphasize that we support our own types.
`default void`	`mergeFrom(PathMap<T> aFrom, String... aFromPathElements)`	Method to semantically emphasize that we support our own types.
`default void`	`mergeFrom(PathMap<T> aFrom, Collection<?> aFromPathElements)`	Method to semantically emphasize that we support our own types.
`default void`	`mergeTo(Object[] aToPathElements, Object aFrom)`	Same as `merge(Object)` though starting merging of object's introspected values at the given "path".
`default void`	`mergeTo(Object[] aToPathElements, PathMap<T> aFrom)`	Method to semantically emphasize that we support our own types.
`default void`	`mergeTo(Object aToPath, Object aFrom)`	Same as `merge(Object)` though starting merging of object's introspected values at the given "path".
`default void`	`mergeTo(Object aToPath, PathMap<T> aFrom)`	Method to semantically emphasize that we support our own types.
`default void`	`mergeTo(String[] aToPathElements, Object aFrom)`	Same as `merge(Object)` though starting merging of object's introspected values at the given "path".
`default void`	`mergeTo(String[] aToPathElements, PathMap<T> aFrom)`	Method to semantically emphasize that we support our own types.
`void`	`mergeTo(String aToPath, Object aFrom)`	Same as `merge(Object)` though starting merging of object's introspected values at the given "path".
`default void`	`mergeTo(String aToPath, PathMap<T> aFrom)`	Method to semantically emphasize that we support our own types.
`default void`	`mergeTo(Collection<?> aToPathElements, Object aFrom)`	Same as `merge(Object)` though starting merging of object's introspected values at the given "path".
`default void`	`mergeTo(Collection<?> aToPathElements, PathMap<T> aFrom)`	Method to semantically emphasize that we support our own types.
`default T`	`put(Object[] aPathElements, T aValue)`	Puts the given value into the child's path, relative to the given parent's path.
`default T`	`put(String[] aPathElements, T aValue)`	Puts the given value into the child's path, relative to the given parent's path.
`default T`	`put(Collection<?> aPathElements, T aValue)`	Puts the given value into the child's path, relative to the given parent's path.
`default T`	`put(Relation<String,T> aRelation)`	Adds the given element related to the given key.
`default T[]`	`putArray(Object[] aPathElements, Collection<T> aValues)`	Sets the leaves below the given path in an array and replaces any existing array.
`default T[]`	`putArray(Object[] aPathElements, T[] aValues)`	Sets the leaves below the given path in an array and replaces any existing array.
`default T[]`	`putArray(Object aPath, Collection<T> aValues)`	Sets the leaves below the given path in an array and replaces any existing array.
`default T[]`	`putArray(Object aPath, T[] aValues)`	Sets the leaves below the given path in an array and replaces any existing array.
`default T[]`	`putArray(String[] aPathElements, Collection<T> aValues)`	Sets the leaves below the given path in an array and replaces any existing array.
`default T[]`	`putArray(String[] aPathElements, T[] aValues)`	Sets the leaves below the given path in an array and replaces any existing array.
`default T[]`	`putArray(String aPath, Collection<T> aValues)`	Sets the leaves below the given path in an array and replaces any existing array.
`default T[]`	`putArray(String aPath, T[] aValues)`	Sets the leaves below the given path in an array and replaces any existing array.
`default T[]`	`putArray(Collection<?> aPathElements, Collection<T> aValues)`	Sets the leaves below the given path in an array and replaces any existing array.
`default T[]`	`putArray(Collection<?> aPathElements, T[] aValues)`	Sets the leaves below the given path in an array and replaces any existing array.
`default T[]`	`putArray(Collection<T> aValues)`	Applies the `putArray(Object[])` method for the root path "/".
`default T[]`	`putArray(T[] aValues)`	Applies the `putArray(Object[])` method for the root path "/".
`default PathMap<T>`	`putDirAt(int aIndex, Object aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default PathMap<T>`	`putDirAt(int aIndex, PathMap<T> aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default PathMap<T>`	`putDirAt(Object[] aPathElements, int aIndex, Object aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default PathMap<T>`	`putDirAt(Object[] aPathElements, int aIndex, PathMap<T> aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default PathMap<T>`	`putDirAt(Object aPath, int aIndex, Object aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default PathMap<T>`	`putDirAt(Object aPath, int aIndex, PathMap<T> aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default PathMap<T>`	`putDirAt(String[] aPathElements, int aIndex, Object aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default PathMap<T>`	`putDirAt(String[] aPathElements, int aIndex, PathMap<T> aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default PathMap<T>`	`putDirAt(String aPath, int aIndex, Object aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default PathMap<T>`	`putDirAt(String aPath, int aIndex, PathMap<T> aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default PathMap<T>`	`putDirAt(Collection<?> aPathElements, int aIndex, Object aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default PathMap<T>`	`putDirAt(Collection<?> aPathElements, int aIndex, PathMap<T> aDir)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default T`	`putValueAt(int aIndex, T aValue)`	Puts a value below the root path at the given index as of `putArray(String, Object[])`.
`default T`	`putValueAt(Object[] aPathElements, int aIndex, T aValue)`	Puts a value below the path at the given index as of `putArray(String, Object[])`.
`default T`	`putValueAt(Object aPath, int aIndex, T aValue)`	Puts a value below the path at the given index as of `putArray(String, Object[])`.
`default T`	`putValueAt(String[] aPathElements, int aIndex, T aValue)`	Puts a value below the path at the given index as of `putArray(String, Object[])`.
`default T`	`putValueAt(String aPath, int aIndex, T aValue)`	Puts a value below the path at the given index as of `putArray(String, Object[])`.
`default T`	`putValueAt(Collection<?> aPathElements, int aIndex, T aValue)`	Puts a value below the path at the given index as of `putArray(String, Object[])`.
`default T`	`remove(Object... aPathElements)`	Removes the property as of `Map.remove(Object)` for the provided path elements (as of `PathMap.toPath(Object...)`).
`default T`	`remove(String... aPathElements)`	Removes the property as of `Map.remove(Object)` for the provided path elements (as of `PathMap.toPath(String...)`).
`default T`	`remove(String aPathElement1, String aPathElement2)`	Removes the property as of `Map.remove(Object)` for the provided path elements (as of `PathMap.toPath(String...)`).
`default PathMap<T>`	`removeAll(Object aPathQuery)`	Removes all elements which's keys match the provided path query.
`default PathMap<T>`	`removeAll(Object... aPathQueryElements)`	Removes all elements which's keys match the provided path query.
`default PathMap<T>`	`removeAll(String aPathQuery)`	Removes all elements which's keys match the provided path query.
`default PathMap<T>`	`removeAll(String... aPathQueryElements)`	Removes all elements which's keys match the provided path query.
`default PathMap<T>`	`removeAll(Collection<?> aPathQueryElements)`	Removes all elements which's keys match the provided path query.
`default PathMap<T>`	`removeAll(Pattern aRegExp)`	Removes all elements which's keys match the provided regular expression: Queries the keys of the instance using the provided `Pattern`.
`default PathMap<T>`	`removeDirAt(int aIndex)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default PathMap<T>`	`removeDirAt(Object[] aPathElements, int aIndex)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default PathMap<T>`	`removeDirAt(Object aPath, int aIndex)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default PathMap<T>`	`removeDirAt(String[] aPathElements, int aIndex)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default PathMap<T>`	`removeDirAt(String aPath, int aIndex)`	An indexed directory represents all elements which begin with a path which's last path element represents an index.
`default PathMap<T>`	`removeFrom(Object aPath)`	Removes all properties below the provided path and returns the `PathMap` with the removed elements, by which the paths exclude the parent's path.
`default PathMap<T>`	`removeFrom(Object... aPathElements)`	Removes all properties below the provided path and returns the `PathMap` with the removed elements, by which the paths exclude the parent's path.
`default PathMap<T>`	`removeFrom(String aPath)`	Removes all properties below the provided path and returns the `PathMap` with the removed elements, by which the paths exclude the parent's path.
`default PathMap<T>`	`removeFrom(String... aPathElements)`	Removes all properties below the provided path and returns the `PathMap` with the removed elements, by which the paths exclude the parent's path.
`default PathMap<T>`	`removeFrom(Collection<?> aPathElements)`	Removes all properties below the provided path and returns the `PathMap` with the removed elements, by which the paths exclude the parent's path.
`default PathMap<T>`	`removePaths(String... aPaths)`	Removes the paths contained in the provided collection.
`default PathMap<T>`	`removePaths(Collection<?> aPaths)`	Removes the paths contained in the provided collection.
`default T`	`removeValueAt(int aIndex)`	Removes the value of an array at the root path with the given array index.
`default T`	`removeValueAt(Object[] aPathElements, int aIndex)`	Removes the value of an array at the given path path with the given array index.
`default T`	`removeValueAt(Object aPath, int aIndex)`	Removes the value of an array at the given path path with the given array index.
`default T`	`removeValueAt(String[] aPathElements, int aIndex)`	Removes the value of an array at the given path path with the given array index.
`default T`	`removeValueAt(String aPath, int aIndex)`	Removes the value of an array at the given path path with the given array index.
`default String`	`toSourceCode()`	Beta, don't know whether to keep this or not: Creates a class (a `String` text to be copy'n'pasted) with getters and setters for the herein contained paths and their values.
`default String`	`toSourceCode(String aClassName, String aPackage)`	Beta, don't know whether to keep this or not: Creates a class (a `String` text to be copy'n'pasted) with getters and setters for the herein contained paths and their values.

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

Methods inherited from interface org.refcodes.mixin.Clearable
clear

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

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

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

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

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

Methods inherited from interface org.refcodes.struct.Keys.MutableValues
put

Methods inherited from interface java.util.Map
clear, compute, computeIfAbsent, computeIfPresent, containsKey, containsValue, entrySet, equals, forEach, get, getOrDefault, hashCode, isEmpty, keySet, merge, put, putAll, putIfAbsent, remove, remove, replace, replace, replaceAll, size, values

Methods inherited from interface org.refcodes.struct.PathMap
children, children, children, children, children, children, containsKey, containsKey, containsKey, dirs, dirs, dirs, dirs, dirs, dirs, findPaths, fromExternalPath, get, get, get, getArray, getArray, getArray, getArray, getArray, getArrayIndexes, getArrayIndexes, getArrayIndexes, getArrayIndexes, getArrayIndexes, getArrayOr, getArrayOr, getArrayOr, getArrayOr, getArrayOr, getDir, getDir, getDir, getDir, getDir, getDirAt, getDirAt, getDirAt, getDirAt, getDirAt, getDirAt, getDirIndexes, getDirIndexes, getDirIndexes, getDirIndexes, getDirIndexes, getDirs, getDirs, getDirs, getDirs, getDirs, 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, query, query, query, query, query, queryBetween, queryBetween, queryBetween, queryBetween, queryBetween, queryBetween, queryFrom, queryFrom, queryFrom, queryFrom, queryFrom, queryFrom, queryPaths, queryPaths, queryPaths, queryPaths, queryPaths, queryPaths, queryTo, queryTo, queryTo, queryTo, queryTo, queryTo, retrieveBetween, retrieveBetween, retrieveBetween, retrieveBetween, retrieveBetween, retrieveFrom, retrieveFrom, retrieveFrom, retrieveFrom, retrieveFrom, retrieveTo, retrieveTo, retrieveTo, retrieveTo, retrieveTo, 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, toMap, toNormalizedPath, toParentPath, toPath, toPath, toPath, toPath, toPathElements, toPathList, toPathStack, toPropertyPath, toType, toType, toType, toType, toType, toType, toType, toType

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

- Method Detail
  - add
```
default void add(Collection<?> aPathElements,
                 T aValue)
```
    Adds the given value to the path not overwriting any existing values: If the path points to a single value (and not to an array), then that value's path is converted to an array representation and the given value is appended to that array.
    
    Parameters:
    
    aPathElements - The path elements to which to add the element.
    
    aValue - The value to be added.
  - add
```
default void add(Object aPath,
                 T aValue)
```
    Adds the given value to the path not overwriting any existing values: If the path points to a single value (and not to an array), then that value's path is converted to an array representation and the given value is appended to that array.
    
    Parameters:
    
    aPath - The path to which to add the element.
    
    aValue - The value to be added.
  - add
```
default void add(Object[] aPathElements,
                 T aValue)
```
    Adds the given value to the path not overwriting any existing values: If the path points to a single value (and not to an array), then that value's path is converted to an array representation and the given value is appended to that array.
    
    Parameters:
    
    aPathElements - The path elements to which to add the element.
    
    aValue - The value to be added.
  - add
```
default void add(String aPath,
                 T aValue)
```
    Adds the given value to the path not overwriting any existing values: If the path points to a single value (and not to an array), then that value's path is converted to an array representation and the given value is appended to that array.
    
    Parameters:
    
    aPath - The path to which to add the element.
    
    aValue - The value to be added.
  - add
```
default void add(String[] aPathElements,
                 T aValue)
```
    Adds the given value to the path not overwriting any existing values: If the path points to a single value (and not to an array), then that value's path is converted to an array representation and the given value is appended to that array.
    
    Parameters:
    
    aPathElements - The path elements to which to add the element.
    
    aValue - The value to be added.
  - add
```
default void add(T aValue)
```
    Adds an element to the next index as of PathMap.nextArrayIndex(String[]). If the path points to a single value (and not to an array), then that value's path is converted to an array representation and the given value is appended to that array.
    
    Parameters:
    
    aValue - The value to be appended.
  - appendDirTo
```
default void appendDirTo(Collection<?> aPathElements,
                         Object aDir)
                  throws IllegalArgumentException
```
    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. Adds all given properties to the next index as of PathMap.nextDirIndex(String[]).
    
    Parameters:
    
    aPathElements - The path elements of the path to which to append the given elements.
    
    aDir - The values to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - appendDirTo
```
default void appendDirTo(Collection<?> aPathElements,
                         PathMap<T> aDir)
                  throws IllegalArgumentException
```
    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. Adds all given properties to the next index as of PathMap.nextDirIndex(String[]).
    
    Parameters:
    
    aPathElements - The path elements of the path to which to append the given elements.
    
    aDir - The values to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - appendDirTo
```
default void appendDirTo(Object aDir)
                  throws IllegalArgumentException
```
    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. Adds all given properties to the next index as of PathMap.nextDirIndex().
    
    Parameters:
    
    aDir - The values to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir().
  - appendDirTo
```
default void appendDirTo(Object aPath,
                         Object aDir)
                  throws IllegalArgumentException
```
    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. Adds all given properties to the next index as of PathMap.nextDirIndex(String[]).
    
    Parameters:
    
    aPath - The path to which to append the given elements.
    
    aDir - The values to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - appendDirTo
```
default void appendDirTo(Object aPath,
                         PathMap<T> aDir)
                  throws IllegalArgumentException
```
    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. Adds all given properties to the next index as of PathMap.nextDirIndex(String[]).
    
    Parameters:
    
    aPath - The path to which to append the given elements.
    
    aDir - The values to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - appendDirTo
```
default void appendDirTo(Object[] aPathElements,
                         Object aDir)
                  throws IllegalArgumentException
```
    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. Adds all given properties to the next index as of PathMap.nextDirIndex(String[]).
    
    Parameters:
    
    aPathElements - The path elements of the path to which to append the given elements.
    
    aDir - The values to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - appendDirTo
```
default void appendDirTo(Object[] aPathElements,
                         PathMap<T> aDir)
                  throws IllegalArgumentException
```
    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. Adds all given properties to the next index as of PathMap.nextDirIndex(String[]).
    
    Parameters:
    
    aPathElements - The path elements of the path to which to append the given elements.
    
    aDir - The values to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - appendDirTo
```
default void appendDirTo(PathMap<T> aDir)
                  throws IllegalArgumentException
```
    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. Adds all given properties to the next index as of PathMap.nextDirIndex().
    
    Parameters:
    
    aDir - The values to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir().
  - appendDirTo
```
default void appendDirTo(String aPath,
                         Object aDir)
                  throws IllegalArgumentException
```
    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. Adds all given properties to the next index as of PathMap.nextDirIndex(String).
    
    Parameters:
    
    aPath - The path to which to append the given elements.
    
    aDir - The values to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - appendDirTo
```
default void appendDirTo(String aPath,
                         PathMap<T> aDir)
                  throws IllegalArgumentException
```
    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. Adds all given properties to the next index as of PathMap.nextDirIndex(String).
    
    Parameters:
    
    aPath - The path to which to append the given elements.
    
    aDir - The values to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - appendDirTo
```
default void appendDirTo(String[] aPathElements,
                         Object aDir)
                  throws IllegalArgumentException
```
    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. Adds all given properties to the next index as of PathMap.nextDirIndex(String).
    
    Parameters:
    
    aPathElements - The path elements of the path to which to append the given elements.
    
    aDir - The values to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - appendDirTo
```
default void appendDirTo(String[] aPathElements,
                         PathMap<T> aDir)
                  throws IllegalArgumentException
```
    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. Adds all given properties to the next index as of PathMap.nextDirIndex(String).
    
    Parameters:
    
    aPathElements - The path elements of the path to which to append the given elements.
    
    aDir - The values to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - appendValueTo
```
default void appendValueTo(Collection<?> aPathElements,
                           T aValue)
                    throws IllegalArgumentException
```
    Adds an element to the next index as of PathMap.nextArrayIndex(String[]).
    
    Parameters:
    
    aPathElements - The path elements of the path to which to append the next indexed element.
    
    aValue - The value to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isArray(String).
  - appendValueTo
```
default void appendValueTo(Object aPath,
                           T aValue)
                    throws IllegalArgumentException
```
    Adds an element to the next index as of PathMap.nextArrayIndex(String[]).
    
    Parameters:
    
    aPath - The path to which to append the next indexed element.
    
    aValue - The value to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isArray(String).
  - appendValueTo
```
default void appendValueTo(Object[] aPathElements,
                           T aValue)
                    throws IllegalArgumentException
```
    Adds an element to the next index as of PathMap.nextArrayIndex(String[]).
    
    Parameters:
    
    aPathElements - The path elements of the path to which to append the next indexed element.
    
    aValue - The value to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isArray(String).
  - appendValueTo
```
default void appendValueTo(String aPath,
                           T aValue)
                    throws IllegalArgumentException
```
    Adds an element to the next index as of PathMap.nextArrayIndex(String).
    
    Parameters:
    
    aPath - The path to which to append the next indexed element.
    
    aValue - The value to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isArray(String).
  - appendValueTo
```
default void appendValueTo(String[] aPathElements,
                           T aValue)
                    throws IllegalArgumentException
```
    Adds an element to the next index as of PathMap.nextArrayIndex(String).
    
    Parameters:
    
    aPathElements - The path elements of the path to which to append the next indexed element.
    
    aValue - The value to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isArray(String).
  - appendValueTo
```
default void appendValueTo(T aValue)
                    throws IllegalArgumentException
```
    Adds an element to the next index as of PathMap.nextArrayIndex().
    
    Parameters:
    
    aValue - The value to be appended.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isArray().
  - delete
```
default T delete(Collection<?> aPathElements)
```
    Removes an element identified by the given key.
    
    Parameters:
    
    aPathElements - The path elements of the path which's element is to be removed.
    
    Returns:
    
    The value being removed.
  - delete
```
default T delete(Object aPath)
```
    Removes an element identified by the given key.
    
    Parameters:
    
    aPath - The path which's element is to be removed.
    
    Returns:
    
    The value being removed.
  - delete
```
default T delete(Object[] aPathElements)
```
    Removes an element identified by the given key.
    
    Parameters:
    
    aPathElements - The path elements of the path which's element is to be removed.
    
    Returns:
    
    The value being removed.
  - delete
```
default T delete(String aPath)
```
    Removes an element identified by the given key.
    
    Specified by:
    
    delete in interface Keys.MutableKeys<String,T>
    
    Parameters:
    
    aPath - The key which's element is to be removed.
    
    Returns:
    
    The value being removed.
  - delete
```
default T delete(String[] aPathElements)
```
    Removes an element identified by the given key.
    
    Parameters:
    
    aPathElements - The path elements of the path which's element is to be removed.
    
    Returns:
    
    The value being removed.
  - insert
```
void insert(Object aFrom)
```
    Inspects the given object and adds all elements found in the given object. Elements of type Map, Collection and arrays are identified and handled as of their type: The path for each value in a Map is appended with its according key. The path for each value in a Collection or array is appended with its according index of occurrence (in case of a List or an array, its actual index). In case of reflection, the path for each member is appended with its according mamber's name. All elements (e.g. the members and values) are inspected recursively which results in the according paths of the terminating values.
    
    Parameters:
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
  - insert
```
default void insert(PathMap<T> aFrom)
```
    Method to semantically emphasize that we support our own types. Actually delegates to insert(Object).
    
    Parameters:
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
  - insertBetween
```
default void insertBetween(Collection<?> aToPathElements,
                           Object aFrom,
                           Collection<?> aFromPathElements)
```
    Same as insert(Object) though starting insertion of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the "from-path" path, them start with the given "to-path".
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to insert the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - insertBetween
```
default void insertBetween(Collection<?> aToPathElements,
                           PathMap<T> aFrom,
                           Collection<?> aFromPathElements)
```
    Method to semantically emphasize that we support our own types. Actually delegates to insertBetween(String, Object, String).
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to insert the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - insertBetween
```
default void insertBetween(Object aToPath,
                           Object aFrom,
                           Object aFromPath)
```
    Same as insert(Object) though starting insertion of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the "from-path" path, them start with the given "to-path".
    
    Parameters:
    
    aToPath - The sub-path where to insert the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPath - The path from where to start adding elements of the provided object.
  - insertBetween
```
default void insertBetween(Object aToPath,
                           PathMap<T> aFrom,
                           Object aFromPath)
```
    Method to semantically emphasize that we support our own types. Actually delegates to insertBetween(String, Object, String).
    
    Parameters:
    
    aToPath - The sub-path where to insert the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPath - The path from where to start adding elements of the provided object.
  - insertBetween
```
default void insertBetween(Object[] aToPathElements,
                           Object aFrom,
                           Object[] aFromPathElements)
```
    Same as insert(Object) though starting insertion of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the "from-path" path, them start with the given "to-path".
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to insert the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - insertBetween
```
default void insertBetween(Object[] aToPathElements,
                           PathMap<T> aFrom,
                           Object[] aFromPathElements)
```
    Method to semantically emphasize that we support our own types. Actually delegates to insertBetween(String, Object, String).
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to insert the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - insertBetween
```
void insertBetween(String aToPath,
                   Object aFrom,
                   String aFromPath)
```
    Same as insert(Object) though starting insertion of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the "from-path" path, them start with the given "to-path".
    
    Parameters:
    
    aToPath - The sub-path where to insert the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPath - The path from where to start adding elements of the provided object.
  - insertBetween
```
default void insertBetween(String aToPath,
                           PathMap<T> aFrom,
                           String aFromPath)
```
    Method to semantically emphasize that we support our own types. Actually delegates to insertBetween(String, Object, String).
    
    Parameters:
    
    aToPath - The sub-path where to insert the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPath - The path from where to start adding elements of the provided object.
  - insertBetween
```
default void insertBetween(String[] aToPathElements,
                           Object aFrom,
                           String[] aFromPathElements)
```
    Same as insert(Object) though starting insertion of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the "from-path" path, them start with the given "to-path".
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to insert the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - insertBetween
```
default void insertBetween(String[] aToPathElements,
                           PathMap<T> aFrom,
                           String[] aFromPathElements)
```
    Method to semantically emphasize that we support our own types. Actually delegates to insertBetween(String, Object, String).
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to insert the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - insertFrom
```
default void insertFrom(Object aFrom,
                        Collection<?> aFromPathElements)
```
    Same as insert(Object) though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the provided path.
    
    Parameters:
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - insertFrom
```
default void insertFrom(Object aFrom,
                        Object aFromPath)
```
    Same as insert(Object) though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the provided path.
    
    Parameters:
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPath - The path from where to start adding elements of the provided object.
  - insertFrom
```
default void insertFrom(Object aFrom,
                        Object... aFromPathElements)
```
    Same as insert(Object) though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the provided path.
    
    Parameters:
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - insertFrom
```
void insertFrom(Object aFrom,
                String aFromPath)
```
    Same as insert(Object) though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the provided path.
    
    Parameters:
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPath - The path from where to start adding elements of the provided object.
  - insertFrom
```
default void insertFrom(Object aFrom,
                        String... aFromPathElements)
```
    Same as insert(Object) though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the provided path.
    
    Parameters:
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - insertFrom
```
default void insertFrom(PathMap<T> aFrom,
                        Collection<?> aFromPathElements)
```
    Method to semantically emphasize that we support our own types. Actually delegates to insertFrom(Object, String).
    
    Parameters:
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - insertFrom
```
default void insertFrom(PathMap<T> aFrom,
                        Object aFromPath)
```
    Method to semantically emphasize that we support our own types. Actually delegates to insertFrom(Object, String).
    
    Parameters:
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPath - The path from where to start adding elements of the provided object.
  - insertFrom
```
default void insertFrom(PathMap<T> aFrom,
                        Object... aFromPathElements)
```
    Method to semantically emphasize that we support our own types. Actually delegates to insertFrom(Object, String).
    
    Parameters:
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - insertFrom
```
default void insertFrom(PathMap<T> aFrom,
                        String aFromPath)
```
    Method to semantically emphasize that we support our own types. Actually delegates to insertFrom(Object, String).
    
    Parameters:
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPath - The path from where to start adding elements of the provided object.
  - insertFrom
```
default void insertFrom(PathMap<T> aFrom,
                        String... aFromPathElements)
```
    Method to semantically emphasize that we support our own types. Actually delegates to insertFrom(Object, String).
    
    Parameters:
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - insertTo
```
default void insertTo(Collection<?> aToPathElements,
                      Object aFrom)
```
    Same as insert(Object) though starting insertion of object's introspected values at the given "path".
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to insert the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
  - insertTo
```
default void insertTo(Collection<?> aToPathElements,
                      PathMap<T> aFrom)
```
    Method to semantically emphasize that we support our own types. Actually delegates to insertTo(String, Object).
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to insert the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
  - insertTo
```
default void insertTo(Object aToPath,
                      Object aFrom)
```
    Same as insert(Object) though starting insertion of object's introspected values at the given "path".
    
    Parameters:
    
    aToPath - The sub-path where to insert the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
  - insertTo
```
default void insertTo(Object aToPath,
                      PathMap<T> aFrom)
```
    Method to semantically emphasize that we support our own types. Actually delegates to insertTo(String, Object).
    
    Parameters:
    
    aToPath - The sub-path where to insert the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
  - insertTo
```
default void insertTo(Object[] aToPathElements,
                      Object aFrom)
```
    Same as insert(Object) though starting insertion of object's introspected values at the given "path".
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to insert the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
  - insertTo
```
default void insertTo(Object[] aToPathElements,
                      PathMap<T> aFrom)
```
    Method to semantically emphasize that we support our own types. Actually delegates to insertTo(String, Object).
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to insert the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
  - insertTo
```
void insertTo(String aToPath,
              Object aFrom)
```
    Same as insert(Object) though starting insertion of object's introspected values at the given "path".
    
    Parameters:
    
    aToPath - The sub-path where to insert the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
  - insertTo
```
default void insertTo(String aToPath,
                      PathMap<T> aFrom)
```
    Method to semantically emphasize that we support our own types. Actually delegates to insertTo(String, Object).
    
    Parameters:
    
    aToPath - The sub-path where to insert the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
  - insertTo
```
default void insertTo(String[] aToPathElements,
                      Object aFrom)
```
    Same as insert(Object) though starting insertion of object's introspected values at the given "path".
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to insert the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
  - insertTo
```
default void insertTo(String[] aToPathElements,
                      PathMap<T> aFrom)
```
    Method to semantically emphasize that we support our own types. Actually delegates to insertTo(String, Object).
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to insert the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
  - merge
```
void merge(Object aFrom)
```
    Inspects the given object and adds all elements found in the given object in case the targeted path does not exist or points to a null value. E.g. existing path/value pairs are not overwritten. Elements of type Map, Collection and arrays are identified and handled as of their type: The path for each value in a Map is appended with its according key. The path for each value in a Collection or array is appended with its according index of occurrence (in case of a List or an array, its actual index). In case of reflection, the path for each member is appended with its according mamber's name. All elements (e.g. the members and values) are inspected recursively which results in the according paths of the terminating values.
    
    Parameters:
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
  - merge
```
default void merge(PathMap<T> aFrom)
```
    Method to semantically emphasize that we support our own types. Actually delegates to merge(Object).
    
    Parameters:
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
  - mergeBetween
```
default void mergeBetween(Collection<?> aToPathElements,
                          Object aFrom,
                          Collection<?> aFromPathElements)
```
    Same as merge(Object) though starting merging of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the "from-path" path, them start with the given "to-path".
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to merge the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - mergeBetween
```
default void mergeBetween(Collection<?> aToPathElements,
                          PathMap<T> aFrom,
                          Collection<?> aFromPathElements)
```
    Method to semantically emphasize that we support our own types. Actually delegates to mergeBetween(String, Object, String).
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to merge the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - mergeBetween
```
default void mergeBetween(Object aToPath,
                          Object aFrom,
                          Object aFromPath)
```
    Same as merge(Object) though starting merging of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the "from-path" path, them start with the given "to-path".
    
    Parameters:
    
    aToPath - The sub-path where to merge the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPath - The path from where to start adding elements of the provided object.
  - mergeBetween
```
default void mergeBetween(Object aToPath,
                          PathMap<T> aFrom,
                          Object aFromPath)
```
    Method to semantically emphasize that we support our own types. Actually delegates to mergeBetween(String, Object, String).
    
    Parameters:
    
    aToPath - The sub-path where to merge the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPath - The path from where to start adding elements of the provided object.
  - mergeBetween
```
default void mergeBetween(Object[] aToPathElements,
                          Object aFrom,
                          Object[] aFromPathElements)
```
    Same as merge(Object) though starting merging of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the "from-path" path, them start with the given "to-path".
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to merge the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - mergeBetween
```
default void mergeBetween(Object[] aToPathElements,
                          PathMap<T> aFrom,
                          Object[] aFromPathElements)
```
    Method to semantically emphasize that we support our own types. Actually delegates to mergeBetween(String, Object, String).
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to merge the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - mergeBetween
```
void mergeBetween(String aToPath,
                  Object aFrom,
                  String aFromPath)
```
    Same as merge(Object) though starting merging of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the "from-path" path, them start with the given "to-path".
    
    Parameters:
    
    aToPath - The sub-path where to merge the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPath - The path from where to start adding elements of the provided object.
  - mergeBetween
```
default void mergeBetween(String aToPath,
                          PathMap<T> aFrom,
                          String aFromPath)
```
    Method to semantically emphasize that we support our own types. Actually delegates to mergeBetween(String, Object, String).
    
    Parameters:
    
    aToPath - The sub-path where to merge the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPath - The path from where to start adding elements of the provided object.
  - mergeBetween
```
default void mergeBetween(String[] aToPathElements,
                          Object aFrom,
                          String[] aFromPathElements)
```
    Same as merge(Object) though starting merging of object's introspected values at the given "to-path" and starting object introspection at the given "from-path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the "from-path" path, them start with the given "to-path".
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to merge the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - mergeBetween
```
default void mergeBetween(String[] aToPathElements,
                          PathMap<T> aFrom,
                          String[] aFromPathElements)
```
    Method to semantically emphasize that we support our own types. Actually delegates to mergeBetween(String, Object, String).
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to merge the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - mergeFrom
```
default void mergeFrom(Object aFrom,
                       Collection<?> aFromPathElements)
```
    Same as merge(Object) though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the provided path.
    
    Parameters:
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - mergeFrom
```
default void mergeFrom(Object aFrom,
                       Object aFromPath)
```
    Same as merge(Object) though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the provided path.
    
    Parameters:
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPath - The path from where to start adding elements of the provided object.
  - mergeFrom
```
default void mergeFrom(Object aFrom,
                       Object... aFromPathElements)
```
    Same as merge(Object) though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the provided path.
    
    Parameters:
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - mergeFrom
```
void mergeFrom(Object aFrom,
               String aFromPath)
```
    Same as merge(Object) though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the provided path.
    
    Parameters:
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPath - The path from where to start adding elements of the provided object.
  - mergeFrom
```
default void mergeFrom(Object aFrom,
                       String... aFromPathElements)
```
    Same as merge(Object) though starting object introspection at the given "path", e.g. ignoring all paths not starting with the given path during the introspection process. The resulting paths do not start with the provided path.
    
    Parameters:
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - mergeFrom
```
default void mergeFrom(PathMap<T> aFrom,
                       Collection<?> aFromPathElements)
```
    Method to semantically emphasize that we support our own types. Actually delegates to mergeFrom(Object, String).
    
    Parameters:
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - mergeFrom
```
default void mergeFrom(PathMap<T> aFrom,
                       Object aFromPath)
```
    Method to semantically emphasize that we support our own types. Actually delegates to mergeFrom(Object, String).
    
    Parameters:
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPath - The path from where to start adding elements of the provided object.
  - mergeFrom
```
default void mergeFrom(PathMap<T> aFrom,
                       Object... aFromPathElements)
```
    Method to semantically emphasize that we support our own types. Actually delegates to mergeFrom(Object, String).
    
    Parameters:
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - mergeFrom
```
default void mergeFrom(PathMap<T> aFrom,
                       String aFromPath)
```
    Method to semantically emphasize that we support our own types. Actually delegates to mergeFrom(Object, String).
    
    Parameters:
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPath - The path from where to start adding elements of the provided object.
  - mergeFrom
```
default void mergeFrom(PathMap<T> aFrom,
                       String... aFromPathElements)
```
    Method to semantically emphasize that we support our own types. Actually delegates to mergeFrom(Object, String).
    
    Parameters:
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
    
    aFromPathElements - The path elements of the path from where to start adding elements of the provided object.
  - mergeTo
```
default void mergeTo(Collection<?> aToPathElements,
                     Object aFrom)
```
    Same as merge(Object) though starting merging of object's introspected values at the given "path".
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to merge the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
  - mergeTo
```
default void mergeTo(Collection<?> aToPathElements,
                     PathMap<T> aFrom)
```
    Method to semantically emphasize that we support our own types. Actually delegates to mergeTo(String, Object).
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to merge the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
  - mergeTo
```
default void mergeTo(Object aToPath,
                     Object aFrom)
```
    Same as merge(Object) though starting merging of object's introspected values at the given "path".
    
    Parameters:
    
    aToPath - The sub-path where to merge the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
  - mergeTo
```
default void mergeTo(Object aToPath,
                     PathMap<T> aFrom)
```
    Method to semantically emphasize that we support our own types. Actually delegates to mergeTo(String, Object).
    
    Parameters:
    
    aToPath - The sub-path where to merge the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
  - mergeTo
```
default void mergeTo(Object[] aToPathElements,
                     Object aFrom)
```
    Same as merge(Object) though starting merging of object's introspected values at the given "path".
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to merge the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
  - mergeTo
```
default void mergeTo(Object[] aToPathElements,
                     PathMap<T> aFrom)
```
    Method to semantically emphasize that we support our own types. Actually delegates to mergeTo(String, Object).
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to merge the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
  - mergeTo
```
void mergeTo(String aToPath,
             Object aFrom)
```
    Same as merge(Object) though starting merging of object's introspected values at the given "path".
    
    Parameters:
    
    aToPath - The sub-path where to merge the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
  - mergeTo
```
default void mergeTo(String aToPath,
                     PathMap<T> aFrom)
```
    Method to semantically emphasize that we support our own types. Actually delegates to mergeTo(String, Object).
    
    Parameters:
    
    aToPath - The sub-path where to merge the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
  - mergeTo
```
default void mergeTo(String[] aToPathElements,
                     Object aFrom)
```
    Same as merge(Object) though starting merging of object's introspected values at the given "path".
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to merge the object's introspected values to.
    
    aFrom - The object which is to be inspected with the therein contained values being added with their according determined paths.
  - mergeTo
```
default void mergeTo(String[] aToPathElements,
                     PathMap<T> aFrom)
```
    Method to semantically emphasize that we support our own types. Actually delegates to mergeTo(String, Object).
    
    Parameters:
    
    aToPathElements - The path elements of the sub-path where to merge the object's introspected values to.
    
    aFrom - The PathMap which is to be inspected with the therein contained values being added with their according determined paths.
  - put
```
default T put(Collection<?> aPathElements,
              T aValue)
```
    Puts the given value into the child's path, relative to the given parent's path.
    
    Parameters:
    
    aPathElements - The path elements of the path relative to which to put the value.
    
    aValue - The value to be added.
    
    Returns:
    
    The replaced value in case a value has already been set for the resulting path, or null.
  - put
```
default T put(Object[] aPathElements,
              T aValue)
```
    Puts the given value into the child's path, relative to the given parent's path.
    
    Parameters:
    
    aPathElements - The path elements of the path relative to which to put the value.
    
    aValue - The value to be added.
    
    Returns:
    
    The replaced value in case a value has already been set for the resulting path, or null.
  - put
```
default T put(Relation<String,T> aRelation)
```
    Adds the given element related to the given key.
    
    Specified by:
    
    put in interface Dictionary.MutableDictionary<String,T>
    
    Parameters:
    
    aRelation - the relation
    
    Returns:
    
    The value being replaced by the provided value or null if none value has been replaced.
  - put
```
default T put(String[] aPathElements,
              T aValue)
```
    Puts the given value into the child's path, relative to the given parent's path.
    
    Parameters:
    
    aPathElements - The path elements of the path relative to which to put the value.
    
    aValue - The value to be added.
    
    Returns:
    
    The replaced value in case a value has already been set for the resulting path, or null.
  - putArray
```
default T[] putArray(Collection<?> aPathElements,
                     Collection<T> aValues)
```
    Sets the leaves below the given path in an array and replaces any existing array. Leaves in a PathMap are reckoned to be part of an array when they belong to the same hierarchy level and when their keys represent integer numbers. Given the below example, the elements below "/animals/dogs" can be represented as an array with five elements (the path is denoted at the left hand side of the assignment ":=" operator and the value at the right and side accordingly):
    
    "/animals/dogs/0" := "ace"
    
    "/animals/dogs/1" := "bandit"
    
    "/animals/dogs/2" := "radar"
    
    "/animals/dogs/3" := "echo"
    
    "/animals/dogs/4" := "snoopy"
    
    The resulting array when calling PathMap.getArray(String) for the path "/animals/dogs" would contain {"ace", "bandit", "radar", "echo", "snoopy"}. Calling isArray("/animals/dogs") would return true whereas calling isArray("/animals") would return false.
    Parameters:
    
    aPathElements - The elements of the path below where to put the array.
    
    aValues - The values to be put.
    
    Returns:
    
    An array of the leaves being replaced by the provided elements.
  - putArray
```
default T[] putArray(Collection<?> aPathElements,
                     T[] aValues)
```
    Sets the leaves below the given path in an array and replaces any existing array. Leaves in a PathMap are reckoned to be part of an array when they belong to the same hierarchy level and when their keys represent integer numbers. Given the below example, the elements below "/animals/dogs" can be represented as an array with five elements (the path is denoted at the left hand side of the assignment ":=" operator and the value at the right and side accordingly):
    
    "/animals/dogs/0" := "ace"
    
    "/animals/dogs/1" := "bandit"
    
    "/animals/dogs/2" := "radar"
    
    "/animals/dogs/3" := "echo"
    
    "/animals/dogs/4" := "snoopy"
    
    The resulting array when calling PathMap.getArray(String) for the path "/animals/dogs" would contain {"ace", "bandit", "radar", "echo", "snoopy"}. Calling isArray("/animals/dogs") would return true whereas calling isArray("/animals") would return false.
    Parameters:
    
    aPathElements - The elements of the path below where to put the array.
    
    aValues - The values to be put.
    
    Returns:
    
    An array of the leaves being replaced by the provided elements.
  - putArray
```
default T[] putArray(Collection<T> aValues)
```
    Applies the putArray(Object[]) method for the root path "/".
    
    Parameters:
    
    aValues - The values to be put.
    
    Returns:
    
    An array of the leaves being replaced by the provided elements.
  - putArray
```
default T[] putArray(Object aPath,
                     Collection<T> aValues)
```
    Sets the leaves below the given path in an array and replaces any existing array. Leaves in a PathMap are reckoned to be part of an array when they belong to the same hierarchy level and when their keys represent integer numbers. Given the below example, the elements below "/animals/dogs" can be represented as an array with five elements (the path is denoted at the left hand side of the assignment ":=" operator and the value at the right and side accordingly):
    
    "/animals/dogs/0" := "ace"
    
    "/animals/dogs/1" := "bandit"
    
    "/animals/dogs/2" := "radar"
    
    "/animals/dogs/3" := "echo"
    
    "/animals/dogs/4" := "snoopy"
    
    The resulting array when calling PathMap.getArray(String) for the path "/animals/dogs" would contain {"ace", "bandit", "radar", "echo", "snoopy"}. Calling isArray("/animals/dogs") would return true whereas calling isArray("/animals") would return false.
    Parameters:
    
    aPath - The path below where to put the array.
    
    aValues - The values to be put.
    
    Returns:
    
    An array of the leaves being replaced by the provided elements.
  - putArray
```
default T[] putArray(Object aPath,
                     T[] aValues)
```
    Sets the leaves below the given path in an array and replaces any existing array. Leaves in a PathMap are reckoned to be part of an array when they belong to the same hierarchy level and when their keys represent integer numbers. Given the below example, the elements below "/animals/dogs" can be represented as an array with five elements (the path is denoted at the left hand side of the assignment ":=" operator and the value at the right and side accordingly):
    
    "/animals/dogs/0" := "ace"
    
    "/animals/dogs/1" := "bandit"
    
    "/animals/dogs/2" := "radar"
    
    "/animals/dogs/3" := "echo"
    
    "/animals/dogs/4" := "snoopy"
    
    The resulting array when calling PathMap.getArray(String) for the path "/animals/dogs" would contain {"ace", "bandit", "radar", "echo", "snoopy"}. Calling isArray("/animals/dogs") would return true whereas calling isArray("/animals") would return false.
    Parameters:
    
    aPath - The path below where to put the array.
    
    aValues - The values to be put.
    
    Returns:
    
    An array of the leaves being replaced by the provided elements.
  - putArray
```
default T[] putArray(Object[] aPathElements,
                     Collection<T> aValues)
```
    Sets the leaves below the given path in an array and replaces any existing array. Leaves in a PathMap are reckoned to be part of an array when they belong to the same hierarchy level and when their keys represent integer numbers. Given the below example, the elements below "/animals/dogs" can be represented as an array with five elements (the path is denoted at the left hand side of the assignment ":=" operator and the value at the right and side accordingly):
    
    "/animals/dogs/0" := "ace"
    
    "/animals/dogs/1" := "bandit"
    
    "/animals/dogs/2" := "radar"
    
    "/animals/dogs/3" := "echo"
    
    "/animals/dogs/4" := "snoopy"
    
    The resulting array when calling PathMap.getArray(String) for the path "/animals/dogs" would contain {"ace", "bandit", "radar", "echo", "snoopy"}. Calling isArray("/animals/dogs") would return true whereas calling isArray("/animals") would return false.
    Parameters:
    
    aPathElements - The elements of the path below where to put the array.
    
    aValues - The values to be put.
    
    Returns:
    
    An array of the leaves being replaced by the provided elements.
  - putArray
```
default T[] putArray(Object[] aPathElements,
                     T[] aValues)
```
    Sets the leaves below the given path in an array and replaces any existing array. Leaves in a PathMap are reckoned to be part of an array when they belong to the same hierarchy level and when their keys represent integer numbers. Given the below example, the elements below "/animals/dogs" can be represented as an array with five elements (the path is denoted at the left hand side of the assignment ":=" operator and the value at the right and side accordingly):
    
    "/animals/dogs/0" := "ace"
    
    "/animals/dogs/1" := "bandit"
    
    "/animals/dogs/2" := "radar"
    
    "/animals/dogs/3" := "echo"
    
    "/animals/dogs/4" := "snoopy"
    
    The resulting array when calling PathMap.getArray(String) for the path "/animals/dogs" would contain {"ace", "bandit", "radar", "echo", "snoopy"}. Calling isArray("/animals/dogs") would return true whereas calling isArray("/animals") would return false.
    Parameters:
    
    aPathElements - The elements of the path below where to put the array.
    
    aValues - The values to be put.
    
    Returns:
    
    An array of the leaves being replaced by the provided elements.
  - putArray
```
default T[] putArray(String aPath,
                     Collection<T> aValues)
```
    Sets the leaves below the given path in an array and replaces any existing array. Leaves in a PathMap are reckoned to be part of an array when they belong to the same hierarchy level and when their keys represent integer numbers. Given the below example, the elements below "/animals/dogs" can be represented as an array with five elements (the path is denoted at the left hand side of the assignment ":=" operator and the value at the right and side accordingly):
    
    "/animals/dogs/0" := "ace"
    
    "/animals/dogs/1" := "bandit"
    
    "/animals/dogs/2" := "radar"
    
    "/animals/dogs/3" := "echo"
    
    "/animals/dogs/4" := "snoopy"
    
    The resulting array when calling PathMap.getArray(String) for the path "/animals/dogs" would contain {"ace", "bandit", "radar", "echo", "snoopy"}. Calling isArray("/animals/dogs") would return true whereas calling isArray("/animals") would return false.
    Parameters:
    
    aPath - The path below where to put the array.
    
    aValues - The values to be put.
    
    Returns:
    
    An array of the leaves being replaced by the provided elements.
  - putArray
```
default T[] putArray(String aPath,
                     T[] aValues)
```
    Sets the leaves below the given path in an array and replaces any existing array. Leaves in a PathMap are reckoned to be part of an array when they belong to the same hierarchy level and when their keys represent integer numbers. Given the below example, the elements below "/animals/dogs" can be represented as an array with five elements (the path is denoted at the left hand side of the assignment ":=" operator and the value at the right and side accordingly):
    
    "/animals/dogs/0" := "ace"
    
    "/animals/dogs/1" := "bandit"
    
    "/animals/dogs/2" := "radar"
    
    "/animals/dogs/3" := "echo"
    
    "/animals/dogs/4" := "snoopy"
    
    The resulting array when calling PathMap.getArray(String) for the path "/animals/dogs" would contain {"ace", "bandit", "radar", "echo", "snoopy"}. Calling isArray("/animals/dogs") would return true whereas calling isArray("/animals") would return false.
    Parameters:
    
    aPath - The path below where to put the array.
    
    aValues - The values to be put.
    
    Returns:
    
    An array of the leaves being replaced by the provided elements.
  - putArray
```
default T[] putArray(String[] aPathElements,
                     Collection<T> aValues)
```
    Sets the leaves below the given path in an array and replaces any existing array. Leaves in a PathMap are reckoned to be part of an array when they belong to the same hierarchy level and when their keys represent integer numbers. Given the below example, the elements below "/animals/dogs" can be represented as an array with five elements (the path is denoted at the left hand side of the assignment ":=" operator and the value at the right and side accordingly):
    
    "/animals/dogs/0" := "ace"
    
    "/animals/dogs/1" := "bandit"
    
    "/animals/dogs/2" := "radar"
    
    "/animals/dogs/3" := "echo"
    
    "/animals/dogs/4" := "snoopy"
    
    The resulting array when calling PathMap.getArray(String) for the path "/animals/dogs" would contain {"ace", "bandit", "radar", "echo", "snoopy"}. Calling isArray("/animals/dogs") would return true whereas calling isArray("/animals") would return false.
    Parameters:
    
    aPathElements - The elements of the path below where to put the array.
    
    aValues - The values to be put.
    
    Returns:
    
    An array of the leaves being replaced by the provided elements.
  - putArray
```
default T[] putArray(String[] aPathElements,
                     T[] aValues)
```
    Sets the leaves below the given path in an array and replaces any existing array. Leaves in a PathMap are reckoned to be part of an array when they belong to the same hierarchy level and when their keys represent integer numbers. Given the below example, the elements below "/animals/dogs" can be represented as an array with five elements (the path is denoted at the left hand side of the assignment ":=" operator and the value at the right and side accordingly):
    
    "/animals/dogs/0" := "ace"
    
    "/animals/dogs/1" := "bandit"
    
    "/animals/dogs/2" := "radar"
    
    "/animals/dogs/3" := "echo"
    
    "/animals/dogs/4" := "snoopy"
    
    The resulting array when calling PathMap.getArray(String) for the path "/animals/dogs" would contain {"ace", "bandit", "radar", "echo", "snoopy"}. Calling isArray("/animals/dogs") would return true whereas calling isArray("/animals") would return false.
    Parameters:
    
    aPathElements - The elements of the path below where to put the array.
    
    aValues - The values to be put.
    
    Returns:
    
    An array of the leaves being replaced by the provided elements.
  - putArray
```
default T[] putArray(T[] aValues)
```
    Applies the putArray(Object[]) method for the root path "/".
    
    Parameters:
    
    aValues - The values to be put.
    
    Returns:
    
    An array of the leaves being replaced by the provided elements.
  - putDirAt
```
default PathMap<T> putDirAt(Collection<?> aPathElements,
                            int aIndex,
                            Object aDir)
                     throws IllegalArgumentException
```
    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. Puts the given values below the path at the given index.
    
    Parameters:
    
    aPathElements - The path elements of the path where to put the indexed element.
    
    aIndex - The index of the indexed element.
    
    aDir - The values to be put at the index.
    
    Returns:
    
    The directory which has been replaced by the given directory.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - putDirAt
```
default PathMap<T> putDirAt(Collection<?> aPathElements,
                            int aIndex,
                            PathMap<T> aDir)
                     throws IllegalArgumentException
```
    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. Puts the given values below the path at the given index.
    
    Parameters:
    
    aPathElements - The path elements of the path where to put the indexed element.
    
    aIndex - The index of the indexed element.
    
    aDir - The values to be put at the index.
    
    Returns:
    
    The directory which has been replaced by the given directory.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - putDirAt
```
default PathMap<T> putDirAt(int aIndex,
                            Object aDir)
                     throws IllegalArgumentException
```
    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. Puts the given values below the root path at the given index.
    
    Parameters:
    
    aIndex - The index of the indexed element.
    
    aDir - The values to be put at the index.
    
    Returns:
    
    The directory which has been replaced by the given directory.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - putDirAt
```
default PathMap<T> putDirAt(int aIndex,
                            PathMap<T> aDir)
                     throws IllegalArgumentException
```
    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. Puts the given values below the root path at the given index.
    
    Parameters:
    
    aIndex - The index of the indexed element.
    
    aDir - The values to be put at the index.
    
    Returns:
    
    The directory which has been replaced by the given directory.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - putDirAt
```
default PathMap<T> putDirAt(Object aPath,
                            int aIndex,
                            Object aDir)
                     throws IllegalArgumentException
```
    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. Puts the given values below the path at the given index.
    
    Parameters:
    
    aPath - The path where to put the indexed element.
    
    aIndex - The index of the indexed element.
    
    aDir - The values to be put at the index.
    
    Returns:
    
    The directory which has been replaced by the given directory.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - putDirAt
```
default PathMap<T> putDirAt(Object aPath,
                            int aIndex,
                            PathMap<T> aDir)
                     throws IllegalArgumentException
```
    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. Puts the given values below the path at the given index.
    
    Parameters:
    
    aPath - The path where to put the indexed element.
    
    aIndex - The index of the indexed element.
    
    aDir - The values to be put at the index.
    
    Returns:
    
    The directory which has been replaced by the given directory.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - putDirAt
```
default PathMap<T> putDirAt(Object[] aPathElements,
                            int aIndex,
                            Object aDir)
                     throws IllegalArgumentException
```
    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. Puts the given values below the path at the given index.
    
    Parameters:
    
    aPathElements - The path elements of the path where to put the indexed element.
    
    aIndex - The index of the indexed element.
    
    aDir - The values to be put at the index.
    
    Returns:
    
    The directory which has been replaced by the given directory.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - putDirAt
```
default PathMap<T> putDirAt(Object[] aPathElements,
                            int aIndex,
                            PathMap<T> aDir)
                     throws IllegalArgumentException
```
    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. Puts the given values below the path at the given index.
    
    Parameters:
    
    aPathElements - The path elements of the path where to put the indexed element.
    
    aIndex - The index of the indexed element.
    
    aDir - The values to be put at the index.
    
    Returns:
    
    The directory which has been replaced by the given directory.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - putDirAt
```
default PathMap<T> putDirAt(String aPath,
                            int aIndex,
                            Object aDir)
                     throws IllegalArgumentException
```
    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. Puts the given values below the path at the given index.
    
    Parameters:
    
    aPath - The path where to put the indexed element.
    
    aIndex - The index of the indexed element.
    
    aDir - The values to be put at the index.
    
    Returns:
    
    The directory which has been replaced by the given directory.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - putDirAt
```
default PathMap<T> putDirAt(String aPath,
                            int aIndex,
                            PathMap<T> aDir)
                     throws IllegalArgumentException
```
    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. Puts the given values below the path at the given index.
    
    Parameters:
    
    aPath - The path where to put the indexed element.
    
    aIndex - The index of the indexed element.
    
    aDir - The values to be put at the index.
    
    Returns:
    
    The directory which has been replaced by the given directory.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - putDirAt
```
default PathMap<T> putDirAt(String[] aPathElements,
                            int aIndex,
                            Object aDir)
                     throws IllegalArgumentException
```
    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. Puts the given values below the path at the given index.
    
    Parameters:
    
    aPathElements - The path elements of the path where to put the indexed element.
    
    aIndex - The index of the indexed element.
    
    aDir - The values to be put at the index.
    
    Returns:
    
    The directory which has been replaced by the given directory.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - putDirAt
```
default PathMap<T> putDirAt(String[] aPathElements,
                            int aIndex,
                            PathMap<T> aDir)
                     throws IllegalArgumentException
```
    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. Puts the given values below the path at the given index.
    
    Parameters:
    
    aPathElements - The path elements of the path where to put the indexed element.
    
    aIndex - The index of the indexed element.
    
    aDir - The values to be put at the index.
    
    Returns:
    
    The directory which has been replaced by the given directory.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isIndexDir(String).
  - putValueAt
```
default T putValueAt(Collection<?> aPathElements,
                     int aIndex,
                     T aValue)
              throws IllegalArgumentException
```
    Puts a value below the path at the given index as of putArray(String, Object[]).
    
    Parameters:
    
    aPathElements - The path elements of the path where to put the indexed element.
    
    aIndex - The index of the indexed element.
    
    aValue - The value to be put at the index.
    
    Returns:
    
    The value which has been replaced by the given value.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isArray(String).
  - putValueAt
```
default T putValueAt(int aIndex,
                     T aValue)
              throws IllegalArgumentException
```
    Puts a value below the root path at the given index as of putArray(String, Object[]).
    
    Parameters:
    
    aIndex - The index of the indexed element.
    
    aValue - The value to be put at the index.
    
    Returns:
    
    The value which has been replaced by the given value.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isArray(String).
  - putValueAt
```
default T putValueAt(Object aPath,
                     int aIndex,
                     T aValue)
              throws IllegalArgumentException
```
    Puts a value below the path at the given index as of putArray(String, Object[]).
    
    Parameters:
    
    aPath - The path where to put the indexed element.
    
    aIndex - The index of the indexed element.
    
    aValue - The value to be put at the index.
    
    Returns:
    
    The value which has been replaced by the given value.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isArray(String).
  - putValueAt
```
default T putValueAt(Object[] aPathElements,
                     int aIndex,
                     T aValue)
              throws IllegalArgumentException
```
    Puts a value below the path at the given index as of putArray(String, Object[]).
    
    Parameters:
    
    aPathElements - The path elements of the path where to put the indexed element.
    
    aIndex - The index of the indexed element.
    
    aValue - The value to be put at the index.
    
    Returns:
    
    The value which has been replaced by the given value.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isArray(String).
  - putValueAt
```
default T putValueAt(String aPath,
                     int aIndex,
                     T aValue)
              throws IllegalArgumentException
```
    Puts a value below the path at the given index as of putArray(String, Object[]).
    
    Parameters:
    
    aPath - The path where to put the indexed element.
    
    aIndex - The index of the indexed element.
    
    aValue - The value to be put at the index.
    
    Returns:
    
    The value which has been replaced by the given value.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isArray(String).
  - putValueAt
```
default T putValueAt(String[] aPathElements,
                     int aIndex,
                     T aValue)
              throws IllegalArgumentException
```
    Puts a value below the path at the given index as of putArray(String, Object[]).
    
    Parameters:
    
    aPathElements - The path elements of the path where to put the indexed element.
    
    aIndex - The index of the indexed element.
    
    aValue - The value to be put at the index.
    
    Returns:
    
    The value which has been replaced by the given value.
    
    Throws:
    
    IllegalArgumentException - in case the path does not represent indexed elements as of PathMap.isArray(String).
  - remove
```
default T remove(Object... aPathElements)
```
    Removes the property as of Map.remove(Object) for the provided path elements (as of PathMap.toPath(Object...)). BEWARE: The method with two arguments as of Map.remove(Object, Object) behaves special as of its inheritance from Map.remove(Object, Object).
    
    Parameters:
    
    aPathElements - The elements of the path from where to remove the property.
    
    Returns:
    
    the previous value associated with the according path, or null if there was no mapping for the according path.
  - remove
```
default T remove(String... aPathElements)
```
    Removes the property as of Map.remove(Object) for the provided path elements (as of PathMap.toPath(String...)).
    
    Parameters:
    
    aPathElements - The elements of the path from where to remove the property.
    
    Returns:
    
    the previous value associated with the according path, or null if there was no mapping for the according path.
  - remove
```
default T remove(String aPathElement1,
                 String aPathElement2)
```
    Removes the property as of Map.remove(Object) for the provided path elements (as of PathMap.toPath(String...)). This method overloads the method Map.remove(Object, Object) in order to prevent unexpected behavior of the remove(String...) method!
    
    Parameters:
    
    aPathElement1 - The first path element of the path from where to remove the property.
    
    aPathElement2 - The second path element of the path from where to remove the property.
    
    Returns:
    
    the previous value associated with the according path, or null if there was no mapping for the according path.
  - removeAll
```
default PathMap<T> removeAll(Collection<?> aPathQueryElements)
```
    Removes all elements which's keys match the provided path query. 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.
    
    Parameters:
    
    aPathQueryElements - The elements representing your path query including your wildcards.
    
    Returns:
    
    The removed properties.
  - removeAll
```
default PathMap<T> removeAll(Object... aPathQueryElements)
```
    Removes all elements which's keys match the provided path query. 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.
    
    Parameters:
    
    aPathQueryElements - The elements representing your path query including your wildcards.
    
    Returns:
    
    The removed properties.
  - removeAll
```
default PathMap<T> removeAll(Object aPathQuery)
```
    Removes all elements which's keys match the provided path query. 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.
    
    Parameters:
    
    aPathQuery - The path query including your wildcards.
    
    Returns:
    
    The removed properties.
  - removeAll
```
default PathMap<T> removeAll(Pattern aRegExp)
```
    Removes all elements which's keys match the provided regular expression: Queries the keys of the instance using the provided Pattern.
    
    Parameters:
    
    aRegExp - The regular expression to be used for the query.
    
    Returns:
    
    The removed properties.
  - removeAll
```
default PathMap<T> removeAll(String... aPathQueryElements)
```
    Removes all elements which's keys match the provided path query. 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.
    
    Parameters:
    
    aPathQueryElements - The elements representing your path query including your wildcards.
    
    Returns:
    
    The removed properties.
  - removeAll
```
default PathMap<T> removeAll(String aPathQuery)
```
    Removes all elements which's keys match the provided path query. 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.
    
    Parameters:
    
    aPathQuery - The path query including your wildcards.
    
    Returns:
    
    The removed properties.
  - removeDirAt
```
default PathMap<T> removeDirAt(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. Removes the elements of the given index below the root 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".
    
    Parameters:
    
    aIndex - The index which to use.
    
    Returns:
    
    The indexed elements without the indexed path "prefixes".
  - removeDirAt
```
default PathMap<T> removeDirAt(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. Removes the elements of the given index below the given 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".
    
    Parameters:
    
    aPath - The path from which to remove the indexed elements.
    
    aIndex - The index which to use.
    
    Returns:
    
    The indexed elements without the indexed path "prefixes".
  - removeDirAt
```
default PathMap<T> removeDirAt(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. Removes the elements of the given index below the given 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".
    
    Parameters:
    
    aPathElements - The elements of the path from which to remove the indexed elements.
    
    aIndex - The index which to use.
    
    Returns:
    
    The indexed elements without the indexed path "prefixes".
  - removeDirAt
```
default PathMap<T> removeDirAt(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. Removes the elements of the given index below the given 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".
    
    Parameters:
    
    aPath - The path from which to remove the indexed elements.
    
    aIndex - The index which to use.
    
    Returns:
    
    The indexed elements without the indexed path "prefixes".
  - removeDirAt
```
default PathMap<T> removeDirAt(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. Removes the elements of the given index below the given 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".
    
    Parameters:
    
    aPathElements - The elements of the path from which to remove the indexed elements.
    
    aIndex - The index which to use.
    
    Returns:
    
    The indexed elements without the indexed path "prefixes".
  - removeFrom
```
default PathMap<T> removeFrom(Collection<?> aPathElements)
```
    Removes all properties below the provided path and returns the PathMap with the removed elements, by which the paths exclude the parent's path.
    
    Parameters:
    
    aPathElements - The path elements for the path from where to remove all properties.
    
    Returns:
    
    The removed properties.
  - removeFrom
```
default PathMap<T> removeFrom(Object... aPathElements)
```
    Removes all properties below the provided path and returns the PathMap with the removed elements, by which the paths exclude the parent's path.
    
    Parameters:
    
    aPathElements - The path elements for the path from where to remove all properties.
    
    Returns:
    
    The removed properties.
  - removeFrom
```
default PathMap<T> removeFrom(Object aPath)
```
    Removes all properties below the provided path and returns the PathMap with the removed elements, by which the paths exclude the parent's path.
    
    Parameters:
    
    aPath - The path from where to remove all properties.
    
    Returns:
    
    The removed properties.
  - removeFrom
```
default PathMap<T> removeFrom(String aPath)
```
    Removes all properties below the provided path and returns the PathMap with the removed elements, by which the paths exclude the parent's path.
    
    Parameters:
    
    aPath - The path from where to remove all properties.
    
    Returns:
    
    The removed properties.
  - removeFrom
```
default PathMap<T> removeFrom(String... aPathElements)
```
    Removes all properties below the provided path and returns the PathMap with the removed elements, by which the paths exclude the parent's path.
    
    Parameters:
    
    aPathElements - The path elements for the path from where to remove all properties.
    
    Returns:
    
    The removed properties.
  - removePaths
```
default PathMap<T> removePaths(Collection<?> aPaths)
```
    Removes the paths contained in the provided collection.
    
    Parameters:
    
    aPaths - The paths to be removed.
    
    Returns:
    
    The removed properties.
  - removePaths
```
default PathMap<T> removePaths(String... aPaths)
```
    Removes the paths contained in the provided collection.
    
    Parameters:
    
    aPaths - The paths to be removed.
    
    Returns:
    
    The removed properties.
  - removeValueAt
```
default T removeValueAt(int aIndex)
```
    Removes the value of an array at the root path with the given array index.
    
    Parameters:
    
    aIndex - The index inside the array for which to remove the value.
    
    Returns:
    
    The removed value.
  - removeValueAt
```
default T removeValueAt(Object aPath,
                        int aIndex)
```
    Removes the value of an array at the given path path with the given array index.
    
    Parameters:
    
    aPath - The path pointing to the array.
    
    aIndex - The index inside the array for which to remove the value.
    
    Returns:
    
    The removed value.
  - removeValueAt
```
default T removeValueAt(Object[] aPathElements,
                        int aIndex)
```
    Removes the value of an array at the given path path with the given array index.
    
    Parameters:
    
    aPathElements - The path elements for the path pointing to the array.
    
    aIndex - The index inside the array for which to remove the value.
    
    Returns:
    
    The removed value.
  - removeValueAt
```
default T removeValueAt(String aPath,
                        int aIndex)
```
    Removes the value of an array at the given path path with the given array index.
    
    Parameters:
    
    aPath - The path pointing to the array.
    
    aIndex - The index inside the array for which to remove the value.
    
    Returns:
    
    The removed value.
  - removeValueAt
```
default T removeValueAt(String[] aPathElements,
                        int aIndex)
```
    Removes the value of an array at the given path path with the given array index.
    
    Parameters:
    
    aPathElements - The path elements for the path pointing to the array.
    
    aIndex - The index inside the array for which to remove the value.
    
    Returns:
    
    The removed value.
  - toSourceCode
```
default String toSourceCode()
```
    Beta, don't know whether to keep this or not: Creates a class (a String text to be copy'n'pasted) with getters and setters for the herein contained paths and their values.
    
    Returns:
    
    The text representing the source code to be copy'n'pasted.
  - toSourceCode
```
default String toSourceCode(String aClassName,
                            String aPackage)
```
    Beta, don't know whether to keep this or not: Creates a class (a String text to be copy'n'pasted) with getters and setters for the herein contained paths and their values.
    
    Parameters:
    
    aClassName - The class name for the class to be generated.
    
    aPackage - The package to which the class is to belong.
    
    Returns:
    
    The text representing the source code to be copy'n'pasted.

Interface PathMap.MutablePathMap<T>

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

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

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

Nested classes/interfaces inherited from interface java.util.Map

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

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

Field Summary

Fields inherited from interface org.refcodes.struct.PathMap

Method Summary

Methods inherited from interface org.refcodes.mixin.AnnotatorAccessor

Methods inherited from interface org.refcodes.mixin.Clearable

Methods inherited from interface org.refcodes.struct.Containable

Methods inherited from interface org.refcodes.mixin.DelimiterAccessor

Methods inherited from interface org.refcodes.mixin.Dumpable

Methods inherited from interface org.refcodes.mixin.EmptyAccessor

Methods inherited from interface org.refcodes.struct.Keys

Methods inherited from interface org.refcodes.struct.Keys.MutableValues

Methods inherited from interface java.util.Map

Methods inherited from interface org.refcodes.struct.PathMap

Methods inherited from interface org.refcodes.mixin.TypeAccessor

Method Detail

add

add

add

add

add

add

appendDirTo

appendDirTo

appendDirTo

appendDirTo

appendDirTo

appendDirTo

appendDirTo

appendDirTo

appendDirTo

appendDirTo

appendDirTo

appendDirTo

appendValueTo

appendValueTo

appendValueTo

appendValueTo

appendValueTo

appendValueTo

delete

delete

delete

delete

delete

insert

insert

insertBetween

insertBetween

insertBetween

insertBetween

insertBetween

insertBetween

insertBetween

insertBetween

insertBetween

insertBetween

insertFrom

insertFrom

insertFrom

insertFrom

insertFrom

insertFrom

insertFrom

insertFrom

insertFrom

insertFrom

insertTo

insertTo

insertTo