From e8ac6b68244f35fce04f421314259ec8683652aa Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Mon, 28 Jan 2019 22:17:54 +0100 Subject: [PATCH] Move NormalizedNode-based DataTreeCandidateNodes into API These utility classes are useful for downstreams, and we have an API point from where we can expose them in a relatively clean fashion. Move them to API package and expose them through DataTreeCandidateNodes utility class. Change-Id: Idaa276323f78baa273200f8d8c6b77e53fa60c6a Signed-off-by: Robert Varga --- .../AbstractAvailableLeafCandidateNode.java | 6 +- .../tree/AbstractDataTreeCandidateNode.java | 42 +++++ .../tree/AbstractLeafCandidateNode.java | 12 +- .../tree/AbstractRecursiveCandidateNode.java | 43 +++++ .../schema/tree/AbstractWriteCandidate.java | 7 +- .../schema/tree/DataTreeCandidateNodes.java | 167 ++++++++++++++++-- .../api/schema/tree/DataTreeCandidates.java | 12 +- .../schema/tree/DeleteLeafCandidateNode.java | 7 +- .../NormalizedNodeDataTreeCandidateNode.java | 9 +- .../tree/RecursiveDeleteCandidateNode.java | 20 +-- .../tree/RecursiveReplaceCandidateNode.java | 16 +- .../RecursiveUnmodifiedCandidateNode.java | 11 +- .../tree/RecursiveWriteCandidateNode.java | 27 ++- .../schema/tree/ReplaceLeafCandidateNode.java | 4 +- .../tree/UnmodifiedLeafCandidateNode.java | 6 +- .../schema/tree/WriteLeafCandidateNode.java | 4 +- .../tree/AbstractDataTreeCandidateNode.java | 119 ------------- ...bstractModifiedNodeBasedCandidateNode.java | 22 +-- .../tree/AbstractRecursiveCandidateNode.java | 94 ---------- 19 files changed, 293 insertions(+), 335 deletions(-) rename yang/{yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl => yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api}/schema/tree/AbstractAvailableLeafCandidateNode.java (76%) create mode 100644 yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/AbstractDataTreeCandidateNode.java rename yang/{yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl => yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api}/schema/tree/AbstractLeafCandidateNode.java (77%) create mode 100644 yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/AbstractRecursiveCandidateNode.java rename yang/{yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl => yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api}/schema/tree/AbstractWriteCandidate.java (69%) rename yang/{yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl => yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api}/schema/tree/DeleteLeafCandidateNode.java (81%) rename yang/{yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl => yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api}/schema/tree/RecursiveDeleteCandidateNode.java (83%) rename yang/{yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl => yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api}/schema/tree/RecursiveReplaceCandidateNode.java (77%) rename yang/{yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl => yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api}/schema/tree/RecursiveUnmodifiedCandidateNode.java (76%) rename yang/{yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl => yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api}/schema/tree/RecursiveWriteCandidateNode.java (83%) rename yang/{yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl => yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api}/schema/tree/ReplaceLeafCandidateNode.java (88%) rename yang/{yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl => yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api}/schema/tree/UnmodifiedLeafCandidateNode.java (80%) rename yang/{yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl => yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api}/schema/tree/WriteLeafCandidateNode.java (86%) delete mode 100644 yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractDataTreeCandidateNode.java delete mode 100644 yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractRecursiveCandidateNode.java diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractAvailableLeafCandidateNode.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/AbstractAvailableLeafCandidateNode.java similarity index 76% rename from yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractAvailableLeafCandidateNode.java rename to yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/AbstractAvailableLeafCandidateNode.java index 8bff7e0aac..71ee5b79d0 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractAvailableLeafCandidateNode.java +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/AbstractAvailableLeafCandidateNode.java @@ -5,18 +5,16 @@ * 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.yangtools.yang.data.impl.schema.tree; +package org.opendaylight.yangtools.yang.data.api.schema.tree; import java.util.Optional; -import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; abstract class AbstractAvailableLeafCandidateNode extends AbstractLeafCandidateNode { - protected AbstractAvailableLeafCandidateNode(final NormalizedNode dataAfter) { + AbstractAvailableLeafCandidateNode(final NormalizedNode dataAfter) { super(dataAfter); } - @Nonnull @Override public final Optional> getDataAfter() { return dataOptional(); diff --git a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/AbstractDataTreeCandidateNode.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/AbstractDataTreeCandidateNode.java new file mode 100644 index 0000000000..89b1d05ff4 --- /dev/null +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/AbstractDataTreeCandidateNode.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2015, 2016 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * 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.yangtools.yang.data.api.schema.tree; + +import static java.util.Objects.requireNonNull; + +import java.util.Optional; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer; + +abstract class AbstractDataTreeCandidateNode implements DataTreeCandidateNode { + private final NormalizedNodeContainer> data; + + AbstractDataTreeCandidateNode(final NormalizedNodeContainer> data) { + this.data = requireNonNull(data); + } + + @Override + public final PathArgument getIdentifier() { + return data.getIdentifier(); + } + + final @NonNull Optional> dataOptional() { + return Optional.of(data); + } + + final NormalizedNodeContainer> data() { + return data; + } + + @Override + public String toString() { + return this.getClass().getSimpleName() + "{data = " + this.data + "}"; + } +} diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractLeafCandidateNode.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/AbstractLeafCandidateNode.java similarity index 77% rename from yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractLeafCandidateNode.java rename to yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/AbstractLeafCandidateNode.java index b25b9c5d78..71b9ad0e7f 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractLeafCandidateNode.java +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/AbstractLeafCandidateNode.java @@ -5,43 +5,41 @@ * 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.yangtools.yang.data.impl.schema.tree; +package org.opendaylight.yangtools.yang.data.api.schema.tree; import static java.util.Objects.requireNonNull; import java.util.Collection; import java.util.Collections; import java.util.Optional; -import javax.annotation.Nonnull; +import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; -import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode; abstract class AbstractLeafCandidateNode implements DataTreeCandidateNode { private final NormalizedNode data; - protected AbstractLeafCandidateNode(final NormalizedNode data) { + AbstractLeafCandidateNode(final NormalizedNode data) { this.data = requireNonNull(data); } - protected final Optional> dataOptional() { + final @NonNull Optional> dataOptional() { return Optional.of(data); } - @Nonnull @Override public final Collection getChildNodes() { return Collections.emptyList(); } @Override - @Nonnull public final PathArgument getIdentifier() { return data.getIdentifier(); } @Override public final DataTreeCandidateNode getModifiedChild(final PathArgument identifier) { + requireNonNull(identifier); return null; } } \ No newline at end of file diff --git a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/AbstractRecursiveCandidateNode.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/AbstractRecursiveCandidateNode.java new file mode 100644 index 0000000000..2ae60776e6 --- /dev/null +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/AbstractRecursiveCandidateNode.java @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * 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.yangtools.yang.data.api.schema.tree; + +import com.google.common.collect.Collections2; +import java.util.Collection; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer; + +abstract class AbstractRecursiveCandidateNode extends AbstractDataTreeCandidateNode { + AbstractRecursiveCandidateNode(final NormalizedNodeContainer> data) { + super(data); + } + + @Override + public final DataTreeCandidateNode getModifiedChild(final PathArgument identifier) { + return data().getChild(identifier).map(this::createChild).orElse(null); + } + + @Override + public final Collection getChildNodes() { + return Collections2.transform(data().getValue(), this::createChild); + } + + abstract DataTreeCandidateNode createContainer( + NormalizedNodeContainer> childData); + + abstract DataTreeCandidateNode createLeaf(NormalizedNode childData); + + @SuppressWarnings("unchecked") + private DataTreeCandidateNode createChild(final NormalizedNode childData) { + if (childData instanceof NormalizedNodeContainer) { + return createContainer((NormalizedNodeContainer>) childData); + } + return createLeaf(childData); + } +} diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractWriteCandidate.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/AbstractWriteCandidate.java similarity index 69% rename from yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractWriteCandidate.java rename to yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/AbstractWriteCandidate.java index 59a4caabab..b85a4eb966 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractWriteCandidate.java +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/AbstractWriteCandidate.java @@ -5,19 +5,16 @@ * 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.yangtools.yang.data.impl.schema.tree; +package org.opendaylight.yangtools.yang.data.api.schema.tree; -import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; -import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType; abstract class AbstractWriteCandidate extends AbstractAvailableLeafCandidateNode { - protected AbstractWriteCandidate(final NormalizedNode dataAfter) { + AbstractWriteCandidate(final NormalizedNode dataAfter) { super(dataAfter); } @Override - @Nonnull public final ModificationType getModificationType() { return ModificationType.WRITE; } diff --git a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidateNodes.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidateNodes.java index 2b133a8765..b7cf43a06f 100644 --- a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidateNodes.java +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidateNodes.java @@ -10,13 +10,18 @@ package org.opendaylight.yangtools.yang.data.api.schema.tree; import static java.util.Objects.requireNonNull; import com.google.common.annotations.Beta; +import com.google.common.collect.Collections2; +import com.google.common.collect.ImmutableList; +import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; +import java.util.Optional; +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.jdt.annotation.Nullable; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer; @Beta public final class DataTreeCandidateNodes { @@ -26,17 +31,122 @@ public final class DataTreeCandidateNodes { /** * Return an empty {@link DataTreeCandidateNode} identified by specified {@link PathArgument}. + * * @param identifier Node identifier * @return An empty DataTreeCandidateNode */ - public static DataTreeCandidateNode empty(final PathArgument identifier) { + public static @NonNull DataTreeCandidateNode empty(final PathArgument identifier) { return new EmptyDataTreeCandidateNode(identifier); } - public static DataTreeCandidateNode fromNormalizedNode(final NormalizedNode node) { + @Deprecated + public static @NonNull DataTreeCandidateNode fromNormalizedNode(final NormalizedNode node) { + return written(node); + } + + /** + * Return an unmodified {@link DataTreeCandidateNode} identified by specified {@link NormalizedNode}. + * + * @param node Unchanged normalized node + * @return An empty DataTreeCandidateNode + */ + public static @NonNull DataTreeCandidateNode unmodified(final NormalizedNode node) { + if (node instanceof NormalizedNodeContainer) { + return new RecursiveUnmodifiedCandidateNode( + (NormalizedNodeContainer>) node); + } + return new UnmodifiedLeafCandidateNode(node); + } + + /** + * Return a {@link DataTreeCandidateNode} pretending specified node was written without the data exsting beforehand. + * + * @param node Unchanged normalized node + * @return An empty DataTreeCandidateNode + * @throws NullPointerException if {@code node} is null + */ + public static @NonNull DataTreeCandidateNode written(final NormalizedNode node) { return new NormalizedNodeDataTreeCandidateNode(node); } + /** + * Return a collection of {@link DataTreeCandidateNode}s summarizing the changes between the contents of two + * {@link NormalizedNodeContainer}s. + * + * @param oldData Old data container, may be null + * @param newData New data container, may be null + * @return Collection of changes + */ + public static @NonNull Collection containerDelta( + final @Nullable NormalizedNodeContainer> oldData, + final @Nullable NormalizedNodeContainer> newData) { + if (newData == null) { + return oldData == null ? ImmutableList.of() + : Collections2.transform(oldData.getValue(), DataTreeCandidateNodes::deleteNode); + } + if (oldData == null) { + return Collections2.transform(newData.getValue(), DataTreeCandidateNodes::writeNode); + } + + /* + * This is slightly inefficient, as it requires N*F(M)+M*F(N) lookup operations, where + * F is dependent on the implementation of NormalizedNodeContainer.getChild(). + * + * We build the return collection by iterating over new data and looking each child up + * in old data. Based on that we construct replaced/written nodes. We then proceed to + * iterate over old data and looking up each child in new data. + */ + final Collection result = new ArrayList<>(); + for (NormalizedNode child : newData.getValue()) { + final DataTreeCandidateNode node; + final Optional> maybeOldChild = oldData.getChild(child.getIdentifier()); + + if (maybeOldChild.isPresent()) { + // This does not find children which have not in fact been modified, as doing that + // reliably would require us running a full equals() on the two nodes. + node = replaceNode(maybeOldChild.get(), child); + } else { + node = writeNode(child); + } + + result.add(node); + } + + // Process removals next, looking into new data to see if we processed it + for (NormalizedNode child : oldData.getValue()) { + if (!newData.getChild(child.getIdentifier()).isPresent()) { + result.add(deleteNode(child)); + } + } + + return result; + } + + /** + * Return a collection of {@link DataTreeCandidateNode}s summarizing the change in a child, identified by a + * {@link PathArgument}, between two {@link NormalizedNodeContainer}s. + * + * @param oldData Old data container, may be null + * @param newData New data container, may be null + * @return A {@link DataTreeCandidateNode} describing the change, or null if the node is not present + */ + public static @Nullable DataTreeCandidateNode containerDelta( + final @Nullable NormalizedNodeContainer> oldData, + final @Nullable NormalizedNodeContainer> newData, + final @NonNull PathArgument child) { + final Optional> maybeNewChild = getChild(newData, child); + final Optional> maybeOldChild = getChild(oldData, child); + if (maybeOldChild.isPresent()) { + final NormalizedNode oldChild = maybeOldChild.get(); + if (maybeNewChild.isPresent()) { + return replaceNode(oldChild, maybeNewChild.get()); + } + return deleteNode(oldChild); + } + + return maybeNewChild.isPresent() ? writeNode(maybeNewChild.get()) : null; + } + /** * Applies the {@code node} to the {@code cursor}, note that if the top node of (@code node} is RootNode * you need to use {@link #applyRootedNodeToCursor(DataTreeModificationCursor, YangInstanceIdentifier, @@ -119,6 +229,42 @@ public final class DataTreeCandidateNodes { } } + private static Optional> getChild( + final NormalizedNodeContainer> container, + final PathArgument identifier) { + return container == null ? Optional.empty() : container.getChild(identifier); + } + + @SuppressWarnings("unchecked") + private static @NonNull DataTreeCandidateNode deleteNode(final NormalizedNode data) { + if (data instanceof NormalizedNodeContainer) { + return new RecursiveDeleteCandidateNode( + (NormalizedNodeContainer>) data); + } + return new DeleteLeafCandidateNode(data); + } + + + @SuppressWarnings("unchecked") + private static @NonNull DataTreeCandidateNode replaceNode(final NormalizedNode oldData, + final NormalizedNode newData) { + if (oldData instanceof NormalizedNodeContainer) { + return new RecursiveReplaceCandidateNode( + (NormalizedNodeContainer>) oldData, + (NormalizedNodeContainer>) newData); + } + return new ReplaceLeafCandidateNode(oldData, newData); + } + + @SuppressWarnings("unchecked") + private static @NonNull DataTreeCandidateNode writeNode(final NormalizedNode data) { + if (data instanceof NormalizedNodeContainer) { + return new RecursiveWriteCandidateNode( + (NormalizedNodeContainer>) data); + } + return new WriteLeafCandidateNode(data); + } + private abstract static class AbstractNodeIterator { private final Iterator iterator; @@ -156,14 +302,14 @@ public final class DataTreeCandidateNodes { return getParent(); } - protected abstract @Nullable AbstractNodeIterator getParent(); + abstract @Nullable AbstractNodeIterator getParent(); - protected abstract void exitNode(DataTreeModificationCursor cursor); + abstract void exitNode(DataTreeModificationCursor cursor); } private static final class RootNonExitingIterator extends AbstractNodeIterator { - protected RootNonExitingIterator(@Nonnull final Iterator iterator) { + RootNonExitingIterator(final Iterator iterator) { super(iterator); } @@ -182,19 +328,18 @@ public final class DataTreeCandidateNodes { private final AbstractNodeIterator parent; - ExitingNodeIterator(@Nullable final AbstractNodeIterator parent, - @Nonnull final Iterator iterator) { + ExitingNodeIterator(final AbstractNodeIterator parent, final Iterator iterator) { super(iterator); this.parent = parent; } @Override - protected AbstractNodeIterator getParent() { + AbstractNodeIterator getParent() { return parent; } @Override - protected void exitNode(final DataTreeModificationCursor cursor) { + void exitNode(final DataTreeModificationCursor cursor) { cursor.exit(); } } diff --git a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidates.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidates.java index b933ce1e3e..51521f1fac 100644 --- a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidates.java +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidates.java @@ -11,8 +11,8 @@ import static java.util.Objects.requireNonNull; import com.google.common.annotations.Beta; import java.util.Iterator; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.jdt.annotation.Nullable; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.slf4j.Logger; @@ -29,12 +29,12 @@ public final class DataTreeCandidates { throw new UnsupportedOperationException(); } - public static DataTreeCandidate newDataTreeCandidate(final YangInstanceIdentifier rootPath, + public static @NonNull DataTreeCandidate newDataTreeCandidate(final YangInstanceIdentifier rootPath, final DataTreeCandidateNode rootNode) { return new DefaultDataTreeCandidate(rootPath, rootNode); } - public static DataTreeCandidate fromNormalizedNode(final YangInstanceIdentifier rootPath, + public static @NonNull DataTreeCandidate fromNormalizedNode(final YangInstanceIdentifier rootPath, final NormalizedNode node) { return new DefaultDataTreeCandidate(rootPath, new NormalizedNodeDataTreeCandidateNode(node)); } @@ -97,8 +97,8 @@ public final class DataTreeCandidates { private final YangInstanceIdentifier path; private final NodeIterator parent; - NodeIterator(@Nullable final NodeIterator parent, @Nonnull final YangInstanceIdentifier path, - @Nonnull final Iterator iterator) { + NodeIterator(final @Nullable NodeIterator parent, final YangInstanceIdentifier path, + final Iterator iterator) { this.iterator = requireNonNull(iterator); this.path = requireNonNull(path); this.parent = parent; diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/DeleteLeafCandidateNode.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DeleteLeafCandidateNode.java similarity index 81% rename from yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/DeleteLeafCandidateNode.java rename to yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DeleteLeafCandidateNode.java index 72036fbbdb..73179c09ff 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/DeleteLeafCandidateNode.java +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DeleteLeafCandidateNode.java @@ -5,12 +5,10 @@ * 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.yangtools.yang.data.impl.schema.tree; +package org.opendaylight.yangtools.yang.data.api.schema.tree; import java.util.Optional; -import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; -import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType; final class DeleteLeafCandidateNode extends AbstractLeafCandidateNode { DeleteLeafCandidateNode(final NormalizedNode data) { @@ -18,19 +16,16 @@ final class DeleteLeafCandidateNode extends AbstractLeafCandidateNode { } @Override - @Nonnull public ModificationType getModificationType() { return ModificationType.DELETE; } @Override - @Nonnull public Optional> getDataAfter() { return Optional.empty(); } @Override - @Nonnull public Optional> getDataBefore() { return dataOptional(); } diff --git a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/NormalizedNodeDataTreeCandidateNode.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/NormalizedNodeDataTreeCandidateNode.java index 68bcdc2dea..359acfed73 100644 --- a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/NormalizedNodeDataTreeCandidateNode.java +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/NormalizedNodeDataTreeCandidateNode.java @@ -13,7 +13,7 @@ import com.google.common.collect.Collections2; import com.google.common.collect.ImmutableList; import java.util.Collection; import java.util.Optional; -import javax.annotation.Nonnull; +import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer; @@ -30,17 +30,15 @@ final class NormalizedNodeDataTreeCandidateNode implements DataTreeCandidateNode * * @param data Backing {@link NormalizedNode} data. */ - NormalizedNodeDataTreeCandidateNode(@Nonnull final NormalizedNode data) { + NormalizedNodeDataTreeCandidateNode(final @NonNull NormalizedNode data) { this.data = requireNonNull(data); } - @Nonnull @Override public PathArgument getIdentifier() { return data.getIdentifier(); } - @Nonnull @Override public Collection getChildNodes() { if (data instanceof NormalizedNodeContainer) { @@ -61,19 +59,16 @@ final class NormalizedNodeDataTreeCandidateNode implements DataTreeCandidateNode return null; } - @Nonnull @Override public ModificationType getModificationType() { return ModificationType.WRITE; } - @Nonnull @Override public Optional> getDataAfter() { return Optional.of(data); } - @Nonnull @Override public Optional> getDataBefore() { return Optional.empty(); diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/RecursiveDeleteCandidateNode.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/RecursiveDeleteCandidateNode.java similarity index 83% rename from yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/RecursiveDeleteCandidateNode.java rename to yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/RecursiveDeleteCandidateNode.java index f4a068f96b..a36ef915cb 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/RecursiveDeleteCandidateNode.java +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/RecursiveDeleteCandidateNode.java @@ -5,15 +5,12 @@ * 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.yangtools.yang.data.impl.schema.tree; +package org.opendaylight.yangtools.yang.data.api.schema.tree; import java.util.Optional; -import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer; -import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode; -import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType; final class RecursiveDeleteCandidateNode extends AbstractRecursiveCandidateNode { RecursiveDeleteCandidateNode(final NormalizedNodeContainer> data) { @@ -21,29 +18,26 @@ final class RecursiveDeleteCandidateNode extends AbstractRecursiveCandidateNode } @Override - @Nonnull public ModificationType getModificationType() { return ModificationType.DELETE; } @Override - DataTreeCandidateNode createContainer( - final NormalizedNodeContainer> childData) { - return new RecursiveDeleteCandidateNode(childData); - } - - @Override - @Nonnull public Optional> getDataAfter() { return Optional.empty(); } - @Nonnull @Override public Optional> getDataBefore() { return dataOptional(); } + @Override + DataTreeCandidateNode createContainer( + final NormalizedNodeContainer> childData) { + return new RecursiveDeleteCandidateNode(childData); + } + @Override DataTreeCandidateNode createLeaf(final NormalizedNode childData) { return new DeleteLeafCandidateNode(childData); diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/RecursiveReplaceCandidateNode.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/RecursiveReplaceCandidateNode.java similarity index 77% rename from yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/RecursiveReplaceCandidateNode.java rename to yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/RecursiveReplaceCandidateNode.java index fb39da0789..74f76d994c 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/RecursiveReplaceCandidateNode.java +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/RecursiveReplaceCandidateNode.java @@ -5,19 +5,15 @@ * 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.yangtools.yang.data.impl.schema.tree; +package org.opendaylight.yangtools.yang.data.api.schema.tree; import static java.util.Objects.requireNonNull; import java.util.Collection; import java.util.Optional; -import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer; -import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode; -import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType; final class RecursiveReplaceCandidateNode extends AbstractDataTreeCandidateNode { private final NormalizedNodeContainer> oldData; @@ -29,18 +25,15 @@ final class RecursiveReplaceCandidateNode extends AbstractDataTreeCandidateNode } @Override - @Nonnull public ModificationType getModificationType() { return ModificationType.WRITE; } - @Nonnull @Override public Optional> getDataAfter() { - return super.dataOptional(); + return dataOptional(); } - @Nonnull @Override public Optional> getDataBefore() { return Optional.of(oldData); @@ -48,12 +41,11 @@ final class RecursiveReplaceCandidateNode extends AbstractDataTreeCandidateNode @Override public DataTreeCandidateNode getModifiedChild(final PathArgument identifier) { - return deltaChild(oldData, getData(), identifier); + return DataTreeCandidateNodes.containerDelta(oldData, data(), identifier); } @Override - @Nonnull public Collection getChildNodes() { - return deltaChildren(oldData, getData()); + return DataTreeCandidateNodes.containerDelta(oldData, data()); } } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/RecursiveUnmodifiedCandidateNode.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/RecursiveUnmodifiedCandidateNode.java similarity index 76% rename from yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/RecursiveUnmodifiedCandidateNode.java rename to yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/RecursiveUnmodifiedCandidateNode.java index a51b708bd6..d3f5bfe53c 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/RecursiveUnmodifiedCandidateNode.java +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/RecursiveUnmodifiedCandidateNode.java @@ -5,35 +5,28 @@ * 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.yangtools.yang.data.impl.schema.tree; +package org.opendaylight.yangtools.yang.data.api.schema.tree; import java.util.Optional; -import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer; -import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode; -import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType; final class RecursiveUnmodifiedCandidateNode extends AbstractRecursiveCandidateNode { - protected RecursiveUnmodifiedCandidateNode( - final NormalizedNodeContainer> data) { + RecursiveUnmodifiedCandidateNode(final NormalizedNodeContainer> data) { super(data); } @Override - @Nonnull public ModificationType getModificationType() { return ModificationType.UNMODIFIED; } - @Nonnull @Override public Optional> getDataAfter() { return dataOptional(); } - @Nonnull @Override public Optional> getDataBefore() { return dataOptional(); diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/RecursiveWriteCandidateNode.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/RecursiveWriteCandidateNode.java similarity index 83% rename from yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/RecursiveWriteCandidateNode.java rename to yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/RecursiveWriteCandidateNode.java index 87e903e31d..0cd155c08d 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/RecursiveWriteCandidateNode.java +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/RecursiveWriteCandidateNode.java @@ -5,48 +5,41 @@ * 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.yangtools.yang.data.impl.schema.tree; +package org.opendaylight.yangtools.yang.data.api.schema.tree; import java.util.Optional; -import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer; -import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode; -import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType; final class RecursiveWriteCandidateNode extends AbstractRecursiveCandidateNode { - RecursiveWriteCandidateNode(final NormalizedNodeContainer> data) { super(data); } @Override - @Nonnull public ModificationType getModificationType() { return ModificationType.WRITE; } @Override - DataTreeCandidateNode createContainer( - final NormalizedNodeContainer> childData) { - return new RecursiveWriteCandidateNode(childData); + public Optional> getDataAfter() { + return dataOptional(); } @Override - DataTreeCandidateNode createLeaf(final NormalizedNode childData) { - return new WriteLeafCandidateNode(childData); + public Optional> getDataBefore() { + return Optional.empty(); } - @Nonnull @Override - public Optional> getDataAfter() { - return dataOptional(); + DataTreeCandidateNode createContainer( + final NormalizedNodeContainer> childData) { + return new RecursiveWriteCandidateNode(childData); } @Override - @Nonnull - public Optional> getDataBefore() { - return Optional.empty(); + DataTreeCandidateNode createLeaf(final NormalizedNode childData) { + return new WriteLeafCandidateNode(childData); } } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ReplaceLeafCandidateNode.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/ReplaceLeafCandidateNode.java similarity index 88% rename from yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ReplaceLeafCandidateNode.java rename to yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/ReplaceLeafCandidateNode.java index 3abef50893..6804264e75 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ReplaceLeafCandidateNode.java +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/ReplaceLeafCandidateNode.java @@ -5,12 +5,11 @@ * 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.yangtools.yang.data.impl.schema.tree; +package org.opendaylight.yangtools.yang.data.api.schema.tree; import static java.util.Objects.requireNonNull; import java.util.Optional; -import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; final class ReplaceLeafCandidateNode extends AbstractWriteCandidate { @@ -21,7 +20,6 @@ final class ReplaceLeafCandidateNode extends AbstractWriteCandidate { this.oldData = requireNonNull(oldData); } - @Nonnull @Override public Optional> getDataBefore() { return Optional.of(oldData); diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/UnmodifiedLeafCandidateNode.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/UnmodifiedLeafCandidateNode.java similarity index 80% rename from yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/UnmodifiedLeafCandidateNode.java rename to yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/UnmodifiedLeafCandidateNode.java index 838bbd9c8d..40ed176c6c 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/UnmodifiedLeafCandidateNode.java +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/UnmodifiedLeafCandidateNode.java @@ -5,12 +5,10 @@ * 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.yangtools.yang.data.impl.schema.tree; +package org.opendaylight.yangtools.yang.data.api.schema.tree; import java.util.Optional; -import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; -import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType; final class UnmodifiedLeafCandidateNode extends AbstractAvailableLeafCandidateNode { UnmodifiedLeafCandidateNode(final NormalizedNode data) { @@ -18,12 +16,10 @@ final class UnmodifiedLeafCandidateNode extends AbstractAvailableLeafCandidateNo } @Override - @Nonnull public ModificationType getModificationType() { return ModificationType.UNMODIFIED; } - @Nonnull @Override public Optional> getDataBefore() { return dataOptional(); diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/WriteLeafCandidateNode.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/WriteLeafCandidateNode.java similarity index 86% rename from yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/WriteLeafCandidateNode.java rename to yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/WriteLeafCandidateNode.java index 5ecb02f260..7f5e020d4d 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/WriteLeafCandidateNode.java +++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/tree/WriteLeafCandidateNode.java @@ -5,10 +5,9 @@ * 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.yangtools.yang.data.impl.schema.tree; +package org.opendaylight.yangtools.yang.data.api.schema.tree; import java.util.Optional; -import javax.annotation.Nonnull; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; final class WriteLeafCandidateNode extends AbstractWriteCandidate { @@ -17,7 +16,6 @@ final class WriteLeafCandidateNode extends AbstractWriteCandidate { } @Override - @Nonnull public Optional> getDataBefore() { return Optional.empty(); } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractDataTreeCandidateNode.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractDataTreeCandidateNode.java deleted file mode 100644 index fd8387d662..0000000000 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractDataTreeCandidateNode.java +++ /dev/null @@ -1,119 +0,0 @@ -/* - * Copyright (c) 2015, 2016 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * 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.yangtools.yang.data.impl.schema.tree; - -import static com.google.common.base.Preconditions.checkArgument; -import static java.util.Objects.requireNonNull; - -import com.google.common.collect.Collections2; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Optional; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; -import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; -import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer; -import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode; - -abstract class AbstractDataTreeCandidateNode implements DataTreeCandidateNode { - private static Optional> getChild( - final NormalizedNodeContainer> container, - final PathArgument identifier) { - return container == null ? Optional.empty() : container.getChild(identifier); - } - - static DataTreeCandidateNode deltaChild( - final NormalizedNodeContainer> oldData, - final NormalizedNodeContainer> newData, - final PathArgument identifier) { - - final Optional> maybeNewChild = getChild(newData, identifier); - final Optional> maybeOldChild = getChild(oldData, identifier); - if (maybeOldChild.isPresent()) { - final NormalizedNode oldChild = maybeOldChild.get(); - if (maybeNewChild.isPresent()) { - return AbstractRecursiveCandidateNode.replaceNode(oldChild, maybeNewChild.get()); - } - return AbstractRecursiveCandidateNode.deleteNode(oldChild); - } - - return maybeNewChild.isPresent() ? AbstractRecursiveCandidateNode.writeNode(maybeNewChild.get()) : null; - } - - static Collection deltaChildren( - @Nullable final NormalizedNodeContainer> oldData, - @Nullable final NormalizedNodeContainer> newData) { - checkArgument(newData != null || oldData != null, - "No old or new data, modification type should be NONE and deltaChildren() mustn't be called."); - if (newData == null) { - return Collections2.transform(oldData.getValue(), AbstractRecursiveCandidateNode::deleteNode); - } - if (oldData == null) { - return Collections2.transform(newData.getValue(), AbstractRecursiveCandidateNode::writeNode); - } - - /* - * This is slightly inefficient, as it requires N*F(M)+M*F(N) lookup operations, where - * F is dependent on the implementation of NormalizedNodeContainer.getChild(). - * - * We build the return collection by iterating over new data and looking each child up - * in old data. Based on that we construct replaced/written nodes. We then proceed to - * iterate over old data and looking up each child in new data. - */ - final Collection result = new ArrayList<>(); - for (NormalizedNode child : newData.getValue()) { - final DataTreeCandidateNode node; - final Optional> maybeOldChild = oldData.getChild(child.getIdentifier()); - - if (maybeOldChild.isPresent()) { - // This does not find children which have not in fact been modified, as doing that - // reliably would require us running a full equals() on the two nodes. - node = AbstractRecursiveCandidateNode.replaceNode(maybeOldChild.get(), child); - } else { - node = AbstractRecursiveCandidateNode.writeNode(child); - } - - result.add(node); - } - - // Process removals next, looking into new data to see if we processed it - for (NormalizedNode child : oldData.getValue()) { - if (!newData.getChild(child.getIdentifier()).isPresent()) { - result.add(AbstractRecursiveCandidateNode.deleteNode(child)); - } - } - - return result; - } - - private final NormalizedNodeContainer> data; - - protected AbstractDataTreeCandidateNode(final NormalizedNodeContainer> data) { - this.data = requireNonNull(data); - } - - protected final Optional> dataOptional() { - return Optional.of(data); - } - - @Override - @Nonnull - public final PathArgument getIdentifier() { - return data.getIdentifier(); - } - - protected final NormalizedNodeContainer> getData() { - return data; - } - - @Override - public String toString() { - return this.getClass().getSimpleName() + "{data = " + this.data + "}"; - } -} diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractModifiedNodeBasedCandidateNode.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractModifiedNodeBasedCandidateNode.java index 7b2e106dea..71f491e8cf 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractModifiedNodeBasedCandidateNode.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractModifiedNodeBasedCandidateNode.java @@ -14,12 +14,12 @@ import com.google.common.collect.Collections2; import com.google.common.collect.ImmutableList; import java.util.Collection; import java.util.Optional; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; +import org.eclipse.jdt.annotation.Nullable; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer; import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode; +import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNodes; import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType; import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode; @@ -51,7 +51,7 @@ abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandida return parent == null ? null : parent.getChild(id).orElse(null); } - private static boolean canHaveChildren(@Nullable final TreeNode oldMeta, @Nullable final TreeNode newMeta) { + private static boolean canHaveChildren(final @Nullable TreeNode oldMeta, final @Nullable TreeNode newMeta) { if (oldMeta != null) { return oldMeta.getData() instanceof NormalizedNodeContainer; } @@ -63,7 +63,7 @@ abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandida @SuppressWarnings("unchecked") private static NormalizedNodeContainer> getContainer( - @Nullable final TreeNode meta) { + final @Nullable TreeNode meta) { return meta == null ? null : (NormalizedNodeContainer>)meta.getData(); } @@ -73,7 +73,6 @@ abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandida } @Override - @Nonnull public Collection getChildNodes() { switch (mod.getModificationType()) { case APPEARED: @@ -88,7 +87,7 @@ abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandida } return Collections2.transform(getContainer(newMeta != null ? newMeta : oldMeta).getValue(), - AbstractRecursiveCandidateNode::unmodifiedNode); + DataTreeCandidateNodes::unmodified); case DELETE: case WRITE: // This is unusual, the user is requesting we follow into an otherwise-terminal node. @@ -96,14 +95,13 @@ abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandida if (!canHaveChildren(oldMeta, newMeta)) { return ImmutableList.of(); } - return AbstractDataTreeCandidateNode.deltaChildren(getContainer(oldMeta), getContainer(newMeta)); + return DataTreeCandidateNodes.containerDelta(getContainer(oldMeta), getContainer(newMeta)); default: throw new IllegalArgumentException("Unhandled modification type " + mod.getModificationType()); } } @Override - @Nonnull public ModificationType getModificationType() { return verifyNotNull(mod.getModificationType(), "Node %s does not have resolved modification type", mod); } @@ -113,13 +111,11 @@ abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandida } @Override - @Nonnull public final Optional> getDataAfter() { return optionalData(newMeta); } @Override - @Nonnull public final Optional> getDataBefore() { return optionalData(oldMeta); } @@ -141,14 +137,13 @@ abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandida } final Optional> maybeChild = getContainer(newMeta != null ? newMeta : oldMeta) .getChild(identifier); - return maybeChild.isPresent() ? AbstractRecursiveCandidateNode.unmodifiedNode(maybeChild.get()) : null; + return maybeChild.isPresent() ? DataTreeCandidateNodes.unmodified(maybeChild.get()) : null; case DELETE: case WRITE: if (!canHaveChildren(oldMeta, newMeta)) { return null; } - return AbstractDataTreeCandidateNode.deltaChild(getContainer(oldMeta), getContainer(newMeta), - identifier); + return DataTreeCandidateNodes.containerDelta(getContainer(oldMeta), getContainer(newMeta), identifier); default: throw new IllegalArgumentException("Unhandled modification type " + mod.getModificationType()); } @@ -160,7 +155,6 @@ abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandida } @Override - @Nonnull public PathArgument getIdentifier() { return getMod().getIdentifier(); } diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractRecursiveCandidateNode.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractRecursiveCandidateNode.java deleted file mode 100644 index b37fcfacf4..0000000000 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractRecursiveCandidateNode.java +++ /dev/null @@ -1,94 +0,0 @@ -/* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * 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.yangtools.yang.data.impl.schema.tree; - -import com.google.common.collect.Collections2; -import java.util.Collection; -import java.util.Optional; -import javax.annotation.Nonnull; -import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; -import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; -import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer; -import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode; - -abstract class AbstractRecursiveCandidateNode extends AbstractDataTreeCandidateNode { - - protected AbstractRecursiveCandidateNode( - final NormalizedNodeContainer> data) { - super(data); - } - - @SuppressWarnings("unchecked") - static DataTreeCandidateNode deleteNode(final NormalizedNode data) { - if (data instanceof NormalizedNodeContainer) { - return new RecursiveDeleteCandidateNode( - (NormalizedNodeContainer>) data); - } - return new DeleteLeafCandidateNode(data); - } - - @SuppressWarnings("unchecked") - static DataTreeCandidateNode replaceNode(final NormalizedNode oldData, final NormalizedNode newData) { - if (isContainer(oldData)) { - return new RecursiveReplaceCandidateNode( - (NormalizedNodeContainer>) oldData, - (NormalizedNodeContainer>) newData); - } - return new ReplaceLeafCandidateNode(oldData, newData); - } - - @SuppressWarnings("unchecked") - static DataTreeCandidateNode unmodifiedNode(final NormalizedNode data) { - if (data instanceof NormalizedNodeContainer) { - return new RecursiveUnmodifiedCandidateNode( - (NormalizedNodeContainer>) data); - } - return new UnmodifiedLeafCandidateNode(data); - } - - @SuppressWarnings("unchecked") - static DataTreeCandidateNode writeNode(final NormalizedNode data) { - if (data instanceof NormalizedNodeContainer) { - return new RecursiveWriteCandidateNode( - (NormalizedNodeContainer>) data); - } - return new WriteLeafCandidateNode(data); - } - - protected static boolean isContainer(final NormalizedNode data) { - return data instanceof NormalizedNodeContainer; - } - - @Override - public final DataTreeCandidateNode getModifiedChild(final PathArgument identifier) { - final Optional> potential = getData().getChild(identifier); - if (potential.isPresent()) { - return createChild(potential.get()); - } - return null; - } - - @Nonnull - @Override - public final Collection getChildNodes() { - return Collections2.transform(getData().getValue(), this::createChild); - } - - @SuppressWarnings("unchecked") - private DataTreeCandidateNode createChild(final NormalizedNode childData) { - if (isContainer(childData)) { - return createContainer((NormalizedNodeContainer>) childData); - } - return createLeaf(childData); - } - - abstract DataTreeCandidateNode createContainer( - NormalizedNodeContainer> childData); - - abstract DataTreeCandidateNode createLeaf(NormalizedNode childData); -} \ No newline at end of file -- 2.36.6