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

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.controller.md.sal.common.impl;
   9
  10 import static org.opendaylight.controller.md.sal.common.api.TransactionStatus.NEW;
  11
  12 import java.util.Collections;
  13 import java.util.Map;
  14 import java.util.Set;
  15 import java.util.concurrent.ConcurrentHashMap;
  16 import java.util.concurrent.ConcurrentMap;
  17
  18 import org.opendaylight.controller.md.sal.common.api.data.DataModification;
  19 import org.opendaylight.controller.md.sal.common.api.data.DataReader;
  20 import org.opendaylight.yangtools.concepts.Path;
  21
  22 public abstract class AbstractDataModification<P extends Path<P>, D> implements DataModification<P, D> {
  23
  24     private final ConcurrentMap<P, D> operationalOriginal;
  25     private final ConcurrentMap<P, D> configurationOriginal;
  26
  27     private final ConcurrentMap<P, D> operationalCreated;
  28     private final ConcurrentMap<P, D> configurationCreated;
  29
  30     private final ConcurrentMap<P, D> configurationUpdate;
  31     private final ConcurrentMap<P, D> operationalUpdate;
  32
  33     private final ConcurrentMap<P, P> configurationRemove;
  34     private final ConcurrentMap<P, P> operationalRemove;
  35
  36     private final Map<P, D> unmodifiable_configurationOriginal;
  37     private final Map<P, D> unmodifiable_operationalOriginal;
  38     private final Map<P, D> unmodifiable_configurationCreated;
  39     private final Map<P, D> unmodifiable_operationalCreated;
  40     private final Map<P, D> unmodifiable_configurationUpdate;
  41     private final Map<P, D> unmodifiable_operationalUpdate;
  42     private final Set<P> unmodifiable_configurationRemove;
  43     private final Set<P> unmodifiable_OperationalRemove;
  44     private DataReader<P, D> reader;
  45
  46     public AbstractDataModification(DataReader<P, D> reader) {
  47         this.reader = reader;
  48         this.configurationUpdate = new ConcurrentHashMap<>();
  49         this.operationalUpdate = new ConcurrentHashMap<>();
  50         this.configurationRemove = new ConcurrentHashMap<>();
  51         this.operationalRemove = new ConcurrentHashMap<>();
  52
  53         this.configurationOriginal = new ConcurrentHashMap<>();
  54         this.operationalOriginal = new ConcurrentHashMap<>();
  55
  56         this.configurationCreated = new ConcurrentHashMap<>();
  57         this.operationalCreated = new ConcurrentHashMap<>();
  58
  59         unmodifiable_configurationOriginal = Collections.unmodifiableMap(configurationOriginal);
  60         unmodifiable_operationalOriginal = Collections.unmodifiableMap(operationalOriginal);
  61         unmodifiable_configurationCreated = Collections.unmodifiableMap(configurationCreated);
  62         unmodifiable_operationalCreated = Collections.unmodifiableMap(operationalCreated);
  63         unmodifiable_configurationUpdate = Collections.unmodifiableMap(configurationUpdate);
  64         unmodifiable_operationalUpdate = Collections.unmodifiableMap(operationalUpdate);
  65         unmodifiable_configurationRemove = Collections.unmodifiableSet(configurationRemove.keySet());
  66         unmodifiable_OperationalRemove = Collections.unmodifiableSet(operationalRemove.keySet());
  67     }
  68
  69     @Override
  70     public final void putConfigurationData(P path, D data) {
  71         checkMutable();
  72         D original = null;
  73         if ((original = getConfigurationOriginal(path)) == null) {
  74             configurationCreated.put(path, data);
  75         }
  76
  77         configurationUpdate.put(path, mergeConfigurationData(path,original, data));
  78     }
  79
  80     @Override
  81     public final void putOperationalData(P path, D data) {
  82         checkMutable();
  83         D original = null;
  84         if ((original = getOperationalOriginal(path)) == null) {
  85             operationalCreated.put(path, data);
  86         }
  87         operationalUpdate.put(path, mergeOperationalData(path,original,data));
  88     }
  89
  90     @Override
  91     public final void putRuntimeData(P path, D data) {
  92         putOperationalData(path, data);
  93     }
  94
  95     @Override
  96     public final void removeOperationalData(P path) {
  97         checkMutable();
  98         getOperationalOriginal(path);
  99         operationalUpdate.remove(path);
 100         operationalRemove.put(path, path);
 101     }
 102
 103     @Override
 104     public final void removeRuntimeData(P path) {
 105         removeOperationalData(path);
 106     }
 107
 108     @Override
 109     public final void removeConfigurationData(P path) {
 110         checkMutable();
 111         getConfigurationOriginal(path);
 112         configurationUpdate.remove(path);
 113         configurationRemove.put(path, path);
 114     }
 115
 116     private final void checkMutable() {
 117         if (!NEW.equals(this.getStatus()))
 118             throw new IllegalStateException("Transaction was already submitted");
 119     }
 120
 121     @Override
 122     public final Map<P, D> getUpdatedConfigurationData() {
 123
 124         return unmodifiable_configurationUpdate;
 125     }
 126
 127     @Override
 128     public final Map<P, D> getUpdatedOperationalData() {
 129         return unmodifiable_operationalUpdate;
 130     }
 131
 132     @Override
 133     public final Set<P> getRemovedConfigurationData() {
 134         return unmodifiable_configurationRemove;
 135     }
 136
 137     @Override
 138     public final Set<P> getRemovedOperationalData() {
 139         return unmodifiable_OperationalRemove;
 140     }
 141
 142     @Override
 143     public Map<P, D> getCreatedConfigurationData() {
 144         return unmodifiable_configurationCreated;
 145     }
 146
 147     @Override
 148     public Map<P, D> getCreatedOperationalData() {
 149         return unmodifiable_operationalCreated;
 150     }
 151
 152     @Override
 153     public Map<P, D> getOriginalConfigurationData() {
 154         return unmodifiable_configurationOriginal;
 155     }
 156
 157     @Override
 158     public Map<P, D> getOriginalOperationalData() {
 159         return unmodifiable_operationalOriginal;
 160     }
 161
 162     @Override
 163     public D readOperationalData(P path) {
 164         return reader.readOperationalData(path);
 165     }
 166
 167     @Override
 168     public D readConfigurationData(P path) {
 169         return reader.readConfigurationData(path);
 170     }
 171
 172     private D getConfigurationOriginal(P path) {
 173         D data = configurationOriginal.get(path);
 174         if (data != null) {
 175             return data;
 176         }
 177         data = reader.readConfigurationData(path);
 178         if (data != null) {
 179             configurationOriginal.putIfAbsent(path, data);
 180             return data;
 181         }
 182         return null;
 183     }
 184
 185     private D getOperationalOriginal(P path) {
 186         D data = operationalOriginal.get(path);
 187         if (data != null) {
 188             return data;
 189         }
 190         data = reader.readOperationalData(path);
 191         if (data != null) {
 192             operationalOriginal.putIfAbsent(path, data);
 193             return data;
 194         }
 195         return null;
 196     }
 197
 198     protected D mergeOperationalData(P path,D stored, D modified) {
 199         return modified;
 200     }
 201
 202     protected D mergeConfigurationData(P path,D stored, D modified) {
 203         return modified;
 204     }
 205 }