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