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

   1 /*
   2  * Copyright (c) 2014, 2015 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
   9 package org.opendaylight.controller.md.sal.common.impl.service;
  10
  11 import java.util.Map;
  12 import java.util.Set;
  13
  14 import org.opendaylight.controller.md.sal.common.api.data.DataChangeEvent;
  15 import org.opendaylight.controller.md.sal.common.api.data.DataModification;
  16 import org.opendaylight.yangtools.concepts.Path;
  17
  18 import com.google.common.base.Predicate;
  19 import com.google.common.collect.ImmutableMap;
  20 import com.google.common.collect.ImmutableSet;
  21 import com.google.common.collect.Maps;
  22 import com.google.common.collect.Sets;
  23
  24 @Deprecated
  25 public final class ImmutableDataChangeEvent<P extends Path<P>, D> implements DataChangeEvent<P,D> {
  26
  27     private final D updatedOperationalSubtree;
  28     private final Map<P, D> updatedOperational;
  29     private final D updatedConfigurationSubtree;
  30     private final Map<P, D> updatedConfiguration;
  31     private final Set<P> removedOperational;
  32     private final Set<P> removedConfiguration;
  33     private final D originalOperationalSubtree;
  34     private final Map<P, D> originalOperational;
  35     private final D originalConfigurationSubtree;
  36     private final Map<P, D> originalConfiguration;
  37     private final Map<P, D> createdOperational;
  38     private final Map<P, D> createdConfiguration;
  39
  40
  41     private ImmutableDataChangeEvent(final Builder<P, D> builder) {
  42
  43         createdConfiguration = builder.getCreatedConfiguration().build();
  44         createdOperational = builder.getCreatedOperational().build();
  45         originalConfiguration = builder.getOriginalConfiguration().build();
  46         originalConfigurationSubtree = builder.getOriginalConfigurationSubtree();
  47         originalOperational = builder.getOriginalOperational().build();
  48         originalOperationalSubtree = builder.getOriginalOperationalSubtree();
  49         removedConfiguration = builder.getRemovedConfiguration().build();
  50         removedOperational = builder.getRemovedOperational().build();
  51         updatedConfiguration = builder.getUpdatedConfiguration().build();
  52         updatedConfigurationSubtree = builder.getUpdatedConfigurationSubtree();
  53         updatedOperational = builder.getUpdatedOperational().build();
  54         updatedOperationalSubtree = builder.getUpdatedOperationalSubtree();
  55     }
  56
  57     @Override
  58     public Map<P, D> getCreatedConfigurationData() {
  59         return createdConfiguration;
  60     }
  61
  62     @Override
  63     public Map<P, D> getCreatedOperationalData() {
  64         return createdOperational;
  65     }
  66
  67     @Override
  68     public Map<P, D> getOriginalConfigurationData() {
  69         return originalConfiguration;
  70     }
  71     @Override
  72     public D getOriginalConfigurationSubtree() {
  73         return originalConfigurationSubtree;
  74     }
  75     @Override
  76     public Map<P, D> getOriginalOperationalData() {
  77         return originalOperational;
  78     }
  79     @Override
  80     public D getOriginalOperationalSubtree() {
  81         return originalOperationalSubtree;
  82     }
  83     @Override
  84     public Set<P> getRemovedConfigurationData() {
  85         return removedConfiguration;
  86     }
  87     @Override
  88     public Set<P> getRemovedOperationalData() {
  89         return removedOperational;
  90     }
  91     @Override
  92     public Map<P, D> getUpdatedConfigurationData() {
  93         return updatedConfiguration;
  94     }
  95     @Override
  96     public D getUpdatedConfigurationSubtree() {
  97         return updatedConfigurationSubtree;
  98     }
  99     @Override
 100     public Map<P, D> getUpdatedOperationalData() {
 101         return updatedOperational;
 102     }
 103     @Override
 104     public D getUpdatedOperationalSubtree() {
 105         return updatedOperationalSubtree;
 106     }
 107
 108     public static final <P extends Path<P>,D> Builder<P, D> builder() {
 109         return new Builder<>();
 110     }
 111
 112     public static final class Builder<P extends Path<P>,D> {
 113
 114         private  D updatedOperationalSubtree;
 115         private  D originalOperationalSubtree;
 116         private  D originalConfigurationSubtree;
 117         private  D updatedConfigurationSubtree;
 118
 119         private final ImmutableMap.Builder<P, D> updatedOperational = ImmutableMap.builder();
 120         private final ImmutableMap.Builder<P, D> updatedConfiguration = ImmutableMap.builder();
 121         private final ImmutableSet.Builder<P> removedOperational = ImmutableSet.builder();
 122         private final ImmutableSet.Builder<P> removedConfiguration = ImmutableSet.builder();
 123         private final ImmutableMap.Builder<P, D> originalOperational = ImmutableMap.builder();
 124
 125         private final ImmutableMap.Builder<P, D> originalConfiguration = ImmutableMap.builder();
 126         private final ImmutableMap.Builder<P, D> createdOperational = ImmutableMap.builder();
 127         private final ImmutableMap.Builder<P, D> createdConfiguration = ImmutableMap.builder();
 128
 129
 130
 131
 132
 133         protected Builder<P,D> addTransaction(final DataModification<P, D> data, final Predicate<P> keyFilter) {
 134             updatedOperational.putAll(Maps.filterKeys(data.getUpdatedOperationalData(), keyFilter));
 135             updatedConfiguration.putAll(Maps.filterKeys(data.getUpdatedConfigurationData(), keyFilter));
 136             originalConfiguration.putAll(Maps.filterKeys(data.getOriginalConfigurationData(), keyFilter));
 137             originalOperational.putAll(Maps.filterKeys(data.getOriginalOperationalData(), keyFilter));
 138             createdOperational.putAll(Maps.filterKeys(data.getCreatedOperationalData(), keyFilter));
 139             createdConfiguration.putAll(Maps.filterKeys(data.getCreatedConfigurationData(), keyFilter));
 140             removedOperational.addAll(Sets.filter(data.getRemovedOperationalData(), keyFilter));
 141             removedConfiguration.addAll(Sets.filter(data.getRemovedConfigurationData(), keyFilter));
 142             return this;
 143         }
 144
 145         protected Builder<P, D> addConfigurationChangeSet(final RootedChangeSet<P, D> changeSet) {
 146             if(changeSet == null) {
 147                 return this;
 148             }
 149
 150             originalConfiguration.putAll(changeSet.getOriginal());
 151             createdConfiguration.putAll(changeSet.getCreated());
 152             updatedConfiguration.putAll(changeSet.getUpdated());
 153             removedConfiguration.addAll(changeSet.getRemoved());
 154             return this;
 155         }
 156
 157         protected Builder<P, D> addOperationalChangeSet(final RootedChangeSet<P, D> changeSet) {
 158             if(changeSet == null) {
 159                 return this;
 160             }
 161             originalOperational.putAll(changeSet.getOriginal());
 162             createdOperational.putAll(changeSet.getCreated());
 163             updatedOperational.putAll(changeSet.getUpdated());
 164             removedOperational.addAll(changeSet.getRemoved());
 165             return this;
 166         }
 167
 168         public ImmutableDataChangeEvent<P, D> build() {
 169             return new ImmutableDataChangeEvent<P,D>(this);
 170         }
 171
 172         protected D getUpdatedOperationalSubtree() {
 173             return updatedOperationalSubtree;
 174         }
 175
 176         public Builder<P, D> setUpdatedOperationalSubtree(final D updatedOperationalSubtree) {
 177             this.updatedOperationalSubtree = updatedOperationalSubtree;
 178             return this;
 179         }
 180
 181         protected D getOriginalOperationalSubtree() {
 182             return originalOperationalSubtree;
 183         }
 184
 185         public Builder<P,D> setOriginalOperationalSubtree(final D originalOperationalSubtree) {
 186             this.originalOperationalSubtree = originalOperationalSubtree;
 187             return this;
 188         }
 189
 190         protected D getOriginalConfigurationSubtree() {
 191             return originalConfigurationSubtree;
 192         }
 193
 194         public Builder<P, D> setOriginalConfigurationSubtree(final D originalConfigurationSubtree) {
 195             this.originalConfigurationSubtree = originalConfigurationSubtree;
 196             return this;
 197         }
 198
 199         protected D getUpdatedConfigurationSubtree() {
 200             return updatedConfigurationSubtree;
 201         }
 202
 203         public Builder<P,D> setUpdatedConfigurationSubtree(final D updatedConfigurationSubtree) {
 204             this.updatedConfigurationSubtree = updatedConfigurationSubtree;
 205             return this;
 206         }
 207
 208         protected ImmutableMap.Builder<P, D> getUpdatedOperational() {
 209             return updatedOperational;
 210         }
 211
 212         protected ImmutableMap.Builder<P, D> getUpdatedConfiguration() {
 213             return updatedConfiguration;
 214         }
 215
 216         protected ImmutableSet.Builder<P> getRemovedOperational() {
 217             return removedOperational;
 218         }
 219
 220         protected ImmutableSet.Builder<P> getRemovedConfiguration() {
 221             return removedConfiguration;
 222         }
 223
 224         protected ImmutableMap.Builder<P, D> getOriginalOperational() {
 225             return originalOperational;
 226         }
 227
 228         protected ImmutableMap.Builder<P, D> getOriginalConfiguration() {
 229             return originalConfiguration;
 230         }
 231
 232         protected ImmutableMap.Builder<P, D> getCreatedOperational() {
 233             return createdOperational;
 234         }
 235
 236         protected ImmutableMap.Builder<P, D> getCreatedConfiguration() {
 237             return createdConfiguration;
 238         }
 239
 240         public Builder<P,D> putOriginalOperational(final Map<? extends P, ? extends D> originalData) {
 241             originalOperational.putAll(originalData);
 242             return this;
 243         }
 244
 245         public Builder<P,D> putCreatedOperational(final Map<? extends P, ? extends D> originalData) {
 246             createdOperational.putAll(originalData);
 247             return this;
 248         }
 249
 250         public Builder<P,D> putUpdatedOperational(final Map<? extends P, ? extends D> originalData) {
 251             updatedOperational.putAll(originalData);
 252             return this;
 253         }
 254
 255         public Builder<P,D> putRemovedOperational(final Set<? extends P> originalData) {
 256             removedOperational.addAll(originalData);
 257             return this;
 258         }
 259     }
 260
 261 }