Rework NormalizedNode type hierarchy

[yangtools.git] / yang / yang-data-api / src / main / java / org / opendaylight / yangtools / yang / data / api / schema / NormalizedNodes.java

diff --git a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/NormalizedNodes.java b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/NormalizedNodes.java
index 08661bf0d019ae3c5a7288e584fdddcaec0719b8..4b3861007bd2751b8d9859876d0466dcd4f16ee7 100644 (file)
--- a/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/NormalizedNodes.java
+++ b/yang/yang-data-api/src/main/java/org/opendaylight/yangtools/yang/data/api/schema/NormalizedNodes.java
@@ -46,43 +46,43 @@ public final class NormalizedNodes {
      * @param node A normalized node subtree, may not be null
      * @return A Map of NormalizedNode/DuplicateEntry relationships.
      */
-    public static Map<NormalizedNode<?, ?>, DuplicateEntry> findDuplicates(final @NonNull NormalizedNode<?, ?> node) {
+    public static Map<NormalizedNode, DuplicateEntry> findDuplicates(final @NonNull NormalizedNode node) {
         return Maps.filterValues(DuplicateFinder.findDuplicates(node), input -> !input.getDuplicates().isEmpty());
     }
 
-    public static Optional<NormalizedNode<?, ?>> findNode(final YangInstanceIdentifier rootPath,
-            final NormalizedNode<?, ?> rootNode, final YangInstanceIdentifier childPath) {
+    public static Optional<NormalizedNode> findNode(final YangInstanceIdentifier rootPath,
+            final NormalizedNode rootNode, final YangInstanceIdentifier childPath) {
         final Optional<YangInstanceIdentifier> relativePath = childPath.relativeTo(rootPath);
         return relativePath.isPresent() ? findNode(rootNode, relativePath.get()) : Optional.empty();
     }
 
-    public static Optional<NormalizedNode<?, ?>> findNode(final Optional<NormalizedNode<?, ?>> parent,
+    public static Optional<NormalizedNode> findNode(final Optional<NormalizedNode> parent,
             final Iterable<PathArgument> relativePath) {
         final Iterator<PathArgument> pathIterator = requireNonNull(relativePath, "Relative path must not be null")
                 .iterator();
-        Optional<NormalizedNode<?, ?>> currentNode = requireNonNull(parent, "Parent must not be null");
+        Optional<NormalizedNode> currentNode = requireNonNull(parent, "Parent must not be null");
         while (currentNode.isPresent() && pathIterator.hasNext()) {
             currentNode = getDirectChild(currentNode.get(), pathIterator.next());
         }
         return currentNode;
     }
 
-    public static Optional<NormalizedNode<?, ?>> findNode(final Optional<NormalizedNode<?, ?>> parent,
+    public static Optional<NormalizedNode> findNode(final Optional<NormalizedNode> parent,
             final PathArgument pathArg) {
         return parent.flatMap(node -> getDirectChild(node, pathArg));
     }
 
-    public static Optional<NormalizedNode<?, ?>> findNode(final Optional<NormalizedNode<?, ?>> parent,
+    public static Optional<NormalizedNode> findNode(final Optional<NormalizedNode> parent,
             final PathArgument... relativePath) {
         return findNode(parent, Arrays.asList(relativePath));
     }
 
-    public static Optional<NormalizedNode<?, ?>> findNode(final @Nullable NormalizedNode<?, ?> parent,
+    public static Optional<NormalizedNode> findNode(final @Nullable NormalizedNode parent,
             final PathArgument pathArg) {
         return parent == null ? Optional.empty() : getDirectChild(parent, pathArg);
     }
 
-    public static Optional<NormalizedNode<?, ?>> findNode(final NormalizedNode<?, ?> parent,
+    public static Optional<NormalizedNode> findNode(final NormalizedNode parent,
             final Iterable<PathArgument> relativePath) {
         return findNode(Optional.ofNullable(parent), relativePath);
     }
@@ -93,38 +93,38 @@ public final class NormalizedNodes {
      * @deprecated Use {@link #findNode(NormalizedNode, Descendant)} instead.
      */
     @Deprecated(forRemoval = true)
-    public static Optional<NormalizedNode<?, ?>> findNode(final NormalizedNode<?, ?> parent,
+    public static Optional<NormalizedNode> findNode(final NormalizedNode parent,
             final SchemaPath relativePath) {
         checkArgument(!relativePath.isAbsolute(), "%s is not a relative path", relativePath);
         return findNode(Optional.ofNullable(parent), Iterables.transform(relativePath.getPathFromRoot(),
             NodeIdentifier::new));
     }
 
-    public static Optional<NormalizedNode<?, ?>> findNode(final NormalizedNode<?, ?> parent, final Descendant path) {
+    public static Optional<NormalizedNode> findNode(final NormalizedNode parent, final Descendant path) {
         return findNode(Optional.ofNullable(parent),
             Iterables.transform(path.getNodeIdentifiers(), NodeIdentifier::new));
     }
 
-    public static Optional<NormalizedNode<?, ?>> findNode(final NormalizedNode<?, ?> parent,
+    public static Optional<NormalizedNode> findNode(final NormalizedNode parent,
             final PathArgument... relativePath) {
         return findNode(parent, Arrays.asList(relativePath));
     }
 
-    public static Optional<NormalizedNode<?, ?>> findNode(final NormalizedNode<?, ?> tree,
+    public static Optional<NormalizedNode> findNode(final NormalizedNode tree,
             final YangInstanceIdentifier path) {
         return findNode(Optional.of(requireNonNull(tree, "Tree must not be null")),
             requireNonNull(path, "Path must not be null").getPathArguments());
     }
 
     @SuppressWarnings({ "unchecked", "rawtypes" })
-    public static Optional<NormalizedNode<?, ?>> getDirectChild(final NormalizedNode<?, ?> node,
+    public static Optional<NormalizedNode> getDirectChild(final NormalizedNode node,
             final PathArgument pathArg) {
         if (node instanceof DataContainerNode) {
-            return (Optional) ((DataContainerNode<?>) node).getChild(pathArg);
+            return (Optional) ((DataContainerNode<?>) node).findChildByArg(pathArg);
         } else if (node instanceof MapNode && pathArg instanceof NodeIdentifierWithPredicates) {
-            return (Optional) ((MapNode) node).getChild((NodeIdentifierWithPredicates) pathArg);
+            return (Optional) ((MapNode) node).findChildByArg((NodeIdentifierWithPredicates) pathArg);
         } else if (node instanceof LeafSetNode && pathArg instanceof NodeWithValue) {
-            return (Optional) ((LeafSetNode<?>) node).getChild((NodeWithValue) pathArg);
+            return (Optional) ((LeafSetNode<?>) node).findChildByArg((NodeWithValue<?>) pathArg);
         }
         // Anything else, including ValueNode
         return Optional.empty();
@@ -136,27 +136,24 @@ public final class NormalizedNodes {
      * @param node Data subtree root
      * @return String containing a human-readable form of the subtree.
      */
-    public static String toStringTree(final NormalizedNode<?, ?> node) {
+    public static String toStringTree(final NormalizedNode node) {
         final StringBuilder builder = new StringBuilder();
         toStringTree(builder, node, 0);
         return builder.toString();
     }
 
-    private static void toStringTree(final StringBuilder builder, final NormalizedNode<?, ?> node, final int offset) {
+    private static void toStringTree(final StringBuilder builder, final NormalizedNode node, final int offset) {
         final String prefix = " ".repeat(offset);
 
         builder.append(prefix).append(toStringTree(node.getIdentifier()));
         if (node instanceof NormalizedNodeContainer) {
-            final NormalizedNodeContainer<?, ?, ?> container = (NormalizedNodeContainer<?, ?, ?>) node;
-
             builder.append(" {\n");
-            for (NormalizedNode<?, ?> child : container.getValue()) {
+            for (NormalizedNode child : ((NormalizedNodeContainer<?, ?>) node).body()) {
                 toStringTree(builder, child, offset + STRINGTREE_INDENT);
             }
-
             builder.append(prefix).append('}');
         } else {
-            builder.append(' ').append(node.getValue());
+            builder.append(' ').append(node.body());
         }
         builder.append('\n');
     }