<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-impl</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-data-spi</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-data-util</artifactId>
<groupId>org.opendaylight.mdsal.binding.model.ietf</groupId>
<artifactId>rfc6991-ietf-inet-types</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal.binding.model.ietf</groupId>
+ <artifactId>rfc6991-ietf-yang-types</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.mdsal.binding.model.ietf</groupId>
<artifactId>rfc8525</artifactId>
import org.opendaylight.yangtools.yang.data.codec.gson.JSONCodecFactorySupplier;
import org.opendaylight.yangtools.yang.data.codec.gson.JsonParserStream;
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
private static final YangInstanceIdentifier MODULES_STATE_MODULE_LIST =
YangInstanceIdentifier.of(MODULES_STATE_NID, MODULE_NID);
- private static final @NonNull ContainerNode GET_MODULES_STATE_MODULE_LIST_RPC = Builders.containerBuilder()
+ private static final @NonNull ContainerNode GET_MODULES_STATE_MODULE_LIST_RPC = ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NETCONF_GET_NODEID)
.withChild(NetconfMessageTransformUtil.toFilterStructure(MODULES_STATE_MODULE_LIST, LIBRARY_CONTEXT))
.build();
import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceProvider;
NodeIdentifier.create(QName.create(GetSchema.QNAME, "identifier").intern());
private static final NodeIdentifier VERSION_PATHARG =
NodeIdentifier.create(QName.create(GetSchema.QNAME, "version").intern());
- private static final LeafNode<?> FORMAT_LEAF =
- Builders.leafBuilder().withNodeIdentifier(FORMAT_PATHARG).withValue(Yang.QNAME).build();
+ private static final LeafNode<?> FORMAT_LEAF = ImmutableNodes.leafNode(FORMAT_PATHARG, Yang.QNAME);
private static final NodeIdentifier NETCONF_DATA_PATHARG = NodeIdentifier.create(Data.QNAME);
private final DOMRpcService rpc;
public static @NonNull ContainerNode createGetSchemaRequest(final String moduleName,
final Optional<String> revision) {
- final var builder = Builders.containerBuilder()
+ final var builder = ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(GET_SCHEMA_PATHARG)
.withChild(ImmutableNodes.leafNode(IDENTIFIER_PATHARG, moduleName))
.withChild(FORMAT_LEAF);
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
// Perhaps add a default schema context to support create-subscription if the model was not provided
// (same as what we do for base netconf operations in transformer)
final var rpcResultListenableFuture = deviceRpc.domRpcService()
- .invokeRpc(CreateSubscription.QNAME, Builders.containerBuilder()
+ .invokeRpc(CreateSubscription.QNAME, ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NodeIdentifier.create(CreateSubscriptionInput.QNAME))
// Note: default 'stream' is 'NETCONF', we do not need to create an explicit leaf
.build());
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
Schemas.QNAME.getLocalName()));
filterElem.appendChild(stateElem);
- GET_SCHEMAS_RPC = Builders.containerBuilder()
+ GET_SCHEMAS_RPC = ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(new NodeIdentifier(GetInput.QNAME))
- .withChild(Builders.anyXmlBuilder()
+ .withChild(ImmutableNodes.newAnyxmlBuilder(DOMSource.class)
.withNodeIdentifier(new NodeIdentifier(Filter.QNAME))
.withValue(new DOMSource(filterElem))
.build())
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
/**
* Provides base operations for NETCONF e.g. {@code get}, {@code get-config}, {@code edit-config}, {@code commit} etc.
public ChoiceNode createEditConfigStructure(final Optional<NormalizedNode> lastChild,
final Optional<EffectiveOperation> operation, final YangInstanceIdentifier dataPath) {
- return Builders.choiceBuilder()
+ return ImmutableNodes.newChoiceBuilder()
.withNodeIdentifier(EDIT_CONTENT_NODEID)
.withChild(transformer.createEditConfigStructure(lastChild, dataPath, operation))
.build();
private static ContainerNode getEditConfigContent(final NodeIdentifier datastore,
final DataContainerChild editStructure, final Optional<EffectiveOperation> defaultOperation,
final boolean rollback) {
- final var editBuilder = Builders.containerBuilder()
+ final var editBuilder = ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NETCONF_EDIT_CONFIG_NODEID)
// Target
.withChild(getTargetNode(datastore));
}
public static @NonNull ContainerNode getSourceNode(final NodeIdentifier datastore) {
- return Builders.containerBuilder()
+ return ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NETCONF_SOURCE_NODEID)
- .withChild(Builders.choiceBuilder()
+ .withChild(ImmutableNodes.newChoiceBuilder()
.withNodeIdentifier(CONFIG_SOURCE_NODEID)
.withChild(ImmutableNodes.leafNode(datastore, Empty.value()))
.build())
}
public static @NonNull ContainerNode getLockContent(final NodeIdentifier datastore) {
- return Builders.containerBuilder()
+ return ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NETCONF_LOCK_NODEID)
.withChild(getTargetNode(datastore))
.build();
}
public static @NonNull ContainerNode getTargetNode(final NodeIdentifier datastore) {
- return Builders.containerBuilder()
+ return ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NETCONF_TARGET_NODEID)
- .withChild(Builders.choiceBuilder()
+ .withChild(ImmutableNodes.newChoiceBuilder()
.withNodeIdentifier(CONFIG_TARGET_NODEID)
.withChild(ImmutableNodes.leafNode(datastore, Empty.value()))
.build())
public static @NonNull ContainerNode getCopyConfigContent(final NodeIdentifier sourceDatastore,
final NodeIdentifier targetDatastore) {
- return Builders.containerBuilder()
+ return ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NETCONF_COPY_CONFIG_NODEID)
.withChild(getTargetNode(targetDatastore))
.withChild(getSourceNode(sourceDatastore))
}
public static @NonNull ContainerNode getValidateContent(final NodeIdentifier sourceDatastore) {
- return Builders.containerBuilder()
+ return ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NETCONF_VALIDATE_NODEID)
.withChild(getSourceNode(sourceDatastore))
.build();
}
public static @NonNull ContainerNode getUnLockContent(final NodeIdentifier datastore) {
- return Builders.containerBuilder()
+ return ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NETCONF_UNLOCK_NODEID)
.withChild(getTargetNode(datastore))
.build();
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
import org.opendaylight.yangtools.yang.data.api.schema.stream.YangInstanceIdentifierWriter;
import org.opendaylight.yangtools.yang.data.codec.xml.XMLStreamNormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedMetadata;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
import org.opendaylight.yangtools.yang.data.impl.schema.SchemaOrderedNormalizedNodeWriter;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContext;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContext.PathMixin;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
public static final @NonNull NodeIdentifier EDIT_CONTENT_NODEID = NodeIdentifier.create(EditContent.QNAME);
// Discard changes message
- public static final @NonNull ContainerNode DISCARD_CHANGES_RPC_CONTENT = Builders.containerBuilder()
+ public static final @NonNull ContainerNode DISCARD_CHANGES_RPC_CONTENT = ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NodeIdentifier.create(DiscardChangesInput.QNAME)).build();
// Commit changes message
- public static final @NonNull ContainerNode COMMIT_RPC_CONTENT = Builders.containerBuilder()
+ public static final @NonNull ContainerNode COMMIT_RPC_CONTENT = ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NodeIdentifier.create(CommitInput.QNAME)).build();
// Get message
- public static final @NonNull ContainerNode GET_RPC_CONTENT = Builders.containerBuilder()
+ public static final @NonNull ContainerNode GET_RPC_CONTENT = ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NETCONF_GET_NODEID).build();
public static final @NonNull AnyxmlNode<?> EMPTY_FILTER = buildFilterStructure(newFilterElement());
}
private static AnyxmlNode<?> buildFilterStructure(final Element element) {
- return Builders.anyXmlBuilder()
+ return ImmutableNodes.newAnyxmlBuilder(DOMSource.class)
.withNodeIdentifier(new NodeIdentifier(Filter.QNAME))
.withValue(new DOMSource(element))
.build();
}
public static @NonNull ContainerNode wrap(final NodeIdentifier name, final DataContainerChild... node) {
- return Builders.containerBuilder().withNodeIdentifier(name).withValue(ImmutableList.copyOf(node)).build();
+ return ImmutableNodes.newContainerBuilder()
+ .withNodeIdentifier(name)
+ .withValue(ImmutableList.copyOf(node))
+ .build();
}
/**
throw new IllegalStateException("Unable to serialize edit config content element for path " + dataPath, e);
}
- return Builders.anyXmlBuilder().withNodeIdentifier(NETCONF_CONFIG_NODEID).withValue(new DOMSource(element))
- .build();
+ return ImmutableNodes.newAnyxmlBuilder(DOMSource.class)
+ .withNodeIdentifier(NETCONF_CONFIG_NODEID)
+ .withValue(new DOMSource(element))
+ .build();
}
private static NormalizedMetadata leafMetadata(final YangInstanceIdentifier path, final EffectiveOperation oper) {
public static DataContainerChild createEditConfigStructure(final EffectiveModelContext ctx,
final YangInstanceIdentifier dataPath, final Optional<EffectiveOperation> operation,
final Optional<NormalizedNode> lastChildOverride) {
- return Builders.choiceBuilder().withNodeIdentifier(EDIT_CONTENT_NODEID)
- .withChild(createEditConfigAnyxml(ctx, dataPath, operation, lastChildOverride)).build();
+ return ImmutableNodes.newChoiceBuilder()
+ .withNodeIdentifier(EDIT_CONTENT_NODEID)
+ .withChild(createEditConfigAnyxml(ctx, dataPath, operation, lastChildOverride))
+ .build();
}
public static @NonNull Absolute toPath(final QName rpc) {
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer;
final var message = resultPayload.getResult();
final ContainerNode normalizedNode;
if (NetconfMessageTransformUtil.isDataRetrievalOperation(rpc)) {
- normalizedNode = Builders.containerBuilder()
- .withNodeIdentifier(NetconfMessageTransformUtil.NETCONF_RPC_REPLY_NODEID)
- .withChild(Builders.anyXmlBuilder()
- .withNodeIdentifier(NetconfMessageTransformUtil.NETCONF_DATA_NODEID)
- .withValue(new DOMSource(NetconfMessageTransformUtil.getDataSubtree(message.getDocument())))
- .build())
- .build();
+ normalizedNode = ImmutableNodes.newContainerBuilder()
+ .withNodeIdentifier(NetconfMessageTransformUtil.NETCONF_RPC_REPLY_NODEID)
+ .withChild(ImmutableNodes.newAnyxmlBuilder(DOMSource.class)
+ .withNodeIdentifier(NetconfMessageTransformUtil.NETCONF_DATA_NODEID)
+ .withValue(new DOMSource(NetconfMessageTransformUtil.getDataSubtree(message.getDocument())))
+ .build())
+ .build();
} else {
// Determine whether a base netconf operation is being invoked
// and also check if the device exposed model for base netconf.
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
+ message + ", cannot find namespace", e);
}
- return new NetconfMessageTransformer.NetconfDeviceNotification(Builders.containerBuilder()
+ return new NetconfMessageTransformer.NetconfDeviceNotification(ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(SCHEMALESS_NOTIFICATION_PAYLOAD)
- .withChild(Builders.anyXmlBuilder()
+ .withChild(ImmutableNodes.newAnyxmlBuilder(DOMSource.class)
.withNodeIdentifier(new NodeIdentifier(notificationNoRev))
.withValue(new DOMSource(stripped.getValue().getDomElement()))
.build())
import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
for (var xmlElement : selectMatchingNodes(getSourceElement(anyxml.body()), path)) {
dataElement.appendChild(result.importNode(xmlElement.getDomElement(), true));
}
- return Optional.of(Builders.anyXmlBuilder()
+ return Optional.of(ImmutableNodes.newAnyxmlBuilder(DOMSource.class)
.withNodeIdentifier(NETCONF_DATA_NODEID)
.withValue(new DOMSource(result))
.build());
operation.ifPresent(modifyAction -> setOperationAttribute(modifyAction, document, dataNode));
//append data
parentXmlStructure.appendChild(document.importNode(dataNode, true));
- return Builders.anyXmlBuilder()
+ return ImmutableNodes.newAnyxmlBuilder(DOMSource.class)
.withNodeIdentifier(NETCONF_CONFIG_NODEID)
.withValue(new DOMSource(document.getDocumentElement()))
.build();
}
private static AnyxmlNode<?> buildFilterXmlNode(final Document document) {
- return Builders.anyXmlBuilder()
+ return ImmutableNodes.newAnyxmlBuilder(DOMSource.class)
.withNodeIdentifier(new NodeIdentifier(Filter.QNAME))
.withValue(new DOMSource(document.getDocumentElement()))
.build();
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.source.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.api.source.YangTextSource;
import org.w3c.dom.Document;
Document xmlDoc = UntrustedXML.newDocumentBuilder().newDocument();
Element root = xmlDoc.createElement("data");
root.setTextContent("module test {}");
- return Builders.containerBuilder()
+ return ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(id)
- .withChild(Builders.anyXmlBuilder()
+ .withChild(ImmutableNodes.newAnyxmlBuilder(DOMSource.class)
.withNodeIdentifier(childId)
.withValue(new DOMSource(root))
.build())
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
@Test
public void testUserDefinedRpcCall() throws Exception {
- final ContainerNode root = Builders.containerBuilder()
+ final ContainerNode root = ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(toId(SUBSCRIBE_RPC_NAME))
.withChild(ImmutableNodes.leafNode(STREAM_NAME, "NETCONF"))
.build();
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.w3c.dom.Element;
import org.xmlunit.builder.DiffBuilder;
@Test
public void toRpcRequest() throws Exception {
final var msg = transformer.toRpcRequest(EditConfig.QNAME,
- Builders.containerBuilder()
+ ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NetconfMessageTransformUtil.NETCONF_EDIT_CONFIG_NODEID)
- .withChild(Builders.choiceBuilder()
+ .withChild(ImmutableNodes.newChoiceBuilder()
.withNodeIdentifier(new NodeIdentifier(EditContent.QNAME))
- .withChild(Builders.anyXmlBuilder()
+ .withChild(ImmutableNodes.newAnyxmlBuilder(DOMSource.class)
.withNodeIdentifier(NetconfMessageTransformUtil.NETCONF_CONFIG_NODEID)
.withValue(new DOMSource(XmlUtil.readXmlToDocument(
BaseRpcSchemalessTransformerTest.class.getResourceAsStream(
.getDocumentElement()))
.build())
.build())
- .withChild(Builders.containerBuilder()
+ .withChild(ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NetconfMessageTransformUtil.NETCONF_TARGET_NODEID)
- .withChild(Builders.choiceBuilder()
+ .withChild(ImmutableNodes.newChoiceBuilder()
.withNodeIdentifier(new NodeIdentifier(ConfigTarget.QNAME))
.withChild(ImmutableNodes.leafNode(Candidate.QNAME, Empty.value()))
.build())
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
-import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public void testCreateSubscriberNotificationSchemaNotPresent() throws Exception {
final var transformer = new NetconfMessageTransformer(MountPointContext.of(SCHEMA), true,
BASE_SCHEMAS.baseSchemaWithNotifications());
- var netconfMessage = transformer.toRpcRequest(CreateSubscription.QNAME, Builders.containerBuilder()
+ var netconfMessage = transformer.toRpcRequest(CreateSubscription.QNAME, ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(new NodeIdentifier(CreateSubscriptionInput.QNAME))
.build());
assertEquals("""
keys.put(value.name().getNodeType(), value.body());
}
- final var schemaNode = Builders.mapEntryBuilder()
+ final var schemaNode = ImmutableNodes.newMapEntryBuilder()
.withNodeIdentifier(NodeIdentifierWithPredicates.of(Schema.QNAME, keys))
.withValue(values)
.build();
keys.put(value.name().getNodeType(), value.body());
}
- final var schemaNode = Builders.mapEntryBuilder()
+ final var schemaNode = ImmutableNodes.newMapEntryBuilder()
.withNodeIdentifier(NodeIdentifierWithPredicates.of(Schema.QNAME, keys))
.withValue(values)
.build();
DOMDataTreeIdentifier domDataTreeIdentifier = prepareDataTreeId(nodeIdentifiers);
- ContainerNode payload = Builders.containerBuilder()
+ ContainerNode payload = ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NodeIdentifier.create(QName.create(barInputQname, "input")))
.withChild(ImmutableNodes.leafNode(barInputQname, barInput))
.build();
}
private static ContainerNode initInputAction(final QName qname, final String value) {
- return Builders.containerBuilder()
+ return ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NodeIdentifier.create(QName.create(qname, "input")))
.withChild(ImmutableNodes.leafNode(qname, value))
.build();
}
private static ContainerNode initEmptyInputAction(final QName qname) {
- return Builders.containerBuilder()
+ return ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NodeIdentifier.create(QName.create(qname, "input")))
.build();
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;
import org.xmlunit.builder.DiffBuilder;
@Test
public void testCreateEditConfigStructure() throws Exception {
- final var data = Builders.anyXmlBuilder()
+ final var data = ImmutableNodes.newAnyxmlBuilder(DOMSource.class)
.withNodeIdentifier(createNodeId(path.getLastPathArgument().getNodeType().getLocalName()))
.withValue(source)
.build();
@Test
public void testSelectFromDataStructure() throws Exception {
- final var data = Builders.anyXmlBuilder()
+ final var data = ImmutableNodes.newAnyxmlBuilder(DOMSource.class)
.withNodeIdentifier(createNodeId(path.getLastPathArgument().getNodeType().getLocalName()))
.withValue(new DOMSource(XmlUtil.readXmlToDocument(getConfigData).getDocumentElement()))
.build();
import org.opendaylight.netconf.common.impl.DefaultNetconfTimer;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.base._1._0.rev110601.GetConfig;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
@ExtendWith(MockitoExtension.class)
class KeepaliveSalFacadeResponseWaitingTest {
//This settable future will be used to check the invokation of keepalive RPC. Should be never invoked.
final var keepaliveSettableFuture = SettableFuture.<DOMRpcResult>create();
- keepaliveSettableFuture.set(new DefaultDOMRpcResult(Builders.containerBuilder()
+ keepaliveSettableFuture.set(new DefaultDOMRpcResult(ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NetconfMessageTransformUtil.NETCONF_RUNNING_NODEID)
.build()));
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
@ExtendWith(MockitoExtension.class)
class KeepaliveSalFacadeTest {
@Test
void testKeepaliveSuccess() throws Exception {
doNothing().when(underlyingSalFacade).onDeviceConnected(isNull(), isNull(), any());
- doReturn(Futures.immediateFuture(new DefaultDOMRpcResult(Builders.containerBuilder()
+ doReturn(Futures.immediateFuture(new DefaultDOMRpcResult(ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NetconfMessageTransformUtil.NETCONF_RUNNING_NODEID)
.build()))).when(deviceRpc).invokeNetconf(any(), any());
import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.w3c.dom.Node;
}
private static ContainerNode createNode(final String namespace, final String date, final String localName) {
- return Builders.containerBuilder().withNodeIdentifier(
- new NodeIdentifier(QName.create(namespace, date, localName))).build();
+ return ImmutableNodes.newContainerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(QName.create(namespace, date, localName)))
+ .build();
}
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
-import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class NetconfDeviceWriteOnlyTxTest extends AbstractBaseSchemasTest {
final var tx = new WriteCandidateTx(ID, new NetconfBaseOps(rpc, mock(MountPointContext.class)), false, true);
tx.init();
- final var emptyList = ImmutableNodes.mapNodeBuilder(new NodeIdentifier(Filter.QNAME)).build();
+ final var emptyList = ImmutableNodes.newSystemMapBuilder()
+ .withNodeIdentifier(new NodeIdentifier(Filter.QNAME))
+ .build();
tx.merge(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.of(Filter.QNAME), emptyList);
tx.put(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.of(Filter.QNAME), emptyList);
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
public final class TxTestUtils {
private static final QName Q_NAME_1 = QName.create("test:namespace", "2013-07-22", "c");
}
static ContainerNode getContainerNode() {
- return ImmutableNodes.containerNode(Q_NAME_1);
+ return ImmutableNodes.newContainerBuilder().withNodeIdentifier(new NodeIdentifier(Q_NAME_1)).build();
}
public static LeafNode<String> getLeafNode() {
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class WriteCandidateRunningTxTest extends AbstractTestModelTest {
}
private static ContainerNode getLockContent(final QName op, final NodeIdentifier datastore) {
- return Builders.containerBuilder()
+ return ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(toId(op))
- .withChild(Builders.containerBuilder()
+ .withChild(ImmutableNodes.newContainerBuilder()
.withNodeIdentifier(NETCONF_TARGET_NODEID)
- .withChild(Builders.choiceBuilder()
+ .withChild(ImmutableNodes.newChoiceBuilder()
.withNodeIdentifier(toId(ConfigTarget.QNAME))
.withChild(ImmutableNodes.leafNode(datastore, Empty.value()))
.build())