Class DITCacheMap<T>

java.lang.Object
java.util.AbstractMap<Dn,T>
org.opends.server.api.DITCacheMap<T>
Type Parameters:
T - arbitrary object type.
All Implemented Interfaces:
Map<Dn,T>
public final class DITCacheMap<T> extends AbstractMap<Dn,T>
The DITCacheMap class implements custom Map for structural storage of arbitrary objects in Directory Information Tree (DIT) like structure.

This Map intended usage is for caching various server objects which can be subject to subtree operations like retrieval or removal of all objects under a specific DN. While using a regular Map it would require the entire Map iteration to achieve, this Map implementation maintains such internal structure that subtree operations are more efficient and do not require iterations over the entire map, instead additional subtree operations methods are provided by this Map to do just that.

API wise it behaves exactly like a regular Map implementation except for providing additional subtree methods. All required linkage and structuring is performed within this Map implementation itself and not exposed via the API in any way. For example, putting these key/value pairs: 

cn=Object1,ou=Objects,dc=example,dc=com : object1
cn=Object2,ou=Objects,dc=example,dc=com : object2
cn=Object3,ou=Objects,dc=example,dc=com : object3

then invoking a subtree method on this Map with any of these keys: 

ou=Objects,dc=example,dc=com
dc=example,dc=com
dc=com

would bring all three objects previously stored in this map into subtree operation scope. Standard Map API methods can only work with the objects previously stored in this map explicitly.

Note that this Map implementation is not synchronized.

  • Constructor Details

    • DITCacheMap

      public DITCacheMap()

  • Method Details

    • size

      public int size()
      Specified by:
      size in interface Map<Dn,T>
      Overrides:
      size in class AbstractMap<Dn,T>

    • isEmpty

      public boolean isEmpty()
      Specified by:
      isEmpty in interface Map<Dn,T>
      Overrides:
      isEmpty in class AbstractMap<Dn,T>

    • containsKey

      public boolean containsKey(Object key)
      Specified by:
      containsKey in interface Map<Dn,T>
      Overrides:
      containsKey in class AbstractMap<Dn,T>

    • containsValue

      public boolean containsValue(Object value)
      Specified by:
      containsValue in interface Map<Dn,T>
      Overrides:
      containsValue in class AbstractMap<Dn,T>

    • get

      public T get(Object key)
      Specified by:
      get in interface Map<Dn,T>
      Overrides:
      get in class AbstractMap<Dn,T>

    • getBaseDn

      public Dn getBaseDn(Dn entryDn)
      Find the Base DN of the provided DN.
      Parameters:
      entryDn - The DN of the entry for which to retrieve the corresponding base DN.
      Returns:
      The base DN if found, or null otherwise.

    • closestSubordinatesIterator

      public Iterator<Map.Entry<Dn,T>> closestSubordinatesIterator(Dn ancestorDn)
      Returns a filtered-view of this map containing only the entries which are the closest subordinates of the provided ancestorDn. Those entries could have a dn which is a child or a subordinate of the provided ancestorDn.
      Parameters:
      ancestorDn - The subtree ancestorDn. The ancestorDn does not have to exist in this map.
      Returns:
      A read-only Iterator on this map returning only entries which are the closest subordinates of ancestorDn. ancestorDn is the common ancestor to all entries returned by the iterator. Iterator.remove() will throw an UnsupportedOperationException.

    • getWholeSubtreeValues

      public Collection<T> getWholeSubtreeValues(Dn key)
      Returns values from the stored objects associated with the subtree having the provided base DN.
      Parameters:
      key - subtree DN.
      Returns:
      values from the stored objects associated with the subtree having the provided base DN

    • computeChildrenDns

      public List<Dn> computeChildrenDns(Dn parentDn, int maxNumberOfChildren)
      Computes the children DNs of the provided parent DN only if subordinate DNs exist for them in the map.

      Example, if this map contains: 

      dc=com
uid=user.0,ou=people,dc=org-foo,dc=com
uid=user.1,ou=people,dc=org-foo,dc=com
cn=admin,ou=groups,dc=org-bar,dc=com
      then: 
      computeChildren(dc=com) -> [dc=org-foo,dc=com - dc=org-bar,dc=com]
computeChildren(dc=org-foo,dc=com) -> [ ]
computeChildren(uid=user.0,ou=people,dc=org-foo,dc=com) -> [ ]
      Parameters:
      parentDn - the parent DN
      maxNumberOfChildren - the maximum number of children to return, 0 means no limit
      Returns:
      the list through the unique children dns, which might be empty if this map does not contain the provided parentDn nor subordinates.

    • hasSubordinate

      public boolean hasSubordinate(Dn ancestorDn)
      Returns true if there are DNs below the provided ancestorDn, excluding the ancestorDn itself.
      Parameters:
      ancestorDn - subtree ancestorDn. The ancestorDn does not have to exist in this map
      Returns:
      true if this map contains a subordinate DN of the ancestorDn, excluding the ancestorDn itself

    • put

      public T put(Dn key, T value)
      Specified by:
      put in interface Map<Dn,T>
      Overrides:
      put in class AbstractMap<Dn,T>

    • remove

      public T remove(Object key)
      Specified by:
      remove in interface Map<Dn,T>
      Overrides:
      remove in class AbstractMap<Dn,T>

    • containsSubtree

      public boolean containsSubtree(Dn key)
      Returns true if there are stored objects associated with the subtree having the provided base DN.
      Parameters:
      key - the subtree DN.
      Returns:
      true if there are stored objects associated with the subtree having the provided base DN

    • removeWholeSubtree

      public void removeWholeSubtree(Dn key, Collection<? super T> removedValues)
      Removes the stored objects associated with the subtree having the provided base DN.
      Parameters:
      key - subtree DN.
      removedValues - Collection in which to put the removed elements, or null.

    • putAll

      public void putAll(Map<? extends Dn, ? extends T> m)
      Specified by:
      putAll in interface Map<Dn,T>
      Overrides:
      putAll in class AbstractMap<Dn,T>

    • clear

      public void clear()
      Specified by:
      clear in interface Map<Dn,T>
      Overrides:
      clear in class AbstractMap<Dn,T>

    • entrySet

      public Set<Map.Entry<Dn,T>> entrySet()
      Specified by:
      entrySet in interface Map<Dn,T>
      Specified by:
      entrySet in class AbstractMap<Dn,T>