*/
<T extends DataObject> @NonNull NormalizedResult toNormalizedNode(InstanceIdentifier<T> path, T data);
+ /**
+ * Translates supplied Binding Instance Identifier and data into NormalizedNode representation.
+ *
+ * @param path Binding Instance Identifier pointing to data
+ * @param data Data object representing data
+ * @return {@link NormalizedResult} representation
+ * @throws IllegalArgumentException If supplied Instance Identifier is not valid.
+ */
+ <A extends Augmentation<?>> @NonNull AugmentationResult toNormalizedAugmentation(InstanceIdentifier<A> path,
+ A data);
+
+ /**
+ * Translates supplied Binding Instance Identifier and data into NormalizedNode representation.
+ *
+ * @param path Binding Instance Identifier pointing to data
+ * @param data Data object representing data
+ * @return {@link NormalizedResult} representation
+ * @throws IllegalArgumentException If supplied Instance Identifier is not valid.
+ */
+ <T extends DataObject> @NonNull NodeResult toNormalizedDataObject(InstanceIdentifier<T> path, T data);
+
/**
* Translates supplied YANG Instance Identifier and NormalizedNode into Binding data.
*
return delegate().toNormalizedNode(path, data);
}
+ @Override
+ public <A extends Augmentation<?>> @NonNull AugmentationResult toNormalizedAugmentation(
+ final InstanceIdentifier<A> path, final A data) {
+ return delegate().toNormalizedAugmentation(path, data);
+ }
+
+ @Override
+ public <T extends DataObject> @NonNull NodeResult toNormalizedDataObject(final InstanceIdentifier<T> path,
+ final T data) {
+ return delegate().toNormalizedDataObject(path, data);
+ }
+
@Override
public ContainerNode toNormalizedNodeNotification(final Notification<?> data) {
return delegate().toNormalizedNodeNotification(data);
return instanceIdentifierCodec.toBinding(dom);
}
+ @Override
+ public <A extends Augmentation<?>> AugmentationResult toNormalizedAugmentation(final InstanceIdentifier<A> path,
+ final A data) {
+ final var result = toNormalizedNode(path, data);
+ if (result instanceof AugmentationResult augment) {
+ return augment;
+ }
+ throw new IllegalArgumentException(path + " does not identify an Augmentation");
+ }
+
+ @Override
+ public <T extends DataObject> NodeResult toNormalizedDataObject(final InstanceIdentifier<T> path, final T data) {
+ final var result = toNormalizedNode(path, data);
+ if (result instanceof NodeResult node) {
+ return node;
+ }
+ throw new IllegalArgumentException(path + " does not identify a plain DataObject");
+ }
+
@Override
public <T extends DataObject> NormalizedResult toNormalizedNode(final InstanceIdentifier<T> path, final T data) {
// We create Binding Stream Writer which translates from Binding to Normalized Nodes
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer.NodeResult;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@SuppressWarnings("unchecked")
protected <T extends DataObject> T thereAndBackAgain(final InstanceIdentifier<T> path, final T data) {
- final var there = (NodeResult) codecContext.toNormalizedNode(path, data);
+ final var there = codecContext.toNormalizedDataObject(path, data);
final var backAgain = codecContext.fromNormalizedNode(there.path(), there.node());
assertEquals(path, backAgain.getKey());
return (T) backAgain.getValue();
import java.util.Map.Entry;
import javax.xml.transform.dom.DOMSource;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer.NodeResult;
import org.opendaylight.yang.gen.v1.mdsal438.norev.Cont;
import org.opendaylight.yang.gen.v1.mdsal438.norev.ContBuilder;
import org.opendaylight.yang.gen.v1.mdsal438.norev.cont.ContAny;
@Test
public void testAnydataFromBinding() {
- final var entry = (NodeResult) codecContext.toNormalizedNode(
- InstanceIdentifier.create(Cont.class), new ContBuilder().setContAny(new FakeCont()).build());
+ final var entry = codecContext.toNormalizedDataObject(InstanceIdentifier.create(Cont.class),
+ new ContBuilder().setContAny(new FakeCont()).build());
assertEquals(YangInstanceIdentifier.of(CONT_NODE_ID), entry.path());
assertEquals(cont, entry.node());
}
import java.util.Map.Entry;
import javax.xml.transform.dom.DOMSource;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer.NodeResult;
import org.opendaylight.yang.gen.v1.mdsal437.norev.Cont;
import org.opendaylight.yang.gen.v1.mdsal437.norev.ContBuilder;
import org.opendaylight.yang.gen.v1.mdsal437.norev.cont.ContAny;
@Test
public void testAnyxmlFromBinding() {
- final var entry = (NodeResult) codecContext.toNormalizedNode(
- InstanceIdentifier.create(Cont.class), new ContBuilder().setContAny(new FakeCont()).build());
+ final var entry = codecContext.toNormalizedDataObject(InstanceIdentifier.create(Cont.class),
+ new ContBuilder().setContAny(new FakeCont()).build());
assertEquals(YangInstanceIdentifier.of(CONT_NODE_ID), entry.path());
assertEquals(cont, entry.node());
}
import static org.junit.Assert.assertEquals;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer.NodeResult;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.RpcComplexUsesAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.RpcComplexUsesAugmentBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeComplexUsesAugmentBuilder;
.withKey(TOP_FOO_KEY)
.addAugmentation(new TreeComplexUsesAugmentBuilder(createComplexData()).build())
.build();
- final var domTreeEntry = ((NodeResult) codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST, baTree)).node();
- final var domRpcEntry = ((NodeResult) codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST, baRpc)).node();
+ final var domTreeEntry = codecContext.toNormalizedDataObject(BA_TOP_LEVEL_LIST, baTree).node();
+ final var domRpcEntry = codecContext.toNormalizedDataObject(BA_TOP_LEVEL_LIST, baRpc).node();
assertEquals(domTreeEntry, domRpcEntry);
}
.addAugmentation(new TreeComplexUsesAugmentBuilder(createComplexData()).build())
.build();
- final var result = (NodeResult) codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST, manuallyConstructed);
+ final var result = codecContext.toNormalizedDataObject(BA_TOP_LEVEL_LIST, manuallyConstructed);
final TopLevelList deserialized =
(TopLevelList) codecContext.fromNormalizedNode(result.path(), result.node()).getValue();
assertEquals(manuallyConstructed, deserialized);
import static org.junit.Assert.assertNotEquals;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer.NodeResult;
import org.opendaylight.yang.gen.v1.odl.test.binary.key.rev160101.BinaryList;
import org.opendaylight.yang.gen.v1.odl.test.binary.key.rev160101.BinaryListBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
}
private BinaryList process(final BinaryList binaryList) {
- final var entry = (NodeResult) codecContext.toNormalizedNode(instanceIdentifier, binaryList);
+ final var entry = codecContext.toNormalizedDataObject(instanceIdentifier, binaryList);
return (BinaryList) codecContext.fromNormalizedNode(entry.path(), entry.node()).getValue();
}
}
import java.util.Collections;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer.NodeResult;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.RpcComplexUsesAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.RpcComplexUsesAugmentBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeComplexUsesAugment;
.withKey(CHOICE_FOO_KEY)
.setChoiceInChoiceList(new ComplexViaUsesBuilder(createComplexData()).build())
.build();
- final var domTreeEntry = ((NodeResult) codecContext.toNormalizedNode(BA_CHOICE_LIST, baTree)).node();
- final var domRpcEntry = ((NodeResult) codecContext.toNormalizedNode(BA_CHOICE_LIST, baRpc)).node();
+ final var domTreeEntry = codecContext.toNormalizedDataObject(BA_CHOICE_LIST, baTree).node();
+ final var domRpcEntry = codecContext.toNormalizedDataObject(BA_CHOICE_LIST, baRpc).node();
assertEquals(domTreeEntry, domRpcEntry);
}
import java.util.Map;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer.NodeResult;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.RpcComplexUsesAugment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.RpcComplexUsesAugmentBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.complex.from.grouping.ContainerWithUsesBuilder;
.withKey(TOP_FOO_KEY)
.setChoiceInList(new EmptyLeafBuilder().setEmptyType(Empty.value()).build())
.build();
- final var dom = (NodeResult) codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST,
- withEmptyCase);
+ final var dom = codecContext.toNormalizedDataObject(BA_TOP_LEVEL_LIST, withEmptyCase);
final var readed = codecContext.fromNormalizedNode(dom.path(), dom.node());
final ChoiceInList list = ((TopLevelList) readed.getValue()).getChoiceInList();
assertTrue(list instanceof EmptyLeaf);
import com.google.common.collect.ImmutableMap;
import java.util.Map.Entry;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer.NodeResult;
import org.opendaylight.yang.gen.v1.mdsal442.keydef.norev.Def;
import org.opendaylight.yang.gen.v1.mdsal442.keydef.norev.DefBuilder;
import org.opendaylight.yang.gen.v1.mdsal442.keydef.norev.grp.LstBuilder;
@Test
public void testFromBinding() {
- final var domDef = (NodeResult) codecContext.toNormalizedNode(DEF_IID, DEF);
+ final var domDef = codecContext.toNormalizedDataObject(DEF_IID, DEF);
Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(domDef.path(), domDef.node());
assertEquals(DEF_IID, entry.getKey());
final Def codecDef = (Def) entry.getValue();
- final var domUse = (NodeResult) codecContext.toNormalizedNode(USE_IID, USE);
+ final var domUse = codecContext.toNormalizedDataObject(USE_IID, USE);
entry = codecContext.fromNormalizedNode(domUse.path(), domUse.node());
assertEquals(USE_IID, entry.getKey());
final Use codecUse = (Use) entry.getValue();
Use copiedUse = new UseBuilder(DEF).build();
assertEquals(USE, copiedUse);
- assertEquals(domUse.node(), ((NodeResult) codecContext.toNormalizedNode(USE_IID, copiedUse)).node());
+ assertEquals(domUse.node(), codecContext.toNormalizedDataObject(USE_IID, copiedUse).node());
copiedUse = new UseBuilder(codecDef).build();
assertEquals(USE, copiedUse);
- assertEquals(domUse.node(), ((NodeResult) codecContext.toNormalizedNode(USE_IID, copiedUse)).node());
+ assertEquals(domUse.node(), codecContext.toNormalizedDataObject(USE_IID, copiedUse).node());
copiedUse = new UseBuilder(codecUse).build();
assertEquals(USE, copiedUse);
- assertEquals(domUse.node(), ((NodeResult) codecContext.toNormalizedNode(USE_IID, copiedUse)).node());
+ assertEquals(domUse.node(), codecContext.toNormalizedDataObject(USE_IID, copiedUse).node());
}
}
import static org.junit.Assert.assertEquals;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer.NodeResult;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.ThirdParty;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeComplexLeaves;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeComplexLeavesBuilder;
.setName("foo")
.addAugmentation(augment)
.build();
- final var dom = (NodeResult) codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST,
- list);
+ final var dom = codecContext.toNormalizedDataObject(BA_TOP_LEVEL_LIST, list);
final var readed = codecContext.fromNormalizedNode(dom.path(), dom.node());
final var readAugment = ((TopLevelList) readed.getValue()).augmentation(TreeComplexLeaves.class);
import static org.junit.Assert.assertNotNull;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer.NodeResult;
import org.opendaylight.yang.gen.v1.bug8449.rev170516.Cont;
import org.opendaylight.yang.gen.v1.bug8449.rev170516.Cont.Ref;
import org.opendaylight.yang.gen.v1.bug8449.rev170516.ContBuilder;
final InstanceIdentifier<Cont> BA_II_CONT = InstanceIdentifier.builder(Cont.class).build();
final Ref refVal = new Ref("myvalue");
final Cont data = new ContBuilder().setRef(refVal).build();
- final var normalizedNode = (NodeResult) codecContext.toNormalizedNode(BA_II_CONT, data);
+ final var normalizedNode = codecContext.toNormalizedDataObject(BA_II_CONT, data);
assertNotNull(normalizedNode);
final var fromNormalizedNode = codecContext.fromNormalizedNode(contYII, normalizedNode.node());
final InstanceIdentifier<ContInt32> BA_II_CONT = InstanceIdentifier.builder(ContInt32.class).build();
final RefUnionInt32 refVal = new RefUnionInt32(Uint32.valueOf(5));
final ContInt32 data = new ContInt32Builder().setRefUnionInt32(refVal).build();
- final var normalizedNode = (NodeResult) codecContext.toNormalizedNode(BA_II_CONT, data);
+ final var normalizedNode = codecContext.toNormalizedDataObject(BA_II_CONT, data);
assertNotNull(normalizedNode);
final var fromNormalizedNode = codecContext.fromNormalizedNode(contYII, normalizedNode.node());
import java.util.Set;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer.NodeResult;
import org.opendaylight.yang.gen.v1.mdsal668.norev.Foo;
import org.opendaylight.yang.gen.v1.mdsal668.norev.FooBuilder;
import org.opendaylight.yang.gen.v1.mdsal668.norev.bar.Bar;
.build())
.build())
.build(),
- ((NodeResult) codecContext.toNormalizedNode(FOO_IID,
- new FooBuilder().setBar(new BarBuilder().setBar(Set.of(FOO_IID)).build()).build())).node());
+ codecContext.toNormalizedDataObject(FOO_IID,
+ new FooBuilder().setBar(new BarBuilder().setBar(Set.of(FOO_IID)).build()).build()).node());
}
}
import java.util.Map.Entry;
import java.util.Set;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer.NodeResult;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TopChoiceAugment1Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TopChoiceAugment2Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.augment.rev140709.TreeComplexUsesAugment;
@Test
public void containerToNormalized() {
- final var entry = (NodeResult) codecContext.toNormalizedNode(InstanceIdentifier.create(Top.class), top());
+ final var entry = codecContext.toNormalizedDataObject(InstanceIdentifier.create(Top.class), top());
assertEquals(getEmptyTop(), entry.node());
}
getNormalizedTopWithChildren(leafNode(AGUMENT_STRING_Q, AUGMENT_STRING_VALUE));
final ContainerNode topNormalized = getEmptyTop();
- final Entry<InstanceIdentifier<?>, DataObject> entry = codecContext.fromNormalizedNode(BI_TOP_PATH,
- topNormalized);
- final Entry<InstanceIdentifier<?>, DataObject> entryWithAugments = codecContext.fromNormalizedNode(BI_TOP_PATH,
- topNormalizedWithAugments);
+ final var entry = codecContext.fromNormalizedNode(BI_TOP_PATH, topNormalized);
+ final var entryWithAugments = codecContext.fromNormalizedNode(BI_TOP_PATH, topNormalizedWithAugments);
// Equals on other with no augmentation should be false
assertNotEquals(top(), entryWithAugments.getValue());
final ContainerNode topNormalizedWithAugments = getNormalizedTopWithChildren(
leafNode(AGUMENT_STRING_Q, AUGMENT_STRING_VALUE),
leafNode(AUGMENT_INT_Q, AUGMENT_INT_VALUE));
- final Entry<InstanceIdentifier<?>, DataObject> entryWithAugments = codecContext.fromNormalizedNode(BI_TOP_PATH,
- topNormalizedWithAugments);
+ final var entryWithAugments = codecContext.fromNormalizedNode(BI_TOP_PATH, topNormalizedWithAugments);
Top topWithAugments = topWithAugments(Map.of(
Top1.class, new Top1Builder().setAugmentedString(AUGMENT_STRING_VALUE).build(),
Top2.class, new Top2Builder().setAugmentedInt(AUGMENT_INT_VALUE).build()));
@Test
public void listWithKeysToNormalized() {
- final var entry = (NodeResult) codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST,
- topLevelList(TOP_LEVEL_LIST_FOO_KEY));
+ final var entry = codecContext.toNormalizedDataObject(BA_TOP_LEVEL_LIST, topLevelList(TOP_LEVEL_LIST_FOO_KEY));
assertEquals(mapEntryBuilder()
.withNodeIdentifier(NodeIdentifierWithPredicates.of(TOP_LEVEL_LIST_QNAME, TOP_LEVEL_LIST_KEY_QNAME,
TOP_LEVEL_LIST_FOO_KEY_VALUE))
@Test
public void leafOnlyAugmentationToNormalized() {
- final var entry = (NodeResult) codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST,
+ final var entry = codecContext.toNormalizedDataObject(BA_TOP_LEVEL_LIST,
topLevelList(TOP_LEVEL_LIST_FOO_KEY,
new TreeLeafOnlyAugmentBuilder().setSimpleValue("simpleValue").build()));
assertEquals(mapEntryBuilder()
@Test
public void orderedleafListToNormalized() {
- final var entry = (NodeResult) codecContext.toNormalizedNode(InstanceIdentifier.create(Top.class),
+ final var entry = codecContext.toNormalizedDataObject(InstanceIdentifier.create(Top.class),
new TopBuilder().setTopLevelOrderedLeafList(List.of("foo")).build());
assertEquals(containerBuilder()
.withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
@Test
public void leafListToNormalized() {
- final var entry = (NodeResult) codecContext.toNormalizedNode(
+ final var entry = codecContext.toNormalizedDataObject(
InstanceIdentifier.create(Top.class), new TopBuilder().setTopLevelLeafList(Set.of("foo")).build());
assertEquals(containerBuilder()
.withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
@Test
public void choiceToNormalized() {
- final var entry = (NodeResult) codecContext.toNormalizedNode(InstanceIdentifier.create(ChoiceContainer.class),
+ final var entry = codecContext.toNormalizedDataObject(InstanceIdentifier.create(ChoiceContainer.class),
new ChoiceContainerBuilder()
.setIdentifier(new ExtendedBuilder()
.setExtendedId(new ExtendedIdBuilder().setId("identifier_value").build())
@Test
public void orderedLisToNormalized() {
- final var entry = (NodeResult) codecContext.toNormalizedNode(BA_TOP_LEVEL_LIST, new TopLevelListBuilder()
+ final var entry = codecContext.toNormalizedDataObject(BA_TOP_LEVEL_LIST, new TopLevelListBuilder()
.withKey(TOP_LEVEL_LIST_FOO_KEY)
.setNestedList(List.of(
new NestedListBuilder().withKey(new NestedListKey("foo")).build(),
).build()
).build();
- final var biResult = (NodeResult) codecContext.toNormalizedNode(InstanceIdentifier.create(Top.class), top);
+ final var biResult = codecContext.toNormalizedDataObject(InstanceIdentifier.create(Top.class), top);
final var topNormalized = containerBuilder()
.withNodeIdentifier(new NodeIdentifier(TOP_QNAME))
import java.util.Set;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer.NodeResult;
import org.opendaylight.yang.gen.v1.mdsal426.norev.BarCont;
import org.opendaylight.yang.gen.v1.mdsal426.norev.BarContBuilder;
import org.opendaylight.yang.gen.v1.mdsal426.norev.BooleanCont;
public void specifiedBooleanLeafTest() {
final BooleanCont booleanCont = new BooleanContBuilder().setIsFoo(true).build();
- final var res = (NodeResult) codecContext.toNormalizedNode(BOOLEAN_CONT_II, booleanCont);
+ final var res = codecContext.toNormalizedDataObject(BOOLEAN_CONT_II, booleanCont);
final var booleanContBinding = (BooleanCont) codecContext.fromNormalizedNode(res.path(), res.node()).getValue();
public void specifiedCommonLeafTest() {
final BarCont barCont = new BarContBuilder().setLeaf2("foo").build();
- final var res = (NodeResult) codecContext.toNormalizedNode(BAR_CONT_II, barCont);
+ final var res = codecContext.toNormalizedDataObject(BAR_CONT_II, barCont);
final var booleanContBinding = (BarCont) codecContext.fromNormalizedNode(res.path(), res.node()).getValue();
final Set<String> testSet = Set.of("test");
final BarCont barCont = new BarContBuilder().setLeafList1(testSet).build();
- final var res = (NodeResult) codecContext.toNormalizedNode(BAR_CONT_II, barCont);
+ final var res = codecContext.toNormalizedDataObject(BAR_CONT_II, barCont);
final var barContAfterConverting = (BarCont) codecContext.fromNormalizedNode(res.path(), res.node()).getValue();
import static org.junit.Assert.assertEquals;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer.NodeResult;
import org.opendaylight.yang.gen.v1.bug8903.rev170829.DefaultPolicy;
import org.opendaylight.yang.gen.v1.bug8903.rev170829.DefaultPolicyBuilder;
import org.opendaylight.yang.gen.v1.bug8903.rev170829.PolicyLoggingFlag;
.setAction2(new PolicyLoggingFlag(false))
.setAction3(true)
.build();
- final var dom = (NodeResult) codecContext.toNormalizedNode(BA_DEFAULT_POLICY, binding);
+ final var dom = codecContext.toNormalizedDataObject(BA_DEFAULT_POLICY, binding);
final var readed = codecContext.fromNormalizedNode(dom.path(),dom.node());
assertEquals(binding, readed.getValue());
.setEmptyLeaf2(new TypedefEmpty(Empty.value()))
.setEmptyLeaf3(Empty.value())
.build();
- final var dom = (NodeResult) codecContext.toNormalizedNode(BA_TEST_CONT, binding);
+ final var dom = codecContext.toNormalizedDataObject(BA_TEST_CONT, binding);
final var readed = codecContext.fromNormalizedNode(dom.path(),dom.node());
assertEquals(binding, readed.getValue());
import java.util.Optional;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer.NodeResult;
import org.opendaylight.yang.gen.v1.urn.opendaylight.yang.union.test.rev220428.IdentOne;
import org.opendaylight.yang.gen.v1.urn.opendaylight.yang.union.test.rev220428.IdentTwo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.yang.union.test.rev220428.Top;
}
@Test
- public void fromNNToBindingTest() throws NoSuchFieldException {
+ public void fromNNToBindingTest() {
verifyIdentityWasTranslatedToBindingCorrectly(IDENTITY_ONE_QNAME, new UnionType(IdentOne.VALUE));
verifyIdentityWasTranslatedToBindingCorrectly(IDENTITY_TWO_QNAME, new UnionType(IdentTwo.VALUE));
}
// create binding instance with identity
final Top topContainer = new TopBuilder().setTestUnionLeaf(chosenIdentity).build();
// translate via codec into NN
- final var translated = (NodeResult) codecContext.toNormalizedNode(InstanceIdentifier.builder(Top.class).build(),
+ final var translated = codecContext.toNormalizedDataObject(InstanceIdentifier.builder(Top.class).build(),
topContainer);
assertNotNull(translated);
// verify translation worked