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 static extension org.opendaylight.controller.sal.dom.broker.impl.DataUtils.*;
  13 import org.opendaylight.controller.sal.core.api.data.DataStore
  14 import java.util.HashSet
  15
  16 class HashMapDataStore implements DataStore, AutoCloseable {
  17
  18     val Map<InstanceIdentifier, CompositeNode> configuration = new ConcurrentHashMap();
  19     val Map<InstanceIdentifier, CompositeNode> operational = new ConcurrentHashMap();
  20
  21     override readConfigurationData(InstanceIdentifier path) {
  22         configuration.read(path);
  23     }
  24
  25     override readOperationalData(InstanceIdentifier path) {
  26         operational.read(path);
  27     }
  28
  29
  30
  31
  32     override requestCommit(DataModification<InstanceIdentifier, CompositeNode> modification) {
  33         return new HashMapDataStoreTransaction(modification, this);
  34     }
  35
  36     def RpcResult<Void> rollback(HashMapDataStoreTransaction transaction) {
  37         return Rpcs.getRpcResult(true, null, Collections.emptySet);
  38     }
  39
  40     def RpcResult<Void> finish(HashMapDataStoreTransaction transaction) {
  41         val modification = transaction.modification;
  42         configuration.putAll(modification.updatedConfigurationData);
  43         operational.putAll(modification.updatedOperationalData);
  44
  45         for (removal : modification.removedConfigurationData) {
  46             remove(configuration,removal);
  47         }
  48         for (removal : modification.removedOperationalData) {
  49             remove(operational,removal);
  50         }
  51         return Rpcs.getRpcResult(true, null, Collections.emptySet);
  52     }
  53
  54     def remove(Map<InstanceIdentifier, CompositeNode> map, InstanceIdentifier identifier) {
  55         val affected = new HashSet<InstanceIdentifier>();
  56         for(path : map.keySet) {
  57             if(identifier.contains(path)) {
  58                 affected.add(path);
  59             }
  60         }
  61         for(pathToRemove : affected) {
  62             map.remove(pathToRemove);
  63         }
  64
  65     }
  66
  67
  68     override close()  {
  69         // NOOP
  70     }
  71
  72 }
  73
  74 class HashMapDataStoreTransaction implements //
  75 DataCommitTransaction<InstanceIdentifier, CompositeNode> {
  76     @Property
  77     val DataModification<InstanceIdentifier, CompositeNode> modification
  78
  79     @Property
  80     val HashMapDataStore datastore;
  81
  82     new(
  83         DataModification<InstanceIdentifier, CompositeNode> modify,
  84         HashMapDataStore store
  85     ) {
  86         _modification = modify;
  87         _datastore = store;
  88     }
  89
  90     override finish() throws IllegalStateException {
  91         datastore.finish(this);
  92
  93     }
  94
  95     override getModification() {
  96         this._modification;
  97     }
  98
  99     override rollback() throws IllegalStateException {
 100         datastore.rollback(this);
 101     }
 102 }