Module org.refcodes.struct

Package org.refcodes.struct

Interface PathMap.MutablePathMap<T>

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

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.
default <TYPE> void	fromType(Object[] aFromPathElements, TYPE aType)	Fills this PathMap from the given type instance's data (e.g.
default <TYPE> void	fromType(Object aFromPath, TYPE aType)	Fills this PathMap from the given type instance's data (e.g.
default <TYPE> void	fromType(String[] aFromPathElements, TYPE aType)	Fills this PathMap from the given type instance's data (e.g.
default <TYPE> void	fromType(String aFromPath, TYPE aType)	Fills this PathMap from the given type instance's data (e.g.
default <TYPE> void	fromType(Collection<?> aFromPathElements, TYPE aType)	Fills this PathMap from the given type instance's data (e.g.
default <TYPE> void	fromType(TYPE aType)	Fills this PathMap from the given type instance's data (e.g.
default <TYPE> void	fromType(TYPE aType, Object... aFromPathElements)	Fills this PathMap from the given type instance's data (e.g.
default <TYPE> void	fromType(TYPE aType, String... aFromPathElements)	Fills this PathMap from the given type instance's data (e.g.
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

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, toPrintable, toPropertyPath, toType, toType, toType, toType, toType, toType, toType, toType

Methods inherited from interface org.refcodes.mixin.TypeAccessor

getType

Method Details

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.

fromType

default <TYPE> void fromType(TYPE aType)

Fills this PathMap from the given type instance's data (e.g. bean properties). This is a counterpart method for PathMap.toType(Class), though in fact it is the same as insert(Object) and provided for semantic emphasis and convenience. See also the methods insertFrom(Object, String), insertTo(String, PathMap) or insertBetween(String, Object, String) as well as them variants.

Type Parameters:

TYPE - the generic type if which to create an instance.

Parameters:

aType - the type if the instance to be filled with the herein contained data.

fromType

default <TYPE> void fromType(Object aFromPath,
 TYPE aType)

Fills this PathMap from the given type instance's data (e.g. bean properties). This is a counterpart method for PathMap.toType(Object, Class), though in fact it is the same as insertTo(Object, Object) and provided for semantic emphasis and convenience. See also the methods insertFrom(Object, String), insertTo(String, PathMap) or insertBetween(String, Object, String) as well as them variants.

Type Parameters:

TYPE - the generic type if which to create an instance.

Parameters:

aFromPath - The path representing the root from which to take the data for the instance.

aType - the type if the instance to be filled with the herein contained data.

fromType

default <TYPE> void fromType(Object[] aFromPathElements,
 TYPE aType)

Fills this PathMap from the given type instance's data (e.g. bean properties). This is a counterpart method for PathMap.toType(Object[], Class), though in fact it is the same as insertTo(Object[], Object) and provided for semantic emphasis and convenience. See also the methods insertFrom(Object, String), insertTo(String, PathMap) or insertBetween(String, Object, String) as well as them variants.

Type Parameters:

TYPE - the generic type if which to create an instance.

Parameters:

aFromPathElements - The path elements representing the root from which to take the data for the instance.

aType - the type if the instance to be filled with the herein contained data.

fromType

default <TYPE> void fromType(TYPE aType,
 Object... aFromPathElements)

Fills this PathMap from the given type instance's data (e.g. bean properties). This is a counterpart method for PathMap.toType(Object[], Class), though in fact it is the same as insertTo(Object[], Object) and provided for semantic emphasis and convenience. See also the methods insertFrom(Object, String), insertTo(String, PathMap) or insertBetween(String, Object, String) as well as them variants.

Type Parameters:

TYPE - the generic type if which to create an instance.

Parameters:

aType - the type if the instance to be filled with the herein contained data.

aFromPathElements - The path elements representing the root from which to take the data for the instance.

fromType

default <TYPE> void fromType(String[] aFromPathElements,
 TYPE aType)

Fills this PathMap from the given type instance's data (e.g. bean properties). This is a counterpart method for PathMap.toType(String[], Class), though in fact it is the same as insertTo(String[], Object) and provided for semantic emphasis and convenience. See also the methods insertFrom(Object, String), insertTo(String, PathMap) or insertBetween(String, Object, String) as well as them variants.

Type Parameters:

TYPE - the generic type if which to create an instance.

Parameters:

aFromPathElements - The path elements representing the root from which to take the data for the instance.

aType - the type if the instance to be filled with the herein contained data.

fromType

default <TYPE> void fromType(TYPE aType,
 String... aFromPathElements)

Fills this PathMap from the given type instance's data (e.g. bean properties). This is a counterpart method for PathMap.toType(String[], Class), though in fact it is the same as insertTo(String[], Object) and provided for semantic emphasis and convenience. See also the methods insertFrom(Object, String), insertTo(String, PathMap) or insertBetween(String, Object, String) as well as them variants.

Type Parameters:

TYPE - the generic type if which to create an instance.

Parameters:

aType - the type if the instance to be filled with the herein contained data.

aFromPathElements - The path elements representing the root from which to take the data for the instance.

fromType

default <TYPE> void fromType(Collection<?> aFromPathElements,
 TYPE aType)

Fills this PathMap from the given type instance's data (e.g. bean properties). This is a counterpart method for PathMap.toType(Collection, Class), though in fact it is the same as insertTo(Collection, Object) and provided for semantic emphasis and convenience. See also the methods insertFrom(Object, String), insertTo(String, PathMap) or insertBetween(String, Object, String) as well as them variants.

Type Parameters:

TYPE - the generic type if which to create an instance.

Parameters:

aFromPathElements - The path elements representing the root from which to take the data for the instance.

aType - the type if the instance to be filled with the herein contained data.

fromType

default <TYPE> void fromType(String aFromPath,
 TYPE aType)

Fills this PathMap from the given type instance's data (e.g. bean properties). This is a counterpart method for PathMap.toType(String, Class), though in fact it is the same as insertTo(String, Object) and provided for semantic emphasis and convenience. See also the methods insertFrom(Object, String), insertTo(String, PathMap) or insertBetween(String, Object, String) as well as them variants.

Type Parameters:

TYPE - the generic type if which to create an instance.

Parameters:

aFromPath - The path representing the root from which to take the data for the instance.

aType - the type if the instance to be filled with the herein contained data.

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.