opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/DOMImmutableDataChangeEvent.java

   1 package org.opendaylight.controller.md.sal.dom.store.impl;
   2
   3 import java.util.Collections;
   4 import java.util.HashMap;
   5 import java.util.HashSet;
   6 import java.util.Map;
   7 import java.util.Set;
   8
   9 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
  10 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  11 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
  12 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
  13 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  14
  15 import com.google.common.base.Preconditions;
  16
  17 public final class DOMImmutableDataChangeEvent implements
  18         AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> {
  19
  20
  21     private static final RemoveEventFactory REMOVE_EVENT_FACTORY = new RemoveEventFactory();
  22     private static final CreateEventFactory CREATE_EVENT_FACTORY = new CreateEventFactory();
  23
  24     private final NormalizedNode<?, ?> original;
  25     private final NormalizedNode<?, ?> updated;
  26     private final Map<InstanceIdentifier, ? extends NormalizedNode<?, ?>> originalData;
  27     private final Map<InstanceIdentifier, NormalizedNode<?, ?>> createdData;
  28     private final Map<InstanceIdentifier, NormalizedNode<?, ?>> updatedData;
  29     private final Set<InstanceIdentifier> removedPaths;
  30     private final DataChangeScope scope;
  31
  32
  33
  34     private DOMImmutableDataChangeEvent(final Builder change) {
  35         original = change.before;
  36         updated = change.after;
  37         originalData = Collections.unmodifiableMap(change.original);
  38         createdData = Collections.unmodifiableMap(change.created);
  39         updatedData = Collections.unmodifiableMap(change.updated);
  40         removedPaths = Collections.unmodifiableSet(change.removed);
  41         scope = change.scope;
  42     }
  43
  44     public static final Builder builder(final DataChangeScope scope) {
  45         return new Builder(scope);
  46     }
  47
  48     protected DataChangeScope getScope() {
  49         return scope;
  50     }
  51
  52     @Override
  53     public NormalizedNode<?, ?> getOriginalSubtree() {
  54         return original;
  55     }
  56
  57     @Override
  58     public NormalizedNode<?, ?> getUpdatedSubtree() {
  59         return updated;
  60     }
  61
  62     @Override
  63     public Map<InstanceIdentifier, ? extends NormalizedNode<?, ?>> getOriginalData() {
  64         return originalData;
  65     }
  66
  67     @Override
  68     public Map<InstanceIdentifier, NormalizedNode<?, ?>> getCreatedData() {
  69         return createdData;
  70     }
  71
  72     @Override
  73     public Map<InstanceIdentifier, NormalizedNode<?, ?>> getUpdatedData() {
  74         return updatedData;
  75     }
  76
  77     @Override
  78     public Set<InstanceIdentifier> getRemovedPaths() {
  79         return removedPaths;
  80     }
  81
  82     @Override
  83     public String toString() {
  84         return "DOMImmutableDataChangeEvent [created=" + createdData.keySet() + ", updated=" + updatedData.keySet()
  85                 + ", removed=" + removedPaths + "]";
  86     }
  87
  88     /**
  89      * Simple event factory which creates event based on path and data
  90      *
  91      *
  92      */
  93     public interface SimpleEventFactory {
  94         DOMImmutableDataChangeEvent create(InstanceIdentifier path, NormalizedNode<PathArgument,?> data);
  95     }
  96
  97     /**
  98      * Event factory which takes after state and creates event for it.
  99      *
 100      * Factory for events based on path and after state.
 101      * After state is set as {@link #getUpdatedSubtree()} and is path,
 102      * state mapping is also present in {@link #getUpdatedData()}.
 103      *
 104      * @return
 105      */
 106     public static final SimpleEventFactory getCreateEventFactory() {
 107         return CREATE_EVENT_FACTORY;
 108     }
 109
 110     /**
 111      * Event factory which takes before state and creates event for it.
 112      *
 113      * Factory for events based on path and after state.
 114      * After state is set as {@link #getOriginalSubtree()} and is path,
 115      * state mapping is also present in {@link #getOriginalSubtree()}.
 116      *
 117      * Path is present in {@link #getRemovedPaths()}.
 118      * @return
 119      */
 120     public static final SimpleEventFactory getRemoveEventFactory() {
 121         return REMOVE_EVENT_FACTORY;
 122     }
 123     public static class Builder {
 124
 125         public DataChangeScope scope;
 126         private NormalizedNode<?, ?> after;
 127         private NormalizedNode<?, ?> before;
 128
 129         private final Map<InstanceIdentifier, NormalizedNode<?, ?>> original = new HashMap<>();
 130         private final Map<InstanceIdentifier, NormalizedNode<?, ?>> created = new HashMap<>();
 131         private final Map<InstanceIdentifier, NormalizedNode<?, ?>> updated = new HashMap<>();
 132         private final Set<InstanceIdentifier> removed = new HashSet<>();
 133
 134         private Builder(final DataChangeScope scope) {
 135             Preconditions.checkNotNull(scope, "Data change scope should not be null.");
 136             this.scope = scope;
 137         }
 138
 139         public Builder setAfter(final NormalizedNode<?, ?> node) {
 140             after = node;
 141             return this;
 142         }
 143
 144         public DOMImmutableDataChangeEvent build() {
 145
 146             return new DOMImmutableDataChangeEvent(this);
 147         }
 148
 149         public void merge(final DOMImmutableDataChangeEvent nestedChanges) {
 150
 151             original.putAll(nestedChanges.getOriginalData());
 152             created.putAll(nestedChanges.getCreatedData());
 153             updated.putAll(nestedChanges.getUpdatedData());
 154             removed.addAll(nestedChanges.getRemovedPaths());
 155
 156         }
 157
 158         public Builder setBefore(final NormalizedNode<?, ?> node) {
 159             this.before = node;
 160             return this;
 161         }
 162
 163         public Builder addCreated(final InstanceIdentifier path, final NormalizedNode<?, ?> node) {
 164             created.put(path, node);
 165             return this;
 166         }
 167
 168         public Builder addRemoved(final InstanceIdentifier path, final NormalizedNode<?, ?> node) {
 169             original.put(path, node);
 170             removed.add(path);
 171             return this;
 172         }
 173
 174         public Builder addUpdated(final InstanceIdentifier path, final NormalizedNode<?, ?> before,
 175                 final NormalizedNode<?, ?> after) {
 176             original.put(path, before);
 177             updated.put(path, after);
 178             return this;
 179         }
 180     }
 181
 182     private static final class RemoveEventFactory implements SimpleEventFactory {
 183
 184         @Override
 185         public DOMImmutableDataChangeEvent create(final InstanceIdentifier path, final NormalizedNode<PathArgument, ?> data) {
 186             return builder(DataChangeScope.BASE) //
 187                     .setBefore(data) //
 188                     .addRemoved(path, data) //
 189                     .build();
 190         }
 191
 192     }
 193
 194     private static final class CreateEventFactory implements SimpleEventFactory {
 195
 196         @Override
 197         public DOMImmutableDataChangeEvent create(final InstanceIdentifier path, final NormalizedNode<PathArgument, ?> data) {
 198             return builder(DataChangeScope.BASE) //
 199                     .setAfter(data) //
 200                     .addCreated(path, data) //
 201                     .build();
 202         }
 203     }
 204
 205 }