1 package org.opendaylight.controller.md.sal.dom.store.impl;
3 import java.util.Collections;
4 import java.util.HashMap;
5 import java.util.HashSet;
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;
15 import com.google.common.base.Preconditions;
17 public final class DOMImmutableDataChangeEvent implements
18 AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> {
21 private static final RemoveEventFactory REMOVE_EVENT_FACTORY = new RemoveEventFactory();
22 private static final CreateEventFactory CREATE_EVENT_FACTORY = new CreateEventFactory();
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;
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);
44 public static final Builder builder(final DataChangeScope scope) {
45 return new Builder(scope);
48 protected DataChangeScope getScope() {
53 public NormalizedNode<?, ?> getOriginalSubtree() {
58 public NormalizedNode<?, ?> getUpdatedSubtree() {
63 public Map<InstanceIdentifier, ? extends NormalizedNode<?, ?>> getOriginalData() {
68 public Map<InstanceIdentifier, NormalizedNode<?, ?>> getCreatedData() {
73 public Map<InstanceIdentifier, NormalizedNode<?, ?>> getUpdatedData() {
78 public Set<InstanceIdentifier> getRemovedPaths() {
83 public String toString() {
84 return "DOMImmutableDataChangeEvent [created=" + createdData.keySet() + ", updated=" + updatedData.keySet()
85 + ", removed=" + removedPaths + "]";
89 * Simple event factory which creates event based on path and data
93 public interface SimpleEventFactory {
94 DOMImmutableDataChangeEvent create(InstanceIdentifier path, NormalizedNode<PathArgument,?> data);
98 * Event factory which takes after state and creates event for it.
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()}.
106 public static final SimpleEventFactory getCreateEventFactory() {
107 return CREATE_EVENT_FACTORY;
111 * Event factory which takes before state and creates event for it.
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()}.
117 * Path is present in {@link #getRemovedPaths()}.
120 public static final SimpleEventFactory getRemoveEventFactory() {
121 return REMOVE_EVENT_FACTORY;
123 public static class Builder {
125 public DataChangeScope scope;
126 private NormalizedNode<?, ?> after;
127 private NormalizedNode<?, ?> before;
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<>();
134 private Builder(final DataChangeScope scope) {
135 Preconditions.checkNotNull(scope, "Data change scope should not be null.");
139 public Builder setAfter(final NormalizedNode<?, ?> node) {
144 public DOMImmutableDataChangeEvent build() {
146 return new DOMImmutableDataChangeEvent(this);
149 public void merge(final DOMImmutableDataChangeEvent nestedChanges) {
151 original.putAll(nestedChanges.getOriginalData());
152 created.putAll(nestedChanges.getCreatedData());
153 updated.putAll(nestedChanges.getUpdatedData());
154 removed.addAll(nestedChanges.getRemovedPaths());
158 public Builder setBefore(final NormalizedNode<?, ?> node) {
163 public Builder addCreated(final InstanceIdentifier path, final NormalizedNode<?, ?> node) {
164 created.put(path, node);
168 public Builder addRemoved(final InstanceIdentifier path, final NormalizedNode<?, ?> node) {
169 original.put(path, node);
174 public Builder addUpdated(final InstanceIdentifier path, final NormalizedNode<?, ?> before,
175 final NormalizedNode<?, ?> after) {
176 original.put(path, before);
177 updated.put(path, after);
182 private static final class RemoveEventFactory implements SimpleEventFactory {
185 public DOMImmutableDataChangeEvent create(final InstanceIdentifier path, final NormalizedNode<PathArgument, ?> data) {
186 return builder(DataChangeScope.BASE) //
188 .addRemoved(path, data) //
194 private static final class CreateEventFactory implements SimpleEventFactory {
197 public DOMImmutableDataChangeEvent create(final InstanceIdentifier path, final NormalizedNode<PathArgument, ?> data) {
198 return builder(DataChangeScope.BASE) //
200 .addCreated(path, data) //