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