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