Seal NormalizedNode hierarchy

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

diff --git a/data/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/builder/impl/ImmutableContainerNodeBuilder.java b/data/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/builder/impl/ImmutableContainerNodeBuilder.java
index 41b30f55466f668eff45671bb7a01ad37ccb510e..6a13ac0d01ca68712a71808304fc195093e17b61 100644 (file)
--- a/data/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/builder/impl/ImmutableContainerNodeBuilder.java
+++ b/data/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/builder/impl/ImmutableContainerNodeBuilder.java
@@ -7,72 +7,85 @@
  */
 package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
 
+import static java.util.Objects.requireNonNull;
+
+import java.util.Collection;
 import java.util.Map;
 import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.util.ImmutableOffsetMap;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.AbstractContainerNode;
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.nodes.AbstractImmutableDataContainerNode;
-import org.opendaylight.yangtools.yang.model.api.ContainerLike;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
+import org.opendaylight.yangtools.yang.data.impl.schema.nodes.LazyLeafOperations;
+import org.opendaylight.yangtools.yang.data.impl.schema.nodes.LazyValues;
 
-public class ImmutableContainerNodeBuilder
-        extends AbstractImmutableDataContainerNodeBuilder<NodeIdentifier, ContainerNode> {
-    protected ImmutableContainerNodeBuilder() {
+public final class ImmutableContainerNodeBuilder
+        extends AbstractImmutableDataContainerNodeBuilder<NodeIdentifier, ContainerNode>
+        implements ContainerNode.Builder {
+    public ImmutableContainerNodeBuilder() {
 
     }
 
-    protected ImmutableContainerNodeBuilder(final int sizeHint) {
+    public ImmutableContainerNodeBuilder(final int sizeHint) {
         super(sizeHint);
     }
 
-    protected ImmutableContainerNodeBuilder(final ImmutableContainerNode node) {
-        super(node);
+    private ImmutableContainerNodeBuilder(final ImmutableContainerNode node) {
+        super(node.name, node.children);
     }
 
-    public static @NonNull DataContainerNodeBuilder<NodeIdentifier, ContainerNode> create() {
-        return new ImmutableContainerNodeBuilder();
+    public static ContainerNode.@NonNull Builder create(final ContainerNode node) {
+        if (node instanceof ImmutableContainerNode immutableNode) {
+            return new ImmutableContainerNodeBuilder(immutableNode);
+        }
+        throw new UnsupportedOperationException("Cannot initialize from class " + node.getClass());
     }
 
-    public static @NonNull DataContainerNodeBuilder<NodeIdentifier, ContainerNode> create(final int sizeHint) {
-        return new ImmutableContainerNodeBuilder(sizeHint);
+    @Override
+    public ContainerNode build() {
+        return new ImmutableContainerNode(getNodeIdentifier(), buildValue());
     }
 
-    public static @NonNull DataContainerNodeBuilder<NodeIdentifier, ContainerNode> create(final ContainerNode node) {
-        if (!(node instanceof ImmutableContainerNode)) {
-            throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
+    protected static final class ImmutableContainerNode extends AbstractContainerNode {
+        private final @NonNull NodeIdentifier name;
+        private final @NonNull Map<NodeIdentifier, Object> children;
+
+        ImmutableContainerNode(final NodeIdentifier name, final Map<NodeIdentifier, Object> children) {
+            this.name = requireNonNull(name);
+            // FIXME: move this to caller
+            this.children = ImmutableOffsetMap.unorderedCopyOf(children);
         }
-        return new ImmutableContainerNodeBuilder((ImmutableContainerNode) node);
-    }
 
-    @Deprecated(since = "6.0.7", forRemoval = true)
-    public static @NonNull DataContainerNodeBuilder<NodeIdentifier, ContainerNode> create(final ContainerLike schema) {
-        return new SchemaAwareImmutableContainerNodeBuilder(schema);
-    }
+        @Override
+        public NodeIdentifier name() {
+            return name;
+        }
+
+        @Override
+        public DataContainerChild childByArg(final NodeIdentifier child) {
+            return LazyLeafOperations.getChild(children, child);
+        }
 
-    @Deprecated(since = "6.0.7", forRemoval = true)
-    public static @NonNull DataContainerNodeBuilder<NodeIdentifier, ContainerNode> create(final ContainerLike schema,
-            final ContainerNode node) {
-        if (!(node instanceof ImmutableContainerNode)) {
-            throw new UnsupportedOperationException("Cannot initialize from class " + node.getClass());
+        @Override
+        public Collection<DataContainerChild> body() {
+            return new LazyValues(children);
         }
-        return new SchemaAwareImmutableContainerNodeBuilder(schema, (ImmutableContainerNode)node);
-    }
 
-    @Override
-    public ContainerNode build() {
-        return new ImmutableContainerNode(getNodeIdentifier(), buildValue());
-    }
+        @Override
+        public int size() {
+            return children.size();
+        }
 
-    protected static final class ImmutableContainerNode
-            extends AbstractImmutableDataContainerNode<NodeIdentifier, ContainerNode> implements ContainerNode {
-        ImmutableContainerNode(final NodeIdentifier nodeIdentifier, final Map<PathArgument, Object> children) {
-            super(children, nodeIdentifier);
+        @Override
+        protected int valueHashCode() {
+            return children.hashCode();
         }
 
         @Override
-        protected Class<ContainerNode> implementedType() {
-            return ContainerNode.class;
+        protected boolean valueEquals(final ContainerNode other) {
+            return other instanceof ImmutableContainerNode immutable ? children.equals(immutable.children)
+                : ImmutableNormalizedNodeMethods.bodyEquals(this, other);
         }
     }
 }