Interface ImmutableCanonicalTable

All Superinterfaces:
org.refcodes.mixin.AnnotatorAccessor, Containable, org.refcodes.mixin.DelimiterAccessor, org.refcodes.mixin.EmptyAccessor, ImmutableInterOperableTable<String>, ImmutablePathTable<String>, ImmutableTable<String,String>, Keys<String,String>, org.refcodes.mixin.TypeAccessor<String>
All Known Subinterfaces:
CanonicalTable, ImmutableCanonicalTable.MutableCanonicalTable
All Known Implementing Classes:
MapCanonicalTable, UnmodifiableCanonicalTableDecorator
public interface ImmutableCanonicalTable extends ImmutableInterOperableTable<String>
The ImmutableCanonicalTable is an "intermediate" type adding type and Data-Structure related functionality to any implementing class.

  • Method Details

    • asArray

      default String[] asArray(Object aKey)
      Same as asArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asArray

      default String[] asArray(Object aKey, char aDelimiter)
      Treats the value associated with the given key as an array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "1, 2, 3, 4, 5", then the corresponding array, when using the comma (',') char as delimiter, will be { "1", "2", "3", "4", "5" }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asArray

      default String[] asArray(String aKey)
      Same as asArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asArray

      default String[] asArray(String aKey, char aDelimiter)
      Treats the value associated with the given key as an array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "1, 2, 3, 4, 5", then the corresponding array, when using the comma (',') char as delimiter, will be { "1", "2", "3", "4", "5" }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asBooleanArray

      default boolean[] asBooleanArray(Object aKey)
      Same as asBooleanArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asBooleanArray

      default boolean[] asBooleanArray(Object aKey, char aDelimiter)
      Treats the value associated with the given key as a boolean array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.
      Throws:
      NumberFormatException - thrown in case conversion fails.

    • asBooleanArray

      default boolean[] asBooleanArray(String aKey)
      Same as asBooleanArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asBooleanArray

      default boolean[] asBooleanArray(String aKey, char aDelimiter)
      Treats the value associated with the given key as a boolean array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.
      Throws:
      NumberFormatException - thrown in case conversion fails.

    • asByteArray

      default byte[] asByteArray(Object aKey)
      Same as asByteArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asByteArray

      default byte[] asByteArray(Object aKey, char aDelimiter)
      Treats the value associated with the given key as a byte array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.
      Throws:
      NumberFormatException - thrown in case conversion fails.

    • asByteArray

      default byte[] asByteArray(String aKey)
      Same as asByteArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asByteArray

      default byte[] asByteArray(String aKey, char aDelimiter)
      Treats the value associated with the given key as a byte array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.
      Throws:
      NumberFormatException - thrown in case conversion fails.

    • asCharArray

      default char[] asCharArray(Object aKey)
      Same as asCharArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asCharArray

      default char[] asCharArray(Object aKey, char aDelimiter)
      Treats the value associated with the given key as a char array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.
      Throws:
      NumberFormatException - thrown in case conversion fails.

    • asCharArray

      default char[] asCharArray(String aKey)
      Same as asCharArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asCharArray

      default char[] asCharArray(String aKey, char aDelimiter)
      Treats the value associated with the given key as a char array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.
      Throws:
      NumberFormatException - thrown in case conversion fails.

    • asDoubleArray

      default double[] asDoubleArray(Object aKey)
      Same as asDoubleArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asDoubleArray

      default double[] asDoubleArray(Object aKey, char aDelimiter)
      Treats the value associated with the given key as a double array with its elements being the elements of the value separated by the given delimiter double. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') double as delimiter, will be { true, false, true, false, true }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.
      Throws:
      NumberFormatException - thrown in case conversion fails.

    • asDoubleArray

      default double[] asDoubleArray(String aKey)
      Same as asDoubleArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asDoubleArray

      default double[] asDoubleArray(String aKey, char aDelimiter)
      Treats the value associated with the given key as a double array with its elements being the elements of the value separated by the given delimiter double. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') double as delimiter, will be { true, false, true, false, true }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.
      Throws:
      NumberFormatException - thrown in case conversion fails.

    • asFloatArray

      default float[] asFloatArray(Object aKey)
      Same as asFloatArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asFloatArray

      default float[] asFloatArray(Object aKey, char aDelimiter)
      Treats the value associated with the given key as a float array with its elements being the elements of the value separated by the given delimiter float. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') float as delimiter, will be { true, false, true, false, true }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.
      Throws:
      NumberFormatException - thrown in case conversion fails.

    • asFloatArray

      default float[] asFloatArray(String aKey)
      Same as asFloatArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asFloatArray

      default float[] asFloatArray(String aKey, char aDelimiter)
      Treats the value associated with the given key as a float array with its elements being the elements of the value separated by the given delimiter float. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') float as delimiter, will be { true, false, true, false, true }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.
      Throws:
      NumberFormatException - thrown in case conversion fails.

    • asIntArray

      default int[] asIntArray(Object aKey)
      Same as asIntArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asIntArray

      default int[] asIntArray(Object aKey, char aDelimiter)
      Treats the value associated with the given key as a integer array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.
      Throws:
      NumberFormatException - thrown in case conversion fails.

    • asIntArray

      default int[] asIntArray(String aKey)
      Same as asIntArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asIntArray

      default int[] asIntArray(String aKey, char aDelimiter)
      Treats the value associated with the given key as a integer array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.
      Throws:
      NumberFormatException - thrown in case conversion fails.

    • asLongArray

      default long[] asLongArray(Object aKey)
      Same as asLongArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asLongArray

      default long[] asLongArray(Object aKey, char aDelimiter)
      Treats the value associated with the given key as a longeger array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.
      Throws:
      NumberFormatException - thrown in case conversion fails.

    • asLongArray

      default long[] asLongArray(String aKey)
      Same as asLongArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asLongArray

      default long[] asLongArray(String aKey, char aDelimiter)
      Treats the value associated with the given key as a longeger array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.
      Throws:
      NumberFormatException - thrown in case conversion fails.

    • asShortArray

      default short[] asShortArray(Object aKey)
      Same as asShortArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asShortArray

      default short[] asShortArray(Object aKey, char aDelimiter)
      Treats the value associated with the given key as a shorteger array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.
      Throws:
      NumberFormatException - thrown in case conversion fails.

    • asShortArray

      default short[] asShortArray(String aKey)
      Same as asShortArray(String, char) using a comma (',') as delimiter.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.

    • asShortArray

      default short[] asShortArray(String aKey, char aDelimiter)
      Treats the value associated with the given key as a shorteger array with its elements being the elements of the value separated by the given delimiter char. Let the value associated to the given key be "true, false, true, false, true", then the corresponding array, when using the comma (',') char as delimiter, will be { true, false, true, false, true }.
      Parameters:
      aKey - The key, which's value is to be converted to an array.
      aDelimiter - The delimiter to be used to identify the elements of the future array.
      Returns:
      The according array or null if no (or a null) value has been associated to the key.
      Throws:
      NumberFormatException - thrown in case conversion fails.

    • containsValue

      default boolean containsValue(Object value)
      This method is defined for the sake of Map conformity. Tests whether the provided value has a key assigned.
      Specified by:
      containsValue in interface Keys<String,String>
      Parameters:
      value - The value to test if a key references this value.
      Returns:
      True in case the given value is referenced by a key.

    • getDirAt

      default CanonicalTable getDirAt(String[] aPathElements, int aIndex)
      An indexed directory represents all elements which begin with a path which's last path element represents an index. There may by many sub-paths for the same indexed path which are all are included by the according directory. Returns the elements of the given index below the path of the path "array" path. Given the following paths and index = 1 with a queried path "/root/child": /root/child/0/0aaa /root/child/0/0bbb /root/child/0/0bbb /root/child/1/1aaa /root/child/1/1bbb /root/child/1/1bbb You will get a result containing all the elements which's keys begin with "/root/child/1/".The keys of the result will exclude the path "prefix" "/root/child/1".
      Specified by:
      getDirAt in interface ImmutablePathTable<String>
      Parameters:
      aPathElements - The elements of the path from which to get the indexed elements.
      aIndex - The index which to use.
      Returns:
      The indexed elements without the indexed path "prefixes".

    • getDirAt

      default CanonicalTable getDirAt(int aIndex)
      An indexed directory represents all elements which begin with a path which's last path element represents an index. There may by many sub-paths for the same indexed path which are all are included by the according directory. Returns the elements of the given index below the path of the root "array" path. Given the following paths and index = 1: /0/0aaa /0/0bbb /0/0bbb /1/1aaa /1/1bbb /1/1bbb You will get a result containing all the elements which's keys begin with "/1/". The keys of the result will exclude the path "prefix" "/1".
      Specified by:
      getDirAt in interface ImmutablePathTable<String>
      Parameters:
      aIndex - The index which to use.
      Returns:
      The indexed elements without the indexed path "prefixes".

    • getDirAt

      default CanonicalTable getDirAt(String aPath, int aIndex)
      An indexed directory represents all elements which begin with a path which's last path element represents an index. There may by many sub-paths for the same indexed path which are all are included by the according directory. Returns the elements of the given index below the path of the path "array" path. Given the following paths and index = 1 with a queried path "/root/child": /root/child/0/0aaa /root/child/0/0bbb /root/child/0/0bbb /root/child/1/1aaa /root/child/1/1bbb /root/child/1/1bbb You will get a result containing all the elements which's keys begin with "/root/child/1/".The keys of the result will exclude the path "prefix" "/root/child/1".
      Specified by:
      getDirAt in interface ImmutablePathTable<String>
      Parameters:
      aPath - The path from which to get the indexed elements.
      aIndex - The index which to use.
      Returns:
      The indexed elements without the indexed path "prefixes".

    • getDirAt

      default CanonicalTable getDirAt(Collection<?> aPathElements, int aIndex)
      An indexed directory represents all elements which begin with a path which's last path element represents an index. There may by many sub-paths for the same indexed path which are all are included by the according directory. Returns the elements of the given index below the path of the path "array" path. Given the following paths and index = 1 with a queried path "/root/child": /root/child/0/0aaa /root/child/0/0bbb /root/child/0/0bbb /root/child/1/1aaa /root/child/1/1bbb /root/child/1/1bbb You will get a result containing all the elements which's keys begin with "/root/child/1/".The keys of the result will exclude the path "prefix" "/root/child/1".
      Specified by:
      getDirAt in interface ImmutablePathTable<String>
      Parameters:
      aPathElements - The elements of the path from which to get the indexed elements.
      aIndex - The index which to use.
      Returns:
      The indexed elements without the indexed path "prefixes".

    • getDirAt

      default CanonicalTable getDirAt(Object aPath, int aIndex)
      An indexed directory represents all elements which begin with a path which's last path element represents an index. There may by many sub-paths for the same indexed path which are all are included by the according directory. Returns the elements of the given index below the path of the path "array" path. Given the following paths and index = 1 with a queried path "/root/child": /root/child/0/0aaa /root/child/0/0bbb /root/child/0/0bbb /root/child/1/1aaa /root/child/1/1bbb /root/child/1/1bbb You will get a result containing all the elements which's keys begin with "/root/child/1/". The keys of the result will exclude the path "prefix" "/root/child/1".
      Specified by:
      getDirAt in interface ImmutablePathTable<String>
      Parameters:
      aPath - The path from which to get the indexed elements.
      aIndex - The index which to use.
      Returns:
      The indexed elements without the indexed path "prefixes".

    • getDirAt

      default CanonicalTable getDirAt(Object[] aPathElements, int aIndex)
      An indexed directory represents all elements which begin with a path which's last path element represents an index. There may by many sub-paths for the same indexed path which are all are included by the according directory. Returns the elements of the given index below the path of the path "array" path. Given the following paths and index = 1 with a queried path "/root/child": /root/child/0/0aaa /root/child/0/0bbb /root/child/0/0bbb /root/child/1/1aaa /root/child/1/1bbb /root/child/1/1bbb You will get a result containing all the elements which's keys begin with "/root/child/1/".The keys of the result will exclude the path "prefix" "/root/child/1".
      Specified by:
      getDirAt in interface ImmutablePathTable<String>
      Parameters:
      aPathElements - The elements of the path from which to get the indexed elements.
      aIndex - The index which to use.
      Returns:
      The indexed elements without the indexed path "prefixes".

    • query

      default CanonicalTable query(Collection<?> aQueryElements)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      query in interface ImmutablePathTable<String>
      Parameters:
      aQueryElements - The elements representing the path query including your wildcards.
      Returns:
      The result contains the matching paths with the according values.

    • query

      default CanonicalTable query(Object... aQueryElements)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      query in interface ImmutablePathTable<String>
      Parameters:
      aQueryElements - The elements representing the path query including your wildcards.
      Returns:
      The result contains the matching paths with the according values.

    • query

      default CanonicalTable query(Pattern aRegExp)
      Queries the keys of the instance using a regular expression as of the provided Pattern instance.
      Specified by:
      query in interface ImmutablePathTable<String>
      Parameters:
      aRegExp - The regular expression to be used for the query.
      Returns:
      The matching properties.

    • query

      default CanonicalTable query(String aPathQuery)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      query in interface ImmutablePathTable<String>
      Parameters:
      aPathQuery - The path query including your wildcards.
      Returns:
      The result contains the matching paths with the according values.

    • query

      default CanonicalTable query(String... aQueryElements)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      query in interface ImmutablePathTable<String>
      Parameters:
      aQueryElements - The elements representing the path query including your wildcards.
      Returns:
      The result contains the matching paths with the according values.

    • queryBetween

      default CanonicalTable queryBetween(Collection<?> aFromPath, Collection<?> aPathQuery, Collection<?> aToPath)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      queryBetween in interface ImmutablePathTable<String>
      Parameters:
      aFromPath - The path from where to start querying and extracting the paths.
      aPathQuery - The path query including your wildcards.
      aToPath - The path where to relocate the result to.
      Returns:
      The result contains the matching paths (with respect to the from-path and the to-path) with the according values.

    • queryBetween

      default CanonicalTable queryBetween(Object aFromPath, Object aPathQuery, Object aToPath)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      queryBetween in interface ImmutablePathTable<String>
      Parameters:
      aFromPath - The path from where to start querying and extracting the paths.
      aPathQuery - The path query including your wildcards.
      aToPath - The path where to relocate the result to.
      Returns:
      The result contains the matching paths (with respect to the from-path and the to-path) with the according values.

    • queryBetween

      default CanonicalTable queryBetween(Object[] aFromPath, Object[] aPathQuery, Object[] aToPath)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      queryBetween in interface ImmutablePathTable<String>
      Parameters:
      aFromPath - The path from where to start querying and extracting the paths.
      aPathQuery - The path query including your wildcards.
      aToPath - The path where to relocate the result to.
      Returns:
      The result contains the matching paths (with respect to the from-path and the to-path) with the according values.

    • queryBetween

      default CanonicalTable queryBetween(String aFromPath, Pattern aRegExp, String aToPath)
      Queries the keys of the instance using a regular expression as of the provided Pattern.
      Specified by:
      queryBetween in interface ImmutablePathTable<String>
      Parameters:
      aFromPath - The path from where to start querying and extracting the paths.
      aRegExp - The regular expression to be used for the query.
      aToPath - The path where to relocate the result to.
      Returns:
      The result contains the matching paths (with respect to the from-path and the to-path) with the according values.

    • queryBetween

      default CanonicalTable queryBetween(String aFromPath, String aPathQuery, String aToPath)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      queryBetween in interface ImmutablePathTable<String>
      Parameters:
      aFromPath - The path from where to start querying and extracting the paths.
      aPathQuery - The path query including your wildcards.
      aToPath - The path where to relocate the result to.
      Returns:
      The result contains the matching paths (with respect to the from-path and the to-path) with the according values.

    • queryBetween

      default CanonicalTable queryBetween(String[] aFromPath, String[] aPathQuery, String[] aToPath)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      queryBetween in interface ImmutablePathTable<String>
      Parameters:
      aFromPath - The path from where to start querying and extracting the paths.
      aPathQuery - The path query including your wildcards.
      aToPath - The path where to relocate the result to.
      Returns:
      The result contains the matching paths (with respect to the from-path and the to-path) with the according values.

    • queryFrom

      default CanonicalTable queryFrom(Collection<?> aPathQuery, Collection<?> aFromPath)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      queryFrom in interface ImmutablePathTable<String>
      Parameters:
      aPathQuery - The path query including your wildcards.
      aFromPath - The path from where to start querying and extracting the paths.
      Returns:
      The result contains the matching paths (with respect to the from-path) with the according values.

    • queryFrom

      default CanonicalTable queryFrom(Object aPathQuery, Object aFromPath)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      queryFrom in interface ImmutablePathTable<String>
      Parameters:
      aPathQuery - The path query including your wildcards.
      aFromPath - The path from where to start querying and extracting the paths.
      Returns:
      The result contains the matching paths (with respect to the from-path) with the according values.

    • queryFrom

      default CanonicalTable queryFrom(Object[] aPathQuery, Object[] aFromPath)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      queryFrom in interface ImmutablePathTable<String>
      Parameters:
      aPathQuery - The path query including your wildcards.
      aFromPath - The path from where to start querying and extracting the paths.
      Returns:
      The result contains the matching paths (with respect to the from-path) with the according values.

    • queryFrom

      default CanonicalTable queryFrom(Pattern aRegExp, String aFromPath)
      Queries the keys of the instance using a regular expression as of the provided Pattern.
      Specified by:
      queryFrom in interface ImmutablePathTable<String>
      Parameters:
      aRegExp - The regular expression to be used for the query.
      aFromPath - The path from where to start querying and extracting the paths.
      Returns:
      The result contains the matching paths (with respect to the from-path) with the according values.

    • queryFrom

      default CanonicalTable queryFrom(String aPathQuery, String aFromPath)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      queryFrom in interface ImmutablePathTable<String>
      Parameters:
      aPathQuery - The path query including your wildcards.
      aFromPath - The path from where to start querying and extracting the paths.
      Returns:
      The result contains the matching paths (with respect to the from-path) with the according values.

    • queryFrom

      default CanonicalTable queryFrom(String[] aPathQuery, String[] aFromPath)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      queryFrom in interface ImmutablePathTable<String>
      Parameters:
      aPathQuery - The path query including your wildcards.
      aFromPath - The path from where to start querying and extracting the paths.
      Returns:
      The result contains the matching paths (with respect to the from-path) with the according values.

    • queryTo

      default CanonicalTable queryTo(Collection<?> aPathQuery, String aToPath)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      queryTo in interface ImmutablePathTable<String>
      Parameters:
      aPathQuery - The path query including your wildcards.
      aToPath - The path where to relocate the result to.
      Returns:
      The result contains the matching paths (with respect to the to-path) with the according values.

    • queryTo

      default CanonicalTable queryTo(Object aPathQuery, String aToPath)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      queryTo in interface ImmutablePathTable<String>
      Parameters:
      aPathQuery - The path query including your wildcards.
      aToPath - The path where to relocate the result to.
      Returns:
      The result contains the matching paths (with respect to the to-path) with the according values.

    • queryTo

      default CanonicalTable queryTo(Object[] aPathQuery, String aToPath)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      queryTo in interface ImmutablePathTable<String>
      Parameters:
      aPathQuery - The path query including your wildcards.
      aToPath - The path where to relocate the result to.
      Returns:
      The result contains the matching paths (with respect to the to-path) with the according values.

    • queryTo

      default CanonicalTable queryTo(Pattern aRegExp, String aToPath)
      Queries the keys of the instance using a regular expression as of the provided Pattern.
      Specified by:
      queryTo in interface ImmutablePathTable<String>
      Parameters:
      aRegExp - The regular expression to be used for the query.
      aToPath - The path where to relocate the result to.
      Returns:
      The result contains the matching paths (with respect to the to-path) with the according values.

    • queryTo

      default CanonicalTable queryTo(String aPathQuery, String aToPath)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      queryTo in interface ImmutablePathTable<String>
      Parameters:
      aPathQuery - The path query including your wildcards.
      aToPath - The path where to relocate the result to.
      Returns:
      The result contains the matching paths (with respect to the to-path) with the according values.

    • queryTo

      default CanonicalTable queryTo(String[] aPathQuery, String aToPath)
      Queries the keys of the instance using the PathMatcher' matching patterns, similar to the wildcards '*', '?' and '**' known when querying folders of a filesystem: The PathMatcher applies the following rules from the ANT path pattern to the query provided: A single asterisk ("*" as of Wildcard.FILE) matches zero or more characters within a path name. A double asterisk ("**" as of Wildcard.PATH) matches zero or more characters across directory levels. A question mark ("?" as of Wildcard.CHAR) matches exactly one character within a path name. The single asterisk ("*" as of Wildcard.FILE), the double asterisk ("**" as of Wildcard.PATH) and the question mark ("?" as of Wildcard.CHAR) we refer to as wildcards.
      Specified by:
      queryTo in interface ImmutablePathTable<String>
      Parameters:
      aPathQuery - The path query including your wildcards.
      aToPath - The path where to relocate the result to.
      Returns:
      The result contains the matching paths (with respect to the to-path) with the according values.

    • retrieveBetween

      default CanonicalTable retrieveBetween(Collection<?> aFromPath, Collection<?> aToPath)
      Extracts a new PathTable from the elements of this instance found below the "from-path". The sub-paths will be relocated to the provided "to-path".
      Specified by:
      retrieveBetween in interface ImmutablePathTable<String>
      Parameters:
      aFromPath - The path from where to start extracting the paths.
      aToPath - The path where to relocate the extracted paths to.
      Returns:
      The PathTable with the elements below the provided path "from-path" relocated to the given "to-path".

    • retrieveBetween

      default CanonicalTable retrieveBetween(Object aFromPath, Object aToPath)
      Extracts a new PathTable from the elements of this instance found below the "from-path". The sub-paths will be relocated to the provided "to-path".
      Specified by:
      retrieveBetween in interface ImmutablePathTable<String>
      Parameters:
      aFromPath - The path from where to start extracting the paths.
      aToPath - The path where to relocate the extracted paths to.
      Returns:
      The PathTable with the elements below the provided path "from-path" relocated to the given "to-path".

    • retrieveBetween

      default CanonicalTable retrieveBetween(Object[] aFromPath, Object[] aToPath)
      Extracts a new PathTable from the elements of this instance found below the "from-path". The sub-paths will be relocated to the provided "to-path".
      Specified by:
      retrieveBetween in interface ImmutablePathTable<String>
      Parameters:
      aFromPath - The path from where to start extracting the paths.
      aToPath - The path where to relocate the extracted paths to.
      Returns:
      The PathTable with the elements below the provided path "from-path" relocated to the given "to-path".

    • retrieveBetween

      default CanonicalTable retrieveBetween(String aFromPath, String aToPath)
      Extracts a new PathTable from the elements of this instance found below the "from-path". The sub-paths will be relocated to the provided "to-path".
      Specified by:
      retrieveBetween in interface ImmutablePathTable<String>
      Parameters:
      aFromPath - The path from where to start extracting the paths.
      aToPath - The path where to relocate the extracted paths to.
      Returns:
      The PathTable with the elements below the provided path "from-path" relocated to the given "to-path".

    • retrieveBetween

      default CanonicalTable retrieveBetween(String[] aFromPath, String[] aToPath)
      Extracts a new PathTable from the elements of this instance found below the "from-path". The sub-paths will be relocated to the provided "to-path".
      Specified by:
      retrieveBetween in interface ImmutablePathTable<String>
      Parameters:
      aFromPath - The path from where to start extracting the paths.
      aToPath - The path where to relocate the extracted paths to.
      Returns:
      The PathTable with the elements below the provided path "from-path" relocated to the given "to-path".

    • retrieveFrom

      default CanonicalTable retrieveFrom(Collection<?> aPathElements)
      Gets the children elements of the provided parent's path elements, excluding the parent's path.
      Specified by:
      retrieveFrom in interface ImmutablePathTable<String>
      Parameters:
      aPathElements - The path elements from where to retrieve the children.
      Returns:
      The children of the given parent's path.

    • retrieveFrom

      default CanonicalTable retrieveFrom(Object aParentPath)
      Gets the children elements of the provided parent's path, excluding the parent's path.
      Specified by:
      retrieveFrom in interface ImmutablePathTable<String>
      Parameters:
      aParentPath - The path from where to retrieve the children.
      Returns:
      The children of the given parent's path.

    • retrieveFrom

      default CanonicalTable retrieveFrom(Object... aPathElements)
      Gets the children elements of the provided parent's path elements, excluding the parent's path.
      Specified by:
      retrieveFrom in interface ImmutablePathTable<String>
      Parameters:
      aPathElements - The path elements from where to retrieve the children.
      Returns:
      The children of the given parent's path.

    • retrieveFrom

      CanonicalTable retrieveFrom(String aFromPath)
      Extracts a new PathTable from the elements of this instance found below the "from-path". The sub-paths will be the root paths for the new PathTable. Given we have a value for path "/dog/cat" in the PathTable and we call ImmutablePathTable.retrieveFrom(String) with "/dog", then the resulting PathTable will contain the path "/cat" for that value.
      Specified by:
      retrieveFrom in interface ImmutablePathTable<String>
      Parameters:
      aFromPath - The path from where to start extracting the paths.
      Returns:
      The PathTable with the elements below the provided path which are root elements in the new PathTable.

    • retrieveFrom

      default CanonicalTable retrieveFrom(String... aPathElements)
      Gets the children elements of the provided parent's path elements, excluding the parent's path.
      Specified by:
      retrieveFrom in interface ImmutablePathTable<String>
      Parameters:
      aPathElements - The path elements from where to retrieve the children.
      Returns:
      The children of the given parent's path.

    • retrieveTo

      default CanonicalTable retrieveTo(Collection<?> aToPathElements)
      Extracts a new PathTable from this instance's elements with the paths relocated to the provided "to-path". Given we have a value for path "/dog/cat" in the PathTable and we call ImmutablePathTable.retrieveTo(String) with "/animals", then the resulting PathTable will contain the path "/animals/dog/cat" for that value.
      Specified by:
      retrieveTo in interface ImmutablePathTable<String>
      Parameters:
      aToPathElements - The path elements representing the path where to relocate the paths of this instance to.
      Returns:
      The PathTable with the elements from the provided PathTable with accordingly relocated paths.

    • retrieveTo

      default CanonicalTable retrieveTo(Object aToPath)
      Extracts a new PathTable from this instance's elements with the paths relocated to the provided "to-path". Given we have a value for path "/dog/cat" in the PathTable and we call ImmutablePathTable.retrieveTo(String) with "/animals", then the resulting PathTable will contain the path "/animals/dog/cat" for that value.
      Specified by:
      retrieveTo in interface ImmutablePathTable<String>
      Parameters:
      aToPath - The path where to relocate the paths of this PathTable to.
      Returns:
      The PathTable with the elements from the provided PathTable with accordingly relocated paths.

    • retrieveTo

      default CanonicalTable retrieveTo(Object... aToPathElements)
      Extracts a new PathTable from this instance's elements with the paths relocated to the provided "to-path". Given we have a value for path "/dog/cat" in the PathTable and we call ImmutablePathTable.retrieveTo(String) with "/animals", then the resulting PathTable will contain the path "/animals/dog/cat" for that value.
      Specified by:
      retrieveTo in interface ImmutablePathTable<String>
      Parameters:
      aToPathElements - The path elements representing the path where to relocate the paths of this instance to.
      Returns:
      The PathTable with the elements from the provided PathTable with accordingly relocated paths.

    • retrieveTo

      CanonicalTable retrieveTo(String aToPath)
      Extracts a new PathTable from this instance's elements with the paths relocated to the provided "to-path". Given we have a value for path "/dog/cat" in the PathTable and we call ImmutablePathTable.retrieveTo(String) with "/animals", then the resulting PathTable will contain the path "/animals/dog/cat" for that value.
      Specified by:
      retrieveTo in interface ImmutablePathTable<String>
      Parameters:
      aToPath - The path where to relocate the paths of this PathTable to.
      Returns:
      The PathTable with the elements from the provided PathTable with accordingly relocated paths.

    • retrieveTo

      default CanonicalTable retrieveTo(String... aToPathElements)
      Extracts a new PathTable from this instance's elements with the paths relocated to the provided "to-path". Given we have a value for path "/dog/cat" in the PathTable and we call ImmutablePathTable.retrieveTo(String) with "/animals", then the resulting PathTable will contain the path "/animals/dog/cat" for that value.
      Specified by:
      retrieveTo in interface ImmutablePathTable<String>
      Parameters:
      aToPathElements - The path elements representing the path where to relocate the paths of this instance to.
      Returns:
      The PathTable with the elements from the provided PathTable with accordingly relocated paths.

    • getDir

      default CanonicalTable getDir(Collection<?> aPathElements)
      Gets the children elements of the provided parent's path elements, excluding the parent's path.
      Specified by:
      getDir in interface ImmutablePathTable<String>
      Parameters:
      aPathElements - The path elements from where to retrieve the children.
      Returns:
      The children of the given parent's path.

    • getDir

      default CanonicalTable getDir(Object aPath)
      Gets the children elements of the provided parent's path, excluding the parent's path.
      Specified by:
      getDir in interface ImmutablePathTable<String>
      Parameters:
      aPath - The path from where to retrieve the children.
      Returns:
      The children of the given parent's path.

    • getDir

      default CanonicalTable getDir(Object... aPathElements)
      Gets the children elements of the provided parent's path elements, excluding the parent's path.
      Specified by:
      getDir in interface ImmutablePathTable<String>
      Parameters:
      aPathElements - The path elements from where to retrieve the children.
      Returns:
      The children of the given parent's path.

    • getDir

      default CanonicalTable getDir(String aPath)
      Gets the children elements of the provided parent's path elements, excluding the parent's path.
      Specified by:
      getDir in interface ImmutablePathTable<String>
      Parameters:
      aPath - The path from where to retrieve the children.
      Returns:
      The children of the given parent's path.

    • getDir

      default CanonicalTable getDir(String... aPathElements)
      Gets the children elements of the provided parent's path elements, excluding the parent's path.
      Specified by:
      getDir in interface ImmutablePathTable<String>
      Parameters:
      aPathElements - The path elements from where to retrieve the children.
      Returns:
      The children of the given parent's path.

    • getDirs

      default CanonicalTable[] getDirs(Collection<?> aPathElements)
      Gets the children elements of the provided parent's path, excluding the parent's path. If the parent points to a directory index (as of ImmutablePathTable.isIndexDir() and the like methods), then the indexed directories are returned with their directory index corresponding to the returned array's index. parent's path.
      Specified by:
      getDirs in interface ImmutablePathTable<String>
      Parameters:
      aPathElements - The path elements from where to retrieve the children.
      Returns:
      An array with the children directories of the given parent's path: If the path points to an indexed directory (as of ImmutablePathTable.isIndexDir() or the like), then each indexed directory is represented by an element of the array at the according index. If the path does not point to an indexed directory, then the directory itself is returned as the only element in the returned array.

    • getDirs

      default CanonicalTable[] getDirs(Object aPath)
      Gets the children elements of the provided parent's path, excluding the parent's path. If the parent points to a directory index (as of ImmutablePathTable.isIndexDir() and the like methods), then the indexed directories are returned with their directory index corresponding to the returned array's index. parent's path.
      Specified by:
      getDirs in interface ImmutablePathTable<String>
      Parameters:
      aPath - The path from where to retrieve the children.
      Returns:
      An array with the children directories of the given parent's path: If the path points to an indexed directory (as of ImmutablePathTable.isIndexDir() or the like), then each indexed directory is represented by an element of the array at the according index. If the path does not point to an indexed directory, then the directory itself is returned as the only element in the returned array.

    • getDirs

      default CanonicalTable[] getDirs(Object... aPathElements)
      Gets the children elements of the provided parent's path elements, excluding the parent's path. If the parent points to a directory index (as of ImmutablePathTable.isIndexDir() and the like methods), then the indexed directories are returned with their directory index corresponding to the returned array's index. parent's path.
      Specified by:
      getDirs in interface ImmutablePathTable<String>
      Parameters:
      aPathElements - The path elements from where to retrieve the children.
      Returns:
      An array with the children directories of the given parent's path: If the path points to an indexed directory (as of ImmutablePathTable.isIndexDir() or the like), then each indexed directory is represented by an element of the array at the according index. If the path does not point to an indexed directory, then the directory itself is returned as the only element in the returned array.

    • getDirs

      default CanonicalTable[] getDirs(String aPath)
      Gets the children elements of the provided parent's path elements, excluding the parent's path. If the parent points to a directory index (as of ImmutablePathTable.isIndexDir() and the like methods), then the indexed directories are returned with their directory index corresponding to the returned array's index. parent's path.
      Specified by:
      getDirs in interface ImmutablePathTable<String>
      Parameters:
      aPath - The path from where to retrieve the children.
      Returns:
      An array with the children directories of the given parent's path: If the path points to an indexed directory (as of ImmutablePathTable.isIndexDir() or the like), then each indexed directory is represented by an element of the array at the according index. If the path does not point to an indexed directory, then the directory itself is returned as the only element in the returned array.

    • getDirs

      default CanonicalTable[] getDirs(String... aPathElements)
      Gets the children elements of the provided parent's path elements, excluding the parent's path. If the parent points to a directory index (as of ImmutablePathTable.isIndexDir() and the like methods), then the indexed directories are returned with their directory index corresponding to the returned array's index. parent's path.
      Specified by:
      getDirs in interface ImmutablePathTable<String>
      Parameters:
      aPathElements - The path elements from where to retrieve the children.
      Returns:
      An array with the children directories of the given parent's path: If the path points to an indexed directory (as of ImmutablePathTable.isIndexDir() or the like), then each indexed directory is represented by an element of the array at the according index. If the path does not point to an indexed directory, then the array. directory itself is returned as the only element in the returned

    • toMap

      default Map<String,String> toMap()
      This method creates a Map instance from this ImmutableCanonicalTable instance's elements (key/value-pairs) as of interoperability reasons.
      Specified by:
      toMap in interface ImmutablePathTable<String>
      Returns:
      A Map object from the herein contained key/value-pairs .

    • toProperties

      default Properties toProperties()
      This method creates a Properties instance from this Properties instance's elements (key/value-pairs) as of interoperability reasons.
      Returns:
      A Properties object from the herein contained key/value-pairs .