2 * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.controller.md.sal.dom.store.impl;
10 import java.util.Collections;
11 import java.util.HashMap;
12 import java.util.HashSet;
16 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
17 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
18 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
19 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
20 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
22 import com.google.common.base.Preconditions;
24 public final class DOMImmutableDataChangeEvent implements
25 AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> {
28 private static final RemoveEventFactory REMOVE_EVENT_FACTORY = new RemoveEventFactory();
29 private static final CreateEventFactory CREATE_EVENT_FACTORY = new CreateEventFactory();
31 private final NormalizedNode<?, ?> original;
32 private final NormalizedNode<?, ?> updated;
33 private final Map<InstanceIdentifier, ? extends NormalizedNode<?, ?>> originalData;
34 private final Map<InstanceIdentifier, NormalizedNode<?, ?>> createdData;
35 private final Map<InstanceIdentifier, NormalizedNode<?, ?>> updatedData;
36 private final Set<InstanceIdentifier> removedPaths;
37 private final DataChangeScope scope;
41 private DOMImmutableDataChangeEvent(final Builder change) {
42 original = change.before;
43 updated = change.after;
44 originalData = Collections.unmodifiableMap(change.original);
45 createdData = Collections.unmodifiableMap(change.created);
46 updatedData = Collections.unmodifiableMap(change.updated);
47 removedPaths = Collections.unmodifiableSet(change.removed);
51 public static final Builder builder(final DataChangeScope scope) {
52 return new Builder(scope);
55 protected DataChangeScope getScope() {
60 public NormalizedNode<?, ?> getOriginalSubtree() {
65 public NormalizedNode<?, ?> getUpdatedSubtree() {
70 public Map<InstanceIdentifier, ? extends NormalizedNode<?, ?>> getOriginalData() {
75 public Map<InstanceIdentifier, NormalizedNode<?, ?>> getCreatedData() {
80 public Map<InstanceIdentifier, NormalizedNode<?, ?>> getUpdatedData() {
85 public Set<InstanceIdentifier> getRemovedPaths() {
90 public String toString() {
91 return "DOMImmutableDataChangeEvent [created=" + createdData.keySet() + ", updated=" + updatedData.keySet()
92 + ", removed=" + removedPaths + "]";
96 * Simple event factory which creates event based on path and data
100 public interface SimpleEventFactory {
101 DOMImmutableDataChangeEvent create(InstanceIdentifier path, NormalizedNode<PathArgument,?> data);
105 * Event factory which takes after state and creates event for it.
107 * Factory for events based on path and after state.
108 * After state is set as {@link #getUpdatedSubtree()} and is path,
109 * state mapping is also present in {@link #getUpdatedData()}.
113 public static final SimpleEventFactory getCreateEventFactory() {
114 return CREATE_EVENT_FACTORY;
118 * Event factory which takes before state and creates event for it.
120 * Factory for events based on path and after state.
121 * After state is set as {@link #getOriginalSubtree()} and is path,
122 * state mapping is also present in {@link #getOriginalSubtree()}.
124 * Path is present in {@link #getRemovedPaths()}.
127 public static final SimpleEventFactory getRemoveEventFactory() {
128 return REMOVE_EVENT_FACTORY;
130 public static class Builder {
132 public DataChangeScope scope;
133 private NormalizedNode<?, ?> after;
134 private NormalizedNode<?, ?> before;
136 private final Map<InstanceIdentifier, NormalizedNode<?, ?>> original = new HashMap<>();
137 private final Map<InstanceIdentifier, NormalizedNode<?, ?>> created = new HashMap<>();
138 private final Map<InstanceIdentifier, NormalizedNode<?, ?>> updated = new HashMap<>();
139 private final Set<InstanceIdentifier> removed = new HashSet<>();
141 private Builder(final DataChangeScope scope) {
142 Preconditions.checkNotNull(scope, "Data change scope should not be null.");
146 public Builder setAfter(final NormalizedNode<?, ?> node) {
151 public DOMImmutableDataChangeEvent build() {
153 return new DOMImmutableDataChangeEvent(this);
156 public void merge(final DOMImmutableDataChangeEvent nestedChanges) {
158 original.putAll(nestedChanges.getOriginalData());
159 created.putAll(nestedChanges.getCreatedData());
160 updated.putAll(nestedChanges.getUpdatedData());
161 removed.addAll(nestedChanges.getRemovedPaths());
165 public Builder setBefore(final NormalizedNode<?, ?> node) {
170 public Builder addCreated(final InstanceIdentifier path, final NormalizedNode<?, ?> node) {
171 created.put(path, node);
175 public Builder addRemoved(final InstanceIdentifier path, final NormalizedNode<?, ?> node) {
176 original.put(path, node);
181 public Builder addUpdated(final InstanceIdentifier path, final NormalizedNode<?, ?> before,
182 final NormalizedNode<?, ?> after) {
183 original.put(path, before);
184 updated.put(path, after);
189 private static final class RemoveEventFactory implements SimpleEventFactory {
192 public DOMImmutableDataChangeEvent create(final InstanceIdentifier path, final NormalizedNode<PathArgument, ?> data) {
193 return builder(DataChangeScope.BASE) //
195 .addRemoved(path, data) //
201 private static final class CreateEventFactory implements SimpleEventFactory {
204 public DOMImmutableDataChangeEvent create(final InstanceIdentifier path, final NormalizedNode<PathArgument, ?> data) {
205 return builder(DataChangeScope.BASE) //
207 .addCreated(path, data) //