opendaylight/md-sal/sal-common-impl/src/main/java/org/opendaylight/controller/md/sal/common/impl/AbstractDataModification.java

   1 package org.opendaylight.controller.md.sal.common.impl;
   2
   3 import static org.opendaylight.controller.md.sal.common.api.TransactionStatus.NEW;
   4
   5 import java.util.Collections;
   6 import java.util.Map;
   7 import java.util.Set;
   8 import java.util.concurrent.ConcurrentHashMap;
   9 import java.util.concurrent.ConcurrentMap;
  10
  11 import org.opendaylight.controller.md.sal.common.api.data.DataModification;
  12 import org.opendaylight.controller.md.sal.common.api.data.DataReader;
  13
  14 public abstract class AbstractDataModification<P /* extends Path<P> */, D> implements DataModification<P, D> {
  15
  16     private final ConcurrentMap<P, D> operationalOriginal;
  17     private final ConcurrentMap<P, D> configurationOriginal;
  18
  19     private final ConcurrentMap<P, D> operationalCreated;
  20     private final ConcurrentMap<P, D> configurationCreated;
  21
  22     private final ConcurrentMap<P, D> configurationUpdate;
  23     private final ConcurrentMap<P, D> operationalUpdate;
  24
  25     private final ConcurrentMap<P, P> configurationRemove;
  26     private final ConcurrentMap<P, P> operationalRemove;
  27
  28     private final Map<P, D> unmodifiable_configurationOriginal;
  29     private final Map<P, D> unmodifiable_operationalOriginal;
  30     private final Map<P, D> unmodifiable_configurationCreated;
  31     private final Map<P, D> unmodifiable_operationalCreated;
  32     private final Map<P, D> unmodifiable_configurationUpdate;
  33     private final Map<P, D> unmodifiable_operationalUpdate;
  34     private final Set<P> unmodifiable_configurationRemove;
  35     private final Set<P> unmodifiable_OperationalRemove;
  36     private DataReader<P, D> reader;
  37
  38     public AbstractDataModification(DataReader<P, D> reader) {
  39         this.reader = reader;
  40         this.configurationUpdate = new ConcurrentHashMap<>();
  41         this.operationalUpdate = new ConcurrentHashMap<>();
  42         this.configurationRemove = new ConcurrentHashMap<>();
  43         this.operationalRemove = new ConcurrentHashMap<>();
  44
  45         this.configurationOriginal = new ConcurrentHashMap<>();
  46         this.operationalOriginal = new ConcurrentHashMap<>();
  47
  48         this.configurationCreated = new ConcurrentHashMap<>();
  49         this.operationalCreated = new ConcurrentHashMap<>();
  50
  51         unmodifiable_configurationOriginal = Collections.unmodifiableMap(configurationOriginal);
  52         unmodifiable_operationalOriginal = Collections.unmodifiableMap(operationalOriginal);
  53         unmodifiable_configurationCreated = Collections.unmodifiableMap(configurationCreated);
  54         unmodifiable_operationalCreated = Collections.unmodifiableMap(operationalCreated);
  55         unmodifiable_configurationUpdate = Collections.unmodifiableMap(configurationUpdate);
  56         unmodifiable_operationalUpdate = Collections.unmodifiableMap(operationalUpdate);
  57         unmodifiable_configurationRemove = Collections.unmodifiableSet(configurationRemove.keySet());
  58         unmodifiable_OperationalRemove = Collections.unmodifiableSet(operationalRemove.keySet());
  59
  60     }
  61
  62     @Override
  63     public final void putConfigurationData(P path, D data) {
  64         checkMutable();
  65
  66         if (!hasConfigurationOriginal(path)) {
  67             configurationCreated.put(path, data);
  68         }
  69
  70         configurationUpdate.put(path, data);
  71         configurationRemove.remove(path);
  72     }
  73
  74     @Override
  75     public final void putOperationalData(P path, D data) {
  76         checkMutable();
  77         if (!hasOperationalOriginal(path)) {
  78             operationalCreated.put(path, data);
  79         }
  80         operationalUpdate.put(path, data);
  81         operationalRemove.remove(path);
  82     }
  83
  84     @Override
  85     public final void putRuntimeData(P path, D data) {
  86         putOperationalData(path, data);
  87     }
  88
  89     @Override
  90     public final void removeOperationalData(P path) {
  91         checkMutable();
  92         hasOperationalOriginal(path);
  93         operationalUpdate.remove(path);
  94         operationalRemove.put(path, path);
  95     }
  96
  97     @Override
  98     public final void removeRuntimeData(P path) {
  99         removeOperationalData(path);
 100     }
 101
 102     @Override
 103     public final void removeConfigurationData(P path) {
 104         checkMutable();
 105         hasConfigurationOriginal(path);
 106         configurationUpdate.remove(path);
 107         configurationRemove.put(path, path);
 108     }
 109
 110     private final void checkMutable() {
 111         if (!NEW.equals(this.getStatus()))
 112             throw new IllegalStateException("Transaction was already submitted");
 113     }
 114
 115     @Override
 116     public final Map<P, D> getUpdatedConfigurationData() {
 117
 118         return unmodifiable_configurationUpdate;
 119     }
 120
 121     @Override
 122     public final Map<P, D> getUpdatedOperationalData() {
 123         return unmodifiable_operationalUpdate;
 124     }
 125
 126     @Override
 127     public final Set<P> getRemovedConfigurationData() {
 128         return unmodifiable_configurationRemove;
 129     }
 130
 131     @Override
 132     public final Set<P> getRemovedOperationalData() {
 133         return unmodifiable_OperationalRemove;
 134     }
 135
 136     @Override
 137     public Map<P, D> getCreatedConfigurationData() {
 138         return unmodifiable_configurationCreated;
 139     }
 140
 141     @Override
 142     public Map<P, D> getCreatedOperationalData() {
 143         return unmodifiable_operationalCreated;
 144     }
 145
 146     @Override
 147     public Map<P, D> getOriginalConfigurationData() {
 148         return unmodifiable_configurationOriginal;
 149     }
 150
 151     @Override
 152     public Map<P, D> getOriginalOperationalData() {
 153         return unmodifiable_operationalOriginal;
 154     }
 155
 156     @Override
 157     public D readOperationalData(P path) {
 158         return reader.readOperationalData(path);
 159     }
 160
 161     @Override
 162     public D readConfigurationData(P path) {
 163         return reader.readConfigurationData(path);
 164     }
 165
 166     private boolean hasConfigurationOriginal(P path) {
 167         if (configurationOriginal.containsKey(path)) {
 168             return true;
 169         }
 170         D data = reader.readConfigurationData(path);
 171         if (data != null) {
 172             configurationOriginal.putIfAbsent(path, data);
 173             return true;
 174         }
 175         return false;
 176     }
 177
 178     private boolean hasOperationalOriginal(P path) {
 179         if (operationalOriginal.containsKey(path)) {
 180             return true;
 181         }
 182         D data = reader.readOperationalData(path);
 183         if (data != null) {
 184             operationalOriginal.putIfAbsent(path, data);
 185             return true;
 186         }
 187         return false;
 188     }
 189 }