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.MapNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.SystemMapNode;
-import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
+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.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.tree.api.CursorAwareDataTreeModification;
import org.opendaylight.yangtools.yang.data.tree.api.DataTree;
import org.opendaylight.yangtools.yang.data.tree.api.DataTreeConfiguration;
private static final MapNode TEN_ITEM_INNER_LIST = initInnerListItems(10);
private static MapNode initInnerListItems(final int count) {
- final CollectionNodeBuilder<MapEntryNode, SystemMapNode> mapEntryBuilder = ImmutableNodes
- .mapNodeBuilder(BenchmarkModel.INNER_LIST);
+ final var mapEntryBuilder = ImmutableNodes.mapNodeBuilder(BenchmarkModel.INNER_LIST);
for (int i = 0; i < count; ++i) {
mapEntryBuilder
return mapEntryBuilder.build();
}
- private static final NormalizedNode[] OUTER_LIST_ONE_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_100K,
+ private static final MapEntryNode[] OUTER_LIST_ONE_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_100K,
ONE_ITEM_INNER_LIST);
- private static final NormalizedNode[] OUTER_LIST_TWO_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_50K,
+ private static final MapEntryNode[] OUTER_LIST_TWO_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_50K,
TWO_ITEM_INNER_LIST);
- private static final NormalizedNode[] OUTER_LIST_TEN_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_10K,
+ private static final MapEntryNode[] OUTER_LIST_TEN_ITEM_INNER_LIST = initOuterListItems(OUTER_LIST_10K,
TEN_ITEM_INNER_LIST);
- private static NormalizedNode[] initOuterListItems(final int outerListItemsCount, final MapNode innerList) {
- return Arrays.stream(OUTER_LIST_IDS).limit(outerListItemsCount)
- .map(id -> ImmutableNodes.mapEntryBuilder().withNodeIdentifier(id).withChild(innerList).build())
- .collect(Collectors.toList()).toArray(new NormalizedNode[0]);
+ private static MapEntryNode[] initOuterListItems(final int outerListItemsCount, final MapNode innerList) {
+ return Arrays.stream(OUTER_LIST_IDS)
+ .limit(outerListItemsCount)
+ .map(id -> ImmutableNodes.mapEntryBuilder().withNodeIdentifier(id).withChild(innerList).build())
+ .toArray(MapEntryNode[]::new);
}
private DataTree datastore;
BenchmarkModel.createTestContext());
final DataTreeModification modification = begin();
- modification.write(BenchmarkModel.TEST_PATH, ImmutableContainerNodeBuilder.create()
- .withNodeIdentifier(BenchmarkModel.TEST).withChild(EMPTY_OUTER_LIST).build());
+ modification.write(BenchmarkModel.TEST_PATH, Builders.containerBuilder()
+ .withNodeIdentifier(BenchmarkModel.TEST)
+ .withChild(EMPTY_OUTER_LIST)
+ .build());
commit(modification);
}
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
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.LeafSetEntryNode;
-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.SystemMapNode;
-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.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.w3c.dom.Node;
@Test
public void testNormalizedNodeStreaming() throws IOException {
-
ByteArrayOutputStream bos = new ByteArrayOutputStream();
NormalizedNodeDataOutput nnout = version.newDataOutput(ByteStreams.newDataOutput(bos));
- NormalizedNode testContainer = createTestContainer();
+ ContainerNode testContainer = createTestContainer();
nnout.writeNormalizedNode(testContainer);
QName toaster = QName.create("http://netconfcentral.org/ns/toaster","2009-11-20","toaster");
assertEquals(toasterContainer, nnin.readNormalizedNode());
}
- private NormalizedNode createTestContainer() {
- byte[] bytes1 = {1, 2, 3};
- LeafSetEntryNode<Object> entry1 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
- new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes1)).withValue(bytes1).build();
-
- byte[] bytes2 = {};
- LeafSetEntryNode<Object> entry2 = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
- new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes2)).withValue(bytes2).build();
+ private ContainerNode createTestContainer() {
+ final byte[] bytes1 = {1, 2, 3};
+ final byte[] bytes2 = {};
return TestModel.createBaseTestContainerBuilder(uint64)
- .withChild(ImmutableLeafSetNodeBuilder.create().withNodeIdentifier(
- new NodeIdentifier(TestModel.BINARY_LEAF_LIST_QNAME))
- .withChild(entry1).withChild(entry2).build())
- .withChild(ImmutableNodes.leafNode(TestModel.SOME_BINARY_DATA_QNAME, new byte[]{1, 2, 3, 4}))
- .withChild(ImmutableNodes.leafNode(TestModel.EMPTY_QNAME, Empty.value()))
- .withChild(Builders.orderedMapBuilder()
- .withNodeIdentifier(new NodeIdentifier(TestModel.ORDERED_LIST_QNAME))
- .withChild(ImmutableNodes.mapEntry(TestModel.ORDERED_LIST_ENTRY_QNAME,
- TestModel.ID_QNAME, 11)).build()).build();
+ .withChild(Builders.leafSetBuilder()
+ .withNodeIdentifier(new NodeIdentifier(TestModel.BINARY_LEAF_LIST_QNAME))
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes1))
+ .withValue(bytes1)
+ .build())
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(new NodeWithValue<>(TestModel.BINARY_LEAF_LIST_QNAME, bytes2))
+ .withValue(bytes2)
+ .build())
+ .build())
+ .withChild(ImmutableNodes.leafNode(TestModel.SOME_BINARY_DATA_QNAME, new byte[]{1, 2, 3, 4}))
+ .withChild(ImmutableNodes.leafNode(TestModel.EMPTY_QNAME, Empty.value()))
+ .withChild(Builders.orderedMapBuilder()
+ .withNodeIdentifier(new NodeIdentifier(TestModel.ORDERED_LIST_QNAME))
+ .withChild(ImmutableNodes.mapEntry(TestModel.ORDERED_LIST_ENTRY_QNAME, TestModel.ID_QNAME, 11))
+ .build())
+ .build();
}
@Test
assertEquals("http://www.w3.org/TR/html4/", xmlNode.getNamespaceURI());
- NormalizedNode anyXmlContainer = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME)).withChild(
- Builders.anyXmlBuilder().withNodeIdentifier(new NodeIdentifier(TestModel.ANY_XML_QNAME))
- .withValue(new DOMSource(xmlNode)).build()).build();
+ ContainerNode anyXmlContainer = Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
+ .withChild(Builders.anyXmlBuilder()
+ .withNodeIdentifier(new NodeIdentifier(TestModel.ANY_XML_QNAME))
+ .withValue(new DOMSource(xmlNode))
+ .build())
+ .build();
ByteArrayOutputStream bos = new ByteArrayOutputStream();
NormalizedNodeDataOutput nnout = version.newDataOutput(ByteStreams.newDataOutput(bos));
*/
@Test
public void testHugeEntries() throws IOException {
- final CollectionNodeBuilder<MapEntryNode, SystemMapNode> mapBuilder = Builders.mapBuilder()
- .withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME));
- final DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> entryBuilder =
- Builders.mapEntryBuilder().withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, (byte) 42));
+ final var mapBuilder = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME));
+ final var entryBuilder = Builders.mapEntryBuilder()
+ .withChild(ImmutableNodes.leafNode(TestModel.DESC_QNAME, (byte) 42));
for (int i = 0; i < 100_000; ++i) {
final String key = "xyzzy" + i;
*/
package org.opendaylight.yangtools.yang.data.codec.binfmt;
+import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.leafNode;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntry;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntryBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import org.opendaylight.yangtools.yang.common.Decimal64;
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.YangInstanceIdentifier.NodeWithValue;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
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.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.api.schema.SystemLeafSetNode;
-import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.data.api.schema.builder.NormalizedNodeBuilder;
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.impl.ImmutableContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder;
public final class TestModel {
-
static final QName TEST_QNAME = QName.create(
"urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test",
"2014-03-13", "test");
-
static final QName AUG_NAME_QNAME = QName.create(
"urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:aug",
"2014-03-13", "name");
-
private static final QName AUG_CONT_QNAME = QName.create(
"urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:aug",
"2014-03-13", "cont");
-
static final QName DESC_QNAME = QName.create(TEST_QNAME, "desc");
static final QName SOME_BINARY_DATA_QNAME = QName.create(TEST_QNAME, "some-binary-data");
static final QName BINARY_LEAF_LIST_QNAME = QName.create(TEST_QNAME, "binary_leaf_list");
// Family specific constants
private static final QName FAMILY_QNAME = QName.create(
"urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:notification-test", "2014-04-17", "family");
- private static final QName CHILDREN_QNAME = QName.create(FAMILY_QNAME, "children");
static final QName CHILD_NUMBER_QNAME = QName.create(FAMILY_QNAME, "child-number");
static final QName CHILD_NAME_QNAME = QName.create(FAMILY_QNAME, "child-name");
- private static final String FIRST_CHILD_NAME = "first child";
-
- private static final MapEntryNode BAR_NODE = mapEntryBuilder(
- OUTER_LIST_QNAME, ID_QNAME, TWO_ID)
- .withChild(mapNodeBuilder(INNER_LIST_QNAME)
- .withChild(mapEntry(INNER_LIST_QNAME, NAME_QNAME, TWO_ONE_NAME))
- .withChild(mapEntry(INNER_LIST_QNAME, NAME_QNAME, TWO_TWO_NAME))
- .build())
- .build();
+ private static final MapEntryNode BAR_NODE = mapEntryBuilder(OUTER_LIST_QNAME, ID_QNAME, TWO_ID)
+ .withChild(mapNodeBuilder(INNER_LIST_QNAME)
+ .withChild(mapEntry(INNER_LIST_QNAME, NAME_QNAME, TWO_ONE_NAME))
+ .withChild(mapEntry(INNER_LIST_QNAME, NAME_QNAME, TWO_TWO_NAME))
+ .build())
+ .build();
private TestModel() {
throw new UnsupportedOperationException();
public static DataContainerNodeBuilder<NodeIdentifier, ContainerNode> createBaseTestContainerBuilder(
final Function<String, Number> uint64) {
- // Create a list of shoes
- // This is to test leaf list entry
- final LeafSetEntryNode<Object> nike = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
- new NodeWithValue<>(SHOE_QNAME, "nike")).withValue("nike").build();
-
- final LeafSetEntryNode<Object> puma = ImmutableLeafSetEntryNodeBuilder.create().withNodeIdentifier(
- new NodeWithValue<>(SHOE_QNAME, "puma")).withValue("puma").build();
-
- final SystemLeafSetNode<Object> shoes = ImmutableLeafSetNodeBuilder.create().withNodeIdentifier(
- new NodeIdentifier(SHOE_QNAME)).withChild(nike).withChild(puma).build();
-
- // Test a leaf-list where each entry contains an identity
- final LeafSetEntryNode<Object> cap1 =
- ImmutableLeafSetEntryNodeBuilder
- .create()
- .withNodeIdentifier(
- new NodeWithValue<>(QName.create(
- TEST_QNAME, "capability"), DESC_QNAME))
- .withValue(DESC_QNAME).build();
-
- final SystemLeafSetNode<Object> capabilities =
- ImmutableLeafSetNodeBuilder
- .create()
- .withNodeIdentifier(
- new NodeIdentifier(QName.create(
- TEST_QNAME, "capability"))).withChild(cap1).build();
-
- ContainerNode switchFeatures =
- ImmutableContainerNodeBuilder
- .create()
- .withNodeIdentifier(
- new NodeIdentifier(SWITCH_FEATURES_QNAME))
- .withChild(capabilities).build();
-
- // Create a leaf list with numbers
- final LeafSetEntryNode<Object> five =
- ImmutableLeafSetEntryNodeBuilder
- .create()
- .withNodeIdentifier(
- new NodeWithValue<>(QName.create(
- TEST_QNAME, "number"), 5)).withValue(5).build();
- final LeafSetEntryNode<Object> fifteen =
- ImmutableLeafSetEntryNodeBuilder
- .create()
- .withNodeIdentifier(
- new NodeWithValue<>(QName.create(
- TEST_QNAME, "number"), 15)).withValue(15).build();
- final SystemLeafSetNode<Object> numbers =
- ImmutableLeafSetNodeBuilder
- .create()
- .withNodeIdentifier(
- new NodeIdentifier(QName.create(
- TEST_QNAME, "number"))).withChild(five).withChild(fifteen)
- .build();
-
-
- // Create augmentations
- MapEntryNode augMapEntry = createAugmentedListEntry(1, "First Test");
-
- // Create a bits leaf
- NormalizedNodeBuilder<NodeIdentifier, Object, LeafNode<Object>>
- myBits = Builders.leafBuilder()
- .withNodeIdentifier(new NodeIdentifier(QName.create(TEST_QNAME, "my-bits")))
- .withValue(ImmutableSet.of("foo", "bar"));
-
- // Create unkeyed list entry
- UnkeyedListEntryNode unkeyedListEntry =
- Builders.unkeyedListEntryBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(
- UNKEYED_LIST_QNAME)).withChild(ImmutableNodes.leafNode(NAME_QNAME, "unkeyed-entry-name")).build();
-
- // Create YangInstanceIdentifier with all path arg types.
- YangInstanceIdentifier instanceID = YangInstanceIdentifier.create(
- new NodeIdentifier(QName.create(TEST_QNAME, "qname")),
- NodeIdentifierWithPredicates.of(QName.create(TEST_QNAME, "list-entry"),
+ // Create the document
+ return Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(TEST_QNAME))
+ // Create a bits leaf
+ .withChild(leafNode(QName.create(TEST_QNAME, "my-bits"), ImmutableSet.of("foo", "bar")))
+ .withChild(leafNode(DESC_QNAME, DESC))
+ .withChild(leafNode(BOOLEAN_LEAF_QNAME, ENABLED))
+ .withChild(leafNode(SHORT_LEAF_QNAME, SHORT_ID))
+ .withChild(leafNode(BYTE_LEAF_QNAME, BYTE_ID))
+ .withChild(leafNode(TestModel.BIGINTEGER_LEAF_QNAME, uint64.apply("100")))
+ .withChild(leafNode(TestModel.BIGDECIMAL_LEAF_QNAME, Decimal64.valueOf("1.2")))
+ .withChild(leafNode(SOME_REF_QNAME,
+ // Create YangInstanceIdentifier with all path arg types.
+ YangInstanceIdentifier.create(new NodeIdentifier(QName.create(TEST_QNAME, "qname")),
+ NodeIdentifierWithPredicates.of(QName.create(TEST_QNAME, "list-entry"),
QName.create(TEST_QNAME, "key"), 10),
- new AugmentationIdentifier(ImmutableSet.of(
+ new AugmentationIdentifier(ImmutableSet.of(
QName.create(TEST_QNAME, "aug1"), QName.create(TEST_QNAME, "aug2"))),
- new NodeWithValue<>(QName.create(TEST_QNAME, "leaf-list-entry"), "foo"));
-
- Map<QName, Object> keyValues = new HashMap<>();
- keyValues.put(CHILDREN_QNAME, FIRST_CHILD_NAME);
-
-
- // Create the document
- return ImmutableContainerNodeBuilder
- .create()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME))
- .withChild(myBits.build())
- .withChild(ImmutableNodes.leafNode(DESC_QNAME, DESC))
- .withChild(ImmutableNodes.leafNode(BOOLEAN_LEAF_QNAME, ENABLED))
- .withChild(ImmutableNodes.leafNode(SHORT_LEAF_QNAME, SHORT_ID))
- .withChild(ImmutableNodes.leafNode(BYTE_LEAF_QNAME, BYTE_ID))
- .withChild(ImmutableNodes.leafNode(TestModel.BIGINTEGER_LEAF_QNAME, uint64.apply("100")))
- .withChild(ImmutableNodes.leafNode(TestModel.BIGDECIMAL_LEAF_QNAME, Decimal64.valueOf("1.2")))
- .withChild(ImmutableNodes.leafNode(SOME_REF_QNAME, instanceID))
- .withChild(ImmutableNodes.leafNode(MYIDENTITY_QNAME, DESC_QNAME))
- .withChild(Builders.unkeyedListBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(UNKEYED_LIST_QNAME))
- .withChild(unkeyedListEntry).build())
- .withChild(Builders.choiceBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TWO_THREE_QNAME))
- .withChild(ImmutableNodes.leafNode(TWO_QNAME, "two")).build())
- .withChild(Builders.orderedMapBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(ORDERED_LIST_QNAME))
- .withValue(ImmutableList.<MapEntryNode>builder().add(
- mapEntryBuilder(ORDERED_LIST_QNAME, ORDERED_LIST_ENTRY_QNAME, "1").build(),
- mapEntryBuilder(ORDERED_LIST_QNAME, ORDERED_LIST_ENTRY_QNAME, "2").build()).build())
+ new NodeWithValue<>(QName.create(TEST_QNAME, "leaf-list-entry"), "foo"))))
+ .withChild(leafNode(MYIDENTITY_QNAME, DESC_QNAME))
+ .withChild(Builders.unkeyedListBuilder()
+ .withNodeIdentifier(new NodeIdentifier(UNKEYED_LIST_QNAME))
+ // Create unkeyed list entry
+ .withChild(Builders.unkeyedListEntryBuilder()
+ .withNodeIdentifier(new NodeIdentifier(UNKEYED_LIST_QNAME))
+ .withChild(leafNode(NAME_QNAME, "unkeyed-entry-name"))
+ .build())
+ .build())
+ .withChild(Builders.choiceBuilder()
+ .withNodeIdentifier(new NodeIdentifier(TWO_THREE_QNAME))
+ .withChild(leafNode(TWO_QNAME, "two"))
+ .build())
+ .withChild(Builders.orderedMapBuilder()
+ .withNodeIdentifier(new NodeIdentifier(ORDERED_LIST_QNAME))
+ .withChild(mapEntryBuilder(ORDERED_LIST_QNAME, ORDERED_LIST_ENTRY_QNAME, "1").build())
+ .withChild(mapEntryBuilder(ORDERED_LIST_QNAME, ORDERED_LIST_ENTRY_QNAME, "2").build())
+ .build())
+ // Create a list of shoes
+ .withChild(Builders.leafSetBuilder()
+ .withNodeIdentifier(new NodeIdentifier(SHOE_QNAME))
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(new NodeWithValue<>(SHOE_QNAME, "nike"))
+ .withValue("nike")
+ .build())
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(new NodeWithValue<>(SHOE_QNAME, "puma"))
+ .withValue("puma")
+ .build())
+ .build())
+ // Create a leaf list with numbers
+ .withChild(Builders.leafSetBuilder()
+ .withNodeIdentifier(new NodeIdentifier(QName.create(TEST_QNAME, "number")))
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(new NodeWithValue<>(QName.create(TEST_QNAME, "number"), 5))
+ .withValue(5)
+ .build())
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(new NodeWithValue<>(QName.create(TEST_QNAME, "number"), 15))
+ .withValue(15)
+ .build())
+ .build())
+ .withChild(Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(SWITCH_FEATURES_QNAME))
+ // Test a leaf-list where each entry contains an identity
+ .withChild(Builders.leafSetBuilder()
+ .withNodeIdentifier(new NodeIdentifier(QName.create(TEST_QNAME, "capability")))
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(new NodeWithValue<>(QName.create(TEST_QNAME, "capability"), DESC_QNAME))
+ .withValue(DESC_QNAME)
.build())
- .withChild(shoes)
- .withChild(numbers)
- .withChild(switchFeatures)
- .withChild(mapNodeBuilder(AUGMENTED_LIST_QNAME).withChild(augMapEntry).build())
- .withChild(mapNodeBuilder(OUTER_LIST_QNAME)
- .withChild(mapEntry(OUTER_LIST_QNAME, ID_QNAME, ONE_ID))
- .withChild(BAR_NODE).build()
- );
+ .build())
+ .build())
+ .withChild(mapNodeBuilder(AUGMENTED_LIST_QNAME)
+ // Create augmentations
+ .withChild(createAugmentedListEntry(1, "First Test"))
+ .build())
+ .withChild(mapNodeBuilder(OUTER_LIST_QNAME)
+ .withChild(mapEntry(OUTER_LIST_QNAME, ID_QNAME, ONE_ID))
+ .withChild(BAR_NODE)
+ .build());
}
static ContainerNode createTestContainer(final Function<String, Number> uint64) {
}
private static MapEntryNode createAugmentedListEntry(final int id, final String name) {
-
- Set<QName> childAugmentations = new HashSet<>();
- childAugmentations.add(AUG_CONT_QNAME);
-
- ContainerNode augCont =
- ImmutableContainerNodeBuilder
- .create()
- .withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifier(AUG_CONT_QNAME))
- .withChild(ImmutableNodes.leafNode(AUG_NAME_QNAME, name)).build();
-
-
- final YangInstanceIdentifier.AugmentationIdentifier augmentationIdentifier =
- new YangInstanceIdentifier.AugmentationIdentifier(childAugmentations);
-
- final AugmentationNode augmentationNode =
- Builders.augmentationBuilder()
- .withNodeIdentifier(augmentationIdentifier).withChild(augCont)
- .build();
-
- return ImmutableMapEntryNodeBuilder
- .create()
- .withNodeIdentifier(
- YangInstanceIdentifier.NodeIdentifierWithPredicates.of(
- AUGMENTED_LIST_QNAME, ID_QNAME, id))
- .withChild(ImmutableNodes.leafNode(ID_QNAME, id))
- .withChild(augmentationNode).build();
+ return Builders.mapEntryBuilder()
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(AUGMENTED_LIST_QNAME, ID_QNAME, id))
+ .withChild(leafNode(ID_QNAME, id))
+ .withChild(Builders.augmentationBuilder()
+ .withNodeIdentifier(new AugmentationIdentifier(Set.of(AUG_CONT_QNAME)))
+ .withChild(Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(AUG_CONT_QNAME))
+ .withChild(leafNode(AUG_NAME_QNAME, name))
+ .build())
+ .build())
+ .build();
}
}
import com.google.gson.JsonParser;
import java.io.File;
import java.io.FileReader;
-import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
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.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter;
+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.impl.ImmutableContainerNodeBuilder;
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;
@Test
public void test() throws Exception {
- final EffectiveModelContext schemaContext =
- YangParserTestUtils.parseYangResource("/bug7246/yang/rpc-test.yang");
- final ContainerNode inputStructure = ImmutableContainerNodeBuilder.create()
- .withNodeIdentifier(new NodeIdentifier(qN("my-name")))
- .withChild(ImmutableNodes.leafNode(new NodeIdentifier(qN("my-name")), "my-value")).build();
- final Writer writer = new StringWriter();
- final String jsonOutput = normalizedNodeToJsonStreamTransformation(schemaContext, writer, inputStructure,
+ final var schemaContext = YangParserTestUtils.parseYangResource("/bug7246/yang/rpc-test.yang");
+ final var inputStructure = Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(qN("my-name")))
+ .withChild(ImmutableNodes.leafNode(new NodeIdentifier(qN("my-name")), "my-value"))
+ .build();
+ final var writer = new StringWriter();
+ final var jsonOutput = normalizedNodeToJsonStreamTransformation(schemaContext, writer, inputStructure,
qN("my-name"), qN("input"));
assertEquals(JsonParser.parseReader(new FileReader(
}
private static String normalizedNodeToJsonStreamTransformation(final EffectiveModelContext schemaContext,
- final Writer writer, final NormalizedNode inputStructure, final QName... path) throws IOException {
- final NormalizedNodeStreamWriter jsonStream = JSONNormalizedNodeStreamWriter.createExclusiveWriter(
+ final Writer writer, final NormalizedNode inputStructure, final QName... path) throws Exception {
+ final var jsonStream = JSONNormalizedNodeStreamWriter.createExclusiveWriter(
JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02.getShared(schemaContext), Absolute.of(path),
XMLNamespace.of(NS), JsonWriterFactory.createJsonWriter(writer, 2));
- try (NormalizedNodeWriter nodeWriter = NormalizedNodeWriter.forStreamWriter(jsonStream)) {
+ try (var nodeWriter = NormalizedNodeWriter.forStreamWriter(jsonStream)) {
nodeWriter.write(inputStructure);
}
return writer.toString();
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.impl.ImmutableLeafNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.w3c.dom.Document;
static final NodeIdentifier CONT_ANY_NODEID = NodeIdentifier.create(CONT_ANY_QNAME);
static final NodeIdentifier CONT_LEAF_NODEID = NodeIdentifier.create(CONT_LEAF_QNAME);
- static final LeafNode<?> CONT_LEAF = ImmutableLeafNodeBuilder.create().withNodeIdentifier(CONT_LEAF_NODEID)
- .withValue("abc").build();
+ static final LeafNode<String> CONT_LEAF = ImmutableNodes.leafNode(CONT_LEAF_NODEID, "abc");
static EffectiveModelContext SCHEMA_CONTEXT;
* @return {@link InputStream}
*/
static InputStream loadResourcesAsInputStream(final String xmlPath) {
- return SchemalessXMLStreamNormalizedNodeStreamWriterTest.class
- .getResourceAsStream(xmlPath);
+ return SchemalessXMLStreamNormalizedNodeStreamWriterTest.class.getResourceAsStream(xmlPath);
}
/**
transformer.transform(source, result);
return result.getWriter().toString();
- } catch (IllegalArgumentException | TransformerFactoryConfigurationError | TransformerException e) {
+ } catch (TransformerFactoryConfigurationError | TransformerException e) {
throw new RuntimeException("Unable to serialize xml element " + xml, e);
}
}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
-import java.io.IOException;
import java.io.StringWriter;
-import java.net.URISyntaxException;
import java.util.Collection;
import javax.xml.stream.XMLOutputFactory;
-import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamWriter;
-import javax.xml.transform.TransformerException;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
import org.custommonkey.xmlunit.Diff;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.data.api.schema.AnydataNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedAnydata;
-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.api.schema.stream.NormalizedNodeWriter;
+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.NormalizedNodeResult;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableAnydataNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.util.ImmutableNormalizedAnydata;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.opendaylight.yangtools.yang.model.spi.DefaultSchemaTreeInference;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
import org.w3c.dom.Document;
-import org.xml.sax.SAXException;
@RunWith(Parameterized.class)
public class AnydataSerializeTest extends AbstractAnydataTest {
}
@Test
- public void testDOMAnydata() throws XMLStreamException, IOException {
+ public void testDOMAnydata() throws Exception {
final StringWriter writer = new StringWriter();
final XMLStreamWriter xmlStreamWriter = factory.createXMLStreamWriter(writer);
xmlStreamWriter, SCHEMA_CONTEXT);
final NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(
xmlNormalizedNodeStreamWriter);
- normalizedNodeWriter.write(ImmutableAnydataNodeBuilder.create(DOMSourceAnydata.class)
- .withNodeIdentifier(FOO_NODEID).withValue(toDOMSource("<bar xmlns=\"test-anydata\"/>")).build());
+ normalizedNodeWriter.write(Builders.anydataBuilder(DOMSourceAnydata.class)
+ .withNodeIdentifier(FOO_NODEID)
+ .withValue(toDOMSource("<bar xmlns=\"test-anydata\"/>"))
+ .build());
normalizedNodeWriter.flush();
final String serializedXml = writer.toString();
}
@Test
- public void testXmlParseAnydata()
- throws IOException, SAXException, XMLStreamException, URISyntaxException, TransformerException {
+ public void testXmlParseAnydata() throws Exception {
// deserialization
final XMLStreamReader reader
= UntrustedXML.createXMLStreamReader(loadResourcesAsInputStream("/test-anydata.xml"));
Inference.ofDataTreePath(SCHEMA_CONTEXT, FOO_QNAME));
xmlParser.parse(reader);
- final NormalizedNode transformedInput = result.getResult();
+ final var transformedInput = result.getResult();
assertThat(transformedInput, instanceOf(AnydataNode.class));
AnydataNode<?> anydataNode = (AnydataNode<?>) transformedInput;
}
@Test
- public void testAnydataLoadFromXML() throws IOException, SAXException, XMLStreamException, URISyntaxException {
+ public void testAnydataLoadFromXML() throws Exception {
// Load XML file
Document doc = loadXmlDocument("/test-anydata.xml");
final DOMSource domSource = new DOMSource(doc.getDocumentElement());
}
@Test
- public void testAnydataSerialization()
- throws IOException, SAXException, XMLStreamException, URISyntaxException, TransformerException {
+ public void testAnydataSerialization() throws Exception {
//Get XML Data.
Document doc = loadXmlDocument("/test-anydata.xml");
final DOMSource domSource = new DOMSource(doc.getDocumentElement());
xmlParser.flush();
//Get Result
- final NormalizedNode node = normalizedResult.getResult();
+ final var node = normalizedResult.getResult();
assertThat(node, instanceOf(AnydataNode.class));
final AnydataNode<?> anydataResult = (AnydataNode<?>) node;
}
@Test
- public void testSiblingSerialize() throws IOException, XMLStreamException {
+ public void testSiblingSerialize() throws Exception {
final StringWriter writer = new StringWriter();
final XMLStreamWriter xmlStreamWriter = factory.createXMLStreamWriter(writer);
xmlStreamWriter, SCHEMA_CONTEXT);
final NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(
xmlNormalizedNodeStreamWriter);
- normalizedNodeWriter.write(ImmutableContainerNodeBuilder.create().withNodeIdentifier(CONT_NODEID)
- .withChild(ImmutableAnydataNodeBuilder.create(DOMSourceAnydata.class).withNodeIdentifier(CONT_ANY_NODEID)
- .withValue(toDOMSource("<bar xmlns=\"test-anydata\"/>")).build())
+ normalizedNodeWriter.write(Builders.containerBuilder()
+ .withNodeIdentifier(CONT_NODEID)
+ .withChild(Builders.anydataBuilder(DOMSourceAnydata.class)
+ .withNodeIdentifier(CONT_ANY_NODEID)
+ .withValue(toDOMSource("<bar xmlns=\"test-anydata\"/>"))
+ .build())
.withChild(CONT_LEAF)
.build());
normalizedNodeWriter.flush();
}
@Test
- public void testNormalizedSerialize() throws IOException, XMLStreamException {
+ public void testNormalizedSerialize() throws Exception {
final StringWriter writer = new StringWriter();
final XMLStreamWriter xmlStreamWriter = factory.createXMLStreamWriter(writer);
xmlStreamWriter, SCHEMA_CONTEXT);
final NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(
xmlNormalizedNodeStreamWriter);
- normalizedNodeWriter.write(ImmutableContainerNodeBuilder.create()
+ normalizedNodeWriter.write(Builders.containerBuilder()
.withNodeIdentifier(CONT_NODEID)
- .withChild(ImmutableAnydataNodeBuilder.create(NormalizedAnydata.class)
+ .withChild(Builders.anydataBuilder(NormalizedAnydata.class)
.withNodeIdentifier(CONT_ANY_NODEID)
.withValue(new ImmutableNormalizedAnydata(
DefaultSchemaTreeInference.of(SCHEMA_CONTEXT, Absolute.of(CONT_QNAME)),
- ImmutableContainerNodeBuilder.create().withNodeIdentifier(CONT_NODEID).build()))
+ Builders.containerBuilder().withNodeIdentifier(CONT_NODEID).build()))
.build())
.build());
normalizedNodeWriter.flush();
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
-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.api.schema.stream.NormalizedNodeWriter;
+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.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.w3c.dom.Document;
}
private static ContainerNode createDocNode() {
- LeafNode<byte[]> ipAddress = ImmutableNodes.leafNode(IP_ADDRESS_QNAME, Base64.getDecoder().decode("fwAAAQ=="));
- ContainerNode root = ImmutableContainerNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(ROOT_QNAME))
- .withChild(ipAddress).build();
- return ImmutableContainerNodeBuilder.create().withNodeIdentifier(new NodeIdentifier(ROOT_QNAME)).withChild(root)
- .build();
+ return Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(ROOT_QNAME))
+ .withChild(Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(ROOT_QNAME))
+ .withChild(ImmutableNodes.leafNode(IP_ADDRESS_QNAME, Base64.getDecoder().decode("fwAAAQ==")))
+ .build())
+ .build();
}
private static DOMResult writeNormalizedNode(final ContainerNode normalized, final EffectiveModelContext context)
normalizedNodeStreamWriter = XMLStreamNormalizedNodeStreamWriter.create(writer, context);
normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(normalizedNodeStreamWriter);
- for (NormalizedNode child : normalized.body()) {
+ for (var child : normalized.body()) {
normalizedNodeWriter.write(child);
}
Code Review / yangtools.git / commitdiff