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.LinkedHashMap;
  14 import java.util.Map;
  15 import java.util.Set;
  16
  17 import org.opendaylight.controller.md.sal.common.api.data.DataModification;
  18 import org.opendaylight.controller.md.sal.common.api.data.DataReader;
  19 import org.opendaylight.yangtools.concepts.Path;
  20
  21 @Deprecated
  22 public abstract class AbstractDataModification<P extends Path<P>, D> implements DataModification<P, D> {
  23
  24     private final Map<P, D> operationalOriginal;
  25     private final Map<P, D> configurationOriginal;
  26
  27     private final Map<P, D> operationalCreated;
  28     private final Map<P, D> configurationCreated;
  29
  30     private final Map<P, D> configurationUpdate;
  31     private final Map<P, D> operationalUpdate;
  32
  33     private final Map<P, P> configurationRemove;
  34     private final Map<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 final DataReader<P, D> reader;
  45
  46     public AbstractDataModification(final DataReader<P, D> reader) {
  47         this.reader = reader;
  48         this.configurationUpdate = new LinkedHashMap<>();
  49         this.operationalUpdate = new LinkedHashMap<>();
  50         this.configurationRemove = new LinkedHashMap<>();
  51         this.operationalRemove = new LinkedHashMap<>();
  52
  53         this.configurationOriginal = new LinkedHashMap<>();
  54         this.operationalOriginal = new LinkedHashMap<>();
  55
  56         this.configurationCreated = new LinkedHashMap<>();
  57         this.operationalCreated = new LinkedHashMap<>();
  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(final P path, final 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(final P path, final 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 removeOperationalData(final P path) {
  92         checkMutable();
  93         getOperationalOriginal(path);
  94         operationalUpdate.remove(path);
  95         operationalRemove.put(path, path);
  96     }
  97
  98     @Override
  99     public final void removeConfigurationData(final P path) {
 100         checkMutable();
 101         getConfigurationOriginal(path);
 102         configurationUpdate.remove(path);
 103         configurationRemove.put(path, path);
 104     }
 105
 106     private final void checkMutable() {
 107         if (!NEW.equals(this.getStatus())) {
 108             throw new IllegalStateException("Transaction was already submitted");
 109         }
 110     }
 111
 112     @Override
 113     public final Map<P, D> getUpdatedConfigurationData() {
 114
 115         return unmodifiable_configurationUpdate;
 116     }
 117
 118     @Override
 119     public final Map<P, D> getUpdatedOperationalData() {
 120         return unmodifiable_operationalUpdate;
 121     }
 122
 123     @Override
 124     public final Set<P> getRemovedConfigurationData() {
 125         return unmodifiable_configurationRemove;
 126     }
 127
 128     @Override
 129     public final Set<P> getRemovedOperationalData() {
 130         return unmodifiable_OperationalRemove;
 131     }
 132
 133     @Override
 134     public Map<P, D> getCreatedConfigurationData() {
 135         return unmodifiable_configurationCreated;
 136     }
 137
 138     @Override
 139     public Map<P, D> getCreatedOperationalData() {
 140         return unmodifiable_operationalCreated;
 141     }
 142
 143     @Override
 144     public Map<P, D> getOriginalConfigurationData() {
 145         return unmodifiable_configurationOriginal;
 146     }
 147
 148     @Override
 149     public Map<P, D> getOriginalOperationalData() {
 150         return unmodifiable_operationalOriginal;
 151     }
 152
 153     @Override
 154     public D readOperationalData(final P path) {
 155         return reader.readOperationalData(path);
 156     }
 157
 158     @Override
 159     public D readConfigurationData(final P path) {
 160         return reader.readConfigurationData(path);
 161     }
 162
 163     private D getConfigurationOriginal(final P path) {
 164         D data = configurationOriginal.get(path);
 165         if (data != null) {
 166             return data;
 167         }
 168         data = reader.readConfigurationData(path);
 169         if (data != null) {
 170             configurationOriginal.put(path, data);
 171             return data;
 172         }
 173         return null;
 174     }
 175
 176     private D getOperationalOriginal(final P path) {
 177         D data = operationalOriginal.get(path);
 178         if (data != null) {
 179             return data;
 180         }
 181         data = reader.readOperationalData(path);
 182         if (data != null) {
 183             operationalOriginal.put(path, data);
 184             return data;
 185         }
 186         return null;
 187     }
 188
 189     protected D mergeOperationalData(final P path,final D stored, final D modified) {
 190         return modified;
 191     }
 192
 193     protected D mergeConfigurationData(final P path,final D stored, final D modified) {
 194         return modified;
 195     }
 196 }