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.DataReader
   4 import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler
   5 import org.opendaylight.controller.md.sal.common.api.data.DataModification
   6 import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction
   7 import org.opendaylight.yangtools.yang.common.RpcResult
   8 import java.util.Map
   9 import java.util.concurrent.ConcurrentHashMap
  10 import org.opendaylight.controller.sal.common.util.Rpcs
  11 import java.util.Collections
  12 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier
  13 import org.opendaylight.yangtools.yang.data.api.CompositeNode
  14 import static extension org.opendaylight.controller.sal.dom.broker.impl.DataUtils.*;
  15
  16 class HashMapDataStore //
  17 implements //
  18 DataReader<InstanceIdentifier, CompositeNode>, DataCommitHandler<InstanceIdentifier, CompositeNode> {
  19
  20     val Map<InstanceIdentifier, CompositeNode> configuration = new ConcurrentHashMap();
  21     val Map<InstanceIdentifier, CompositeNode> operational = new ConcurrentHashMap();
  22
  23     override readConfigurationData(InstanceIdentifier path) {
  24         configuration.read(path);
  25     }
  26
  27     override readOperationalData(InstanceIdentifier path) {
  28         operational.read(path);
  29     }
  30
  31
  32
  33
  34     override requestCommit(DataModification<InstanceIdentifier, CompositeNode> modification) {
  35         return new HashMapDataStoreTransaction(modification, this);
  36     }
  37
  38     def RpcResult<Void> rollback(HashMapDataStoreTransaction transaction) {
  39         return Rpcs.getRpcResult(true, null, Collections.emptySet);
  40     }
  41
  42     def RpcResult<Void> finish(HashMapDataStoreTransaction transaction) {
  43         val modification = transaction.modification;
  44         configuration.putAll(modification.updatedConfigurationData);
  45         operational.putAll(modification.updatedOperationalData);
  46
  47         for (removal : modification.removedConfigurationData) {
  48             configuration.remove(removal);
  49         }
  50         for (removal : modification.removedOperationalData) {
  51             operational.remove(removal);
  52         }
  53         return Rpcs.getRpcResult(true, null, Collections.emptySet);
  54     }
  55
  56 }
  57
  58 class HashMapDataStoreTransaction implements //
  59 DataCommitTransaction<InstanceIdentifier, CompositeNode> {
  60     @Property
  61     val DataModification<InstanceIdentifier, CompositeNode> modification
  62
  63     @Property
  64     val HashMapDataStore datastore;
  65
  66     new(
  67         DataModification<InstanceIdentifier, CompositeNode> modify,
  68         HashMapDataStore store
  69     ) {
  70         _modification = modify;
  71         _datastore = store;
  72     }
  73
  74     override finish() throws IllegalStateException {
  75         datastore.finish(this);
  76
  77     }
  78
  79     override getModification() {
  80         this._modification;
  81     }
  82
  83     override rollback() throws IllegalStateException {
  84         datastore.rollback(this);
  85     }
  86 }