From: Robert Varga Date: Tue, 20 May 2014 08:52:59 +0000 (+0200) Subject: BUG-509: Refactor listener walking X-Git-Tag: autorelease-tag-v20140601202136_82eb3f9~47^2 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=commitdiff_plain;h=0dc58e503c111621d7d28c880b1a3fca61e47311 BUG-509: Refactor listener walking This patch creates a proper abstraction for examining a DataTreeCandidate for changes. This has the nice property of finishing the hiding of all implementation details behind proper interfaces, such that our implementation is free to do proper lifecycle as it pleases. Also gets rid of the AutoCloseable from candidate. It can be reintroduced in the need appears. Change-Id: I13301548594d4ae34e929c7202661997ea5aca90 Signed-off-by: Robert Varga --- diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/InMemoryDOMDataStore.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/InMemoryDOMDataStore.java index 9e11fc70fc..00df6580ef 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/InMemoryDOMDataStore.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/InMemoryDOMDataStore.java @@ -335,12 +335,8 @@ public class InMemoryDOMDataStore implements DOMStore, Identifiable, Sch @Override public ListenableFuture abort() { - if (candidate != null) { - candidate.close(); - candidate = null; - } - - return Futures. immediateFuture(null); + candidate = null; + return Futures.immediateFuture(null); } @Override @@ -360,7 +356,7 @@ public class InMemoryDOMDataStore implements DOMStore, Identifiable, Sch } } - return Futures. immediateFuture(null); + return Futures.immediateFuture(null); } } } diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/ResolveDataChangeEventsTask.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/ResolveDataChangeEventsTask.java index db9bb0fef2..b36ef3dd7c 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/ResolveDataChangeEventsTask.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/ResolveDataChangeEventsTask.java @@ -23,11 +23,11 @@ import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataCh 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.DataTreeCandidate; +import org.opendaylight.controller.md.sal.dom.store.impl.tree.DataTreeCandidateNode; import org.opendaylight.controller.md.sal.dom.store.impl.tree.ListenerTree; import org.opendaylight.controller.md.sal.dom.store.impl.tree.ListenerTree.Node; import org.opendaylight.controller.md.sal.dom.store.impl.tree.ListenerTree.Walker; -import org.opendaylight.controller.md.sal.dom.store.impl.tree.data.NodeModification; -import org.opendaylight.controller.md.sal.dom.store.impl.tree.data.StoreMetadataNode; +import org.opendaylight.controller.md.sal.dom.store.impl.tree.ModificationType; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates; @@ -73,9 +73,9 @@ final class ResolveDataChangeEventsTask implements Callable call() { try (final Walker w = listenerRoot.getWalker()) { - resolveAnyChangeEvent(candidate.getRootPath(), Collections.singleton(w.getRootNode()), - candidate.getModificationRoot(), Optional.fromNullable(candidate.getBeforeRoot()), - Optional.fromNullable(candidate.getAfterRoot())); + resolveAnyChangeEvent(candidate.getRootPath(), Collections.singleton(w.getRootNode()), candidate.getRootNode()); return createNotificationTasks(); } } @@ -256,29 +254,38 @@ final class ResolveDataChangeEventsTask implements Callable listeners, final NodeModification modification, - final Optional before, final Optional after) { - // No listeners are present in listener registration subtree - // no before and after state is present - if (!before.isPresent() && !after.isPresent()) { + final Collection listeners, final DataTreeCandidateNode node) { + + if (node.getModificationType() != ModificationType.UNMODIFIED && + !node.getDataAfter().isPresent() && !node.getDataBefore().isPresent()) { + LOG.debug("Modification at {} has type {}, but no before- and after-data. Assuming unchanged.", + path, node.getModificationType()); return NO_CHANGE; } - switch (modification.getModificationType()) { + + // no before and after state is present + + switch (node.getModificationType()) { case SUBTREE_MODIFIED: - return resolveSubtreeChangeEvent(path, listeners, modification, before.get(), after.get()); + return resolveSubtreeChangeEvent(path, listeners, node); case MERGE: case WRITE: - if (before.isPresent()) { - return resolveReplacedEvent(path, listeners, before.get().getData(), after.get().getData()); + Preconditions.checkArgument(node.getDataAfter().isPresent(), + "Modification at {} has type {} but no after-data", path, node.getModificationType()); + if (node.getDataBefore().isPresent()) { + return resolveReplacedEvent(path, listeners, node.getDataBefore().get(), node.getDataAfter().get()); } else { - return resolveCreateEvent(path, listeners, after.get()); + return resolveCreateEvent(path, listeners, node.getDataAfter().get()); } case DELETE: - return resolveDeleteEvent(path, listeners, before.get()); - default: + Preconditions.checkArgument(node.getDataBefore().isPresent(), + "Modification at {} has type {} but no before-data", path, node.getModificationType()); + return resolveDeleteEvent(path, listeners, node.getDataBefore().get()); + case UNMODIFIED: return NO_CHANGE; } + throw new IllegalStateException(String.format("Unhandled node state %s at %s", node.getModificationType(), path)); } private DOMImmutableDataChangeEvent resolveReplacedEvent(final InstanceIdentifier path, @@ -313,7 +320,7 @@ final class ResolveDataChangeEventsTask implements Callable listeners, final NormalizedNodeContainer> beforeCont, - final NormalizedNodeContainer> afterCont) { + final NormalizedNodeContainer> afterCont) { final Set alreadyProcessed = new HashSet<>(); final List childChanges = new LinkedList<>(); @@ -388,17 +395,17 @@ final class ResolveDataChangeEventsTask implements Callable listeners, final StoreMetadataNode afterState) { + final Collection listeners, final NormalizedNode afterState) { @SuppressWarnings({ "unchecked", "rawtypes" }) - final NormalizedNode node = (NormalizedNode) afterState.getData(); + final NormalizedNode node = (NormalizedNode) afterState; return resolveSameEventRecursivelly(path, listeners, node, DOMImmutableDataChangeEvent.getCreateEventFactory()); } private DOMImmutableDataChangeEvent resolveDeleteEvent(final InstanceIdentifier path, - final Collection listeners, final StoreMetadataNode beforeState) { + final Collection listeners, final NormalizedNode beforeState) { @SuppressWarnings({ "unchecked", "rawtypes" }) - final NormalizedNode node = (NormalizedNode) beforeState.getData(); + final NormalizedNode node = (NormalizedNode) beforeState; return resolveSameEventRecursivelly(path, listeners, node, DOMImmutableDataChangeEvent.getRemoveEventFactory()); } @@ -408,7 +415,7 @@ final class ResolveDataChangeEventsTask implements Callable) { LOG.trace("Resolving subtree recursive event for {}, type {}", path, eventFactory); @@ -439,30 +446,31 @@ final class ResolveDataChangeEventsTask implements Callable listeners, final NodeModification modification, - final StoreMetadataNode before, final StoreMetadataNode after) { + final Collection listeners, final DataTreeCandidateNode modification) { - Builder one = builder(DataChangeScope.ONE).setBefore(before.getData()).setAfter(after.getData()); + Preconditions.checkArgument(modification.getDataBefore().isPresent(), "Subtree change with before-data not present at path %s", path); + Preconditions.checkArgument(modification.getDataAfter().isPresent(), "Subtree change with after-data not present at path %s", path); - Builder subtree = builder(DataChangeScope.SUBTREE).setBefore(before.getData()).setAfter(after.getData()); + Builder one = builder(DataChangeScope.ONE). + setBefore(modification.getDataBefore().get()). + setAfter(modification.getDataAfter().get()); + Builder subtree = builder(DataChangeScope.SUBTREE). + setBefore(modification.getDataBefore().get()). + setAfter(modification.getDataAfter().get()); - for (NodeModification childMod : modification.getModifications()) { + for (DataTreeCandidateNode childMod : modification.getChildNodes()) { PathArgument childId = childMod.getIdentifier(); InstanceIdentifier childPath = append(path, childId); Collection childListeners = getListenerChildrenWildcarded(listeners, childId); - Optional childBefore = before.getChild(childId); - Optional childAfter = after.getChild(childId); - switch (childMod.getModificationType()) { case WRITE: case MERGE: case DELETE: - one.merge(resolveAnyChangeEvent(childPath, childListeners, childMod, childBefore, childAfter)); + one.merge(resolveAnyChangeEvent(childPath, childListeners, childMod)); break; case SUBTREE_MODIFIED: - subtree.merge(resolveSubtreeChangeEvent(childPath, childListeners, childMod, childBefore.get(), - childAfter.get())); + subtree.merge(resolveSubtreeChangeEvent(childPath, childListeners, childMod)); break; case UNMODIFIED: // no-op @@ -514,7 +522,7 @@ final class ResolveDataChangeEventsTask implements Callable getChildNodes(); + + ModificationType getModificationType(); + Optional> getDataAfter(); + Optional> getDataBefore(); +} diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/ModificationType.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/ModificationType.java similarity index 91% rename from opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/ModificationType.java rename to opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/ModificationType.java index 9d2e965ff7..b16e907120 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/ModificationType.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/ModificationType.java @@ -5,7 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -package org.opendaylight.controller.md.sal.dom.store.impl.tree.data; +package org.opendaylight.controller.md.sal.dom.store.impl.tree; public enum ModificationType { diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/AbstractDataTreeCandidate.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/AbstractDataTreeCandidate.java index b2faf79565..cddda5ccc5 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/AbstractDataTreeCandidate.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/AbstractDataTreeCandidate.java @@ -13,21 +13,15 @@ import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier; import com.google.common.base.Preconditions; abstract class AbstractDataTreeCandidate implements DataTreeCandidate { - private final InstanceIdentifier rootPath; - private final NodeModification modificationRoot; + private final InstanceIdentifier rootPath; - protected AbstractDataTreeCandidate(final InstanceIdentifier rootPath, NodeModification modificationRoot) { - this.rootPath = Preconditions.checkNotNull(rootPath); - this.modificationRoot = Preconditions.checkNotNull(modificationRoot); - } + protected AbstractDataTreeCandidate(final InstanceIdentifier rootPath) { + this.rootPath = Preconditions.checkNotNull(rootPath); + } - @Override - public final InstanceIdentifier getRootPath() { - return rootPath; - } + @Override + public final InstanceIdentifier getRootPath() { + return rootPath; + } - @Override - public final NodeModification getModificationRoot() { - return modificationRoot; - } } diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/InMemoryDataTree.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/InMemoryDataTree.java index 5a300a071d..f04e379dd9 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/InMemoryDataTree.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/InMemoryDataTree.java @@ -14,6 +14,7 @@ import org.opendaylight.controller.md.sal.dom.store.impl.tree.DataPreconditionFa import org.opendaylight.controller.md.sal.dom.store.impl.tree.DataTree; import org.opendaylight.controller.md.sal.dom.store.impl.tree.DataTreeCandidate; import org.opendaylight.controller.md.sal.dom.store.impl.tree.DataTreeModification; +import org.opendaylight.controller.md.sal.dom.store.impl.tree.ModificationType; import org.opendaylight.controller.md.sal.dom.store.impl.tree.StoreUtils; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier; import org.opendaylight.yangtools.yang.model.api.SchemaContext; @@ -127,7 +128,7 @@ final class InMemoryDataTree implements DataTree { rwLock.writeLock().lock(); try { Preconditions.checkState(c.getBeforeRoot() == rootNode, - String.format("Store snapshot %s and transaction snapshot %s differ.", rootNode, c.getBeforeRoot())); + String.format("Store tree %s and candidate base %s differ.", rootNode, c.getBeforeRoot())); this.rootNode = c.getAfterRoot(); } finally { rwLock.writeLock().unlock(); diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/InMemoryDataTreeCandidate.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/InMemoryDataTreeCandidate.java index 93719b7f53..72562f0a72 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/InMemoryDataTreeCandidate.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/InMemoryDataTreeCandidate.java @@ -1,32 +1,119 @@ package org.opendaylight.controller.md.sal.dom.store.impl.tree.data; +import org.opendaylight.controller.md.sal.dom.store.impl.tree.DataTreeCandidateNode; +import org.opendaylight.controller.md.sal.dom.store.impl.tree.ModificationType; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import com.google.common.base.Function; +import com.google.common.base.Optional; import com.google.common.base.Preconditions; +import com.google.common.collect.Iterables; final class InMemoryDataTreeCandidate extends AbstractDataTreeCandidate { - private final StoreMetadataNode newRoot; - private final StoreMetadataNode oldRoot; - - InMemoryDataTreeCandidate(final InstanceIdentifier rootPath, final NodeModification modificationRoot, - final StoreMetadataNode oldRoot, final StoreMetadataNode newRoot) { - super(rootPath, modificationRoot); - this.newRoot = Preconditions.checkNotNull(newRoot); - this.oldRoot = Preconditions.checkNotNull(oldRoot); - } - - @Override - public void close() { - // FIXME: abort operation here :) - } - - @Override - public StoreMetadataNode getBeforeRoot() { - return oldRoot; - } - - @Override - public StoreMetadataNode getAfterRoot() { - return newRoot; - } + private static abstract class AbstractNode implements DataTreeCandidateNode { + private final StoreMetadataNode newMeta; + private final StoreMetadataNode oldMeta; + private final NodeModification mod; + + protected AbstractNode(final NodeModification mod, + final StoreMetadataNode oldMeta, final StoreMetadataNode newMeta) { + this.newMeta = newMeta; + this.oldMeta = oldMeta; + this.mod = Preconditions.checkNotNull(mod); + } + + protected final NodeModification getMod() { + return mod; + } + + protected final StoreMetadataNode getNewMeta() { + return newMeta; + } + + protected final StoreMetadataNode getOldMeta() { + return oldMeta; + } + + private static final StoreMetadataNode childMeta(final StoreMetadataNode parent, final PathArgument id) { + return parent == null ? null : parent.getChild(id).orNull(); + } + + @Override + public Iterable getChildNodes() { + return Iterables.transform(mod.getModifications(), new Function() { + @Override + public DataTreeCandidateNode apply(final NodeModification input) { + final PathArgument id = input.getIdentifier(); + return new ChildNode(input, childMeta(oldMeta, id), childMeta(newMeta, id)); + } + }); + } + + @Override + public ModificationType getModificationType() { + return mod.getModificationType(); + } + + private Optional> optionalData(StoreMetadataNode meta) { + if (meta == null) { + return Optional.absent(); + } + return Optional.>of(meta.getData()); + } + + @Override + public Optional> getDataAfter() { + return optionalData(newMeta); + } + + @Override + public Optional> getDataBefore() { + return optionalData(oldMeta); + } + } + + private static final class ChildNode extends AbstractNode { + public ChildNode(NodeModification mod, StoreMetadataNode oldMeta, StoreMetadataNode newMeta) { + super(mod, oldMeta, newMeta); + } + + @Override + public PathArgument getIdentifier() { + return getMod().getIdentifier(); + } + } + + private static final class RootNode extends AbstractNode { + public RootNode(NodeModification mod, StoreMetadataNode oldMeta, StoreMetadataNode newMeta) { + super(mod, oldMeta, newMeta); + } + + @Override + public PathArgument getIdentifier() { + throw new IllegalStateException("Attempted to get identifier of the root node"); + } + } + + private final RootNode root; + + InMemoryDataTreeCandidate(final InstanceIdentifier rootPath, final NodeModification modificationRoot, + final StoreMetadataNode oldRoot, final StoreMetadataNode newRoot) { + super(rootPath); + this.root = new RootNode(modificationRoot, oldRoot, newRoot); + } + + StoreMetadataNode getAfterRoot() { + return root.getNewMeta(); + } + + StoreMetadataNode getBeforeRoot() { + return root.getOldMeta(); + } + + @Override + public DataTreeCandidateNode getRootNode() { + return root; + } } diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/NodeModification.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/NodeModification.java index 18179afd50..f2720b57ae 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/NodeModification.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/NodeModification.java @@ -14,6 +14,7 @@ import java.util.Map; import javax.annotation.concurrent.GuardedBy; +import org.opendaylight.controller.md.sal.dom.store.impl.tree.ModificationType; import org.opendaylight.controller.md.sal.dom.store.impl.tree.StoreTreeNode; import org.opendaylight.yangtools.concepts.Identifiable; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument; @@ -30,10 +31,8 @@ import com.google.common.base.Predicate; * * This tree is lazily created and populated via {@link #modifyChild(PathArgument)} * and {@link StoreMetadataNode} which represents original state {@link #getOriginal()}. - * */ -// FIXME: hide this class -public class NodeModification implements StoreTreeNode, Identifiable { +final class NodeModification implements StoreTreeNode, Identifiable { public static final Predicate IS_TERMINAL_PREDICATE = new Predicate() { @Override diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/NoopDataTreeCandidate.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/NoopDataTreeCandidate.java index 1782da2835..8a46748414 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/NoopDataTreeCandidate.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/NoopDataTreeCandidate.java @@ -7,25 +7,52 @@ */ package org.opendaylight.controller.md.sal.dom.store.impl.tree.data; +import java.util.Collections; + +import org.opendaylight.controller.md.sal.dom.store.impl.tree.DataTreeCandidateNode; +import org.opendaylight.controller.md.sal.dom.store.impl.tree.ModificationType; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; + +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; final class NoopDataTreeCandidate extends AbstractDataTreeCandidate { - protected NoopDataTreeCandidate(final InstanceIdentifier rootPath, final NodeModification modificationRoot) { - super(rootPath, modificationRoot); - } - - @Override - public void close() { - // NO-OP - } - - @Override - public StoreMetadataNode getBeforeRoot() { - return null; - } - - @Override - public StoreMetadataNode getAfterRoot() { - return null; - } + private static final DataTreeCandidateNode ROOT = new DataTreeCandidateNode() { + @Override + public ModificationType getModificationType() { + return ModificationType.UNMODIFIED; + } + + @Override + public Iterable getChildNodes() { + return Collections.emptyList(); + } + + @Override + public PathArgument getIdentifier() { + throw new IllegalStateException("Attempted to read identifier of the no-operation change"); + } + + @Override + public Optional> getDataAfter() { + return Optional.absent(); + } + + @Override + public Optional> getDataBefore() { + return Optional.absent(); + } + }; + + protected NoopDataTreeCandidate(final InstanceIdentifier rootPath, final NodeModification modificationRoot) { + super(rootPath); + Preconditions.checkArgument(modificationRoot.getModificationType() == ModificationType.UNMODIFIED); + } + + @Override + public DataTreeCandidateNode getRootNode() { + return ROOT; + } } diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/SchemaAwareApplyOperation.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/SchemaAwareApplyOperation.java index 02244d9f98..ca5371297d 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/SchemaAwareApplyOperation.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/SchemaAwareApplyOperation.java @@ -16,6 +16,7 @@ import java.util.Set; import java.util.concurrent.ExecutionException; import org.opendaylight.controller.md.sal.dom.store.impl.tree.DataPreconditionFailedException; +import org.opendaylight.controller.md.sal.dom.store.impl.tree.ModificationType; import org.opendaylight.controller.md.sal.dom.store.impl.tree.StoreUtils; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier; diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/StoreMetadataNode.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/StoreMetadataNode.java index 8addb89bd1..0ee0d9b32c 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/StoreMetadataNode.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/StoreMetadataNode.java @@ -24,15 +24,12 @@ import com.google.common.base.Optional; import com.google.common.base.Preconditions; import com.google.common.primitives.UnsignedLong; -// FIXME: this should not be public -public class StoreMetadataNode implements Immutable, Identifiable, StoreTreeNode { - +class StoreMetadataNode implements Immutable, Identifiable, StoreTreeNode { + private final Map children; private final UnsignedLong nodeVersion; private final UnsignedLong subtreeVersion; private final NormalizedNode data; - private final Map children; - /** * * @param data @@ -42,9 +39,9 @@ public class StoreMetadataNode implements Immutable, Identifiable, */ protected StoreMetadataNode(final NormalizedNode data, final UnsignedLong nodeVersion, final UnsignedLong subtreeVersion, final Map children) { - this.nodeVersion = nodeVersion; - this.subtreeVersion = subtreeVersion; - this.data = data; + this.nodeVersion = Preconditions.checkNotNull(nodeVersion); + this.subtreeVersion = Preconditions.checkNotNull(subtreeVersion); + this.data = Preconditions.checkNotNull(data); this.children = Preconditions.checkNotNull(children); }