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

   1 package org.opendaylight.controller.sal.binding.impl
   2
   3 import org.opendaylight.controller.md.sal.common.api.data.DataReader
   4 import org.opendaylight.controller.sal.binding.api.data.RuntimeDataProvider
   5 import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler
   6 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier
   7 import org.opendaylight.yangtools.yang.binding.DataObject
   8 import org.opendaylight.controller.md.sal.common.api.data.DataModification
   9 import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction
  10 import org.opendaylight.yangtools.yang.common.RpcResult
  11 import java.util.Map
  12 import java.util.concurrent.ConcurrentHashMap
  13 import org.opendaylight.controller.sal.common.util.Rpcs
  14 import java.util.Collections
  15
  16 class HashMapDataStore //
  17 implements //
  18 RuntimeDataProvider, DataCommitHandler<InstanceIdentifier<? extends DataObject>, DataObject> {
  19
  20     val Map<InstanceIdentifier<? extends DataObject>,DataObject> configuration = new ConcurrentHashMap();
  21     val Map<InstanceIdentifier<? extends DataObject>,DataObject> operational = new ConcurrentHashMap();
  22
  23
  24     override readConfigurationData(InstanceIdentifier<? extends DataObject> path) {
  25         configuration.get(path);
  26     }
  27
  28     override readOperationalData(InstanceIdentifier<? extends DataObject> path) {
  29         operational.get(path);
  30     }
  31
  32     override requestCommit(DataModification<InstanceIdentifier<? extends DataObject>, DataObject> 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             configuration.remove(removal);
  47         }
  48         for(removal : modification.removedOperationalData) {
  49             operational.remove(removal);
  50         }
  51         return Rpcs.getRpcResult(true,null,Collections.emptySet);
  52     }
  53
  54 }
  55
  56 class HashMapDataStoreTransaction implements //
  57 DataCommitTransaction<InstanceIdentifier<? extends DataObject>, DataObject> {
  58     @Property
  59     val DataModification<InstanceIdentifier<? extends DataObject>, DataObject> modification
  60
  61     @Property
  62     val HashMapDataStore datastore;
  63
  64
  65     new(
  66         DataModification<InstanceIdentifier<? extends DataObject>, DataObject> modify,
  67         HashMapDataStore store
  68     ) {
  69         _modification = modify;
  70         _datastore = store;
  71     }
  72
  73     override finish() throws IllegalStateException {
  74         datastore.finish(this);
  75
  76     }
  77
  78     override getModification() {
  79         this._modification;
  80     }
  81
  82     override rollback() throws IllegalStateException {
  83         datastore.rollback(this);
  84     }
  85 }