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