Remove EffectiveModelContext{Listener,Provider}

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

diff --git a/data/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ImmutableNodes.java b/data/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ImmutableNodes.java
index 91e7459beaa644838f1dcdf14514bc156f5c3b2d..38e7fa8fbd9fe5c5206af4bcc11a7fd6ecc1d9ef 100644 (file)
--- a/data/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ImmutableNodes.java
+++ b/data/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ImmutableNodes.java
@@ -7,8 +7,6 @@
  */
 package org.opendaylight.yangtools.yang.data.impl.schema;
 
-import static com.google.common.base.Verify.verify;
-
 import java.io.IOException;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.common.QName;
@@ -21,17 +19,23 @@ import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode.BuilderFactory;
 import org.opendaylight.yangtools.yang.data.api.schema.SystemMapNode;
 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
 import org.opendaylight.yangtools.yang.data.api.schema.UserMapNode;
-import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
-import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
 import org.opendaylight.yangtools.yang.data.api.schema.stream.YangInstanceIdentifierWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
 
+/**
+ * Utility methods producing immutable implementations of various {@link NormalizedNode}s.
+ *
+ * @deprecated Use {@link org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes} instead.
+ */
+@Deprecated(since = "12.0.0", forRemoval = true)
 public final class ImmutableNodes {
+    private static final @NonNull BuilderFactory BUILDER_FACTORY =
+        org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes.builderFactory();
     // FIXME: YANGTOOLS-1074: we do not want this name
     private static final NodeIdentifier SCHEMACONTEXT_NAME = NodeIdentifier.create(SchemaContext.NAME);
 
@@ -39,17 +43,19 @@ public final class ImmutableNodes {
         // Hidden on purpose
     }
 
-    public static @NonNull CollectionNodeBuilder<MapEntryNode, SystemMapNode> mapNodeBuilder() {
-        return Builders.mapBuilder();
+    public static SystemMapNode.@NonNull Builder mapNodeBuilder() {
+        return BUILDER_FACTORY.newSystemMapBuilder();
     }
 
-    public static @NonNull CollectionNodeBuilder<MapEntryNode, SystemMapNode> mapNodeBuilder(final QName name) {
+    public static SystemMapNode.@NonNull Builder mapNodeBuilder(final QName name) {
         return mapNodeBuilder(NodeIdentifier.create(name));
     }
 
-    public static @NonNull CollectionNodeBuilder<MapEntryNode, SystemMapNode> mapNodeBuilder(
-            final NodeIdentifier name) {
-        return Builders.mapBuilder().withNodeIdentifier(name);
+    public static SystemMapNode.@NonNull Builder mapNodeBuilder(final NodeIdentifier name) {
+        final var ret = mapNodeBuilder();
+        // FIXME: use fluent once we have specialized enough
+        ret.withNodeIdentifier(name);
+        return ret;
     }
 
     /**
@@ -89,7 +95,7 @@ public final class ImmutableNodes {
      * @return An ordered Map node
      */
     public static @NonNull UserMapNode orderedMapNode(final NodeIdentifier name) {
-        return Builders.orderedMapBuilder().withNodeIdentifier(name).build();
+        return BUILDER_FACTORY.newUserMapBuilder().withNodeIdentifier(name).build();
     }
 
     /**
@@ -101,7 +107,7 @@ public final class ImmutableNodes {
      * @return Leaf node with supplied identifier and value
      */
     public static <T> @NonNull LeafNode<T> leafNode(final NodeIdentifier name, final T value) {
-        return ImmutableLeafNodeBuilder.createNode(name, value);
+        return org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes.leafNode(name, value);
     }
 
     /**
@@ -113,18 +119,20 @@ public final class ImmutableNodes {
      * @return Leaf node with supplied identifier and value
      */
     public static <T> @NonNull LeafNode<T> leafNode(final QName name, final T value) {
-        return leafNode(NodeIdentifier.create(name), value);
+        return org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes.leafNode(name, value);
     }
 
-    public static @NonNull DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder(
-            final QName nodeName, final QName keyName, final Object keyValue) {
-        return Builders.mapEntryBuilder()
-                .withNodeIdentifier(NodeIdentifierWithPredicates.of(nodeName, keyName, keyValue))
-                .withChild(leafNode(keyName, keyValue));
+    public static MapEntryNode.@NonNull Builder mapEntryBuilder(final QName nodeName, final QName keyName,
+            final Object keyValue) {
+        final var ret = mapEntryBuilder();
+        // FIXME: use fluent once we have specialized enough
+        ret.withNodeIdentifier(NodeIdentifierWithPredicates.of(nodeName, keyName, keyValue))
+            .withChild(leafNode(keyName, keyValue));
+        return ret;
     }
 
-    public static @NonNull DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder() {
-        return Builders.mapEntryBuilder();
+    public static MapEntryNode.@NonNull Builder mapEntryBuilder() {
+        return BUILDER_FACTORY.newMapEntryBuilder();
     }
 
     public static @NonNull MapEntryNode mapEntry(final QName nodeName, final QName keyName, final Object keyValue) {
@@ -148,7 +156,7 @@ public final class ImmutableNodes {
      * @return A container node
      */
     public static @NonNull ContainerNode containerNode(final NodeIdentifier name) {
-        return Builders.containerBuilder().withNodeIdentifier(name).build();
+        return BUILDER_FACTORY.newContainerBuilder().withNodeIdentifier(name).build();
     }
 
     /**
@@ -168,7 +176,7 @@ public final class ImmutableNodes {
      * @return A choice node
      */
     public static @NonNull ChoiceNode choiceNode(final NodeIdentifier name) {
-        return Builders.choiceBuilder().withNodeIdentifier(name).build();
+        return BUILDER_FACTORY.newChoiceBuilder().withNodeIdentifier(name).build();
     }
 
     /**
@@ -188,7 +196,7 @@ public final class ImmutableNodes {
      * @return An unkeyed list node
      */
     public static @NonNull UnkeyedListNode listNode(final NodeIdentifier name) {
-        return Builders.unkeyedListBuilder().withNodeIdentifier(name).build();
+        return BUILDER_FACTORY.newUnkeyedListBuilder().withNodeIdentifier(name).build();
     }
 
     /**
@@ -206,20 +214,19 @@ public final class ImmutableNodes {
             return containerNode(SCHEMACONTEXT_NAME);
         }
 
-        final var result = new NormalizedNodeResult();
+        final var result = new NormalizationResultHolder();
         try (var writer = ImmutableNormalizedNodeStreamWriter.from(result)) {
             try (var iidWriter = YangInstanceIdentifierWriter.open(writer, ctx, id)) {
                 // leaf-list entry nodes are special: they require a value and we can derive it from our instance
                 // identitifier
                 final var lastArg = id.getLastPathArgument();
-                if (lastArg instanceof NodeWithValue) {
-                    writer.scalarValue(((NodeWithValue<?>) lastArg).getValue());
+                if (lastArg instanceof NodeWithValue<?> withValue) {
+                    writer.scalarValue(withValue.getValue());
                 }
             }
         } catch (IOException e) {
             throw new IllegalArgumentException("Failed to convert " + id, e);
         }
-        verify(result.isFinished());
-        return result.getResult();
+        return result.getResult().data();
     }
 }