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.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
//init notification mocks
doReturn(NOTIFICATION_1_PATH).when(matchnigNotification).getType();
doReturn(NOTIFICATION_2_PATH).when(nonMachtingNotification).getType();
- DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> body = Builders
+ DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> body = Builders
.containerBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(QName.create("ns1",
"1970-01-15", "not1data")));
doReturn(body.build()).when(matchnigNotification).getBody();
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
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.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
public static ContainerNode createGetSchemaRequest(final String moduleName, final Optional<String> revision) {
final LeafNode<?> identifier =
Builders.leafBuilder().withNodeIdentifier(IDENTIFIER_PATHARG).withValue(moduleName).build();
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builder = Builders.containerBuilder()
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> builder = Builders.containerBuilder()
.withNodeIdentifier(GET_SCHEMA_PATHARG).withChild(identifier).withChild(FORMAT_LEAF);
if (revision.isPresent()) {
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.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
/**
private static ContainerNode getEditConfigContent(
final QName datastore, final DataContainerChild<?, ?> editStructure,
final Optional<ModifyAction> defaultOperation, final boolean rollback) {
- final DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> editBuilder =
+ final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> editBuilder =
Builders.containerBuilder().withNodeIdentifier(NETCONF_EDIT_CONFIG_NODEID);
// Target
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.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
@Test
public void testUserDefinedRpcCall() throws Exception {
- final DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> rootBuilder =
+ final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> rootBuilder =
Builders.containerBuilder();
rootBuilder.withNodeIdentifier(toId(SUBSCRIBE_RPC_NAME));
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.netconf.sal.rest.impl;
import com.google.common.base.Preconditions;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
Preconditions.checkState(errorsSchemaNode instanceof ContainerSchemaNode,
"Found Errors SchemaNode isn't ContainerNode");
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> errContBuild =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> errContBuild =
Builders.containerBuilder((ContainerSchemaNode) errorsSchemaNode);
final List<DataSchemaNode> schemaList = ControllerContext.findInstanceDataChildrenByName(errorsSchemaNode,
Preconditions.checkArgument(errListSchemaNode instanceof ListSchemaNode,
"errListSchemaNode has to be of type ListSchemaNode");
final ListSchemaNode listStreamSchemaNode = (ListSchemaNode) errListSchemaNode;
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> errNodeValues = Builders
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> errNodeValues = Builders
.mapEntryBuilder(listStreamSchemaNode);
List<DataSchemaNode> lsChildDataSchemaNode = ControllerContext.findInstanceDataChildrenByName(
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
final DataSchemaContextTree baseSchemaCtxTree = DataSchemaContextTree.from(ctx);
final DataSchemaNode baseSchemaNode = baseSchemaCtxTree.getChild(path).getDataSchemaNode();
if (result instanceof ContainerNode) {
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builder =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> builder =
Builders.containerBuilder((ContainerSchemaNode) baseSchemaNode);
buildCont(builder, (ContainerNode) result, baseSchemaCtxTree, path, trim);
return builder.build();
}
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder =
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder =
Builders.mapEntryBuilder((ListSchemaNode) baseSchemaNode);
buildMapEntryBuilder(builder, (MapEntryNode) result, baseSchemaCtxTree, path, trim,
((ListSchemaNode) baseSchemaNode).getKeyDefinition());
}
private void buildMapEntryBuilder(
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder,
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder,
final MapEntryNode result, final DataSchemaContextTree baseSchemaCtxTree,
final YangInstanceIdentifier actualPath, final boolean trim, final List<QName> keys) {
for (final DataContainerChild<? extends PathArgument, ?> child : result.getValue()) {
final YangInstanceIdentifier path = actualPath.node(child.getIdentifier());
final DataSchemaNode childSchema = baseSchemaCtxTree.getChild(path).getDataSchemaNode();
if (child instanceof ContainerNode) {
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> childBuilder =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> childBuilder =
Builders.containerBuilder((ContainerSchemaNode) childSchema);
buildCont(childBuilder, (ContainerNode) child, baseSchemaCtxTree, path, trim);
builder.withChild(childBuilder.build());
} else if (child instanceof LeafNode) {
final Object defaultVal = ((LeafSchemaNode) childSchema).getType().getDefaultValue().orElse(null);
final Object nodeVal = child.getValue();
- final NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>> leafBuilder =
+ final NormalizedNodeBuilder<NodeIdentifier, Object, LeafNode<Object>> leafBuilder =
Builders.leafBuilder((LeafSchemaNode) childSchema);
if (keys.contains(child.getNodeType())) {
leafBuilder.withValue(child.getValue());
for (final MapEntryNode mapEntryNode : result.getValue()) {
final YangInstanceIdentifier actualNode = path.node(mapEntryNode.getIdentifier());
final DataSchemaNode childSchema = baseSchemaCtxTree.getChild(actualNode).getDataSchemaNode();
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder =
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder =
Builders.mapEntryBuilder((ListSchemaNode) childSchema);
buildMapEntryBuilder(mapEntryBuilder, mapEntryNode, baseSchemaCtxTree, actualNode, trim, keys);
builder.withChild(mapEntryBuilder.build());
}
}
- private void buildCont(final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builder,
+ private void buildCont(final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> builder,
final ContainerNode result, final DataSchemaContextTree baseSchemaCtxTree,
final YangInstanceIdentifier actualPath, final boolean trim) {
for (final DataContainerChild<? extends PathArgument, ?> child : result.getValue()) {
final YangInstanceIdentifier path = actualPath.node(child.getIdentifier());
final DataSchemaNode childSchema = baseSchemaCtxTree.getChild(path).getDataSchemaNode();
if (child instanceof ContainerNode) {
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builderChild =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> builderChild =
Builders.containerBuilder((ContainerSchemaNode) childSchema);
buildCont(builderChild, result, baseSchemaCtxTree, actualPath, trim);
builder.withChild(builderChild.build());
} else if (child instanceof LeafNode) {
final Object defaultVal = ((LeafSchemaNode) childSchema).getType().getDefaultValue().orElse(null);
final Object nodeVal = child.getValue();
- final NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>> leafBuilder =
+ final NormalizedNodeBuilder<NodeIdentifier, Object, LeafNode<Object>> leafBuilder =
Builders.leafBuilder((LeafSchemaNode) childSchema);
if (trim) {
if (defaultVal == null || !defaultVal.equals(nodeVal)) {
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.builder.api.CollectionNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
class NormalizedDataPrunner {
private DataContainerChild<?, ?> processContainerNode(final NormalizedNode<?, ?> node, final Integer depth) {
final ContainerNode containerNode = (ContainerNode) node;
- DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> newContainerBuilder = Builders.containerBuilder()
+ DataContainerNodeBuilder<NodeIdentifier, ContainerNode> newContainerBuilder = Builders.containerBuilder()
.withNodeIdentifier(containerNode.getIdentifier());
if (depth > 1) {
processDataContainerChild((DataContainerNode<?>) node, depth, newContainerBuilder);
.unkeyedListBuilder();
if (depth > 1) {
for (UnkeyedListEntryNode oldUnkeyedListEntry : ((UnkeyedListNode) node).getValue()) {
- DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> newUnkeyedListEntry = Builders
+ DataContainerNodeBuilder<NodeIdentifier, UnkeyedListEntryNode> newUnkeyedListEntry = Builders
.unkeyedListEntryBuilder().withNodeIdentifier(oldUnkeyedListEntry.getIdentifier());
for (DataContainerChild<? extends PathArgument, ?> oldUnkeyedListEntryValue : oldUnkeyedListEntry
.getValue()) {
}
private void processMapEntries(final NormalizedNode<?, ?> node, final Integer depth,
- CollectionNodeBuilder<MapEntryNode, ? extends MapNode> newOrderedMapNodeBuilder) {
+ final CollectionNodeBuilder<MapEntryNode, ? extends MapNode> newOrderedMapNodeBuilder) {
if (depth > 1) {
for (MapEntryNode oldMapEntryNode : ((MapNode) node).getValue()) {
- DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> newMapEntryNodeBuilder =
+ DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> newMapEntryNodeBuilder =
Builders.mapEntryBuilder().withNodeIdentifier(oldMapEntryNode.getIdentifier());
for (DataContainerChild<? extends PathArgument, ?> mapEntryNodeValue : oldMapEntryNode.getValue()) {
newMapEntryNodeBuilder.withChild(pruneDataAtDepth(mapEntryNodeValue, depth - 1));
}
}
}
-
-
}
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
restconfModule, Draft02.RestConfModule.MODULES_CONTAINER_SCHEMA_NODE);
Preconditions.checkState(modulesSchemaNode instanceof ContainerSchemaNode);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> moduleContainerBuilder =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> moduleContainerBuilder =
Builders.containerBuilder((ContainerSchemaNode) modulesSchemaNode);
moduleContainerBuilder.withChild(allModuleMap);
restconfModule, Draft02.RestConfModule.MODULES_CONTAINER_SCHEMA_NODE);
Preconditions.checkState(modulesSchemaNode instanceof ContainerSchemaNode);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> moduleContainerBuilder =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> moduleContainerBuilder =
Builders.containerBuilder((ContainerSchemaNode) modulesSchemaNode);
moduleContainerBuilder.withChild(mountPointModulesMap);
restconfModule, Draft02.RestConfModule.STREAMS_CONTAINER_SCHEMA_NODE);
Preconditions.checkState(streamsContainerSchemaNode instanceof ContainerSchemaNode);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> streamsContainerBuilder =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> streamsContainerBuilder =
Builders.containerBuilder((ContainerSchemaNode) streamsContainerSchemaNode);
streamsContainerBuilder.withChild(listStreamsBuilder.build());
}
final ContainerSchemaNode fakeCont = new FakeContainerSchemaNode(fakeRpcSchema);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> containerBuilder =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> containerBuilder =
Builders.containerBuilder(fakeCont);
for (final LeafSchemaNode leaf : fakeRpcSchema) {
if (response != null) {
// prepare node with value of location
final InstanceIdentifierContext<?> iid = prepareIIDSubsStreamOutput();
- final NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>> builder =
+ final NormalizedNodeBuilder<NodeIdentifier, Object, LeafNode<Object>> builder =
ImmutableLeafNodeBuilder.create().withValue(response.toString());
builder.withNodeIdentifier(
NodeIdentifier.create(QName.create("subscribe:to:notification", "2016-10-28", "location")));
Preconditions.checkArgument(moduleSchemaNode instanceof ListSchemaNode,
"moduleSchemaNode has to be of type ListSchemaNode");
final ListSchemaNode listModuleSchemaNode = (ListSchemaNode) moduleSchemaNode;
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> moduleNodeValues =
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> moduleNodeValues =
Builders.mapEntryBuilder(listModuleSchemaNode);
List<DataSchemaNode> instanceDataChildrenByName =
Preconditions.checkArgument(streamSchemaNode instanceof ListSchemaNode,
"streamSchemaNode has to be of type ListSchemaNode");
final ListSchemaNode listStreamSchemaNode = (ListSchemaNode) streamSchemaNode;
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> streamNodeValues =
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> streamNodeValues =
Builders.mapEntryBuilder(listStreamSchemaNode);
List<DataSchemaNode> instanceDataChildrenByName =
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
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.builder.api.DataContainerNodeAttrBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.valid.DataValidationException;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
final DataSchemaNode testNodeSchemaNode = schemaContextTestModule.getDataChildByName(lstWithCompositeKey);
assertTrue(testNodeSchemaNode != null);
assertTrue(testNodeSchemaNode instanceof ListSchemaNode);
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> testNodeContainer =
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> testNodeContainer =
Builders.mapEntryBuilder((ListSchemaNode) testNodeSchemaNode);
List<DataSchemaNode> testChildren = ControllerContext.findInstanceDataChildrenByName(
final DataSchemaNode testLeafKey1SchemaNode = Iterables.getFirst(testChildren, null);
assertTrue(testLeafKey1SchemaNode != null);
assertTrue(testLeafKey1SchemaNode instanceof LeafSchemaNode);
- final NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>> leafKey1 =
+ final NormalizedNodeBuilder<NodeIdentifier, Object, LeafNode<Object>> leafKey1 =
Builders.leafBuilder((LeafSchemaNode) testLeafKey1SchemaNode);
leafKey1.withValue(payloadKey1);
testNodeContainer.withChild(leafKey1.build());
final DataSchemaNode testLeafKey2SchemaNode = Iterables.getFirst(testChildren, null);
assertTrue(testLeafKey2SchemaNode != null);
assertTrue(testLeafKey2SchemaNode instanceof LeafSchemaNode);
- final NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>> leafKey2 =
+ final NormalizedNodeBuilder<NodeIdentifier, Object, LeafNode<Object>> leafKey2 =
Builders.leafBuilder((LeafSchemaNode) testLeafKey2SchemaNode);
leafKey2.withValue(payloadKey2);
testNodeContainer.withChild(leafKey2.build());
}
return uriBuilder.toString();
}
-
}
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
final DataSchemaNode schemaCont = schemaContext.getDataChildByName(cont);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> dataCont = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> dataCont = Builders
.containerBuilder((ContainerSchemaNode) schemaCont);
final DataSchemaNode schemaCont1 = ((ContainerSchemaNode) schemaCont)
.getDataChildByName(cont1);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> dataCont1 = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> dataCont1 = Builders
.containerBuilder((ContainerSchemaNode) schemaCont1);
final List<DataSchemaNode> instanceLfLst11 = ControllerContext
final DataSchemaNode schemaCont = schemaContext.getDataChildByName(cont);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> dataCont = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> dataCont = Builders
.containerBuilder((ContainerSchemaNode) schemaCont);
final DataSchemaNode schemaCont1 = ((ContainerSchemaNode) schemaCont)
.getDataChildByName(cont1);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> dataCont1 = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> dataCont1 = Builders
.containerBuilder((ContainerSchemaNode) schemaCont1);
final List<DataSchemaNode> instanceLst11 = ControllerContext
final CollectionNodeBuilder<MapEntryNode, MapNode> dataLst11 = Builders
.mapBuilder((ListSchemaNode) lst11Schema);
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> dataLst11Vaule = Builders
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> dataLst11Vaule = Builders
.mapEntryBuilder((ListSchemaNode) lst11Schema);
dataLst11Vaule.withChild(buildLeaf(lst11Schema, keyvalue111, dataLst11,
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
final DataSchemaNode contSchema = schemaContext.getDataChildByName(cont);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contData = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> contData = Builders
.containerBuilder((ContainerSchemaNode) contSchema);
final List<DataSchemaNode> instanceLf = ControllerContext
final DataSchemaNode contSchema = schemaContext.getDataChildByName(cont);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contData = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> contData = Builders
.containerBuilder((ContainerSchemaNode) contSchema);
List<DataSchemaNode> instanceLf = ControllerContext
final QName lfLfref = QName.create("basic:module", "2013-12-02", "lfLfrefNegative");
final DataSchemaNode contSchema = schemaContext.getDataChildByName(cont);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contData = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> contData = Builders
.containerBuilder((ContainerSchemaNode) contSchema);
final List<DataSchemaNode> instanceLf = ControllerContext.findInstanceDataChildrenByName((DataNodeContainer)
final DataSchemaNode contSchema = schemaContext.getDataChildByName(cont);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contData = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> contData = Builders
.containerBuilder((ContainerSchemaNode) contSchema);
final DataSchemaNode cont1Schema = ((ContainerSchemaNode) contSchema).getDataChildByName(cont1);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> cont1Data = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> cont1Data = Builders
.containerBuilder((ContainerSchemaNode) cont1Schema);
Object value = null;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
final DataSchemaNode contSchemaNode = schemaContext
.getDataChildByName(contQname);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> dataContainerNodeAttrBuilder = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> dataContainerNodeAttrBuilder = Builders
.containerBuilder((ContainerSchemaNode) contSchemaNode);
final DataSchemaNode choiceSchemaNode = ((ContainerSchemaNode) contSchemaNode)
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
assertTrue(schemaContNode instanceof ContainerSchemaNode);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> dataContSchemaContNode = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> dataContSchemaContNode = Builders
.containerBuilder((ContainerSchemaNode) schemaContNode);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> modul1 = buildContBuilderMod1(
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> modul1 = buildContBuilderMod1(
"module:one", rev, "cont_m1", "contB_m1", "lf1_m1",
"lf1 m1 value");
dataContSchemaContNode.withChild(modul1.build());
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> modul2 = buildContBuilderMod1(
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> modul2 = buildContBuilderMod1(
"module:two", rev, "cont_m2", "contB_m2", "lf1_m2",
"lf1 m2 value");
dataContSchemaContNode.withChild(modul2.build());
return testNormalizedNodeContext;
}
- private static DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> buildContBuilderMod1(
+ private static DataContainerNodeBuilder<NodeIdentifier, ContainerNode> buildContBuilderMod1(
final String uri, final String rev, final String cont, final String contB, final String lf1,
final String lf1Value) {
final QName contQname = QName.create(uri, rev, cont);
final DataSchemaNode contSchemaNode = schemaContext
.getDataChildByName(contQname);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> dataContainerNodeAttrBuilder = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> dataContainerNodeAttrBuilder = Builders
.containerBuilder((ContainerSchemaNode) contSchemaNode);
Preconditions.checkState(contSchemaNode instanceof ContainerSchemaNode);
final DataSchemaNode contBSchemaNode = ((ContainerSchemaNode) contSchemaNode)
.getDataChildByName(contBQname);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> dataContainerB = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> dataContainerB = Builders
.containerBuilder((ContainerSchemaNode) contBSchemaNode);
return dataContainerNodeAttrBuilder.withChild(dataContainerB.build());
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.builder.api.CollectionNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
}
private static ContainerNode container(final String localName, final DataContainerChild<?, ?>... children) {
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> containerBuilder =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> containerBuilder =
Builders.containerBuilder();
for (final DataContainerChild<?, ?> child : children) {
containerBuilder.withChild(child);
private static UnkeyedListEntryNode unkeyedEntry(final String localName,
final DataContainerChild<?, ?>... children) {
- final DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> builder =
+ final DataContainerNodeBuilder<NodeIdentifier, UnkeyedListEntryNode> builder =
Builders.unkeyedListEntryBuilder();
builder.withNodeIdentifier(toIdentifier(localName));
for (final DataContainerChild<?, ?> child : children) {
private static MapEntryNode mapEntryNode(final String localName, final int keysNumber,
final DataContainerChild<?, ?>... children) {
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder =
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder =
Builders.mapEntryBuilder();
final Map<QName, Object> keys = new HashMap<>();
for (int i = 0; i < keysNumber; i++) {
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
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.builder.api.DataContainerNodeAttrBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
}
assertNotNull(rpcInputSchemaNode);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> container =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> container =
Builders.containerBuilder(rpcInputSchemaNode);
final QName contQName = QName.create(rpcModule.getQNameModule(), "cont");
final DataSchemaNode contSchemaNode = rpcInputSchemaNode.getDataChildByName(contQName);
assertTrue(contSchemaNode instanceof ContainerSchemaNode);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> contNode =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> contNode =
Builders.containerBuilder((ContainerSchemaNode) contSchemaNode);
final QName lfQName = QName.create(rpcModule.getQNameModule(), "lf");
assertNotNull(rpcDef);
assertNotNull(rpcInputSchemaNode);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> containerBuilder =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> containerBuilder =
Builders.containerBuilder(rpcInputSchemaNode);
final NormalizedNodeContext payload =
}
assertNotNull(rpcDef);
assertNotNull(rpcOutputSchemaNode);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> containerBuilder =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> containerBuilder =
Builders.containerBuilder(rpcOutputSchemaNode);
final DataSchemaNode leafSchema = rpcOutputSchemaNode
.getDataChildByName(QName.create(rpcModule.getQNameModule(), "textOut"));
assertTrue(leafSchema instanceof LeafSchemaNode);
- final NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>> leafBuilder =
+ final NormalizedNodeBuilder<NodeIdentifier, Object, LeafNode<Object>> leafBuilder =
Builders.leafBuilder((LeafSchemaNode) leafSchema);
leafBuilder.withValue("brm");
containerBuilder.withChild(leafBuilder.build());
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
public static NormalizedNode<?, ?> prepareNormalizedNodeWithIetfInterfacesInterfacesData() throws ParseException {
final String ietfInterfacesDate = "2013-07-04";
final String namespace = "urn:ietf:params:xml:ns:yang:ietf-interfaces";
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryNode =
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryNode =
ImmutableMapEntryNodeBuilder.create();
final Map<String, Object> predicates = new HashMap<>();
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.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
}
assertNotNull("RPC ContainerSchemaNode was not found!", rpcInputSchemaNode);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> container =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> container =
Builders.containerBuilder(rpcInputSchemaNode);
final QName pathQName =
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.slf4j.Logger;
// prepare node with value of location
final InstanceIdentifierContext<?> iid =
SubscribeToStreamUtil.prepareIIDSubsStreamOutput(this.handlersHolder.getSchemaHandler());
- final NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>> builder =
+ final NormalizedNodeBuilder<NodeIdentifier, Object, LeafNode<Object>> builder =
ImmutableLeafNodeBuilder.create().withValue(response.toString());
builder.withNodeIdentifier(
NodeIdentifier.create(QName.create("subscribe:to:notification", "2016-10-28", "location")));
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
final DataSchemaContextTree baseSchemaCtxTree = DataSchemaContextTree.from(ctx);
final DataSchemaNode baseSchemaNode = baseSchemaCtxTree.getChild(path).getDataSchemaNode();
if (result instanceof ContainerNode) {
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builder =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> builder =
Builders.containerBuilder((ContainerSchemaNode) baseSchemaNode);
buildCont(builder, (ContainerNode) result, baseSchemaCtxTree, path, trim);
return builder.build();
} else {
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder =
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder =
Builders.mapEntryBuilder((ListSchemaNode) baseSchemaNode);
buildMapEntryBuilder(builder, (MapEntryNode) result, baseSchemaCtxTree, path, trim,
((ListSchemaNode) baseSchemaNode).getKeyDefinition());
}
private static void buildMapEntryBuilder(
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder,
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder,
final MapEntryNode result, final DataSchemaContextTree baseSchemaCtxTree,
final YangInstanceIdentifier actualPath, final boolean trim, final List<QName> keys) {
for (final DataContainerChild<? extends PathArgument, ?> child : result.getValue()) {
final YangInstanceIdentifier path = actualPath.node(child.getIdentifier());
final DataSchemaNode childSchema = baseSchemaCtxTree.getChild(path).getDataSchemaNode();
if (child instanceof ContainerNode) {
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> childBuilder =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> childBuilder =
Builders.containerBuilder((ContainerSchemaNode) childSchema);
buildCont(childBuilder, (ContainerNode) child, baseSchemaCtxTree, path, trim);
builder.withChild(childBuilder.build());
} else if (child instanceof LeafNode) {
final Object defaultVal = ((LeafSchemaNode) childSchema).getType().getDefaultValue().orElse(null);
final Object nodeVal = child.getValue();
- final NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>> leafBuilder =
+ final NormalizedNodeBuilder<NodeIdentifier, Object, LeafNode<Object>> leafBuilder =
Builders.leafBuilder((LeafSchemaNode) childSchema);
if (keys.contains(child.getNodeType())) {
leafBuilder.withValue(((LeafNode) child).getValue());
for (final MapEntryNode mapEntryNode : result.getValue()) {
final YangInstanceIdentifier actualNode = path.node(mapEntryNode.getIdentifier());
final DataSchemaNode childSchema = baseSchemaCtxTree.getChild(actualNode).getDataSchemaNode();
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder =
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder =
Builders.mapEntryBuilder((ListSchemaNode) childSchema);
buildMapEntryBuilder(mapEntryBuilder, mapEntryNode, baseSchemaCtxTree, actualNode, trim, keys);
builder.withChild(mapEntryBuilder.build());
}
}
- private static void buildCont(final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builder,
+ private static void buildCont(final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> builder,
final ContainerNode result, final DataSchemaContextTree baseSchemaCtxTree,
final YangInstanceIdentifier actualPath, final boolean trim) {
for (final DataContainerChild<? extends PathArgument, ?> child : result.getValue()) {
final YangInstanceIdentifier path = actualPath.node(child.getIdentifier());
final DataSchemaNode childSchema = baseSchemaCtxTree.getChild(path).getDataSchemaNode();
if (child instanceof ContainerNode) {
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builderChild =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> builderChild =
Builders.containerBuilder((ContainerSchemaNode) childSchema);
buildCont(builderChild, result, baseSchemaCtxTree, actualPath, trim);
builder.withChild(builderChild.build());
} else if (child instanceof LeafNode) {
final Object defaultVal = ((LeafSchemaNode) childSchema).getType().getDefaultValue().orElse(null);
final Object nodeVal = child.getValue();
- final NormalizedNodeAttrBuilder<NodeIdentifier, Object, LeafNode<Object>> leafBuilder =
+ final NormalizedNodeBuilder<NodeIdentifier, Object, LeafNode<Object>> leafBuilder =
Builders.leafBuilder((LeafSchemaNode) childSchema);
if (trim) {
if (defaultVal == null || !defaultVal.equals(nodeVal)) {
return builder.build();
} else if (configDataNode instanceof ContainerNode) {
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> builder = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> builder = Builders
.containerBuilder().withNodeIdentifier(((ContainerNode) configDataNode).getIdentifier());
mapValueToBuilder(
((UnkeyedListNode) stateDataNode).getValue(), builder);
return builder.build();
} else if (configDataNode instanceof UnkeyedListEntryNode) {
- final DataContainerNodeAttrBuilder<NodeIdentifier, UnkeyedListEntryNode> builder = Builders
+ final DataContainerNodeBuilder<NodeIdentifier, UnkeyedListEntryNode> builder = Builders
.unkeyedListEntryBuilder().withNodeIdentifier(((UnkeyedListEntryNode) configDataNode).getIdentifier());
mapValueToBuilder(((UnkeyedListEntryNode) configDataNode).getValue(),
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
}
final ContainerSchemaNode fakeCont = new FakeContainerSchemaNode(fakeRpcSchema);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> containerBuilder =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> containerBuilder =
Builders.containerBuilder(fakeCont);
for (final LeafSchemaNode leaf : fakeRpcSchema) {
import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.ListNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
final SchemaContext context, final String moduleSetId) {
final DataSchemaNode modulesStateSch =
ietfYangLibraryModule.getDataChildByName(IetfYangLibrary.MODUELS_STATE_CONT_QNAME);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> modulesStateBuilder =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> modulesStateBuilder =
Builders.containerBuilder((ContainerSchemaNode) modulesStateSch);
final DataSchemaNode moduleSetIdSch =
private static void fillMapByModules(final CollectionNodeBuilder<MapEntryNode, OrderedMapNode> mapBuilder,
final DataSchemaNode moduleSch, final boolean isSubmodule, final Module module,
final Module ietfYangLibraryModule, final SchemaContext context) {
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder =
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder =
Builders.mapEntryBuilder((ListSchemaNode) moduleSch);
addCommonLeafs(module, mapEntryBuilder, ietfYangLibraryModule);
addChildOfModuleBySpecificModuleInternal(
* schema context
*/
private static void addSubmodules(final Module module,
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
final Module ietfYangLibraryModule, final SchemaContext context) {
final DataSchemaNode listSubm = findSchemaInListOfModulesSchema(
IetfYangLibrary.SPECIFIC_MODULE_SUBMODULE_LIST_QNAME, ietfYangLibraryModule);
* schema context
*/
private static void addDeviationList(final Module module,
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
final Module ietfYangLibraryModule, final SchemaContext context) {
final DataSchemaNode deviationsSchema = findSchemaInListOfModulesSchema(
IetfYangLibrary.SPECIFIC_MODULE_DEVIATION_LIST_QNAME, ietfYangLibraryModule);
final CollectionNodeBuilder<MapEntryNode, MapNode> deviations =
Builders.mapBuilder((ListSchemaNode) deviationsSchema);
for (final Deviation deviation : module.getDeviations()) {
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> deviationEntryNode =
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> deviationEntryNode =
Builders.mapEntryBuilder((ListSchemaNode) deviationsSchema);
final QName lastComponent = deviation.getTargetPath().getLastComponent();
addChildOfModuleBySpecificModule(IetfYangLibrary.SPECIFIC_MODULE_NAME_LEAF_QNAME, deviationEntryNode,
* ieat-yang-library module
*/
private static void addFeatureLeafList(final QName qnameOfFeaturesLeafList,
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
final Set<FeatureDefinition> features, final Module ietfYangLibraryModule) {
final DataSchemaNode schemaNode =
findSchemaInListOfModulesSchema(qnameOfFeaturesLeafList, ietfYangLibraryModule);
* ietf-yang-library module
*/
private static void addCommonLeafs(final Module module,
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
final Module ietfYangLibraryModule) {
addChildOfModuleBySpecificModuleInternal(IetfYangLibrary.SPECIFIC_MODULE_NAME_LEAF_QNAME, mapEntryBuilder,
module.getName(), ietfYangLibraryModule);
* ietf-yang-library module
*/
private static void addChildOfModuleBySpecificModuleOfListChild(final QName specificQName,
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
final Object value, final Module ietfYangLibraryModule) {
final DataSchemaNode leafSch = findSchemaInListOfModulesSchema(specificQName, ietfYangLibraryModule);
mapEntryBuilder.withChild(Builders.leafBuilder((LeafSchemaNode) leafSch).withValue(value).build());
* ietf-yang-library module
*/
private static void addChildOfModuleBySpecificModuleInternal(final QName specifiLeafQName,
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
final Object value, final Module ietfYangLibraryModule) {
final DataSchemaNode nameLeaf = findNodeInInternGroupings(specifiLeafQName, ietfYangLibraryModule);
mapEntryBuilder.withChild(Builders.leafBuilder((LeafSchemaNode) nameLeaf).withValue(value).build());
* ietf-yang-library module
*/
private static void addChildOfModuleBySpecificModule(final QName specifiLeafQName,
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryBuilder,
final Object value, final Module ietfYangLibraryModule) {
final DataSchemaNode nameLeaf = findNodeInGroupings(specifiLeafQName, ietfYangLibraryModule);
mapEntryBuilder.withChild(Builders.leafBuilder((LeafSchemaNode) nameLeaf).withValue(value).build());
mapCapabilites(final Module monitoringModule) {
final DataSchemaNode restconfState =
monitoringModule.getDataChildByName(MonitoringModule.CONT_RESTCONF_STATE_QNAME);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> restStateContBuilder =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> restStateContBuilder =
Builders.containerBuilder((ContainerSchemaNode) restconfState);
final DataSchemaNode capabilitesContSchema =
getChildOfCont((ContainerSchemaNode) restconfState, MonitoringModule.CONT_CAPABILITES_QNAME);
- final DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> capabilitesContBuilder =
+ final DataContainerNodeBuilder<NodeIdentifier, ContainerNode> capabilitesContBuilder =
Builders.containerBuilder((ContainerSchemaNode) capabilitesContSchema);
final DataSchemaNode leafListCapa = getChildOfCont((ContainerSchemaNode) capabilitesContSchema,
MonitoringModule.LEAF_LIST_CAPABILITY_QNAME);
.getDataChildByName(MonitoringModule.CONT_RESTCONF_STATE_QNAME))
.getDataChildByName(MonitoringModule.CONT_STREAMS_QNAME))
.getDataChildByName(MonitoringModule.LIST_STREAM_QNAME);
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> streamEntry =
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> streamEntry =
Builders.mapEntryBuilder((ListSchemaNode) streamListSchema);
final ListSchemaNode listSchema = (ListSchemaNode) streamListSchema;
}
private static void prepareListAndFillEntryBuilder(
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> streamEntry,
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> streamEntry,
final ListSchemaNode listSchemaNode, final String outputType, final URI uriToWebsocketServer) {
final CollectionNodeBuilder<MapEntryNode, MapNode> accessListBuilder = Builders.mapBuilder(listSchemaNode);
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> entryAccessList =
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> entryAccessList =
Builders.mapEntryBuilder(listSchemaNode);
prepareLeafAndFillEntryBuilder(entryAccessList,
listSchemaNode.getDataChildByName(MonitoringModule.LEAF_ENCODING_ACCESS_QNAME), outputType);
* @param value Value
*/
private static void prepareLeafAndFillEntryBuilder(
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> streamEntry,
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> streamEntry,
final DataSchemaNode leafSchema, final Object value) {
streamEntry.withChild(Builders.leafBuilder((LeafSchemaNode) leafSchema).withValue(value).build());
}
.getDataChildByName(MonitoringModule.CONT_RESTCONF_STATE_QNAME))
.getDataChildByName(MonitoringModule.CONT_STREAMS_QNAME))
.getDataChildByName(MonitoringModule.LIST_STREAM_QNAME);
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> streamEntry =
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> streamEntry =
Builders.mapEntryBuilder((ListSchemaNode) streamListSchema);
final ListSchemaNode listSchema = (ListSchemaNode) streamListSchema;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
public static NormalizedNode<?, ?> prepareNormalizedNodeWithIetfInterfacesInterfacesData() throws ParseException {
final String ietfInterfacesDate = "2013-07-04";
final String namespace = "urn:ietf:params:xml:ns:yang:ietf-interfaces";
- final DataContainerNodeAttrBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryNode =
+ final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> mapEntryNode =
ImmutableMapEntryNodeBuilder.create();
final Map<String, Object> predicates = new HashMap<>();
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
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.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
}
assertNotNull(rpcInputSchemaNode);
- final DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> container =
+ final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> container =
Builders.containerBuilder(rpcInputSchemaNode);
final QName lfQName = QName.create(rpcModule.getQNameModule(), inputOutputName);