Rework NormalizedNode type hierarchy

[yangtools.git] / yang / yang-data-impl / src / main / java / org / opendaylight / yangtools / yang / data / impl / schema / tree / ModifiedNode.java

diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ModifiedNode.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ModifiedNode.java
index 9c4f29abdedd340afa939835696d613ba7b37e51..735418ee59d617dadd21adbe2ad35574a9a25567 100644 (file)
--- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ModifiedNode.java
+++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ModifiedNode.java
@@ -12,14 +12,16 @@ import static java.util.Objects.requireNonNull;
 
 import com.google.common.base.MoreObjects;
 import com.google.common.base.MoreObjects.ToStringHelper;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Optional;
 import java.util.function.Predicate;
 import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer;
 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.ModificationType;
 import org.opendaylight.yangtools.yang.data.api.schema.tree.StoreTreeNode;
 import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
@@ -61,7 +63,7 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode<Modif
     private final PathArgument identifier;
     private LogicalOperation operation = LogicalOperation.NONE;
     private Optional<TreeNode> snapshotCache;
-    private NormalizedNode<?, ?> value;
+    private NormalizedNode value;
     private ModificationType modType;
 
     // Alternative history introduced in WRITE nodes. Instantiated when we touch any child underneath such a node.
@@ -102,7 +104,7 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode<Modif
      *
      * @return Currently-written value
      */
-    @NonNull NormalizedNode<?, ?> getWrittenValue() {
+    @NonNull NormalizedNode getWrittenValue() {
         return verifyNotNull(value);
     }
 
@@ -112,12 +114,12 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode<Modif
      * @return Child modification if direct child or it's subtree was modified.
      */
     @Override
-    public Optional<ModifiedNode> getChild(final PathArgument child) {
-        return Optional.ofNullable(children.get(child));
+    public ModifiedNode childByArg(final PathArgument arg) {
+        return children.get(arg);
     }
 
     private Optional<? extends TreeNode> metadataFromSnapshot(final @NonNull PathArgument child) {
-        return original.isPresent() ? original.get().getChild(child) : Optional.empty();
+        return original.isPresent() ? original.get().findChildByArg(child) : Optional.empty();
     }
 
     private Optional<? extends TreeNode> metadataFromData(final @NonNull PathArgument child, final Version modVersion) {
@@ -128,7 +130,7 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode<Modif
             writtenOriginal = TreeNodeFactory.createTreeNode(value, modVersion);
         }
 
-        return writtenOriginal.getChild(child);
+        return writtenOriginal.findChildByArg(child);
     }
 
     /**
@@ -188,9 +190,9 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode<Modif
              * value contains this component, we need to materialize it as a MERGE modification.
              */
             @SuppressWarnings({ "rawtypes", "unchecked" })
-            final Optional<NormalizedNode<?, ?>> childData = ((NormalizedNodeContainer)value).getChild(child);
-            if (childData.isPresent()) {
-                childOper.mergeIntoModifiedNode(newlyCreated, childData.get(), modVersion);
+            final NormalizedNode childData = ((DistinctNodeContainer)value).childByArg(child);
+            if (childData != null) {
+                childOper.mergeIntoModifiedNode(newlyCreated, childData, modVersion);
             }
         }
 
@@ -251,7 +253,7 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode<Modif
      *
      * @param newValue new value
      */
-    void write(final NormalizedNode<?, ?> newValue) {
+    void write(final NormalizedNode newValue) {
         updateValue(LogicalOperation.WRITE, newValue);
         children.clear();
     }
@@ -334,7 +336,7 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode<Modif
      * @param type New operation type
      * @param newValue New node value
      */
-    void updateValue(final LogicalOperation type, final NormalizedNode<?, ?> newValue) {
+    void updateValue(final LogicalOperation type, final NormalizedNode newValue) {
         this.value = requireNonNull(newValue);
         updateOperationType(type);
     }
@@ -362,7 +364,18 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode<Modif
         this.validatedNode = requireNonNull(node);
     }
 
-    Optional<? extends TreeNode> getValidatedNode(final ModificationApplyOperation op,
+    /**
+     * Acquire pre-validated node assuming a previous operation and node. This is a counterpart to
+     * {@link #setValidatedNode(ModificationApplyOperation, Optional, Optional)}.
+     *
+     * @param op Currently-executing operation
+     * @param current Currently-used tree node
+     * @return {@code null} if there is a mismatch with previously-validated node (if present) or the result of previous
+     *         validation.
+     */
+    @SuppressFBWarnings(value = "NP_OPTIONAL_RETURN_NULL",
+            justification = "The contract is package-internal and well documented, we do not need a separate wrapper")
+    @Nullable Optional<? extends TreeNode> getValidatedNode(final ModificationApplyOperation op,
             final Optional<? extends TreeNode> current) {
         return op.equals(validatedOp) && current.equals(validatedCurrent) ? validatedNode : null;
     }