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         configurationRemove.remove(path);
  79     }
  80
  81     @Override
  82     public final void putOperationalData(P path, D data) {
  83         checkMutable();
  84         D original = null;
  85         if ((original = getOperationalOriginal(path)) == null) {
  86             operationalCreated.put(path, data);
  87         }
  88         operationalUpdate.put(path, mergeOperationalData(path,original,data));
  89         operationalRemove.remove(path);
  90     }
  91
  92     @Override
  93     public final void putRuntimeData(P path, D data) {
  94         putOperationalData(path, data);
  95     }
  96
  97     @Override
  98     public final void removeOperationalData(P path) {
  99         checkMutable();
 100         getOperationalOriginal(path);
 101         operationalUpdate.remove(path);
 102         operationalRemove.put(path, path);
 103     }
 104
 105     @Override
 106     public final void removeRuntimeData(P path) {
 107         removeOperationalData(path);
 108     }
 109
 110     @Override
 111     public final void removeConfigurationData(P path) {
 112         checkMutable();
 113         getConfigurationOriginal(path);
 114         configurationUpdate.remove(path);
 115         configurationRemove.put(path, path);
 116     }
 117
 118     private final void checkMutable() {
 119         if (!NEW.equals(this.getStatus()))
 120             throw new IllegalStateException("Transaction was already submitted");
 121     }
 122
 123     @Override
 124     public final Map<P, D> getUpdatedConfigurationData() {
 125
 126         return unmodifiable_configurationUpdate;
 127     }
 128
 129     @Override
 130     public final Map<P, D> getUpdatedOperationalData() {
 131         return unmodifiable_operationalUpdate;
 132     }
 133
 134     @Override
 135     public final Set<P> getRemovedConfigurationData() {
 136         return unmodifiable_configurationRemove;
 137     }
 138
 139     @Override
 140     public final Set<P> getRemovedOperationalData() {
 141         return unmodifiable_OperationalRemove;
 142     }
 143
 144     @Override
 145     public Map<P, D> getCreatedConfigurationData() {
 146         return unmodifiable_configurationCreated;
 147     }
 148
 149     @Override
 150     public Map<P, D> getCreatedOperationalData() {
 151         return unmodifiable_operationalCreated;
 152     }
 153
 154     @Override
 155     public Map<P, D> getOriginalConfigurationData() {
 156         return unmodifiable_configurationOriginal;
 157     }
 158
 159     @Override
 160     public Map<P, D> getOriginalOperationalData() {
 161         return unmodifiable_operationalOriginal;
 162     }
 163
 164     @Override
 165     public D readOperationalData(P path) {
 166         return reader.readOperationalData(path);
 167     }
 168
 169     @Override
 170     public D readConfigurationData(P path) {
 171         return reader.readConfigurationData(path);
 172     }
 173
 174     private D getConfigurationOriginal(P path) {
 175         D data = configurationOriginal.get(path);
 176         if (data != null) {
 177             return data;
 178         }
 179         data = reader.readConfigurationData(path);
 180         if (data != null) {
 181             configurationOriginal.putIfAbsent(path, data);
 182             return data;
 183         }
 184         return null;
 185     }
 186
 187     private D getOperationalOriginal(P path) {
 188         D data = operationalOriginal.get(path);
 189         if (data != null) {
 190             return data;
 191         }
 192         data = reader.readOperationalData(path);
 193         if (data != null) {
 194             operationalOriginal.putIfAbsent(path, data);
 195             return data;
 196         }
 197         return null;
 198     }
 199
 200     protected D mergeOperationalData(P path,D stored, D modified) {
 201         return modified;
 202     }
 203
 204     protected D mergeConfigurationData(P path,D stored, D modified) {
 205         return modified;
 206     }
 207 }