Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.infinispan.tree.impl;
  
 
 import java.util.Map;
 import java.util.Set;

Implementation backed by an org.infinispan.atomic.AtomicMap

Author(s):
Manik Surtani (manik AT jboss DOT org)
Since:
4.0
 
 public class NodeImpl<K, V> extends TreeStructureSupport implements Node<K, V> {
    Fqn fqn;
 
    public NodeImpl(Fqn fqnAdvancedCache<?, ?> cacheBatchContainer batchContainer) {
       super(cachebatchContainer);
       this. = fqn;
        = new NodeKey(fqn..);
        = new NodeKey(fqn..);
    }
 
    @Override
    public Node<K, V> getParent() {
       return getParent();
    }
 
    @Override
    public Node<K, V> getParent(Flag... flags) {
       return getParent(.withFlags(flags));
    }
 
    private Node<K, V> getParent(AdvancedCache<?, ?> cache) {
       if (.isRoot()) return this;
       return new NodeImpl<K, V>(.getParent(), cache);
    }
 
    @Override
    public Set<Node<K, V>> getChildren() {
       return getChildren();
    }
 
    @Override
    public Set<Node<K, V>> getChildren(Flag... flags) {
       return getChildren(.withFlags(flags));
    }
 
    private Set<Node<K, V>> getChildren(AdvancedCache<?, ?> cache) {
       startAtomic();
       try {
          Set<Node<K, V>> result = new HashSet<Node<K, V>>();
          for (Fqn f : getStructure().values()) {
             NodeImpl<K, V> n = new NodeImpl<K, V>(fcache);
             result.add(n);
          }
          return Immutables.immutableSetWrap(result);
       }
       finally {
          endAtomic();
       }
    }
 
    @Override
    public Set<ObjectgetChildrenNames() {
       return getChildrenNames();
    }
 
    @Override
    public Set<ObjectgetChildrenNames(Flag... flags) {
       return getChildrenNames(.withFlags(flags));
    }
 
    private Set<ObjectgetChildrenNames(AdvancedCache<?, ?> cache) {
       return Immutables.immutableSetCopy(getStructure(cache).keySet());
    }
 
    @Override
    public Map<K, V> getData() {
       return getData();
    }
 
    @Override
    public Map<K, V> getData(Flag... flags) {
       return getData(.withFlags(flags));
    }
 
   private Map<K, V> getData(AdvancedCache<?, ?> cache) {
      return Collections.unmodifiableMap(new HashMap<K, V>(getDataInternal(cache)));
   }
   public Set<K> getKeys() {
      return getKeys();
   }
   public Set<K> getKeys(Flag... flags) {
      return getKeys(.withFlags(flags));
   }
   private Set<K> getKeys(AdvancedCache<?, ?> cache) {
      startAtomic();
      try {
         return getData(cache).keySet();
      }
      finally {
         endAtomic();
      }
   }
   public Fqn getFqn() {
      return ;
   }
   public Node<K, V> addChild(Fqn f) {
      return addChild(f);
   }
   public Node<K, V> addChild(Fqn fFlag... flags) {
      return addChild(.withFlags(flags), f);
   }
   private Node<K, V> addChild(AdvancedCache<?, ?> cacheFqn f) {
      startAtomic();
      try {
         Fqn absoluteChildFqn = Fqn.fromRelativeFqn(f);
         //1) first register it with the parent
         AtomicMap<ObjectFqnstructureMap = getStructure(cache);
         structureMap.put(f.getLastElement(), absoluteChildFqn);
         //2) then create the structure and data maps
         createNodeInCache(cacheabsoluteChildFqn);
         return new NodeImpl<K, V>(absoluteChildFqncache);
      }
      finally {
         endAtomic();
      }
   }
   public boolean removeChild(Fqn f) {
      return removeChild(f);
   }
   public boolean removeChild(Fqn fFlag... flags) {
      return removeChild(.withFlags(flags), f);
   }
   public boolean removeChild(AdvancedCache<?, ?> cacheFqn f) {
      return removeChild(cachef.getLastElement());
   }
   public boolean removeChild(Object childName) {
      return removeChild(childName);
   }
   public boolean removeChild(Object childNameFlag... flags) {
      return removeChild(.withFlags(flags), childName);
   }
   private boolean removeChild(AdvancedCache cacheObject childName) {
      startAtomic();
      try {
         AtomicMap<ObjectFqns = getStructure(cache);
         Fqn childFqn = s.remove(childName);
         if (childFqn != null) {
            Node<K, V> child = new NodeImpl<K, V>(childFqncache);
            child.removeChildren();
            child.clearData();  // this is necessary in case we have a remove and then an add on the same node, in the same tx.
            cache.remove(new NodeKey(childFqn..));
            cache.remove(new NodeKey(childFqn..));
            return true;
         }
         return false;
      }
      finally {
         endAtomic();
      }
   }
   public Node<K, V> getChild(Fqn f) {
      return getChild(f);
   }
   public Node<K, V> getChild(Fqn fFlag... flags) {
      return getChild(.withFlags(flags), f);
   }
   private Node<K, V> getChild(AdvancedCache cacheFqn f) {
      startAtomic();
      try {
         if (hasChild(f))
            return new NodeImpl<K, V>(Fqn.fromRelativeFqn(f), cache);
         else
            return null;
      }
      finally {
         endAtomic();
      }
   }
   public Node<K, V> getChild(Object name) {
      return getChild(name);
   }
   public Node<K, V> getChild(Object nameFlag... flags) {
      return getChild(.withFlags(flags), name);
   }
   private Node<K, V> getChild(AdvancedCache cacheObject name) {
      startAtomic();
      try {
         if (hasChild(name))
            return new NodeImpl<K, V>(Fqn.fromRelativeElements(name), cache);
         else
            return null;
      }
      finally {
         endAtomic();
      }
   }
   public V put(K key, V value) {
      return put(keyvalue);
   }
   public V put(K key, V valueFlag... flags) {
      return put(.withFlags(flags), keyvalue);
   }
   private V put(AdvancedCache cache, K key, V value) {
      startAtomic();
      try {
         AtomicHashMapProxy<K, V> map = (AtomicHashMapProxy<K, V>) getDataInternal(cache);
         return map.put(keyvalue);
      }
      finally {
         endAtomic();
      }
   }
   public V putIfAbsent(K key, V value) {
      return putIfAbsent(keyvalue);
   }
   public V putIfAbsent(K key, V valueFlag... flags) {
      return putIfAbsent(.withFlags(flags), keyvalue);
   }
   private V putIfAbsent(AdvancedCache<?, ?> cache, K key, V value) {
      startAtomic();
      try {
         AtomicMap<K, V> data = getDataInternal(cache);
         if (!data.containsKey(key)) return data.put(keyvalue);
         return null;
      }
      finally {
         endAtomic();
      }
   }
   public V replace(K key, V value) {
      return replace(keyvalue);
   }
   public V replace(K key, V valueFlag... flags) {
      return replace(.withFlags(flags), keyvalue);
   }
   private V replace(AdvancedCache<?, ?> cache, K key, V value) {
      startAtomic();
      try {
         AtomicMap<K, V> map = getAtomicMap(cache);
         if (map.containsKey(key))
            return map.put(keyvalue);
         else
            return null;
      }
      finally {
         endAtomic();
      }
   }
   public boolean replace(K key, V oldValue, V newValue) {
      return replace(keyoldValuenewValue);
   }
   public boolean replace(K key, V oldValue, V newValueFlag... flags) {
      return replace(.withFlags(flags), keyoldValuenewValue);
   }
   private boolean replace(AdvancedCache<?, ?> cache, K key, V oldValue, V newValue) {
      startAtomic();
      try {
         AtomicMap<K, V> data = getDataInternal(cache);
         V old = data.get(key);
         if (Util.safeEquals(oldValueold)) {
            data.put(keynewValue);
            return true;
         }
         return false;
      }
      finally {
         endAtomic();
      }
   }
   public void putAll(Map<? extends K, ? extends V> map) {
      putAll(map);
   }
   public void putAll(Map<? extends K, ? extends V> mapFlag... flags) {
      putAll(.withFlags(flags), map);
   }
   private void putAll(AdvancedCache cacheMap<? extends K, ? extends V> map) {
      startAtomic();
      try {
         getDataInternal(cache).putAll(map);
      }
      finally {
         endAtomic();
      }
   }
   public void replaceAll(Map<? extends K, ? extends V> map) {
      replaceAll(map);
   }
   public void replaceAll(Map<? extends K, ? extends V> mapFlag... flags) {
      replaceAll(.withFlags(flags), map);
   }
   private void replaceAll(AdvancedCache cacheMap<? extends K, ? extends V> map) {
      startAtomic();
      try {
         AtomicMap<K, V> data = getDataInternal(cache);
         data.clear();
         data.putAll(map);
      }
      finally {
         endAtomic();
      }
   }
   public V get(K key) {
      return get(key);
   }
   public V get(K keyFlag... flags) {
      return get(.withFlags(flags), key);
   }
   private V get(AdvancedCache cache, K key) {
      return getData(cache).get(key);
   }
   public V remove(K key) {
      return remove(key);
   }
   public V remove(K keyFlag... flags) {
      return remove(.withFlags(flags), key);
   }
   private V remove(AdvancedCache cache, K key) {
      startAtomic();
      try {
         return getDataInternal(cache).remove(key);
      }
      finally {
         endAtomic();
      }
   }
   public void clearData() {
      clearData();
   }
   public void clearData(Flag... flags) {
      clearData(.withFlags(flags));
   }
   private void clearData(AdvancedCache<?, ?> cache) {
      getDataInternal(cache).clear();
   }
   public int dataSize() {
      return dataSize();
   }
   public int dataSize(Flag... flags) {
      return dataSize(.withFlags(flags));
   }
   private int dataSize(AdvancedCache<?, ?> cache) {
      return getData(cache).size();
   }
   public boolean hasChild(Fqn f) {
      return hasChild(f);
   }
   public boolean hasChild(Fqn fFlag... flags) {
      return hasChild(.withFlags(flags), f);
   }
   private boolean hasChild(AdvancedCache<?, ?> cacheFqn f) {
      if (f.size() > 1) {
         // indirect child.
         Fqn absoluteFqn = Fqn.fromRelativeFqn(f);
         return exists(cacheabsoluteFqn);
      } else {
         return hasChild(f.getLastElement());
      }
   }
   public boolean hasChild(Object o) {
      return hasChild(o);
   }
   public boolean hasChild(Object oFlag... flags) {
      return hasChild(.withFlags(flags), o);
   }
   private boolean hasChild(AdvancedCache<?, ?> cacheObject o) {
      return getStructure(cache).containsKey(o);
   }
   public boolean isValid() {
      return .containsKey();
   }
   public void removeChildren() {
      removeChildren();
   }
   public void removeChildren(Flag... flags) {
      removeChildren(.withFlags(flags));
   }
   private void removeChildren(AdvancedCache<?, ?> cache) {
      startAtomic();
      try {
         Map<ObjectFqns = getStructure(cache);
         for (Object o : Immutables.immutableSetCopy(s.keySet()))
            removeChild(cacheo);
      }
      finally {
         endAtomic();
      }
   }
   AtomicMap<K, V> getDataInternal(AdvancedCache<?, ?> cache) {
      return getAtomicMap(cache);
   }
      return getAtomicMap();
   }
   private AtomicMap<ObjectFqngetStructure(AdvancedCache<?, ?> cache) {
      return getAtomicMap(cache);
   }
   public boolean equals(Object o) {
      if (this == oreturn true;
      if (o == null || getClass() != o.getClass()) return false;
      NodeImpl<?, ?> node = (NodeImpl<?, ?>) o;
      if ( != null ? !.equals(node.fqn) : node.fqn != nullreturn false;
      return true;
   }
   public int hashCode() {
      return ( != null ? .hashCode() : 0);
   }
   public String toString() {
      return "NodeImpl{" +
            "fqn=" +  +
            '}';
   }
New to GrepCode? Check out our FAQ X