package org.opendaylight.controller.md.sal.dom.store.impl;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
import java.util.Collection;
import java.util.Map.Entry;
+import java.util.Optional;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.dom.spi.RegistrationTreeSnapshot;
import org.opendaylight.controller.md.sal.dom.store.impl.DOMImmutableDataChangeEvent.Builder;
import org.opendaylight.controller.md.sal.dom.store.impl.DOMImmutableDataChangeEvent.SimpleEventFactory;
-import org.opendaylight.controller.md.sal.dom.store.impl.tree.ListenerTree;
+import org.opendaylight.controller.sal.core.compat.DataChangeListenerRegistration;
+import org.opendaylight.controller.sal.core.compat.ListenerTree;
+import org.opendaylight.mdsal.dom.spi.RegistrationTreeSnapshot;
import org.opendaylight.yangtools.util.concurrent.NotificationManager;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
/**
* Resolve Data Change Events based on modifications and listeners
*
- * Computes data change events for all affected registered listeners in data
- * tree.
+ * <p>
+ * Computes data change events for all affected registered listeners in data tree.
*/
@Beta
public final class ResolveDataChangeEventsTask {
/**
* Resolves and submits notification tasks to the specified manager.
*/
- public synchronized void resolve(final NotificationManager<DataChangeListenerRegistration<?>, DOMImmutableDataChangeEvent> manager) {
- try (final RegistrationTreeSnapshot<DataChangeListenerRegistration<?>> w = listenerRoot.takeSnapshot()) {
+ public synchronized void resolve(final NotificationManager<DataChangeListenerRegistration<?>,
+ DOMImmutableDataChangeEvent> manager) {
+ try (RegistrationTreeSnapshot<DataChangeListenerRegistration<?>> w = listenerRoot.takeSnapshot()) {
// Defensive: reset internal state
collectedEvents = ArrayListMultimap.create();
* Convert to tasks, but be mindful of multiple values -- those indicate multiple
* wildcard matches, which need to be merged.
*/
- for (Entry<DataChangeListenerRegistration<?>, Collection<DOMImmutableDataChangeEvent>> e : collectedEvents.asMap().entrySet()) {
+ for (Entry<DataChangeListenerRegistration<?>, Collection<DOMImmutableDataChangeEvent>> e :
+ collectedEvents.asMap().entrySet()) {
final Collection<DOMImmutableDataChangeEvent> col = e.getValue();
final DOMImmutableDataChangeEvent event;
}
/**
- * Resolves data change event for supplied node
+ * Resolves data change event for supplied node.
*
* @param path
* Path to current node in tree
// no before and after state is present
switch (type) {
- case SUBTREE_MODIFIED:
- return resolveSubtreeChangeEvent(state, node);
- case MERGE:
- case WRITE:
- Preconditions.checkArgument(maybeAfter.isPresent(),
- "Modification at {} has type {} but no after-data", state.getPath(), type);
- if (!maybeBefore.isPresent()) {
- @SuppressWarnings({ "unchecked", "rawtypes" })
- final NormalizedNode<PathArgument, ?> afterNode = (NormalizedNode)maybeAfter.get();
- resolveSameEventRecursivelly(state, afterNode, DOMImmutableDataChangeEvent.getCreateEventFactory());
- return true;
- }
+ case SUBTREE_MODIFIED:
+ return resolveSubtreeChangeEvent(state, node);
+ case APPEARED:
+ case WRITE:
+ Preconditions.checkArgument(maybeAfter.isPresent(),
+ "Modification at {} has type {} but no after-data", state.getPath(), type);
+ if (!maybeBefore.isPresent()) {
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ final NormalizedNode<PathArgument, ?> afterNode = (NormalizedNode)maybeAfter.get();
+ resolveSameEventRecursivelly(state, afterNode, DOMImmutableDataChangeEvent.getCreateEventFactory());
+ return true;
+ }
- return resolveReplacedEvent(state, maybeBefore.get(), maybeAfter.get());
- case DELETE:
- Preconditions.checkArgument(maybeBefore.isPresent(),
- "Modification at {} has type {} but no before-data", state.getPath(), type);
+ return resolveReplacedEvent(state, maybeBefore.get(), maybeAfter.get());
+ case DISAPPEARED:
+ case DELETE:
+ Preconditions.checkArgument(maybeBefore.isPresent(),
+ "Modification at {} has type {} but no before-data", state.getPath(), type);
- @SuppressWarnings({ "unchecked", "rawtypes" })
- final NormalizedNode<PathArgument, ?> beforeNode = (NormalizedNode)maybeBefore.get();
- resolveSameEventRecursivelly(state, beforeNode, DOMImmutableDataChangeEvent.getRemoveEventFactory());
- return true;
- case UNMODIFIED:
- return false;
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ final NormalizedNode<PathArgument, ?> beforeNode = (NormalizedNode)maybeBefore.get();
+ resolveSameEventRecursivelly(state, beforeNode, DOMImmutableDataChangeEvent.getRemoveEventFactory());
+ return true;
+ case UNMODIFIED:
+ return false;
+ default:
+ break;
}
throw new IllegalStateException(String.format("Unhandled node state %s at %s", type, state.getPath()));
* resolution of changes on children level and can not
* shortcut resolution.
*/
- LOG.trace("Resolving subtree replace event for {} before {}, after {}", state.getPath(), beforeData, afterData);
+ LOG.trace("Resolving subtree replace event for {} before {}, after {}", state.getPath(), beforeData,
+ afterData);
@SuppressWarnings("unchecked")
- NormalizedNodeContainer<?, PathArgument, NormalizedNode<PathArgument, ?>> beforeCont = (NormalizedNodeContainer<?, PathArgument, NormalizedNode<PathArgument, ?>>) beforeData;
+ NormalizedNodeContainer<?, PathArgument, NormalizedNode<PathArgument, ?>> beforeCont =
+ (NormalizedNodeContainer<?, PathArgument, NormalizedNode<PathArgument, ?>>) beforeData;
@SuppressWarnings("unchecked")
- NormalizedNodeContainer<?, PathArgument, NormalizedNode<PathArgument, ?>> afterCont = (NormalizedNodeContainer<?, PathArgument, NormalizedNode<PathArgument, ?>>) afterData;
+ NormalizedNodeContainer<?, PathArgument, NormalizedNode<PathArgument, ?>> afterCont =
+ (NormalizedNodeContainer<?, PathArgument, NormalizedNode<PathArgument, ?>>) afterData;
return resolveNodeContainerReplaced(state, beforeCont, afterCont);
}
}
LOG.trace("Resolving leaf replace event for {} , before {}, after {}", state.getPath(), beforeData, afterData);
- DOMImmutableDataChangeEvent event = DOMImmutableDataChangeEvent.builder(DataChangeScope.BASE).addUpdated(state.getPath(), beforeData, afterData).build();
+ DOMImmutableDataChangeEvent event = DOMImmutableDataChangeEvent.builder(DataChangeScope.BASE)
+ .addUpdated(state.getPath(), beforeData, afterData).build();
state.addEvent(event);
state.collectEvents(beforeData, afterData, collectedEvents);
return true;
* created.
*/
if (!beforeCont.getChild(childId).isPresent()) {
- resolveSameEventRecursivelly(state.child(childId), afterChild, DOMImmutableDataChangeEvent.getCreateEventFactory());
+ resolveSameEventRecursivelly(state.child(childId), afterChild,
+ DOMImmutableDataChangeEvent.getCreateEventFactory());
childChanged = true;
}
}
// Node has children, so we will try to resolve it's children
// changes.
@SuppressWarnings("unchecked")
- NormalizedNodeContainer<?, PathArgument, NormalizedNode<PathArgument, ?>> container = (NormalizedNodeContainer<?, PathArgument, NormalizedNode<PathArgument, ?>>) node;
+ NormalizedNodeContainer<?, PathArgument, NormalizedNode<PathArgument, ?>> container =
+ (NormalizedNodeContainer<?, PathArgument, NormalizedNode<PathArgument, ?>>) node;
for (NormalizedNode<PathArgument, ?> child : container.getValue()) {
final PathArgument childId = child.getIdentifier();
state.collectEvents(event.getOriginalSubtree(), event.getUpdatedSubtree(), collectedEvents);
}
- private boolean resolveSubtreeChangeEvent(final ResolveDataChangeState state, final DataTreeCandidateNode modification) {
+ private boolean resolveSubtreeChangeEvent(final ResolveDataChangeState state,
+ final DataTreeCandidateNode modification) {
final Optional<NormalizedNode<?, ?>> maybeBefore = modification.getDataBefore();
final Optional<NormalizedNode<?, ?>> maybeAfter = modification.getDataAfter();
- Preconditions.checkArgument(maybeBefore.isPresent(), "Subtree change with before-data not present at path %s", state.getPath());
- Preconditions.checkArgument(maybeAfter.isPresent(), "Subtree change with after-data not present at path %s", state.getPath());
+ Preconditions.checkArgument(maybeBefore.isPresent(), "Subtree change with before-data not present at path %s",
+ state.getPath());
+ Preconditions.checkArgument(maybeAfter.isPresent(), "Subtree change with after-data not present at path %s",
+ state.getPath());
if (!state.needsProcessing()) {
LOG.trace("Not processing modified subtree {}", state.getPath());
final ResolveDataChangeState childState = state.child(childMod.getIdentifier());
switch (childMod.getModificationType()) {
- case WRITE:
- case MERGE:
- case DELETE:
- if (resolveAnyChangeEvent(childState, childMod)) {
- scope = DataChangeScope.ONE;
- }
- break;
- case SUBTREE_MODIFIED:
- if (resolveSubtreeChangeEvent(childState, childMod) && scope == null) {
- scope = DataChangeScope.SUBTREE;
- }
- break;
- case UNMODIFIED:
- // no-op
- break;
+ case APPEARED:
+ case DELETE:
+ case DISAPPEARED:
+ case WRITE:
+ if (resolveAnyChangeEvent(childState, childMod)) {
+ scope = DataChangeScope.ONE;
+ }
+ break;
+ case SUBTREE_MODIFIED:
+ if (resolveSubtreeChangeEvent(childState, childMod) && scope == null) {
+ scope = DataChangeScope.SUBTREE;
+ }
+ break;
+ case UNMODIFIED:
+ // no-op
+ break;
+ default:
+ break;
}
}
final NormalizedNode<?, ?> after = maybeAfter.get();
if (scope != null) {
- DOMImmutableDataChangeEvent one = DOMImmutableDataChangeEvent.builder(scope).addUpdated(state.getPath(), before, after).build();
+ DOMImmutableDataChangeEvent one = DOMImmutableDataChangeEvent.builder(scope)
+ .addUpdated(state.getPath(), before, after).build();
state.addEvent(one);
}
return scope != null;
}
- public static ResolveDataChangeEventsTask create(final DataTreeCandidate candidate, final ListenerTree listenerTree) {
+ public static ResolveDataChangeEventsTask create(final DataTreeCandidate candidate,
+ final ListenerTree listenerTree) {
return new ResolveDataChangeEventsTask(candidate, listenerTree);
}
}