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

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