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