opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/sal/dom/broker/impl/HashMapDataStore.xtend

   1 package org.opendaylight.controller.sal.dom.broker.impl
   2
   3 import org.opendaylight.controller.md.sal.common.api.data.DataModification
   4 import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction
   5 import org.opendaylight.yangtools.yang.common.RpcResult
   6 import java.util.Map
   7 import java.util.concurrent.ConcurrentHashMap
   8 import org.opendaylight.controller.sal.common.util.Rpcs
   9 import java.util.Collections
  10 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier
  11 import org.opendaylight.yangtools.yang.data.api.CompositeNode
  12 import org.opendaylight.controller.sal.core.api.data.DataStore
  13 import java.util.HashSet
  14
  15 class HashMapDataStore implements DataStore, AutoCloseable {
  16
  17
  18     val Map<InstanceIdentifier, CompositeNode> configuration = new ConcurrentHashMap();
  19     val Map<InstanceIdentifier, CompositeNode> operational = new ConcurrentHashMap();
  20
  21
  22
  23     override containsConfigurationPath(InstanceIdentifier path) {
  24         throw new UnsupportedOperationException("TODO: auto-generated method stub")
  25
  26     }
  27
  28     override containsOperationalPath(InstanceIdentifier path) {
  29         throw new UnsupportedOperationException("TODO: auto-generated method stub")
  30     }
  31
  32     override getStoredConfigurationPaths() {
  33         configuration.keySet
  34     }
  35
  36     override getStoredOperationalPaths() {
  37         operational.keySet
  38     }
  39
  40     override readConfigurationData(InstanceIdentifier path) {
  41         configuration.get(path);
  42     }
  43
  44     override readOperationalData(InstanceIdentifier path) {
  45         operational.get(path);
  46     }
  47
  48
  49
  50     override requestCommit(DataModification<InstanceIdentifier, CompositeNode> modification) {
  51         return new HashMapDataStoreTransaction(modification, this);
  52     }
  53
  54     def RpcResult<Void> rollback(HashMapDataStoreTransaction transaction) {
  55         return Rpcs.getRpcResult(true, null, Collections.emptySet);
  56     }
  57
  58     def RpcResult<Void> finish(HashMapDataStoreTransaction transaction) {
  59         val modification = transaction.modification;
  60         configuration.putAll(modification.updatedConfigurationData);
  61         operational.putAll(modification.updatedOperationalData);
  62
  63         for (removal : modification.removedConfigurationData) {
  64             remove(configuration,removal);
  65         }
  66         for (removal : modification.removedOperationalData) {
  67             remove(operational,removal);
  68         }
  69         return Rpcs.getRpcResult(true, null, Collections.emptySet);
  70     }
  71
  72     def remove(Map<InstanceIdentifier, CompositeNode> map, InstanceIdentifier identifier) {
  73         val affected = new HashSet<InstanceIdentifier>();
  74         for(path : map.keySet) {
  75             if(identifier.contains(path)) {
  76                 affected.add(path);
  77             }
  78         }
  79         for(pathToRemove : affected) {
  80             map.remove(pathToRemove);
  81         }
  82
  83     }
  84
  85
  86     override close()  {
  87         // NOOP
  88     }
  89
  90 }
  91
  92 class HashMapDataStoreTransaction implements //
  93 DataCommitTransaction<InstanceIdentifier, CompositeNode> {
  94     @Property
  95     val DataModification<InstanceIdentifier, CompositeNode> modification
  96
  97     @Property
  98     val HashMapDataStore datastore;
  99
 100     new(
 101         DataModification<InstanceIdentifier, CompositeNode> modify,
 102         HashMapDataStore store
 103     ) {
 104         _modification = modify;
 105         _datastore = store;
 106     }
 107
 108     override finish() throws IllegalStateException {
 109         datastore.finish(this);
 110
 111     }
 112
 113     override getModification() {
 114         this._modification;
 115     }
 116
 117     override rollback() throws IllegalStateException {
 118         datastore.rollback(this);
 119     }
 120 }