Package com.evolveum.midpoint.prism.path

Class ItemPathCollectionsUtil

java.lang.Object
com.evolveum.midpoint.prism.path.ItemPathCollectionsUtil
public class ItemPathCollectionsUtil extends Object
Methods that operate on path collections.

  • Constructor Details

    • ItemPathCollectionsUtil

      public ItemPathCollectionsUtil()

  • Method Details

    • containsEquivalent

      public static boolean containsEquivalent(Collection<? extends ItemPath> paths, ItemPath pathToBeFound)
      Returns true if the collection contains a path equivalent to `pathToBeFound`.

    • containsSubpath

      public static boolean containsSubpath(Collection<? extends ItemPath> paths, ItemPath pathToBeFound)
      Returns true if the collection contains a sub-path (prefix) of the given path. I.e. having collection = { `A/B`, `A/C` } then the method for this collection and `path` returns: - `path` = `A/B` -> `false` - `path` = `A` -> `false` - `path` = `A/B/C` -> `true` as `A/B` is a sub-path (prefix) for `A/B/C` - `path` = `X` -> `false`

    • containsSuperpathOrEquivalent

      public static boolean containsSuperpathOrEquivalent(Collection<? extends ItemPath> paths, ItemPath pathToBeFound)
      Returns true if the collection contains a superpath of or equivalent path to the given path. I.e. having collection = { A/B, A/C } then the method for this collection and 'pathToBeFound' returns: - pathToBeFound = A/B -> true - pathToBeFound = A -> true - pathToBeFound = A/B/C -> false - pathToBeFound = X -> false

    • containsSuperpath

      public static boolean containsSuperpath(Collection<? extends ItemPath> paths, ItemPath pathToBeFound)
      Returns true if the collection contains a superpath of the given path. I.e. having collection = { A/B, A/C } then the method for this collection and 'path' returns: - path = A/B -> false - path = A -> true - path = A/B/C -> false - path = X -> false

    • containsSubpathOrEquivalent

      public static boolean containsSubpathOrEquivalent(Collection<? extends ItemPath> paths, ItemPath pathToBeFound)
      Returns true if the collection contains a subpath of or equivalent path to the given path. I.e. having collection = { A/B, A/C } then the method for this collection and 'path' returns: - path = A/B -> true - path = A -> false - path = A/B/C -> true - path = X -> false

    • containsRelated

      public static boolean containsRelated(Collection<? extends ItemPath> paths, ItemPath pathToBeFound)
      Returns true if the collection contains a path related to (overlapping) the given one. By related-to/overlapping we mean that the set covers the given path either fully (i.e. it contains an equivalent path or a sub-path), or partially (i.e. it contains a super-path). I.e. having collection = { `A/B`, `A/C` } then the method for this collection and `path` returns: - `path` = `A/B` -> `true` - `path` = `A` -> `true` - `path` = `A/B/C` -> `true` - `path` = `X` -> `false`

    • remainder

      public static List<ItemPath> remainder(Collection<? extends ItemPath> paths, ItemPath prefix, boolean alsoEquivalent)
      Strips the prefix from a set of paths.
      Parameters:
      alsoEquivalent - If true, 'prefix' in paths is processed as well (resulting in empty path). Otherwise, it is skipped.

    • pathListFromStrings

      @NotNull public static @NotNull List<ItemPath> pathListFromStrings(List<String> pathsAsStrings, PrismContext prismContext)

    • asPathArray

      public static ItemPath[] asPathArray(QName... names)

    • asUniformPathArray

      public static UniformItemPath[] asUniformPathArray(PrismContext prismContext, QName... names)

    • putToMap

      public static <T> T putToMap(Map<UniformItemPath,T> map, UniformItemPath itemPath, T value)

    • putAllToMap

      public static <T> void putAllToMap(Map<UniformItemPath,T> target, Map<UniformItemPath,T> source)

    • getFromMap

      public static <T> T getFromMap(Map<UniformItemPath,T> map, UniformItemPath itemPath)

    • getFromMap

      public static <T> T getFromMap(Map<ItemPath,T> map, ItemPath itemPath)