import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableList.Builder;
-import com.google.common.collect.Sets;
+import com.google.common.collect.ImmutableSet;
import java.io.DataInput;
import java.io.IOException;
import java.io.StringReader;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
}
private void streamAugmentation(final NormalizedNodeStreamWriter writer) throws IOException {
- final AugmentationIdentifier augIdentifier = readAugmentationIdentifier();
+ final var augIdentifier = readAugmentationIdentifier();
LOG.trace("Streaming augmentation node {}", augIdentifier);
- writer.startAugmentationNode(augIdentifier);
- commonStreamContainer(writer);
+ for (byte nodeType = input.readByte(); nodeType != LithiumNode.END_NODE; nodeType = input.readByte()) {
+ streamNormalizedNode(writer, nodeType);
+ }
}
private void streamChoice(final NormalizedNodeStreamWriter writer) throws IOException {
};
}
- private Set<QName> readQNameSet() throws IOException {
+ private ImmutableSet<QName> readQNameSet() throws IOException {
// Read the children count
final int count = input.readInt();
- final Set<QName> children = Sets.newHashSetWithExpectedSize(count);
+ final var children = ImmutableSet.<QName>builderWithExpectedSize(count);
for (int i = 0; i < count; i++) {
children.add(readQName());
}
- return children;
+ return children.build();
}
- abstract @NonNull AugmentationIdentifier readAugmentationIdentifier() throws IOException;
+ abstract @NonNull LegacyAugmentationIdentifier readAugmentationIdentifier() throws IOException;
abstract @NonNull NodeIdentifier readNodeIdentifier() throws IOException;
- final @NonNull AugmentationIdentifier defaultReadAugmentationIdentifier() throws IOException {
- return AugmentationIdentifier.create(readQNameSet());
+ final @NonNull LegacyAugmentationIdentifier defaultReadAugmentationIdentifier() throws IOException {
+ return new LegacyAugmentationIdentifier(readQNameSet());
}
private @NonNull NodeIdentifierWithPredicates readNormalizedNodeWithPredicates() throws IOException {
}
@Override
- public final PathArgument readPathArgument() throws IOException {
+ @Deprecated(since = "11.0.0", forRemoval = true)
+ public final Either<PathArgument, LegacyPathArgument> readLegacyPathArgument() throws IOException {
// read Type
int type = input.readByte();
return switch (type) {
- case LithiumPathArgument.AUGMENTATION_IDENTIFIER -> readAugmentationIdentifier();
- case LithiumPathArgument.NODE_IDENTIFIER -> readNodeIdentifier();
- case LithiumPathArgument.NODE_IDENTIFIER_WITH_PREDICATES -> readNormalizedNodeWithPredicates();
- case LithiumPathArgument.NODE_IDENTIFIER_WITH_VALUE -> new NodeWithValue<>(readQName(), readObject());
+ case LithiumPathArgument.AUGMENTATION_IDENTIFIER -> Either.ofSecond(readAugmentationIdentifier());
+ case LithiumPathArgument.NODE_IDENTIFIER -> Either.ofFirst(readNodeIdentifier());
+ case LithiumPathArgument.NODE_IDENTIFIER_WITH_PREDICATES ->
+ Either.ofFirst(readNormalizedNodeWithPredicates());
+ case LithiumPathArgument.NODE_IDENTIFIER_WITH_VALUE ->
+ Either.ofFirst(new NodeWithValue<>(readQName(), readObject()));
default -> throw new InvalidNormalizedNodeStreamException("Unexpected PathArgument type " + type);
};
}
-
- @Override
- @Deprecated(since = "11.0.0", forRemoval = true)
- public final Either<PathArgument, LegacyPathArgument> readLegacyPathArgument() throws IOException {
- return Either.ofFirst(readPathArgument());
- }
}
import org.opendaylight.yangtools.yang.common.Uint64;
import org.opendaylight.yangtools.yang.common.Uint8;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
private static final @NonNull Integer INT32_0 = 0;
private static final @NonNull Long INT64_0 = 0L;
private static final byte @NonNull[] BINARY_0 = new byte[0];
- private static final @NonNull AugmentationIdentifier EMPTY_AID = AugmentationIdentifier.create(ImmutableSet.of());
+ private static final @NonNull LegacyAugmentationIdentifier EMPTY_AID =
+ new LegacyAugmentationIdentifier(ImmutableSet.of());
- private final List<AugmentationIdentifier> codedAugments = new ArrayList<>();
+ private final List<LegacyAugmentationIdentifier> codedAugments = new ArrayList<>();
private final List<NodeIdentifier> codedNodeIdentifiers = new ArrayList<>();
private final List<QNameModule> codedModules = new ArrayList<>();
private final List<String> codedStrings = new ArrayList<>();
streamNormalizedNode(requireNonNull(writer), null, input.readByte());
}
- private void streamNormalizedNode(final NormalizedNodeStreamWriter writer, final PathArgument parent,
+ private void streamNormalizedNode(final NormalizedNodeStreamWriter writer, final Object parent,
final byte nodeHeader) throws IOException {
switch (nodeHeader & MagnesiumNode.TYPE_MASK) {
case MagnesiumNode.NODE_LEAF:
}
private void streamAugmentation(final NormalizedNodeStreamWriter writer, final byte nodeHeader) throws IOException {
- final AugmentationIdentifier augIdentifier = decodeAugmentationIdentifier(nodeHeader);
+ final var augIdentifier = decodeAugmentationIdentifier(nodeHeader);
LOG.trace("Streaming augmentation node {}", augIdentifier);
- writer.startAugmentationNode(augIdentifier);
- commonStreamContainer(writer, augIdentifier);
+ for (byte nodeType = input.readByte(); nodeType != MagnesiumNode.NODE_END; nodeType = input.readByte()) {
+ streamNormalizedNode(writer, augIdentifier, nodeType);
+ }
}
private void streamChoice(final NormalizedNodeStreamWriter writer, final byte nodeHeader) throws IOException {
commonStreamContainer(writer, identifier);
}
- private void streamLeaf(final NormalizedNodeStreamWriter writer, final PathArgument parent, final byte nodeHeader)
+ private void streamLeaf(final NormalizedNodeStreamWriter writer, final Object parent, final byte nodeHeader)
throws IOException {
final NodeIdentifier identifier = decodeNodeIdentifier(nodeHeader);
LOG.trace("Streaming leaf node {}", identifier);
commonStreamContainer(writer, identifier);
}
- private void streamLeafsetEntry(final NormalizedNodeStreamWriter writer, final PathArgument parent,
- final byte nodeHeader) throws IOException {
+ private void streamLeafsetEntry(final NormalizedNodeStreamWriter writer, final Object parent, final byte nodeHeader)
+ throws IOException {
final NodeIdentifier nodeId = decodeNodeIdentifier(nodeHeader, parent);
final Object value = readLeafValue();
final NodeWithValue<Object> leafIdentifier = new NodeWithValue<>(nodeId.getNodeType(), value);
commonStreamContainer(writer, identifier);
}
- private void streamListEntry(final NormalizedNodeStreamWriter writer, final PathArgument parent,
- final byte nodeHeader) throws IOException {
+ private void streamListEntry(final NormalizedNodeStreamWriter writer, final Object parent, final byte nodeHeader)
+ throws IOException {
final NodeIdentifier identifier = decodeNodeIdentifier(nodeHeader, parent);
LOG.trace("Streaming unkeyed list item node {}", identifier);
writer.startUnkeyedListItem(identifier, UNKNOWN_SIZE);
commonStreamContainer(writer, identifier);
}
- private void streamMapEntry(final NormalizedNodeStreamWriter writer, final PathArgument parent,
- final byte nodeHeader) throws IOException {
+ private void streamMapEntry(final NormalizedNodeStreamWriter writer, final Object parent, final byte nodeHeader)
+ throws IOException {
final NodeIdentifier nodeId = decodeNodeIdentifier(nodeHeader, parent);
final int size = switch (mask(nodeHeader, MagnesiumNode.PREDICATE_MASK)) {
return decodeNodeIdentifier(nodeHeader, null);
}
- private NodeIdentifier decodeNodeIdentifier(final byte nodeHeader, final PathArgument parent) throws IOException {
+ private NodeIdentifier decodeNodeIdentifier(final byte nodeHeader, final Object parent) throws IOException {
final int index;
switch (nodeHeader & MagnesiumNode.ADDR_MASK) {
case MagnesiumNode.ADDR_DEFINE:
}
}
- private AugmentationIdentifier decodeAugmentationIdentifier(final byte nodeHeader) throws IOException {
+ private LegacyAugmentationIdentifier decodeAugmentationIdentifier(final byte nodeHeader) throws IOException {
final int index;
switch (nodeHeader & MagnesiumNode.ADDR_MASK) {
case MagnesiumNode.ADDR_DEFINE:
public final Either<PathArgument, LegacyPathArgument> readLegacyPathArgument() throws IOException {
final byte header = input.readByte();
return switch (header & MagnesiumPathArgument.TYPE_MASK) {
- case MagnesiumPathArgument.AUGMENTATION_IDENTIFIER -> Either.ofFirst(readAugmentationIdentifier(header));
+ case MagnesiumPathArgument.AUGMENTATION_IDENTIFIER -> Either.ofSecond(readAugmentationIdentifier(header));
case MagnesiumPathArgument.NODE_IDENTIFIER -> {
verifyPathIdentifierOnly(header);
yield Either.ofFirst(readNodeIdentifier(header));
};
}
- private AugmentationIdentifier readAugmentationIdentifier() throws IOException {
- final AugmentationIdentifier result = readAugmentationIdentifier(input.readInt());
+ private @NonNull LegacyAugmentationIdentifier readAugmentationIdentifier() throws IOException {
+ final var result = readAugmentationIdentifier(input.readInt());
codedAugments.add(result);
return result;
}
- private @NonNull AugmentationIdentifier readAugmentationIdentifier(final byte header) throws IOException {
+ private @NonNull LegacyAugmentationIdentifier readAugmentationIdentifier(final byte header) throws IOException {
final byte count = mask(header, MagnesiumPathArgument.AID_COUNT_MASK);
return switch (count) {
case MagnesiumPathArgument.AID_COUNT_1B -> readAugmentationIdentifier(input.readUnsignedByte());
};
}
- private @NonNull AugmentationIdentifier readAugmentationIdentifier(final int size) throws IOException {
+ private @NonNull LegacyAugmentationIdentifier readAugmentationIdentifier(final int size) throws IOException {
if (size > 0) {
- final List<QName> qnames = new ArrayList<>(size);
+ final var qnames = ImmutableSet.<QName>builderWithExpectedSize(size);
for (int i = 0; i < size; ++i) {
qnames.add(readQName());
}
- return AugmentationIdentifier.create(ImmutableSet.copyOf(qnames));
+ return new LegacyAugmentationIdentifier(qnames.build());
} else if (size == 0) {
return EMPTY_AID;
} else {
import com.google.common.collect.ImmutableSet;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
/**
- * Representation of legacy {@link AugmentationIdentifier}.
+ * Representation of legacy {@code yang.data.api.YangInstanceIdentifier.AugmentationIdentifier}.
*/
@Deprecated(since = "11.0.0")
public record LegacyAugmentationIdentifier(@NonNull ImmutableSet<QName> childNames) implements LegacyPathArgument {
import java.io.DataInput;
import java.io.IOException;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
/**
}
@Override
- AugmentationIdentifier readAugmentationIdentifier() throws IOException {
+ LegacyAugmentationIdentifier readAugmentationIdentifier() throws IOException {
return defaultReadAugmentationIdentifier();
}
*/
package org.opendaylight.yangtools.yang.data.codec.binfmt;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
return NODE_IDENTIFIER;
} else if (pathArgument instanceof NodeIdentifierWithPredicates) {
return NODE_IDENTIFIER_WITH_PREDICATES;
- } else if (pathArgument instanceof AugmentationIdentifier) {
- return AUGMENTATION_IDENTIFIER;
} else if (pathArgument instanceof NodeWithValue) {
return NODE_IDENTIFIER_WITH_VALUE;
} else {
import org.opendaylight.yangtools.yang.common.Uint64;
import org.opendaylight.yangtools.yang.common.Uint8;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
private final Deque<Object> stack = new ArrayDeque<>();
// Coding maps
- private final Map<AugmentationIdentifier, Integer> aidCodeMap = new HashMap<>();
private final Map<QNameModule, Integer> moduleCodeMap = new HashMap<>();
private final Map<String, Integer> stringCodeMap = new HashMap<>();
private final Map<QName, Integer> qnameCodeMap = new HashMap<>();
startQNameNode(MagnesiumNode.NODE_CHOICE, name);
}
- @Override
- public void startAugmentationNode(final AugmentationIdentifier identifier) throws IOException {
- final Integer code = aidCodeMap.get(identifier);
- if (code == null) {
- aidCodeMap.put(identifier, aidCodeMap.size());
- output.writeByte(MagnesiumNode.NODE_AUGMENTATION | MagnesiumNode.ADDR_DEFINE);
- final Set<QName> qnames = identifier.getPossibleChildNames();
- output.writeInt(qnames.size());
- for (QName qname : qnames) {
- writeQNameInternal(qname);
- }
- } else {
- writeNodeType(MagnesiumNode.NODE_AUGMENTATION, code);
- }
- stack.push(identifier);
- }
-
@Override
public boolean startAnyxmlNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
if (DOMSource.class.isAssignableFrom(objectModel)) {
writeNodeIdentifier(nid);
} else if (pathArgument instanceof NodeIdentifierWithPredicates nip) {
writeNodeIdentifierWithPredicates(nip);
- } else if (pathArgument instanceof AugmentationIdentifier augid) {
- writeAugmentationIdentifier(augid);
} else if (pathArgument instanceof NodeWithValue<?> niv) {
writeNodeWithValue(niv);
} else {
}
}
- private void writeAugmentationIdentifier(final AugmentationIdentifier identifier) throws IOException {
- final Set<QName> qnames = identifier.getPossibleChildNames();
- final int size = qnames.size();
- if (size < 29) {
- output.writeByte(MagnesiumPathArgument.AUGMENTATION_IDENTIFIER
- | size << MagnesiumPathArgument.AID_COUNT_SHIFT);
- } else if (size < 256) {
- output.writeByte(MagnesiumPathArgument.AUGMENTATION_IDENTIFIER | MagnesiumPathArgument.AID_COUNT_1B);
- output.writeByte(size);
- } else if (size < 65536) {
- output.writeByte(MagnesiumPathArgument.AUGMENTATION_IDENTIFIER | MagnesiumPathArgument.AID_COUNT_2B);
- output.writeShort(size);
- } else {
- output.writeByte(MagnesiumPathArgument.AUGMENTATION_IDENTIFIER | MagnesiumPathArgument.AID_COUNT_4B);
- output.writeInt(size);
- }
-
- for (QName qname : qnames) {
- writeQNameInternal(qname);
- }
- }
-
private void writeNodeIdentifier(final NodeIdentifier identifier) throws IOException {
writePathArgumentQName(identifier.getNodeType(), MagnesiumPathArgument.NODE_IDENTIFIER);
}
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
/**
*/
final class NeonSR2NormalizedNodeInputStreamReader extends AbstractLithiumDataInput {
private final ArrayList<NodeIdentifier> codedNodeIdentifiers = new ArrayList<>();
- private final List<AugmentationIdentifier> codedAugments = new ArrayList<>();
+ private final List<LegacyAugmentationIdentifier> codedAugments = new ArrayList<>();
private final List<QNameModule> codedModules = new ArrayList<>();
private final List<QName> codedQNames = new ArrayList<>();
}
@Override
- AugmentationIdentifier readAugmentationIdentifier() throws IOException {
+ LegacyAugmentationIdentifier readAugmentationIdentifier() throws IOException {
final byte valueType = readByte();
return switch (valueType) {
case NeonSR2Tokens.IS_AUGMENT_CODE -> codedAugmentId(readInt());
return qname;
}
- private AugmentationIdentifier codedAugmentId(final int code) throws IOException {
+ private LegacyAugmentationIdentifier codedAugmentId(final int code) throws IOException {
return getCode("QName set", codedAugments, code);
}
- private AugmentationIdentifier rawAugmentId() throws IOException {
- final AugmentationIdentifier aid = defaultReadAugmentationIdentifier();
+ private LegacyAugmentationIdentifier rawAugmentId() throws IOException {
+ final var aid = defaultReadAugmentationIdentifier();
codedAugments.add(aid);
return aid;
}
if (legacy.isFirst()) {
return legacy.getFirst();
}
- throw new IOException(legacy.getSecond() + " does not have a representation");
+ throw new InvalidNormalizedNodeStreamException(legacy.getSecond() + " does not have a representation");
}
/**
+++ /dev/null
-/*
- * Copyright (c) 2019 PANTHEON.tech, s.r.o. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * 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.yangtools.yang.data.codec.binfmt;
-
-import com.google.common.collect.ImmutableSet;
-import java.util.Collections;
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
-
-@RunWith(Parameterized.class)
-public class AidSerializationTest extends AbstractSerializationTest {
- @Parameters(name = "{0}")
- public static Iterable<Object[]> data() {
- return Collections.singletonList(
- new Object[] { NormalizedNodeStreamVersion.MAGNESIUM, 4, 94, 332, 2_376, 716_618, 912_975 });
- }
-
- @Parameter(1)
- public int emptySize;
- @Parameter(2)
- public int oneSize;
- @Parameter(3)
- public int size29;
- @Parameter(4)
- public int size256;
- @Parameter(5)
- public int size65536;
- @Parameter(6)
- public int twiceSize65536;
-
- @Test
- public void testEmptyIdentifier() {
- assertSame(fillIdentifier(0), emptySize);
- }
-
- @Test
- public void testOneIdentifier() {
- assertEquals(fillIdentifier(1), oneSize);
- }
-
- @Test
- public void test29() {
- assertEquals(fillIdentifier(29), size29);
- }
-
- @Test
- public void test256() {
- assertEquals(fillIdentifier(256), size256);
- }
-
- @Test
- public void test65536() {
- final AugmentationIdentifier id = fillIdentifier(65536);
- assertEquals(id, size65536);
- assertEqualsTwice(id, twiceSize65536);
- }
-
- private static AugmentationIdentifier fillIdentifier(final int size) {
- final AugmentationIdentifier ret = AugmentationIdentifier.create(ImmutableSet.copyOf(generateQNames(size)));
- Assert.assertEquals(size, ret.getPossibleChildNames().size());
- return ret;
- }
-}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThrows;
-import com.google.common.collect.ImmutableSet;
import com.google.common.io.ByteStreams;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Serializable;
import java.io.StringReader;
import java.io.StringWriter;
-import java.util.ArrayList;
import java.util.Collections;
-import java.util.List;
import java.util.Optional;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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.YangInstanceIdentifier.PathArgument;
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;
@Parameters(name = "{0} {1}")
public static Iterable<Object[]> data() {
return Collections.singletonList(
- new Object[] { NormalizedNodeStreamVersion.MAGNESIUM, 1_049_618, 2_289_103, 139, 825, 103, 229, 99 });
+ new Object[] { NormalizedNodeStreamVersion.MAGNESIUM, 1_049_589, 2_289_103, 139, 796, 103, 229, 99 });
}
@Parameter(0)
assertEquals(expected, nnin.readNormalizedNode());
}
- @Test
- public void testAugmentationIdentifier() throws IOException {
- final List<QName> qnames = new ArrayList<>();
- for (int i = 0; i < 257; ++i) {
- qnames.add(QName.create(TestModel.TEST_QNAME, "a" + Integer.toHexString(i)));
- }
-
- for (int i = 0; i < qnames.size(); ++i) {
- assertAugmentationIdentifier(AugmentationIdentifier.create(ImmutableSet.copyOf(qnames.subList(0, i))));
- }
-
- for (int i = qnames.size(); i < 65536; ++i) {
- qnames.add(QName.create(TestModel.TEST_QNAME, "a" + Integer.toHexString(i)));
- }
- assertAugmentationIdentifier(AugmentationIdentifier.create(ImmutableSet.copyOf(qnames)));
- }
-
- private void assertAugmentationIdentifier(final AugmentationIdentifier expected) throws IOException {
- final ByteArrayOutputStream bos = new ByteArrayOutputStream();
- try (NormalizedNodeDataOutput nnout = version.newDataOutput(ByteStreams.newDataOutput(bos))) {
- nnout.writePathArgument(expected);
- }
-
- final byte[] bytes = bos.toByteArray();
-
- NormalizedNodeDataInput nnin = NormalizedNodeDataInput.newDataInput(ByteStreams.newDataInput(bytes));
- PathArgument arg = nnin.readPathArgument();
- assertEquals(expected, arg);
- }
-
private static <T extends Serializable> T clone(final T obj) {
final ByteArrayOutputStream baos = new ByteArrayOutputStream(512);
try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder;
import com.google.common.collect.ImmutableSet;
-import java.util.Set;
import org.opendaylight.yangtools.yang.common.Decimal64;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint64;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
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(
- QName.create(TEST_QNAME, "aug1"), QName.create(TEST_QNAME, "aug2"))),
new NodeWithValue<>(QName.create(TEST_QNAME, "leaf-list-entry"), "foo"))))
.withChild(leafNode(MYIDENTITY_QNAME, DESC_QNAME))
.withChild(Builders.unkeyedListBuilder()
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())
+ .withChild(Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(AUG_CONT_QNAME))
+ .withChild(leafNode(AUG_NAME_QNAME, name))
.build())
.build();
}
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.rfc8528.model.api.MountPointLabel;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
context = new JSONStreamWriterInvisibleContext(context);
}
- @Override
- public final void startAugmentationNode(final AugmentationIdentifier identifier) {
- tracker.startAugmentationNode(identifier);
- context = new JSONStreamWriterInvisibleContext(context);
- }
-
@Override
public final boolean startAnydataNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
if (NormalizedAnydata.class.isAssignableFrom(objectModel)) {
import static org.opendaylight.yangtools.yang.data.codec.gson.TestUtils.loadTextFile;
import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
.node(TOP_QNAME)
.node(FOOLIST_QNAME)
.node(NodeIdentifierWithPredicates.of(FOOLIST_QNAME, ImmutableMap.of(NAME_QNAME, "key-value")))
- .node(new AugmentationIdentifier(ImmutableSet.of(BARCONTAINER_QNAME)))
.node(BARCONTAINER_QNAME)
.node(QName.create(BARMOD, "bar-leaf"))
.build();
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThrows;
import static org.opendaylight.yangtools.yang.data.codec.gson.TestUtils.loadTextFile;
-import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.augmentationBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.choiceBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.containerBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.leafNode;
-import com.google.common.collect.ImmutableSet;
import com.google.gson.stream.JsonReader;
import java.io.IOException;
import java.io.StringReader;
import java.net.URISyntaxException;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
final var cont1Normalized = containerBuilder()
.withNodeIdentifier(new NodeIdentifier(CONT_1))
- .withChild(augmentationBuilder()
- .withNodeIdentifier(new AugmentationIdentifier(ImmutableSet.of(augmentChoice1QName)))
+ .withChild(choiceBuilder()
+ .withNodeIdentifier(new NodeIdentifier(augmentChoice1QName))
.withChild(choiceBuilder()
- .withNodeIdentifier(new NodeIdentifier(augmentChoice1QName))
- .withChild(augmentationBuilder()
- .withNodeIdentifier(new AugmentationIdentifier(ImmutableSet.of(augmentChoice2QName)))
- .withChild(choiceBuilder()
- .withNodeIdentifier(new NodeIdentifier(augmentChoice2QName))
- .withChild(containerBuilder()
- .withNodeIdentifier(new NodeIdentifier(containerQName))
- .withChild(leafNode(leafQName, "leaf-value"))
- .build())
- .build())
+ .withNodeIdentifier(new NodeIdentifier(augmentChoice2QName))
+ .withChild(containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(containerQName))
+ .withChild(leafNode(leafQName, "leaf-value"))
.build())
.build())
.build())
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
.withValue("lf17 value").build();
}
- private static AugmentationNode externalAugmentC11AWithLf15_11AndLf15_12Node() {
- return Builders.augmentationBuilder()
- .withNodeIdentifier(new AugmentationIdentifier(ImmutableSet.of(
- QName.create(COMPLEX_JSON_AUG, "lf15_11"),
- QName.create(COMPLEX_JSON_AUG, "lf15_12"))))
- .withChild(lf15_11NodeExternal())
- .withChild(lf15_12NodeExternal())
- .build();
- }
-
private static LeafNode<Object> lf15_12NodeExternal() {
return Builders.leafBuilder()
.withNodeIdentifier(new NodeIdentifier(QName.create(COMPLEX_JSON_AUG, "lf15_12")))
.withValue("lf13 value").build();
}
- private static AugmentationNode augmentC11AWithLf15_21Node() {
- return Builders.augmentationBuilder().withNodeIdentifier(
- new AugmentationIdentifier(ImmutableSet.of(QName.create(COMPLEX_JSON, "lf15_21"))))
- .withChild(lf15_21Node()).build();
- }
-
private static LeafNode<Object> lf15_21Node() {
return Builders.leafBuilder()
.withNodeIdentifier(new NodeIdentifier(QName.create(COMPLEX_JSON, "lf15_21")))
.withValue("lf15_21 value").build();
}
- private static AugmentationNode augmentC11AWithLf15_11AndLf15_12Node() {
- return Builders.augmentationBuilder()
- .withNodeIdentifier(new AugmentationIdentifier(ImmutableSet.of(
- QName.create(COMPLEX_JSON, "lf15_11"),
- QName.create(COMPLEX_JSON, "lf15_12"))))
- .withChild(lf15_11Node())
- .withChild(lf15_12Node())
- .build();
- }
-
private static LeafNode<Object> lf15_12Node() {
return Builders.leafBuilder()
.withNodeIdentifier(new NodeIdentifier(QName.create(COMPLEX_JSON, "lf15_12")))
.withValue(ImmutableSet.of("one", "two")).build();
}
- private static AugmentationNode lf12_1Node() {
- return Builders.augmentationBuilder()
- .withNodeIdentifier(new AugmentationIdentifier(ImmutableSet.of(
- QName.create(COMPLEX_JSON, "lf12_1"),
- QName.create(COMPLEX_JSON, "lf12_2"))))
- .withChild(Builders.leafBuilder()
- .withNodeIdentifier(new NodeIdentifier(QName.create(COMPLEX_JSON, "lf12_1")))
- .withValue("lf12 value").build())
- .build();
- }
-
private static SystemMapNode childLst11() {
return Builders.mapBuilder()
.withNodeIdentifier(new NodeIdentifier(QName.create(COMPLEX_JSON, "lst11")))
}
public static ContainerNode leafNodeViaAugmentationInContainer() {
- return cont1Node(lf12_1Node());
+ return cont1Node(Builders.leafBuilder()
+ .withNodeIdentifier(new NodeIdentifier(QName.create(COMPLEX_JSON, "lf12_1")))
+ .withValue("lf12 value")
+ .build());
}
public static ContainerNode choiceNodeInContainer() {
* choc11 contains lf13, lf15_11 and lf15_12 are added via external augmentation.
*/
public static ContainerNode caseNodeAugmentationInChoiceInContainer() {
- return cont1Node(choc11Node(augmentC11AWithLf15_11AndLf15_12Node(), lf13Node(), augmentC11AWithLf15_21Node()));
+ return cont1Node(choc11Node(lf15_11Node(), lf15_12Node(), lf13Node(), lf15_21Node()));
}
public static ContainerNode caseNodeExternalAugmentationInChoiceInContainer() {
- return cont1Node(choc11Node(lf13Node(), augmentC11AWithLf15_11AndLf15_12Node(),
- externalAugmentC11AWithLf15_11AndLf15_12Node()));
+ return cont1Node(choc11Node(lf13Node(), lf15_11Node(), lf15_12Node(),
+ lf15_11NodeExternal(), lf15_12NodeExternal()));
}
public static ContainerNode choiceNodeAugmentationInContainer() {
}
public static ContainerNode emptyContainerInContainer() {
- return cont1Node(Builders.augmentationBuilder()
- .withNodeIdentifier(new AugmentationIdentifier(ImmutableSet.of(QName.create(COMPLEX_JSON, "cont11"))))
- .withChild(Builders.containerBuilder()
- .withNodeIdentifier(new NodeIdentifier(QName.create(COMPLEX_JSON, "cont11")))
- .build())
- .build());
+ return cont1Node(Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(QName.create(COMPLEX_JSON, "cont11")))
+ .build());
}
}
import com.google.gson.stream.JsonReader;
import java.io.StringReader;
import java.util.Map;
-import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
final QName augmentChoice1 = QName.create(CONT_1, "augment-choice1");
assertEquals(YangInstanceIdentifier.create(
CONT_1_NODEID,
- AugmentationIdentifier.create(Set.of(augmentChoice1)),
new NodeIdentifier(augmentChoice1),
new NodeIdentifier(QName.create(CONT_1, "augment-choice2")),
new NodeIdentifier(QName.create(CONT_1, "case11-choice-case-container"))),
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.rfc7952.model.api.AnnotationSchemaNode;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
tracker.startChoiceNode(name);
}
- @Override
- public void startAugmentationNode(final AugmentationIdentifier identifier) {
- tracker.startAugmentationNode(identifier);
- }
-
@Override
public boolean startAnyxmlNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
if (DOMSource.class.isAssignableFrom(objectModel)) {
import javax.xml.stream.XMLStreamWriter;
import javax.xml.transform.dom.DOMSource;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
nodeTypeStack.push(NodeType.CHOICE);
}
- @Override
- public void startAugmentationNode(final AugmentationIdentifier identifier) throws IOException {
- nodeTypeStack.push(NodeType.AUGMENTATION);
- }
-
@Override
public boolean startAnyxmlNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
if (DOMSource.class.isAssignableFrom(objectModel)) {
import static java.util.Objects.requireNonNull;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.augmentationBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.choiceBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.Builders.containerBuilder;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.leafNode;
-import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.util.Arrays;
import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamWriter;
import javax.xml.transform.OutputKeys;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
final QName containerQName = QName.create(augmentChoice1QName, "case11-choice-case-container");
final QName leafQName = QName.create(augmentChoice1QName, "case11-choice-case-leaf");
- final AugmentationIdentifier aug1Id = new AugmentationIdentifier(ImmutableSet.of(augmentChoice1QName));
- final AugmentationIdentifier aug2Id = new AugmentationIdentifier(ImmutableSet.of(augmentChoice2QName));
final NodeIdentifier augmentChoice1Id = new NodeIdentifier(augmentChoice1QName);
final NodeIdentifier augmentChoice2Id = new NodeIdentifier(augmentChoice2QName);
final NodeIdentifier containerId = new NodeIdentifier(containerQName);
return containerBuilder().withNodeIdentifier(container)
- .withChild(augmentationBuilder().withNodeIdentifier(aug1Id)
- .withChild(choiceBuilder().withNodeIdentifier(augmentChoice1Id)
- .withChild(augmentationBuilder().withNodeIdentifier(aug2Id)
- .withChild(choiceBuilder().withNodeIdentifier(augmentChoice2Id)
- .withChild(containerBuilder().withNodeIdentifier(containerId)
- .withChild(leafNode(leafQName, "leaf-value"))
- .build())
- .build())
- .build())
- .build())
- .build()).build();
+ .withChild(choiceBuilder().withNodeIdentifier(augmentChoice1Id)
+ .withChild(choiceBuilder().withNodeIdentifier(augmentChoice2Id)
+ .withChild(containerBuilder().withNodeIdentifier(containerId)
+ .withChild(leafNode(leafQName, "leaf-value"))
+ .build())
+ .build())
+ .build())
+ .build();
}
private static ContainerNode withAttributes() {
Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("c3Leaf")).withValue("3").build())
.build());
- b.withChild(augmentationBuilder()
- .withNodeIdentifier(getAugmentIdentifier("augLeaf"))
- .withChild(
- Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("augLeaf")).withValue("augment")
- .build()).build());
+ b.withChild(Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("augLeaf")).withValue("augment")
+ .build());
- b.withChild(augmentationBuilder()
- .withNodeIdentifier(getAugmentIdentifier("ch"))
- .withChild(
- choiceBuilder()
- .withNodeIdentifier(getNodeIdentifier("ch"))
- .withChild(
- Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("c1Leaf"))
- .withValue("1").build())
- .withChild(
- augmentationBuilder()
- .withNodeIdentifier(
- getAugmentIdentifier("c1Leaf_AnotherAugment", "deepChoice"))
- .withChild(
- Builders.leafBuilder()
- .withNodeIdentifier(
- getNodeIdentifier("c1Leaf_AnotherAugment"))
- .withValue("1").build())
- .withChild(
- choiceBuilder()
- .withNodeIdentifier(getNodeIdentifier("deepChoice"))
- .withChild(
- Builders.leafBuilder()
- .withNodeIdentifier(
- getNodeIdentifier("deepLeafc1"))
- .withValue("1").build()).build())
- .build()).build()).build());
+ b.withChild(choiceBuilder()
+ .withNodeIdentifier(getNodeIdentifier("ch"))
+ .withChild(Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("c1Leaf")).withValue("1").build())
+ .withChild(Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("c1Leaf_AnotherAugment"))
+ .withValue("1").build())
+ .withChild(choiceBuilder()
+ .withNodeIdentifier(getNodeIdentifier("deepChoice"))
+ .withChild(Builders.leafBuilder()
+ .withNodeIdentifier(getNodeIdentifier("deepLeafc1"))
+ .withValue("1").build()).build())
+ .build());
return b.build();
}
return new NodeIdentifier(QName.create(MODULE, localName));
}
- private static AugmentationIdentifier getAugmentIdentifier(final String... childNames) {
- final Set<QName> qn = new HashSet<>();
-
- for (final String childName : childNames) {
- qn.add(getNodeIdentifier(childName).getNodeType());
- }
-
- return new AugmentationIdentifier(qn);
- }
-
private final ContainerNode expectedNode;
private final String xmlPath;
* 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.yangtools.yang.data.codec.xml;
import static java.util.Objects.requireNonNull;
-import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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.ChoiceNode;
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.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.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.w3c.dom.Document;
private NormalizedNode buildOuterContainerNode() {
// my-container-1
- MapNode myKeyedListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(myKeyedList))
- .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
- NodeIdentifierWithPredicates.of(myKeyedList, myKeyLeaf, "listkeyvalue1"))
- .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList1))
- .withValue("listleafvalue1").build())
- .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList2))
- .withValue("listleafvalue2").build()).build())
- .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
- NodeIdentifierWithPredicates.of(myKeyedList, myKeyLeaf, "listkeyvalue2"))
- .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList1))
- .withValue("listleafvalue12").build())
- .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInList2))
- .withValue("listleafvalue22").build()).build()).build();
-
- LeafNode<?> myLeaf1Node = Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeaf1))
- .withValue("value1").build();
+ MapNode myKeyedListNode = Builders.mapBuilder()
+ .withNodeIdentifier(new NodeIdentifier(myKeyedList))
+ .withChild(Builders.mapEntryBuilder()
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(myKeyedList, myKeyLeaf, "listkeyvalue1"))
+ .withChild(ImmutableNodes.leafNode(myLeafInList1, "listleafvalue1"))
+ .withChild(ImmutableNodes.leafNode(myLeafInList2, "listleafvalue2"))
+ .build())
+ .withChild(Builders.mapEntryBuilder()
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(myKeyedList, myKeyLeaf, "listkeyvalue2"))
+ .withChild(ImmutableNodes.leafNode(myLeafInList1, "listleafvalue12"))
+ .withChild(ImmutableNodes.leafNode(myLeafInList2, "listleafvalue22"))
+ .build())
+ .build();
+
+ LeafNode<?> myLeaf1Node = ImmutableNodes.leafNode(myLeaf1, "value1");
SystemLeafSetNode<?> myLeafListNode = Builders.leafSetBuilder()
- .withNodeIdentifier(new NodeIdentifier(myLeafList))
- .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
- new NodeWithValue<>(myLeafList, "lflvalue1")).withValue("lflvalue1").build())
- .withChild(Builders.leafSetEntryBuilder().withNodeIdentifier(
- new NodeWithValue<>(myLeafList, "lflvalue2")).withValue("lflvalue2").build()).build();
-
- ContainerNode myContainer1Node = Builders.containerBuilder().withNodeIdentifier(
- new NodeIdentifier(myContainer1))
- .withChild(myKeyedListNode)
- .withChild(myLeaf1Node)
- .withChild(myLeafListNode).build();
+ .withNodeIdentifier(new NodeIdentifier(myLeafList))
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(new NodeWithValue<>(myLeafList, "lflvalue1"))
+ .withValue("lflvalue1")
+ .build())
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(new NodeWithValue<>(myLeafList, "lflvalue2"))
+ .withValue("lflvalue2")
+ .build())
+ .build();
+
+ ContainerNode myContainer1Node = Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(myContainer1))
+ .withChild(myKeyedListNode)
+ .withChild(myLeaf1Node)
+ .withChild(myLeafListNode)
+ .build();
// my-container-2
- ContainerNode innerContainerNode = Builders.containerBuilder().withNodeIdentifier(
- new NodeIdentifier(innerContainer))
- .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeaf2))
- .withValue("value2").build()).build();
+ ContainerNode innerContainerNode = Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(innerContainer))
+ .withChild(ImmutableNodes.leafNode(myLeaf2, "value2"))
+ .build();
- LeafNode<?> myLeaf3Node = Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeaf3))
- .withValue("value3").build();
+ LeafNode<?> myLeaf3Node = ImmutableNodes.leafNode(myLeaf3, "value3");
- ChoiceNode myChoiceNode = Builders.choiceBuilder().withNodeIdentifier(new NodeIdentifier(myChoice))
- .withChild(Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(myLeafInCase2))
- .withValue("case2value").build()).build();
+ ChoiceNode myChoiceNode = Builders.choiceBuilder()
+ .withNodeIdentifier(new NodeIdentifier(myChoice))
+ .withChild(ImmutableNodes.leafNode(myLeafInCase2, "case2value"))
+ .build();
- ContainerNode myContainer2Node = Builders.containerBuilder().withNodeIdentifier(
- new NodeIdentifier(myContainer2))
- .withChild(innerContainerNode)
- .withChild(myLeaf3Node)
- .withChild(myChoiceNode).build();
+ ContainerNode myContainer2Node = Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(myContainer2))
+ .withChild(innerContainerNode)
+ .withChild(myLeaf3Node)
+ .withChild(myChoiceNode)
+ .build();
// my-container-3
Map<QName, Object> keys = new HashMap<>();
keys.put(myFirstKeyLeaf, "listkeyvalue1");
keys.put(mySecondKeyLeaf, "listkeyvalue2");
- MapNode myDoublyKeyedListNode = Builders.mapBuilder().withNodeIdentifier(new NodeIdentifier(myDoublyKeyedList))
- .withChild(Builders.mapEntryBuilder().withNodeIdentifier(
- NodeIdentifierWithPredicates.of(myDoublyKeyedList, keys))
- .withChild(Builders.leafBuilder().withNodeIdentifier(
- new NodeIdentifier(myLeafInList3)).withValue("listleafvalue1").build()).build())
- .build();
-
- AugmentationNode myDoublyKeyedListAugNode = Builders.augmentationBuilder().withNodeIdentifier(
- new AugmentationIdentifier(ImmutableSet.of(myDoublyKeyedList)))
- .withChild(myDoublyKeyedListNode).build();
-
- ContainerNode myContainer3Node = Builders.containerBuilder().withNodeIdentifier(
- new NodeIdentifier(myContainer3))
- .withChild(myDoublyKeyedListAugNode).build();
-
- AugmentationNode myContainer3AugNode = Builders.augmentationBuilder().withNodeIdentifier(
- new AugmentationIdentifier(ImmutableSet.of(myContainer3)))
- .withChild(myContainer3Node).build();
-
- ContainerNode outerContainerNode = Builders.containerBuilder().withNodeIdentifier(
- new NodeIdentifier(outerContainer))
- .withChild(myContainer1Node)
- .withChild(myContainer2Node)
- .withChild(myContainer3AugNode).build();
+ MapNode myDoublyKeyedListNode = Builders.mapBuilder()
+ .withNodeIdentifier(new NodeIdentifier(myDoublyKeyedList))
+ .withChild(Builders.mapEntryBuilder()
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(myDoublyKeyedList, keys))
+ .withChild(Builders.leafBuilder()
+ .withNodeIdentifier(new NodeIdentifier(myLeafInList3))
+ .withValue("listleafvalue1")
+ .build())
+ .build())
+ .build();
+
+ ContainerNode myContainer3Node = Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(myContainer3))
+ .withChild(myDoublyKeyedListNode).build();
+
+
+ ContainerNode outerContainerNode = Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(outerContainer))
+ .withChild(myContainer1Node)
+ .withChild(myContainer2Node)
+ .withChild(myContainer3Node)
+ .build();
return outerContainerNode;
}
* 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.yangtools.yang.data.codec.xml;
import static java.util.Objects.requireNonNull;
-import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
new NodeIdentifier(myLeafInList3)).withValue("listleafvalue1").build()).build())
.build();
- AugmentationNode myDoublyKeyedListAugNode = Builders.augmentationBuilder().withNodeIdentifier(
- new AugmentationIdentifier(ImmutableSet.of(myDoublyKeyedList)))
- .withChild(myDoublyKeyedListNode).build();
-
ContainerNode myContainer3Node = Builders.containerBuilder().withNodeIdentifier(
new NodeIdentifier(myContainer3))
- .withChild(myDoublyKeyedListAugNode).build();
-
- AugmentationNode myContainer3AugNode = Builders.augmentationBuilder().withNodeIdentifier(
- new AugmentationIdentifier(ImmutableSet.of(myContainer3)))
- .withChild(myContainer3Node).build();
+ .withChild(myDoublyKeyedListNode).build();
ContainerNode outerContainerNode = Builders.containerBuilder().withNodeIdentifier(
new NodeIdentifier(outerContainer))
.withChild(myContainer1Node)
.withChild(myContainer2Node)
- .withChild(myContainer3AugNode).build();
+ .withChild(myContainer3Node).build();
return outerContainerNode;
}
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThrows;
-import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.net.URISyntaxException;
import java.util.HashMap;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
new NodeIdentifier(MY_LEAF_IN_LIST_3)).withValue("listleafvalue1").build()).build())
.build();
- AugmentationNode myDoublyKeyedListAugNode = Builders.augmentationBuilder().withNodeIdentifier(
- new AugmentationIdentifier(ImmutableSet.of(MY_DOUBLY_KEYED_LIST)))
- .withChild(myDoublyKeyedListNode).build();
-
ContainerNode myContainer3Node = Builders.containerBuilder().withNodeIdentifier(
new NodeIdentifier(MY_CONTAINER_3))
- .withChild(myDoublyKeyedListAugNode).build();
-
- AugmentationNode myContainer3AugNode = Builders.augmentationBuilder().withNodeIdentifier(
- new AugmentationIdentifier(ImmutableSet.of(MY_CONTAINER_3)))
- .withChild(myContainer3Node).build();
+ .withChild(myDoublyKeyedListNode).build();
ContainerNode outerContainerNode = Builders.containerBuilder().withNodeIdentifier(
new NodeIdentifier(OUTER_CONTAINER))
.withChild(myContainer1Node)
.withChild(myContainer2Node)
- .withChild(myContainer3AugNode).build();
+ .withChild(myContainer3Node).build();
return outerContainerNode;
}
+++ /dev/null
-/*
- * Copyright (c) 2019 PANTHEON.tech, s.r.o. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * 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.yangtools.yang.data.api;
-
-import static java.util.Objects.requireNonNull;
-
-import com.google.common.collect.ImmutableSet;
-import java.io.Externalizable;
-import java.io.IOException;
-import java.io.ObjectInput;
-import java.io.ObjectOutput;
-import java.io.Serial;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
-
-/**
- * Externalizable proxy for {@link AugmentationIdentifier}.
- */
-final class AIv1 implements Externalizable {
- @Serial
- private static final long serialVersionUID = 1L;
-
- private AugmentationIdentifier ai;
-
- @SuppressWarnings("checkstyle:redundantModifier")
- public AIv1() {
- // For Externalizable
- }
-
- AIv1(final AugmentationIdentifier ai) {
- this.ai = requireNonNull(ai);
- }
-
- @Override
- public void writeExternal(final ObjectOutput out) throws IOException {
- out.writeInt(ai.getPossibleChildNames().size());
- for (QName qname : ai.getPossibleChildNames()) {
- qname.writeTo(out);
- }
- }
-
- @Override
- public void readExternal(final ObjectInput in) throws IOException {
- final int count = in.readInt();
- final QName[] qnames = new QName[count];
- for (int i = 0; i < count; ++i) {
- qnames[i] = QName.readFrom(in);
- }
- ai = new AugmentationIdentifier(ImmutableSet.copyOf(qnames));
- }
-
- @Serial
- private Object readResolve() {
- return ai;
- }
-}
package org.opendaylight.yangtools.yang.data.api;
import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Verify.verify;
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
import com.google.common.cache.LoadingCache;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
-import com.google.common.collect.Sets;
import java.io.Serializable;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.lang.reflect.Array;
import java.util.AbstractMap.SimpleImmutableEntry;
-import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Deque;
* tree</li>
* <li>{@link NodeIdentifierWithPredicates} - Identifier of node (list item), which has cardinality {@code 0..n}</li>
* <li>{@link NodeWithValue} - Identifier of instance {@code leaf} node or {@code leaf-list} node</li>
- * <li>{@link AugmentationIdentifier} - Identifier of instance of {@code augmentation} node</li>
* </ul>
*
* @see <a href="http://tools.ietf.org/html/rfc6020#section-9.13">RFC6020</a>
* <ul>
* <li>{@link NodeIdentifier} - Identifier of container or leaf
* <li>{@link NodeIdentifierWithPredicates} - Identifier of list entries, which have key defined
- * <li>{@link AugmentationIdentifier} - Identifier of augmentation
* <li>{@link NodeWithValue} - Identifier of leaf-list entry
* </ul>
*/
public sealed interface PathArgument extends Comparable<PathArgument>, Immutable, Serializable
- permits AbstractPathArgument, AugmentationIdentifier {
+ permits AbstractPathArgument {
/**
* Returns unique QName of data node as defined in YANG Schema, if available.
*
}
}
- /**
- * Composite path argument identifying a {@link org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode}
- * node in particular subtree.
- *
- * <p>
- * Augmentation is uniquely identified by set of all possible child nodes.
- * This is possible
- * to identify instance of augmentation,
- * since RFC6020 states that <code>augment</code> that augment
- * statement must not add multiple nodes from same namespace
- * / module to the target node.
- *
- * @see <a href="http://tools.ietf.org/html/rfc6020#section-7.15">RFC6020</a>
- */
- public static final class AugmentationIdentifier implements PathArgument {
- private static final long serialVersionUID = -8122335594681936939L;
-
- private static final LoadingCache<ImmutableSet<QName>, AugmentationIdentifier> CACHE = CacheBuilder.newBuilder()
- .weakValues().build(new CacheLoader<ImmutableSet<QName>, AugmentationIdentifier>() {
- @Override
- public AugmentationIdentifier load(final ImmutableSet<QName> key) {
- return new AugmentationIdentifier(key);
- }
- });
-
- private final @NonNull ImmutableSet<QName> childNames;
-
- @Override
- public QName getNodeType() {
- // This should rather throw exception than return always null
- throw new UnsupportedOperationException("Augmentation node has no QName");
- }
-
- /**
- * Construct new augmentation identifier using supplied set of possible
- * child nodes.
- *
- * @param childNames
- * Set of possible child nodes.
- */
- public AugmentationIdentifier(final ImmutableSet<QName> childNames) {
- this.childNames = requireNonNull(childNames);
- }
-
- /**
- * Construct new augmentation identifier using supplied set of possible
- * child nodes.
- *
- * @param childNames
- * Set of possible child nodes.
- */
- public AugmentationIdentifier(final Set<QName> childNames) {
- this.childNames = ImmutableSet.copyOf(childNames);
- }
-
- /**
- * Return an AugmentationIdentifier for a particular set of QNames. Unlike the constructor, this factory method
- * uses a global instance cache, resulting in object reuse for equal inputs.
- *
- * @param childNames Set of possible child nodes
- * @return An {@link AugmentationIdentifier}
- */
- public static @NonNull AugmentationIdentifier create(final ImmutableSet<QName> childNames) {
- return CACHE.getUnchecked(childNames);
- }
-
- /**
- * Return an AugmentationIdentifier for a particular set of QNames. Unlike the constructor, this factory method
- * uses a global instance cache, resulting in object reuse for equal inputs.
- *
- * @param childNames Set of possible child nodes
- * @return An {@link AugmentationIdentifier}
- */
- public static @NonNull AugmentationIdentifier create(final Set<QName> childNames) {
- final AugmentationIdentifier existing = CACHE.getIfPresent(childNames);
- return existing != null ? existing : create(ImmutableSet.copyOf(childNames));
- }
-
- /**
- * Returns set of all possible child nodes.
- *
- * @return set of all possible child nodes.
- */
- public @NonNull Set<QName> getPossibleChildNames() {
- return childNames;
- }
-
- @Override
- public String toString() {
- return "AugmentationIdentifier{" + "childNames=" + childNames + '}';
- }
-
- @Override
- public String toRelativeString(final PathArgument previous) {
- return toString();
- }
-
- @Override
- public boolean equals(final Object obj) {
- return this == obj || obj instanceof AugmentationIdentifier other && childNames.equals(other.childNames);
- }
-
- @Override
- public int hashCode() {
- return childNames.hashCode();
- }
-
- @Override
- @SuppressWarnings("checkstyle:parameterName")
- public int compareTo(final PathArgument o) {
- if (!(o instanceof AugmentationIdentifier other)) {
- return -1;
- }
- Set<QName> otherChildNames = other.getPossibleChildNames();
- int thisSize = childNames.size();
- int otherSize = otherChildNames.size();
- if (thisSize == otherSize) {
- // Quick Set-based comparison
- if (childNames.equals(otherChildNames)) {
- return 0;
- }
-
- // We already know the sets are not equal, but have equal size, hence the sets differ in their elements,
- // but potentially share a common set of elements. The most consistent way of comparing them is using
- // total ordering defined by QName's compareTo. Hence convert both sets to lists ordered
- // by QName.compareTo() and decide on the first differing element.
- final List<QName> diff = new ArrayList<>(Sets.symmetricDifference(childNames, otherChildNames));
- verify(!diff.isEmpty(), "Augmentation identifiers %s and %s report no difference", this, o);
- diff.sort(QName::compareTo);
- return childNames.contains(diff.get(0)) ? -1 : 1;
- } else if (thisSize < otherSize) {
- return 1;
- } else {
- return -1;
- }
- }
-
- private Object writeReplace() {
- return new AIv1(this);
- }
- }
-
/**
* Fluent Builder of Instance Identifier instances.
*/
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * 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.yangtools.yang.data.api.schema;
-
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
-
-/**
- * Data instance of <code>augment</code> associated with parent node.
- *
- * <p>
- * Augmentation is addition of subtree defined by other external YANG Model and is schema for subtree is described
- * by an instance of {@link AugmentationSchemaNode} associated with parent node of this node.
- *
- * <p>
- * Augmentation node MUST NOT be direct child of other augmentation node.
- */
-public interface AugmentationNode extends DataContainerNode, DataContainerChild, MixinNode {
- @Override
- default Class<AugmentationNode> contract() {
- return AugmentationNode.class;
- }
-
- /**
- * Gets identifier of augmentation node. Returned identifier of augmentation node contains all possible
- * direct child QNames.
- *
- * <p>
- * This is sufficient to identify instance of augmentation, since RFC6020 states that <code>augment</code>
- * that augment statement must not add multiple nodes from same namespace / module to the target node.
- *
- * @return Identifier which uniquely identifies augmentation in particular subtree.
- */
- @Override
- AugmentationIdentifier getIdentifier();
-}
* This interface should not be implemented directly, but rather using one of its subinterfaces:
*
* <ul>
- * <li>{@link AugmentationNode}</li>
* <li>{@link ChoiceNode}</li>
* <li>{@link ContainerNode}</li>
* <li>{@link ForeignDataNode}</li>
* <h2>Implementation notes</h2>
* This interface should not be implemented directly, but rather implementing one of it's subclasses
* <ul>
- * <li>{@link AugmentationNode}</li>
* <li>{@link ChoiceNode}</li>
* <li>{@link ContainerNode}</li>
* <li>{@link MapEntryNode} and its specializations</li>
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
}
private static void appendPathArgument(final StringBuilder sb, final PathArgument arg) {
+ sb.append(arg.getNodeType().getLocalName());
if (arg instanceof NodeIdentifierWithPredicates nip) {
- sb.append(arg.getNodeType().getLocalName()).append(nip.values());
- } else if (arg instanceof AugmentationIdentifier) {
- sb.append("augmentation");
- } else {
- sb.append(arg.getNodeType().getLocalName());
+ sb.append(nip.values());
}
}
}
* which represents a leaf, which occurs mostly once per parent node, but
* possible values could have different types. Maps to <i>choice</i> statement.
* Types maps to the <i>case</i> statements for that <i>choice</i>.</li>
- * <li> {@link org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode}
- * - Node which represents a leaf, which occurs mostly once per parent node.</li>
* </ul>
* </li>
* <li> {@link org.opendaylight.yangtools.yang.data.api.schema.LeafNode} - Node
* {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier}
* | {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates}
* | {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue}
- * | {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier}
*
* TreeRoot = {@link org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode}
* {@link org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode} =
* ( {@link org.opendaylight.yangtools.yang.data.api.schema.LeafNode}
* | {@link org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode}
- * | {@link org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode}
* | {@link org.opendaylight.yangtools.yang.data.api.schema.MapNode}
* | {@link org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode})*
* ContainerDataNode =
*
* {@link org.opendaylight.yangtools.yang.data.api.schema.LeafNode} =
* {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier} SimpleValue
- * {@link org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode} =
- * {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier}
- * {@link org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode}
* {@link org.opendaylight.yangtools.yang.data.api.schema.MapNode} =
* {@link org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier}
* {@link org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode}
* </li>
* </ul>
* </li>
- * <li>(0..n) AugmentationNode
- * <ul>
- * <li>(Same as DataContainerNode)</li>
- * </ul>
- * </li>
* </ul>
* </li>
* </ul>
* allows for more efficient implementations. If such ordering is required by
* clients for serialization / debugability it SHOULD be done externally in
* code using these interfaces.
- *
*/
package org.opendaylight.yangtools.yang.data.api.schema;
import java.util.Deque;
import javax.xml.transform.dom.DOMSource;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
abstract void enterChoiceNode(NodeIdentifier name, String indent);
- @Override
- public final void startAugmentationNode(final AugmentationIdentifier identifier) {
- enterAugmentationNode(identifier, ind());
- incIndent();
- }
-
- abstract void enterAugmentationNode(AugmentationIdentifier identifier, String indent);
-
@Override
public final void startLeafSetEntryNode(final NodeWithValue<?> name) {
enterLeafSetEntryNode(name, ind());
import com.google.common.annotations.Beta;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
sb.append(indent).append(name).append("(choice)\n");
}
- @Override
- void enterAugmentationNode(final AugmentationIdentifier identifier, final String indent) {
- sb.append(indent).append(identifier).append("(augmentation)\n");
- }
-
@Override
void enterLeafSetEntryNode(final NodeWithValue<?> name, final String indent) {
sb.append(indent).append(name.getNodeType()).append("(entry)\n");
import java.util.Collection;
import javax.xml.transform.dom.DOMSource;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
delegate().startChoiceNode(name, childSizeHint);
}
- @Override
- public void startAugmentationNode(final AugmentationIdentifier identifier) throws IOException {
- delegate().startAugmentationNode(identifier);
- }
-
@Override
public boolean startAnyxmlNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
return delegate().startAnyxmlNode(name, objectModel);
import com.google.common.annotations.Beta;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
LOG.debug("{}{}(choice)", indent, name);
}
- @Override
- void enterAugmentationNode(final AugmentationIdentifier identifier, final String indent) {
- LOG.debug("{}{}(augmentation)", indent, identifier);
- }
-
@Override
void enterLeafSetEntryNode(final NodeWithValue<?> name, final String indent) {
LOG.debug("{}{}(entry}", indent, name.getNodeType());
import org.opendaylight.yangtools.concepts.ObjectExtension;
import org.opendaylight.yangtools.rfc8528.model.api.MountPointLabel;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
* <li>{@code anyxml} - An anyxml node event is emitted using {@link #startAnyxmlNode(NodeIdentifier, Class)}.</li>
*
* <li>{@code choice} - Choice node event is emitted by {@link #startChoiceNode(NodeIdentifier, int)} event.</li>
- *
- * <li>{@code augment} - Represents augmentation, augmentation node is started by invoking
- * {@link #startAugmentationNode(AugmentationIdentifier)}.
- * </li>
* </ul>
*
* <h3>Implementation notes</h3>
* <li>{@link #startLeafSet(NodeIdentifier, int)}</li>
* <li>{@link #startMapNode(NodeIdentifier, int)}</li>
* <li>{@link #startUnkeyedList(NodeIdentifier, int)}</li>
- * <li>{@link #startAugmentationNode(AugmentationIdentifier)}</li>
* </ul>
*
* @param name name of node as defined in schema, namespace and revision are derived from parent node.
* <li>{@link #startLeafSet(NodeIdentifier, int)}</li>
* <li>{@link #startMapNode(NodeIdentifier, int)}</li>
* <li>{@link #startUnkeyedList(NodeIdentifier, int)}</li>
- * <li>{@link #startAugmentationNode(AugmentationIdentifier)}</li>
* </ul>
*
* @param name Identifier of node
* <li>{@link #startLeafSet(NodeIdentifier, int)}</li>
* <li>{@link #startMapNode(NodeIdentifier, int)}</li>
* <li>{@link #startUnkeyedList(NodeIdentifier, int)}</li>
- * <li>{@link #startAugmentationNode(AugmentationIdentifier)}</li>
* </ul>
*
* @param identifier QName to value pairs of keys of map entry node.
*/
void startChoiceNode(NodeIdentifier name, int childSizeHint) throws IOException;
- /**
- * Emits start of augmentation node. Valid sub-events are:
- * <ul>
- * <li>{@link #startLeafNode}</li>
- * <li>{@link #startContainerNode(NodeIdentifier, int)}</li>
- * <li>{@link #startChoiceNode(NodeIdentifier, int)}</li>
- * <li>{@link #startLeafSet(NodeIdentifier, int)}</li>
- * <li>{@link #startMapNode(NodeIdentifier, int)}</li>
- * <li>{@link #startUnkeyedList(NodeIdentifier, int)}</li>
- * </ul>
- *
- * @param identifier Augmentation identifier
- * @throws NullPointerException if {@code identifier} is null
- * @throws IllegalArgumentException If augmentation is invalid in current context.
- * @throws IOException if an underlying IO error occurs
- */
- void startAugmentationNode(AugmentationIdentifier identifier) throws IOException;
-
/**
* Start emitting a new anydata node identified by name.
*
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AnydataNode;
import org.opendaylight.yangtools.yang.data.api.schema.AnyxmlNode;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
} else if (node instanceof ChoiceNode n) {
writer.startChoiceNode(n.getIdentifier(), childSizeHint(n.body()));
return writeChildren(n.body());
- } else if (node instanceof AugmentationNode n) {
- writer.startAugmentationNode(n.getIdentifier());
- return writeChildren(n.body());
} else if (node instanceof UnkeyedListNode n) {
writer.startUnkeyedList(n.getIdentifier(), childSizeHint(n.body()));
return writeChildren(n.body());
// Write all the rest
return writeChildren(Iterables.filter(node.body(), input -> {
- if (input instanceof AugmentationNode) {
- return true;
- }
- if (!qnames.contains(input.getIdentifier().getNodeType())) {
- return true;
+ if (qnames.contains(input.getIdentifier().getNodeType())) {
+ LOG.debug("Skipping key child {}", input);
+ return false;
}
-
- LOG.debug("Skipping key child {}", input);
- return false;
+ return true;
}));
}
}
import static java.util.Objects.requireNonNull;
-import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import java.io.IOException;
import java.util.List;
import org.opendaylight.yangtools.util.ImmutableOffsetMap;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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.NormalizedAnydata;
import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerLike;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import org.opendaylight.yangtools.yang.model.util.EffectiveAugmentationSchema;
/**
* Utility for emitting a {@link YangInstanceIdentifier} into a {@link NormalizedNodeStreamWriter} as a set of
}
final var arg = it.next();
- if (arg instanceof AugmentationIdentifier augId) {
- if (!(parent instanceof AugmentationTarget target)) {
- throw new IOException(parent + " does not support augmentations, cannot resolve " + arg);
- }
- if (reuse) {
- throw new IOException(parent + " is expecting a nested item, cannot resolve " + arg);
- }
-
- if (target instanceof DataNodeContainer container) {
- parent = new EffectiveAugmentationSchema(enterAugmentation(target, augId), container);
- } else if (target instanceof ChoiceSchemaNode) {
- throw new IOException(parent + " should not use addressing through " + arg);
- } else {
- throw new IOException("Unhandled parent " + target + " while resolving " + arg);
- }
- writer.startAugmentationNode(augId);
- } else if (arg instanceof NodeWithValue<?> nodeId) {
+ if (arg instanceof NodeWithValue<?> nodeId) {
if (!(parent instanceof LeafListSchemaNode)) {
throw new IOException(parent + " does not support leaf-list entry " + arg);
}
return NodeIdentifierWithPredicates.of(input.getNodeType(), ImmutableOffsetMap.orderedCopyOf(builder.build()));
}
-
- private static AugmentationSchemaNode enterAugmentation(final AugmentationTarget target,
- final AugmentationIdentifier id) throws IOException {
- final var augs = target.getAvailableAugmentations();
- for (var augment : augs) {
- if (id.equals(augmentationIdentifierFrom(augment))) {
- return augment;
- }
- }
- throw new IOException("Cannot find augmentation " + id + " in " + target + ", available: "
- + Collections2.transform(augs, YangInstanceIdentifierWriter::augmentationIdentifierFrom));
- }
-
- // FIXME: duplicate of data.util.DataSchemaContextNode.augmentationIdentifierFrom()
- static @NonNull AugmentationIdentifier augmentationIdentifierFrom(final AugmentationSchemaNode schema) {
- return new AugmentationIdentifier(
- schema.getChildNodes().stream().map(DataSchemaNode::getQName).collect(ImmutableSet.toImmutableSet()));
- }
}
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
-import com.google.common.collect.ImmutableSet;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
final NodeIdentifier node1 = new NodeIdentifier(NODENAME1);
assertEquals(NODENAME1, node1.getNodeType());
final NodeIdentifier node2 = new NodeIdentifier(NODENAME1);
- final AugmentationIdentifier node3 = new AugmentationIdentifier(ImmutableSet.of(NODENAME1, NODENAME2));
assertEquals(node1.hashCode(), node2.hashCode());
assertEquals(0, node1.compareTo(node2));
assertTrue(node1.compareTo(new NodeIdentifier(NODENAME3)) != 0);
assertFalse(node1.equals(null));
- assertFalse(node1.equals(node3));
assertTrue(node1.equals(node1));
assertTrue(node1.equals(node2));
assertFalse(node1.equals(new NodeIdentifier(NODENAME3)));
assertNotNull(node1.toString());
}
- @Test
- public void testAugmentationIdentifierNodeType() {
- AugmentationIdentifier node1 = new AugmentationIdentifier(ImmutableSet.of(NODENAME1, NODENAME2));
- assertThrows(UnsupportedOperationException.class, () -> node1.getNodeType());
- }
-
- @Test
- public void testAugmentationIdentifier() {
-
- final AugmentationIdentifier node1 = new AugmentationIdentifier(ImmutableSet.of(NODENAME1, NODENAME2));
- assertEquals(ImmutableSet.of(NODENAME1, NODENAME2), node1.getPossibleChildNames());
- final AugmentationIdentifier node2 = new AugmentationIdentifier(ImmutableSet.of(NODENAME2, NODENAME1));
- final AugmentationIdentifier node3 = new AugmentationIdentifier(ImmutableSet.of(NODENAME1, NODENAME3));
- final AugmentationIdentifier node4 = new AugmentationIdentifier(ImmutableSet.of(NODENAME1, NODENAME2,
- NODENAME3));
- final NodeIdentifier node5 = new NodeIdentifier(NODENAME3);
-
- assertEquals(node1.hashCode(), node2.hashCode());
-
- assertTrue(node1.equals(node1));
- assertTrue(node1.equals(node2));
- assertFalse(node1.equals(node3));
- assertFalse(node1.equals(new AugmentationIdentifier(ImmutableSet.of(NODENAME1))));
- assertFalse(node1.equals(new Object()));
-
- assertEquals(-1, node1.compareTo(node5));
- assertEquals(0, node1.compareTo(node2));
- assertEquals(0, node1.compareTo(node2));
- assertEquals(1, node1.compareTo(node4));
- assertEquals(-1, node4.compareTo(node1));
-
- // for code coverage
- assertNotNull(node1.toString());
- assertNotNull(node1.toRelativeString(node5));
- }
-
private static YangInstanceIdentifier serdes(final YangInstanceIdentifier id) throws IOException,
ClassNotFoundException {
final ByteArrayOutputStream bos = new ByteArrayOutputStream();
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
-import com.google.common.collect.ImmutableSet;
import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.mockito.junit.jupiter.MockitoExtension;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
assertNotNull(stringTree);
assertEquals("leaf-node str-value-1\n", stringTree);
- final AugmentationNode mockedAugmentationNode = mock(AugmentationNode.class);
final QName listQName = QName.create("test-ns", "2016-09-16", "list-node");
- final AugmentationIdentifier augNodeId = new AugmentationIdentifier(ImmutableSet.of(listQName));
- doReturn(augNodeId).when(mockedAugmentationNode).getIdentifier();
final SystemMapNode mockedMapNode = mock(SystemMapNode.class);
final NodeIdentifier listNodeId = new NodeIdentifier(listQName);
doReturn(listNodeId).when(mockedMapNode).getIdentifier();
- doReturn(List.of(mockedMapNode)).when(mockedAugmentationNode).body();
final MapEntryNode mockedMapEntryNode = mock(MapEntryNode.class);
final NodeIdentifierWithPredicates listEntryNodeId = NodeIdentifierWithPredicates.of(listQName,
doReturn(List.of(mockedLeafNode)).when(mockedMapEntryNode).body();
- stringTree = NormalizedNodes.toStringTree(mockedAugmentationNode);
+ stringTree = NormalizedNodes.toStringTree(mockedMapNode);
assertNotNull(stringTree);
assertEquals("""
- augmentation {
- list-node {
- list-node[key-leaf-value] {
- leaf-node str-value-1
- }
+ list-node {
+ list-node[key-leaf-value] {
+ leaf-node str-value-1
}
}
""", stringTree);
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.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
assertNotNull(orderedNormalizedNodeWriter.write(mock(ChoiceNode.class)));
- assertNotNull(orderedNormalizedNodeWriter.write(mock(AugmentationNode.class)));
-
final UnkeyedListNode mockedUnkeyedListNode = mock(UnkeyedListNode.class);
final Set<?> value = Set.of(mockedUnkeyedListEntryNode);
doReturn(value).when(mockedUnkeyedListNode).body();
orderedNormalizedNodeWriter.flush();
orderedNormalizedNodeWriter.close();
- final NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(
- loggingNormalizedNodeStreamWriter, false);
-
- assertNotNull(normalizedNodeWriter.write(mockedMapEntryNode));
-
- normalizedNodeWriter.flush();
- normalizedNodeWriter.close();
+ try (var nnWriter = NormalizedNodeWriter.forStreamWriter(loggingNormalizedNodeStreamWriter, false)) {
+ assertNotNull(nnWriter.write(mockedMapEntryNode));
+ }
}
}
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.io.IOException;
-import java.util.Set;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
.node(QName.create("foo", "foo"))
- .node(AugmentationIdentifier.create(Set.of(bar)))
.node(bar)
- .node(AugmentationIdentifier.create(Set.of(baz)))
.node(baz)
.build();
assertEquals("""
(foo)foo(container)
- AugmentationIdentifier{childNames=[(foo)bar]}(augmentation)
- (foo)bar(container)
- AugmentationIdentifier{childNames=[(foo)baz]}(augmentation)
- (foo)baz(container)
- (end)
- (end)
+ (foo)bar(container)
+ (foo)baz(container)
(end)
(end)
(end)
import org.mockito.junit.jupiter.MockitoExtension;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
final YangInstanceIdentifier path = YangInstanceIdentifier.builder()
.node(QName.create("test", "container-1"))
- .node(AugmentationIdentifier.create(Set.of(augmented)))
.node(augmented)
.node(QName.create(augmented, "container-2"))
.build();
assertEquals("""
(test)container-1(container)
- AugmentationIdentifier{childNames=[(augment-namespace)augmented-container]}(augmentation)
- (augment-namespace)augmented-container(container)
- (augment-namespace)container-2(container)
- (test)payload-container(container)
- (test)payload-leaf(leaf)
- (String)=leaf-value
- (end)
+ (augment-namespace)augmented-container(container)
+ (augment-namespace)container-2(container)
+ (test)payload-container(container)
+ (test)payload-leaf(leaf)
+ (String)=leaf-value
(end)
(end)
(end)
package org.opendaylight.yangtools.yang.data.impl.schema;
import javax.xml.transform.dom.DOMSource;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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.AnydataNode;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
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.builder.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableAnyXmlNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableAnydataNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableAugmentationNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableChoiceNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
return ImmutableMapNodeBuilder.create(sizeHint);
}
- public static DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> augmentationBuilder() {
- return ImmutableAugmentationNodeBuilder.create();
- }
-
- public static DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> augmentationBuilder(
- final int sizeHint) {
- return ImmutableAugmentationNodeBuilder.create(sizeHint);
- }
-
public static DataContainerNodeBuilder<NodeIdentifier, ChoiceNode> choiceBuilder() {
return ImmutableChoiceNodeBuilder.create();
}
import java.util.Deque;
import javax.xml.transform.dom.DOMSource;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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.builder.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.data.api.schema.builder.NormalizedNodeContainerBuilder;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableAugmentationNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
enter(name, UNKNOWN_SIZE == childSizeHint ? Builders.choiceBuilder() : Builders.choiceBuilder(childSizeHint));
}
- @Override
- public void startAugmentationNode(final AugmentationIdentifier identifier) {
- checkDataNodeContainer();
- checkArgument(!(current() instanceof ImmutableAugmentationNodeBuilder));
- enter(identifier, Builders.augmentationBuilder());
- }
-
@Override
public void flush() {
// no-op
import java.io.IOException;
import java.util.Collection;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
}
private static void putChild(final Multimap<QName, NormalizedNode> qnameToNodes, final NormalizedNode child) {
- if (child instanceof AugmentationNode augmentChild) {
- for (DataContainerChild grandChild : augmentChild.body()) {
- putChild(qnameToNodes, grandChild);
- }
- } else {
- qnameToNodes.put(child.getIdentifier().getNodeType(), child);
- }
+ qnameToNodes.put(child.getIdentifier().getNodeType(), child);
}
private final class SchemaNodeSetter implements AutoCloseable {
-
private final SchemaNode previousSchemaNode;
/**
+++ /dev/null
-/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * 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.yangtools.yang.data.impl.schema.builder.impl;
-
-import java.util.Map;
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
-import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
-import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.valid.DataValidationException;
-import org.opendaylight.yangtools.yang.data.impl.schema.nodes.AbstractImmutableDataContainerNode;
-
-public class ImmutableAugmentationNodeBuilder
- extends AbstractImmutableDataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> {
-
- protected ImmutableAugmentationNodeBuilder() {
- }
-
- protected ImmutableAugmentationNodeBuilder(final int sizeHint) {
- super(sizeHint);
- }
-
- ImmutableAugmentationNodeBuilder(final ImmutableAugmentationNode node) {
- super(node);
- }
-
- public static @NonNull DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> create() {
- return new ImmutableAugmentationNodeBuilder();
- }
-
- public static @NonNull DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> create(
- final int sizeHint) {
- return new ImmutableAugmentationNodeBuilder(sizeHint);
- }
-
- public static @NonNull DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> create(
- final AugmentationNode node) {
- if (!(node instanceof ImmutableAugmentationNode immutableNode)) {
- throw new UnsupportedOperationException("Cannot initialize from class " + node.getClass());
- }
- return new ImmutableAugmentationNodeBuilder(immutableNode);
- }
-
- @Override
- public DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> withChild(
- final DataContainerChild child) {
- // Check nested augments
- if (child instanceof AugmentationNode aug) {
- final var myId = getNodeIdentifier();
- throw new DataValidationException(String.format(
- "Unable to add: %s, as a child for: %s, Nested augmentations are not permitted", aug.getIdentifier(),
- myId == null ? this : myId));
- }
-
- return super.withChild(child);
- }
-
- @Override
- public DataContainerNodeBuilder<AugmentationIdentifier, AugmentationNode> withoutChild(final PathArgument key) {
- return super.withoutChild(key);
- }
-
- @Override
- public AugmentationNode build() {
- return new ImmutableAugmentationNode(getNodeIdentifier(), buildValue());
- }
-
- private static final class ImmutableAugmentationNode
- extends AbstractImmutableDataContainerNode<AugmentationIdentifier, AugmentationNode>
- implements AugmentationNode {
-
- ImmutableAugmentationNode(final AugmentationIdentifier nodeIdentifier,
- final Map<PathArgument, Object> children) {
- super(children, nodeIdentifier);
- }
-
- @Override
- protected Class<AugmentationNode> implementedType() {
- return AugmentationNode.class;
- }
- }
-}
import java.util.Map.Entry;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
private static void putQName(final Map<QName, PathArgument> map, final DataContainerChild child) {
// Augmentation nodes cannot be keys, and do not have to be present in childrenQNamesToPaths map
final PathArgument identifier = child.getIdentifier();
- if (!(identifier instanceof AugmentationIdentifier)) {
- map.put(identifier.getNodeType(), identifier);
- }
+ map.put(identifier.getNodeType(), identifier);
}
@Override
import java.util.HashSet;
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
-import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
* General validator for container like statements, e.g. container, list-entry, choice, augment
*/
public class DataNodeContainerValidator {
- private final Set<AugmentationIdentifier> augments = new HashSet<>();
private final DataNodeContainer schema;
private final Set<QName> childNodes;
public DataNodeContainerValidator(final DataNodeContainer schema) {
this.schema = requireNonNull(schema, "Schema was null");
childNodes = getChildNodes(schema);
-
- if (schema instanceof AugmentationTarget target) {
- for (var augmentation : target.getAvailableAugmentations()) {
- augments.add(DataSchemaContextNode.augmentationIdentifierFrom(augmentation));
- }
- }
}
private boolean isKnownChild(final PathArgument child) {
- if (child instanceof AugmentationIdentifier) {
- return augments.contains(child);
- }
-
return childNodes.contains(child.getNodeType());
}
public void validateChild(final PathArgument child) {
- DataValidationException.checkLegalChild(isKnownChild(child), child, schema, childNodes, augments);
+ DataValidationException.checkLegalChild(isKnownChild(child), child, schema, childNodes);
}
public DataContainerChild validateChild(final DataContainerChild child) {
import java.util.Objects;
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
}
public static void checkLegalChild(final boolean isLegal, final PathArgument child, final DataNodeContainer schema,
- final Set<QName> childNodes, final Set<AugmentationIdentifier> augments) {
+ final Set<QName> childNodes) {
if (!isLegal) {
- throw new IllegalChildException(child, schema, childNodes, augments);
+ throw new IllegalChildException(child, schema, childNodes);
}
}
private static final class IllegalChildException extends DataValidationException {
private static final long serialVersionUID = 1L;
- IllegalChildException(final PathArgument child, final DataNodeContainer schema,
- final Set<QName> childNodes, final Set<AugmentationIdentifier> augments) {
- super(String.format("Unknown child node: %s, does not belong to: %s as a direct child. "
- + "Direct child nodes: %s, augmented child nodes: %s", child, schema, childNodes, augments));
+ IllegalChildException(final PathArgument child, final DataNodeContainer schema, final Set<QName> childNodes) {
+ super(String.format(
+ "Unknown child node: %s, does not belong to: %s as a direct child. Direct child nodes: %s",
+ child, schema, childNodes));
}
IllegalChildException(final PathArgument child, final ChoiceSchemaNode schema) {
import org.opendaylight.yangtools.yang.data.api.schema.UserLeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.UserMapNode;
import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableAugmentationNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableChoiceNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder;
assertEquals(choiceNodeCreated.getIdentifier(), choiceNode.getIdentifier());
}
-
- @Test
- public void immutableAugmentationNodeBuilderExceptionTest() {
- final var builder = ImmutableAugmentationNodeBuilder.create(1);
- assertThrows(NullPointerException.class, builder::build);
- }
-
@Test
public void immutableContainerNodeBuilderExceptionTest() {
final ContainerNode immutableContainerNode = ImmutableContainerNodeBuilder.create(1)
* 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.yangtools.yang.data.impl.schema;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.text.ParseException;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
.withValue(anyxmlDomSource)
.build())
.build())
- .withChild(Builders.augmentationBuilder()
- .withNodeIdentifier(new AugmentationIdentifier(ImmutableSet.of(myContainer3)))
- .withChild(Builders.containerBuilder()
- .withNodeIdentifier(new NodeIdentifier(myContainer3))
- .withChild(Builders.augmentationBuilder()
- .withNodeIdentifier(new AugmentationIdentifier(ImmutableSet.of(myDoublyKeyedList)))
- .withChild(Builders.mapBuilder()
- .withNodeIdentifier(new NodeIdentifier(myDoublyKeyedList))
- .withChild(Builders.mapEntryBuilder()
- .withNodeIdentifier(NodeIdentifierWithPredicates.of(myDoublyKeyedList,
- Map.of(myFirstKeyLeaf, "listkeyvalue1", mySecondKeyLeaf, "listkeyvalue2")))
- .withChild(ImmutableNodes.leafNode(myLeafInList3, "listleafvalue1"))
- .build())
- .build())
+ .withChild(Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(myContainer3))
+ .withChild(Builders.mapBuilder()
+ .withNodeIdentifier(new NodeIdentifier(myDoublyKeyedList))
+ .withChild(Builders.mapEntryBuilder()
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(myDoublyKeyedList,
+ Map.of(myFirstKeyLeaf, "listkeyvalue1", mySecondKeyLeaf, "listkeyvalue2")))
+ .withChild(ImmutableNodes.leafNode(myLeafInList3, "listleafvalue1"))
.build())
.build())
.build())
*/
package org.opendaylight.yangtools.yang.data.impl.schema;
-import com.google.common.collect.ImmutableSet;
import java.util.Collections;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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.LeafSetNode;
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.builder.DataContainerNodeBuilder;
public class NormalizedDataBuilderTest {
getNodeIdentifier("list").getNodeType(), Collections.singletonMap(
getNodeIdentifier("uint32InList").getNodeType(), 1))).build();
- MapNode list = Builders.mapBuilder().withChild(listChild1).withNodeIdentifier(getNodeIdentifier("list"))
- .build();
- builder.withChild(list);
-
- AugmentationNode augmentation = Builders
- .augmentationBuilder()
- .withNodeIdentifier(
- new AugmentationIdentifier(ImmutableSet.of(getQName("augmentUint32"))))
- .withChild(
- Builders.<Integer>leafBuilder().withNodeIdentifier(getNodeIdentifier("augmentUint32"))
- .withValue(11).build()).build();
-
- builder.withChild(augmentation);
+ builder
+ .withChild(Builders.mapBuilder()
+ .withNodeIdentifier(getNodeIdentifier("list"))
+ .withChild(listChild1)
+ .build())
+ .withChild(Builders.<Integer>leafBuilder()
+ .withNodeIdentifier(getNodeIdentifier("augmentUint32"))
+ .withValue(11).build());
// This works without schema (adding child from augment as a direct
// child)
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ForeignDataNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
appendIndent(sb, depth);
sb.append(simpleName.toLowerCase(Locale.ROOT).charAt(0)).append(simpleName, 1, simpleName.length()).append(' ');
- final QNameModule currentNamespace;
- if (node instanceof AugmentationNode) {
- // Add identifier, but augmentations are special enough
- currentNamespace = ((AugmentationNode) node).getIdentifier().getPossibleChildNames().iterator().next()
- .getModule();
- if (appendNamespace(sb, parentNamespace, currentNamespace)) {
- sb.append(' ');
- }
- } else {
- final QName qname = node.getIdentifier().getNodeType();
- currentNamespace = qname.getModule();
- appendNamespace(sb, parentNamespace, currentNamespace);
- sb.append(qname.getLocalName()).append(' ');
- }
+ final QName qname = node.getIdentifier().getNodeType();
+ final QNameModule currentNamespace = qname.getModule();
+ appendNamespace(sb, parentNamespace, currentNamespace);
+ sb.append(qname.getLocalName()).append(' ');
if (node instanceof NormalizedNodeContainer) {
final NormalizedNodeContainer<?> container = (NormalizedNodeContainer<?>) node;
*/
package org.opendaylight.yangtools.transform;
-import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
super.startChoiceNode(transform(name), childSizeHint);
}
- @Override
- public void startAugmentationNode(final AugmentationIdentifier identifier) throws IOException {
- super.startAugmentationNode(transform(identifier));
- }
-
@Override
public boolean startAnyxmlNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
return super.startAnyxmlNode(transform(name), objectModel);
return transformed == original ? name : new NodeWithValue<>(transformed, name.getValue());
}
- private AugmentationIdentifier transform(final AugmentationIdentifier identifier) {
- ImmutableSet.Builder<QName> builder = ImmutableSet.builder();
- for (QName original : identifier.getPossibleChildNames()) {
- builder.add(transform(original));
- }
- return new AugmentationIdentifier(builder.build());
- }
-
private NodeIdentifierWithPredicates transform(final NodeIdentifierWithPredicates identifier) {
Map<QName, Object> keyValues = new HashMap<>();
for (Map.Entry<QName, Object> original : identifier.entrySet()) {
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * 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.yangtools.yang.data.tree.impl;
-
-import java.util.Optional;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
-import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableAugmentationNodeBuilder;
-import org.opendaylight.yangtools.yang.data.tree.api.DataTreeConfiguration;
-import org.opendaylight.yangtools.yang.data.tree.impl.node.TreeNode;
-import org.opendaylight.yangtools.yang.data.tree.impl.node.Version;
-import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.util.EffectiveAugmentationSchema;
-
-final class AugmentationModificationStrategy
- extends DataNodeContainerModificationStrategy<AugmentationSchemaNode> {
- private static final NormalizedNodeContainerSupport<AugmentationIdentifier, AugmentationNode> SUPPORT =
- new NormalizedNodeContainerSupport<>(AugmentationNode.class, ImmutableAugmentationNodeBuilder::create,
- ImmutableAugmentationNodeBuilder::create);
-
- private final AugmentationNode emptyNode;
-
- AugmentationModificationStrategy(final AugmentationSchemaNode schema, final DataNodeContainer resolved,
- final DataTreeConfiguration treeConfig) {
- super(SUPPORT, new EffectiveAugmentationSchema(schema, resolved), treeConfig);
- emptyNode = Builders.augmentationBuilder()
- .withNodeIdentifier(DataSchemaContextNode.augmentationIdentifierFrom(schema))
- .build();
- }
-
- @Override
- Optional<? extends TreeNode> apply(final ModifiedNode modification, final Optional<? extends TreeNode> storeMeta,
- final Version version) {
- return AutomaticLifecycleMixin.apply(super::apply, this::applyWrite, emptyNode, modification, storeMeta,
- version);
- }
-
- @Override
- TreeNode defaultTreeNode() {
- return defaultTreeNode(emptyNode);
- }
-}
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
-import com.google.common.collect.Sets;
import java.util.Map.Entry;
import java.util.Set;
import org.opendaylight.yangtools.concepts.Immutable;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.tree.api.DataTreeConfiguration;
import org.opendaylight.yangtools.yang.data.tree.api.TreeType;
-import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
private final MandatoryLeafEnforcer enforcer;
EnforcingMandatory(final ImmutableMap<NodeIdentifier, DataSchemaNode> children,
- final ImmutableMap<AugmentationIdentifier, AugmentationSchemaNode> augmentations,
final MandatoryLeafEnforcer enforcer) {
- super(children, augmentations);
+ super(children);
this.enforcer = requireNonNull(enforcer);
}
}
private final ImmutableMap<NodeIdentifier, DataSchemaNode> children;
- private final ImmutableMap<AugmentationIdentifier, AugmentationSchemaNode> augmentations;
- CaseEnforcer(final ImmutableMap<NodeIdentifier, DataSchemaNode> children,
- final ImmutableMap<AugmentationIdentifier, AugmentationSchemaNode> augmentations) {
+ CaseEnforcer(final ImmutableMap<NodeIdentifier, DataSchemaNode> children) {
this.children = requireNonNull(children);
- this.augmentations = requireNonNull(augmentations);
}
static CaseEnforcer forTree(final CaseSchemaNode schema, final DataTreeConfiguration treeConfig) {
final TreeType type = treeConfig.getTreeType();
final Builder<NodeIdentifier, DataSchemaNode> childrenBuilder = ImmutableMap.builder();
- final Builder<AugmentationIdentifier, AugmentationSchemaNode> augmentationsBuilder = ImmutableMap.builder();
if (SchemaAwareApplyOperation.belongsToTree(type, schema)) {
for (final DataSchemaNode child : schema.getChildNodes()) {
if (SchemaAwareApplyOperation.belongsToTree(type, child)) {
childrenBuilder.put(NodeIdentifier.create(child.getQName()), child);
}
}
- for (final AugmentationSchemaNode augment : schema.getAvailableAugmentations()) {
- if (augment.getChildNodes().stream()
- .anyMatch(child -> SchemaAwareApplyOperation.belongsToTree(type, child))) {
- augmentationsBuilder.put(DataSchemaContextNode.augmentationIdentifierFrom(augment), augment);
- }
- }
}
final ImmutableMap<NodeIdentifier, DataSchemaNode> children = childrenBuilder.build();
if (children.isEmpty()) {
return null;
}
- final ImmutableMap<AugmentationIdentifier, AugmentationSchemaNode> augmentations = augmentationsBuilder.build();
final var enforcer = MandatoryLeafEnforcer.forContainer(schema, treeConfig);
- return enforcer != null ? new EnforcingMandatory(children, augmentations, enforcer)
- : new CaseEnforcer(children, augmentations);
+ return enforcer != null ? new EnforcingMandatory(children, enforcer) : new CaseEnforcer(children);
}
final Set<Entry<NodeIdentifier, DataSchemaNode>> getChildEntries() {
return children.keySet();
}
- final Set<Entry<AugmentationIdentifier, AugmentationSchemaNode>> getAugmentationEntries() {
- return augmentations.entrySet();
- }
-
- final Set<AugmentationIdentifier> getAugmentationIdentifiers() {
- return augmentations.keySet();
- }
-
- final Set<PathArgument> getAllChildIdentifiers() {
- return Sets.union(children.keySet(), augmentations.keySet());
- }
-
void enforceOnTreeNode(final NormalizedNode normalizedNode) {
// Default is no-op
}
import java.util.Map.Entry;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.tree.impl.AbstractNodeContainerModificationStrategy.Visible;
import org.opendaylight.yangtools.yang.data.tree.impl.node.TreeNode;
import org.opendaylight.yangtools.yang.data.tree.impl.node.Version;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
childBuilder.put(entry.getKey(), childOper);
enforcerBuilder.put(entry.getKey(), enforcer);
}
- for (final Entry<AugmentationIdentifier, AugmentationSchemaNode> e
- : enforcer.getAugmentationEntries()) {
- childBuilder.put(e.getKey(), new AugmentationModificationStrategy(e.getValue(), caze, treeConfig));
- enforcerBuilder.put(e.getKey(), enforcer);
- }
}
}
childNodes = childBuilder.build();
// Make sure no leaves from other cases are present
for (final CaseEnforcer other : verifyNotNull(exclusions.get(enforcer))) {
- for (final PathArgument id : other.getAllChildIdentifiers()) {
+ for (final PathArgument id : other.getChildIdentifiers()) {
final Optional<NormalizedNode> maybeChild = NormalizedNodes.getDirectChild(normalizedNode, id);
checkArgument(!maybeChild.isPresent(),
"Child %s (from case %s) implies non-presence of child %s (from case %s), which is %s",
import java.lang.invoke.VarHandle;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.tree.api.DataTreeConfiguration;
import org.opendaylight.yangtools.yang.data.tree.impl.AbstractNodeContainerModificationStrategy.Visible;
-import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
import org.slf4j.Logger;
private ModificationApplyOperation resolveChild(final PathArgument identifier) {
final T schema = getSchema();
- if (identifier instanceof AugmentationIdentifier augId && schema instanceof AugmentationTarget augTarget) {
- return SchemaAwareApplyOperation.from(schema, augTarget, augId, treeConfig);
- }
-
final var qname = identifier.getNodeType();
final var child = schema.dataChildByName(qname);
if (child == null) {
import static com.google.common.base.Verify.verify;
import static java.util.Objects.requireNonNull;
-import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes;
-import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
}
static @NonNull MandatoryDescendant create(final YangInstanceIdentifier parentId,
- final DataNodeContainer parentSchema, final DataSchemaNode childSchema, final boolean inAugmentedSubtree) {
- final NodeIdentifier childId = NodeIdentifier.create(childSchema.getQName());
-
- if (childSchema.isAugmenting()) {
- if (!inAugmentedSubtree) {
- final AugmentationSchemaNode aug = getAugIdentifierOfChild(parentSchema, childSchema);
- return new MandatoryDescendant(
- parentId.node(DataSchemaContextNode.augmentationIdentifierFrom(aug)).node(childId).toOptimized(),
- parentId.node(childId).toOptimized());
- }
-
- final List<PathArgument> augSubtreePath = parentId.getPathArguments();
- // in case of augmented choice-case the pathArguments might be empty
- final YangInstanceIdentifier legacyPath = !augSubtreePath.isEmpty()
- ? YangInstanceIdentifier.create(augSubtreePath.subList(1, augSubtreePath.size())) : null;
- return new MandatoryDescendant(parentId.node(childId).toOptimized(), legacyPath);
- }
-
- return new MandatoryDescendant(parentId.node(childId).toOptimized(), null);
+ final DataNodeContainer parentSchema, final DataSchemaNode childSchema) {
+ return new MandatoryDescendant(parentId.node(NodeIdentifier.create(childSchema.getQName())).toOptimized(),
+ null);
}
void enforceOnData(final NormalizedNode data) {
package org.opendaylight.yangtools.yang.data.tree.impl;
import static java.util.Objects.requireNonNull;
-import static org.opendaylight.yangtools.yang.data.tree.impl.MandatoryDescendant.getAugIdentifierOfChild;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableList.Builder;
import org.opendaylight.yangtools.yang.data.tree.api.DataTreeConfiguration;
import org.opendaylight.yangtools.yang.data.tree.api.TreeType;
import org.opendaylight.yangtools.yang.data.tree.impl.node.TreeNode;
-import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.CopyableNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraintAware;
}
final var builder = ImmutableList.<MandatoryDescendant>builder();
- final var isAugmentingNode = schema instanceof CopyableNode && ((CopyableNode) schema).isAugmenting();
- findMandatoryNodes(builder, YangInstanceIdentifier.empty(), schema, treeConfig.getTreeType(), isAugmentingNode);
+ findMandatoryNodes(builder, YangInstanceIdentifier.empty(), schema, treeConfig.getTreeType());
final var mandatoryNodes = builder.build();
return mandatoryNodes.isEmpty() ? null : new MandatoryLeafEnforcer(mandatoryNodes);
}
enforceOnData(tree.getData());
}
- private static void findMandatoryNodes(final Builder<MandatoryDescendant> builder,
- final YangInstanceIdentifier id, final DataNodeContainer schema, final TreeType type,
- final boolean augmentedSubtree) {
+ private static void findMandatoryNodes(final Builder<MandatoryDescendant> builder, final YangInstanceIdentifier id,
+ final DataNodeContainer schema, final TreeType type) {
for (final DataSchemaNode child : schema.getChildNodes()) {
if (SchemaAwareApplyOperation.belongsToTree(type, child)) {
if (child instanceof ContainerSchemaNode container) {
if (!container.isPresenceContainer()) {
- if (!augmentedSubtree) {
- // this container is not part of augmented subtree.
- final boolean parentSchemaAugmenting = schema instanceof CopyableNode copyable
- && copyable.isAugmenting();
- if (container.isAugmenting() && !parentSchemaAugmenting) {
- // the container is augmenting, but the parent schema is not. Meaning this is the root
- // of the augmentation (the augmented subtree starts here). The container has to be
- // represented by AugmentationID and the whole subtree needs to be based on it.
- final AugmentationSchemaNode aug = getAugIdentifierOfChild(schema, child);
- findMandatoryNodes(builder, id.node(DataSchemaContextNode
- .augmentationIdentifierFrom(aug)).node(NodeIdentifier.create(container.getQName())),
- container, type, true);
- continue;
- }
- }
// the container is either:
// - not in an augmented subtree and not augmenting
// - in an augmented subtree
// in both cases just append the NodeID to the ongoing ID and continue the search.
- findMandatoryNodes(builder, id.node(NodeIdentifier.create(container.getQName())),
- container, type, augmentedSubtree);
+ findMandatoryNodes(builder, id.node(NodeIdentifier.create(container.getQName())), container,
+ type);
}
} else {
boolean needEnforce = child instanceof MandatoryAware aware && aware.isMandatory();
.orElse(Boolean.FALSE);
}
if (needEnforce) {
- final MandatoryDescendant desc = MandatoryDescendant.create(id, schema, child,
- augmentedSubtree);
+ final MandatoryDescendant desc = MandatoryDescendant.create(id, schema, child);
LOG.debug("Adding mandatory child {}", desc);
builder.add(desc);
}
import java.util.List;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.AnydataNode;
import org.opendaylight.yangtools.yang.data.api.schema.AnyxmlNode;
import org.opendaylight.yangtools.yang.data.tree.impl.node.Version;
import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
}
}
- static @Nullable AugmentationModificationStrategy from(final DataNodeContainer resolvedTree,
- final AugmentationTarget augSchemas, final AugmentationIdentifier identifier,
- final DataTreeConfiguration treeConfig) {
- for (final AugmentationSchemaNode potential : augSchemas.getAvailableAugmentations()) {
- for (final DataSchemaNode child : potential.getChildNodes()) {
- if (identifier.getPossibleChildNames().contains(child.getQName())) {
- return new AugmentationModificationStrategy(potential, resolvedTree, treeConfig);
- }
- }
- }
-
- return null;
- }
-
static void checkConflicting(final ModificationPath path, final boolean condition, final String message)
throws ConflictingModificationAppliedException {
if (!condition) {
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
final LeafRefContext referencingCtx, final ModificationType modificationType,
final YangInstanceIdentifier current) {
for (final DataContainerChild child : node.body()) {
- if (child instanceof AugmentationNode) {
- validateNodeData(child, referencedByCtx, referencingCtx, modificationType, current.node(
- child.getIdentifier()));
- return;
- }
-
validateChildNodeData(child, referencedByCtx, referencingCtx, modificationType, current);
}
}
for (final MapEntryNode mapEntry : node.asMap().values()) {
final YangInstanceIdentifier mapEntryIdentifier = current.node(mapEntry.getIdentifier());
for (final DataContainerChild child : mapEntry.body()) {
- if (child instanceof AugmentationNode) {
- validateNodeData(child, referencedByCtx, referencingCtx, modificationType, current.node(
- child.getIdentifier()));
- return;
- }
-
validateChildNodeData(child, referencedByCtx, referencingCtx, modificationType, mapEntryIdentifier);
}
}
final DataContainerChild child = parent.childByArg(arg);
if (child == null) {
// FIXME: YANGTOOLS-901. We have SchemaContext nearby, hence we should be able to cache how to get
- // to the leaf with with specified QName, without having to iterate through Choices/Augmentations.
+ // to the leaf with with specified QName, without having to iterate through Choices.
// That perhaps means we should not have QNameWithPredicates, but NodeIdentifierWithPredicates as
// the path specification.
for (final DataContainerChild mixin : parent.body()) {
- if (mixin instanceof AugmentationNode || mixin instanceof ChoiceNode) {
+ if (mixin instanceof ChoiceNode) {
addValues(values, mixin, nodePredicates, path, current);
}
}
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder;
import java.util.List;
-import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.schema.AnydataNode;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
protected static ChoiceNode createChoiceNode() {
return Builders.choiceBuilder()
.withNodeIdentifier(NodeIdentifier.create(CHOICE_QNAME))
- .withChild(createAugmentationNode())
- .build();
- }
-
- protected static AugmentationNode createAugmentationNode() {
- return Builders.augmentationBuilder()
- .withNodeIdentifier(AugmentationIdentifier
- .create(Set.of(AUGMENT_QNAME)))
.withChild(createAugmentedLeafNode())
.build();
}
*/
package org.opendaylight.yangtools.yang.data.tree.impl;
-import static org.junit.Assert.assertTrue;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertThrows;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.leafNode;
-import com.google.common.collect.ImmutableSet;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.tree.api.DataTree;
public class CaseAugmentTest {
private static final QName CHOICE1_QNAME = QName.create(TestModel.TEST_QNAME, "choice1");
- private static final QName C1L1_QNAME = QName.create(TestModel.TEST_QNAME, "case1-leaf1");
private static final QName C1L2_QNAME = QName.create(TestModel.TEST_QNAME, "case1-leaf2");
private static final QName C1L3_QNAME = QName.create(TestModel.TEST_QNAME, "case1-leaf3");
- private static final QName C2L1_QNAME = QName.create(TestModel.TEST_QNAME, "case2-leaf1");
private static final NodeIdentifier CHOICE_ID = new NodeIdentifier(CHOICE1_QNAME);
- private static final AugmentationIdentifier AUGMENT_ID = new AugmentationIdentifier(
- ImmutableSet.of(C1L2_QNAME, C1L3_QNAME));
private static EffectiveModelContext SCHEMA_CONTEXT;
public void testWriteAugment() throws DataValidationFailedException {
final DataTree inMemoryDataTree = initDataTree();
- AugmentationNode augmentationNode = Builders.augmentationBuilder()
- .withNodeIdentifier(AUGMENT_ID)
- .withChild(leafNode(C1L2_QNAME, "leaf-value"))
- .build();
-
final ContainerNode container = Builders.containerBuilder()
- .withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
- .withChild(
- Builders.choiceBuilder().withNodeIdentifier(CHOICE_ID)
- .withChild(augmentationNode)
- .build()).build();
+ .withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
+ .withChild(Builders.choiceBuilder()
+ .withNodeIdentifier(CHOICE_ID)
+ .withChild(leafNode(C1L2_QNAME, "leaf-value"))
+ .build())
+ .build();
final DataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
modificationTree.write(TestModel.TEST_PATH, container);
modificationTree.ready();
public void testWriteCase1All() throws DataValidationFailedException {
final DataTree inMemoryDataTree = initDataTree();
- AugmentationNode augmentationNode = Builders.augmentationBuilder()
- .withNodeIdentifier(AUGMENT_ID)
+ final DataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
+ modificationTree.write(TestModel.TEST_PATH, Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
+ .withChild(Builders.choiceBuilder()
+ .withNodeIdentifier(CHOICE_ID)
+ .withChild(leafNode(QName.create(TestModel.TEST_QNAME, "case1-leaf1"), "leaf-value"))
.withChild(leafNode(C1L2_QNAME, "leaf-value"))
.withChild(leafNode(C1L3_QNAME, "leaf-value"))
- .build();
-
- final ContainerNode container = Builders
- .containerBuilder()
- .withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
- .withChild(
- Builders.choiceBuilder().withNodeIdentifier(CHOICE_ID)
- .withChild(leafNode(QName.create(TestModel.TEST_QNAME, "case1-leaf1"), "leaf-value"))
- .withChild(augmentationNode)
- .build()).build();
- final DataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
- modificationTree.write(TestModel.TEST_PATH, container);
+ .build())
+ .build());
modificationTree.ready();
inMemoryDataTree.validate(modificationTree);
inMemoryDataTree.commit(prepare);
}
- @Test(expected = IllegalArgumentException.class)
+ @Test
public void testWriteConflict() throws DataValidationFailedException {
- final DataTree inMemoryDataTree = initDataTree();
-
- AugmentationNode augmentationNode = Builders.augmentationBuilder()
- .withNodeIdentifier(AUGMENT_ID)
+ final DataTreeModification modificationTree = initDataTree().takeSnapshot().newModification();
+ modificationTree.write(TestModel.TEST_PATH, Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
+ .withChild(Builders.choiceBuilder()
+ .withNodeIdentifier(CHOICE_ID)
.withChild(leafNode(C1L2_QNAME, "leaf-value"))
- .build();
-
- final ContainerNode container = Builders.containerBuilder()
- .withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
- .withChild(
- Builders.choiceBuilder().withNodeIdentifier(CHOICE_ID)
- .withChild(augmentationNode)
- .withChild(leafNode(QName.create(TestModel.TEST_QNAME, "case2-leaf1"), "leaf-value"))
- .build()).build();
-
- try {
- final DataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
- modificationTree.write(TestModel.TEST_PATH, container);
- modificationTree.ready();
+ .withChild(leafNode(QName.create(TestModel.TEST_QNAME, "case2-leaf1"), "leaf-value"))
+ .build())
+ .build());
- inMemoryDataTree.validate(modificationTree);
- final DataTreeCandidate prepare = inMemoryDataTree.prepare(modificationTree);
- inMemoryDataTree.commit(prepare);
- } catch (IllegalArgumentException e) {
- assertTrue(e.getMessage().contains("implies non-presence of child"));
- throw e;
- }
+ final IllegalArgumentException e = assertThrows(IllegalArgumentException.class, modificationTree::ready);
+ assertThat(e.getMessage(), containsString(" implies non-presence of child "));
}
}
public void testChoicePrettyTree() {
assertEquals(String.join("\n",
"choiceNode (urn:opendaylight:controller:sal:dom:store:test@2014-03-13)choice = {",
- " augmentationNode = {",
- " leafNode augment = \"Augmented leaf value\"",
- " }",
- "}"), createChoiceNode().prettyTree().get());
- }
-
- @Test
- public void testAugmentationPrettyTree() {
- assertEquals(String.join("\n",
- "augmentationNode (urn:opendaylight:controller:sal:dom:store:test@2014-03-13) = {",
" leafNode augment = \"Augmented leaf value\"",
- "}"), createAugmentationNode().prettyTree().get());
+ "}"), createChoiceNode().prettyTree().get());
}
@Test
" }",
" }",
" choiceNode choice = {",
- " augmentationNode = {",
- " leafNode augment = \"Augmented leaf value\"",
- " }",
+ " leafNode augment = \"Augmented leaf value\"",
" }",
" anydataNode any-data = (java.lang.String)",
" unkeyedListNode unkeyed-list = {",
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThrows;
-import java.util.Set;
import java.util.function.Consumer;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
applyOperation(mod -> {
mod.write(YangInstanceIdentifier.of(FOO), Builders.containerBuilder()
.withNodeIdentifier(new NodeIdentifier(FOO))
- .withChild(Builders.augmentationBuilder()
- .withNodeIdentifier(new AugmentationIdentifier(Set.of(BAR)))
- .withChild(ImmutableNodes.leafNode(BAR, "xyzzy"))
- .build())
+ .withChild(ImmutableNodes.leafNode(BAR, "xyzzy"))
.build());
});
}
.withNodeIdentifier(new NodeIdentifier(FOO))
.build());
});
- assertEquals(
- "Node (foo)foo is missing mandatory descendant /AugmentationIdentifier{childNames=[(foo)bar]}/(foo)bar",
- ex.getMessage());
+ assertEquals("Node (foo)foo is missing mandatory descendant /(foo)bar", ex.getMessage());
}
@Test
.withChild(Builders.choiceBuilder()
.withNodeIdentifier(new NodeIdentifier(BAZ))
.withChild(ImmutableNodes.leafNode(XYZZY_LEAF, "xyzzy"))
- .withChild(Builders.augmentationBuilder()
- .withNodeIdentifier(new AugmentationIdentifier(Set.of(XYZZY_AUGMENT, XYZZY_AUGMENT_CONT)))
- .withChild(ImmutableNodes.leafNode(XYZZY_AUGMENT, "xyzzy"))
+ .withChild(ImmutableNodes.leafNode(XYZZY_AUGMENT, "xyzzy"))
+ .withChild(Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(XYZZY_AUGMENT_CONT))
.withChild(Builders.containerBuilder()
- .withNodeIdentifier(new NodeIdentifier(XYZZY_AUGMENT_CONT))
- .withChild(Builders.containerBuilder()
- .withNodeIdentifier(new NodeIdentifier(XYZZY_AUGMENT_CONT_INNER))
- .withChild(ImmutableNodes.leafNode(XYZZY_AUGMENT_CONT_LEAF, "aug-cont-leaf"))
- .build())
+ .withNodeIdentifier(new NodeIdentifier(XYZZY_AUGMENT_CONT_INNER))
+ .withChild(ImmutableNodes.leafNode(XYZZY_AUGMENT_CONT_LEAF, "aug-cont-leaf"))
.build())
.build())
.build())
.withNodeIdentifier(new NodeIdentifier(BAR))
.withChild(Builders.choiceBuilder()
.withNodeIdentifier(new NodeIdentifier(BAZ))
- .withChild(Builders.augmentationBuilder()
- .withNodeIdentifier(new AugmentationIdentifier(Set.of(XYZZY_AUGMENT, XYZZY_AUGMENT_CONT)))
- .withChild(ImmutableNodes.leafNode(XYZZY_AUGMENT, "xyzzy"))
+ .withChild(ImmutableNodes.leafNode(XYZZY_AUGMENT, "xyzzy"))
+ .withChild(Builders.containerBuilder()
+ .withNodeIdentifier(NodeIdentifier.create(XYZZY_AUGMENT_CONT))
.withChild(Builders.containerBuilder()
- .withNodeIdentifier(NodeIdentifier.create(XYZZY_AUGMENT_CONT))
- .withChild(Builders.containerBuilder()
- .withNodeIdentifier(NodeIdentifier.create(XYZZY_AUGMENT_CONT_INNER))
- .withChild(ImmutableNodes.leafNode(XYZZY_AUGMENT_CONT_LEAF, "aug-cont-leaf"))
- .build())
+ .withNodeIdentifier(NodeIdentifier.create(XYZZY_AUGMENT_CONT_INNER))
+ .withChild(ImmutableNodes.leafNode(XYZZY_AUGMENT_CONT_LEAF, "aug-cont-leaf"))
.build())
.build())
.build())
.build())
.build());
});
- assertEquals("Node (foo)baz is missing mandatory descendant /AugmentationIdentifier{childNames="
- + "[(foo)xyzzy-augment, (foo)xyzzy-augment-container]}/(foo)xyzzy-augment", ex.getMessage());
+ assertEquals("Node (foo)baz is missing mandatory descendant /(foo)xyzzy-augment", ex.getMessage());
}
*/
package org.opendaylight.yangtools.yang.data.tree.leafref;
-import com.google.common.collect.ImmutableSet;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
.withChild(ImmutableNodes.leafNode(NAME, "bar1"))
.withChild(Builders.containerBuilder()
.withNodeIdentifier(new NodeIdentifier(CONTAINER_IN_LIST))
- .withChild(Builders.augmentationBuilder()
- .withNodeIdentifier(AugmentationIdentifier.create(ImmutableSet.of(REF_FROM_AUG)))
- .withChild(ImmutableNodes.leafNode(REF_FROM_AUG, refValue))
- .build())
+ .withChild(ImmutableNodes.leafNode(REF_FROM_AUG, refValue))
.build())
.build())
.build())
.withChild(Builders.mapEntryBuilder()
.withNodeIdentifier(NodeIdentifierWithPredicates.of(BAR, NAME, "bar1"))
.withChild(ImmutableNodes.leafNode(NAME, "bar1"))
- .withChild(Builders.augmentationBuilder()
- .withNodeIdentifier(AugmentationIdentifier.create(ImmutableSet.of(CONTAINER_FROM_AUG)))
- .withChild(Builders.containerBuilder()
- .withNodeIdentifier(new NodeIdentifier(CONTAINER_FROM_AUG))
- .withChild(ImmutableNodes.leafNode(REF_IN_CONTAINER, refValue))
- .build())
+ .withChild(Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(CONTAINER_FROM_AUG))
+ .withChild(ImmutableNodes.leafNode(REF_IN_CONTAINER, refValue))
.build())
.build())
.build())
package org.opendaylight.yangtools.yang.data.tree.leafref;
import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint8;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
.withChild(ImmutableNodes.leafNode(IDENTIFIER, BGP_POLICY))
.withChild(ImmutableNodes.leafNode(NAME, "test-bgp-instance"))
.build())
- .withChild(Builders.augmentationBuilder()
- .withNodeIdentifier(
- AugmentationIdentifier.create(ImmutableSet.of(TEST_BGP)))
+ .withChild(Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(TEST_BGP))
.withChild(Builders.containerBuilder()
- .withNodeIdentifier(new NodeIdentifier(TEST_BGP))
- .withChild(Builders.containerBuilder()
- .withNodeIdentifier(new NodeIdentifier(NEIGHBORS))
- .withChild(Builders.mapBuilder()
- .withNodeIdentifier(new NodeIdentifier(NEIGHBOR))
- .withChild(Builders.mapEntryBuilder()
- .withNodeIdentifier(NodeIdentifierWithPredicates.of(NEIGHBOR,
- NEIGHBOR_ADDRESS, "10.25.1.9"))
- .withChild(ImmutableNodes.leafNode(NEIGHBOR_ADDRESS,
- "10.25.1.9"))
- .withChild(Builders.containerBuilder()
- .withNodeIdentifier(new NodeIdentifier(TEST_CONFIG))
- .withChild(Builders.augmentationBuilder()
- .withNodeIdentifier(AugmentationIdentifier.create(
- ImmutableSet.of(TEST_PEER_GROUP)))
- .withChild(ImmutableNodes.leafNode(TEST_PEER_GROUP,
- "application-peers"))
- .build())
- .build())
- .withChild(Builders.containerBuilder()
- .withNodeIdentifier(new NodeIdentifier(AFI_SAFIS))
- .withChild(Builders.mapBuilder()
- .withNodeIdentifier(new NodeIdentifier(AFI_SAFI))
- .withChild(Builders.mapEntryBuilder()
- .withNodeIdentifier(NodeIdentifierWithPredicates.of(
- AFI_SAFI,
- ImmutableMap.of(AFI_SAFI_NAME, IPV4_UNICAST)))
- .withChild(ImmutableNodes.leafNode(AFI_SAFI_NAME,
- IPV4_UNICAST))
- .withChild(Builders.containerBuilder()
- .withNodeIdentifier(
- new NodeIdentifier(TEST_CONFIG))
- .withChild(ImmutableNodes.leafNode(
- AFI_SAFI_NAME, IPV4_UNICAST))
- .build())
- .withChild(Builders.augmentationBuilder()
- .withNodeIdentifier(
- AugmentationIdentifier.create(
- ImmutableSet.of(RECEIVE, SEND_MAX)))
- .withChild(ImmutableNodes.leafNode(RECEIVE,
- Boolean.TRUE))
- .withChild(ImmutableNodes.leafNode(SEND_MAX,
- Uint8.ZERO))
- .build())
+ .withNodeIdentifier(new NodeIdentifier(NEIGHBORS))
+ .withChild(Builders.mapBuilder()
+ .withNodeIdentifier(new NodeIdentifier(NEIGHBOR))
+ .withChild(Builders.mapEntryBuilder()
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(NEIGHBOR,
+ NEIGHBOR_ADDRESS, "10.25.1.9"))
+ .withChild(ImmutableNodes.leafNode(NEIGHBOR_ADDRESS, "10.25.1.9"))
+ .withChild(Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(TEST_CONFIG))
+ .withChild(ImmutableNodes.leafNode(TEST_PEER_GROUP,
+ "application-peers"))
+ .build())
+ .withChild(Builders.containerBuilder()
+ .withNodeIdentifier(new NodeIdentifier(AFI_SAFIS))
+ .withChild(Builders.mapBuilder()
+ .withNodeIdentifier(new NodeIdentifier(AFI_SAFI))
+ .withChild(Builders.mapEntryBuilder()
+ .withNodeIdentifier(NodeIdentifierWithPredicates.of(
+ AFI_SAFI,
+ ImmutableMap.of(AFI_SAFI_NAME, IPV4_UNICAST)))
+ .withChild(ImmutableNodes.leafNode(AFI_SAFI_NAME,
+ IPV4_UNICAST))
+ .withChild(Builders.containerBuilder()
+ .withNodeIdentifier(
+ new NodeIdentifier(TEST_CONFIG))
+ .withChild(ImmutableNodes.leafNode(
+ AFI_SAFI_NAME, IPV4_UNICAST))
.build())
+ .withChild(ImmutableNodes.leafNode(RECEIVE,
+ Boolean.TRUE))
+ .withChild(ImmutableNodes.leafNode(SEND_MAX,
+ Uint8.ZERO))
.build())
.build())
.build())
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * 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.yangtools.yang.data.util;
-
-import java.util.Set;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.util.EffectiveAugmentationSchema;
-import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
-
-final class AugmentationContextNode extends DataContainerContextNode<AugmentationIdentifier> {
- AugmentationContextNode(final AugmentationSchemaNode augmentation, final DataNodeContainer target) {
- super(augmentationIdentifierFrom(augmentation), new EffectiveAugmentationSchema(augmentation, target), null);
- }
-
- @Override
- public boolean isMixin() {
- return true;
- }
-
- @Override
- protected DataSchemaContextNode<?> fromLocalSchemaAndQName(final DataNodeContainer schema, final QName child) {
- final DataSchemaNode result = findChildSchemaNode(schema, child);
- // We try to look up if this node was added by augmentation
- if (schema instanceof DataSchemaNode && result.isAugmenting()) {
- return fromAugmentation(schema, (AugmentationTarget) schema, result);
- }
- return lenientOf(result);
- }
-
- @Override
- protected Set<QName> getQNameIdentifiers() {
- return getIdentifier().getPossibleChildNames();
- }
-
- @Override
- protected void pushToStack(final SchemaInferenceStack stack) {
- // No-op
- }
-}
import java.util.Collection;
import java.util.Deque;
import java.util.List;
-import java.util.Map.Entry;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter.MetadataExtension;
for (AbstractNodeDataWithSchema<?> child : children) {
child.write(writer, metaWriter);
}
- for (Entry<AugmentationSchemaNode, Collection<AbstractNodeDataWithSchema<?>>> augmentationToChild
- : augmentationsToChild.asMap().entrySet()) {
- final Collection<AbstractNodeDataWithSchema<?>> childsFromAgumentation = augmentationToChild.getValue();
- if (!childsFromAgumentation.isEmpty()) {
- // FIXME: can we get the augmentation schema?
- writer.startAugmentationNode(DataSchemaContextNode.augmentationIdentifierFrom(
- augmentationToChild.getKey()));
-
- for (AbstractNodeDataWithSchema<?> nodeDataWithSchema : childsFromAgumentation) {
- nodeDataWithSchema.write(writer, metaWriter);
- }
-
- writer.endNode();
+ for (var childsFromAgumentation : augmentationsToChild.asMap().values()) {
+ for (var nodeDataWithSchema : childsFromAgumentation) {
+ nodeDataWithSchema.write(writer, metaWriter);
}
}
}
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
}
private DataSchemaContextNode<?> fromLocalSchema(final PathArgument child) {
- if (child instanceof AugmentationIdentifier augId) {
- return fromSchemaAndQNameChecked(container, augId.getPossibleChildNames().iterator().next());
- }
return fromSchemaAndQNameChecked(container, child.getNodeType());
}
import com.google.common.collect.Iterables;
import java.util.Optional;
import java.util.Set;
-import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.AbstractSimpleIdentifiable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerLike;
* This node is a {@link NormalizedNode} intermediate, not represented in RFC7950 XML encoding. This is typically
* one of
* <ul>
- * <li>{@link AugmentationNode} backed by an {@link AugmentationSchemaNode}, or</li>
* <li>{@link ChoiceNode} backed by a {@link ChoiceSchemaNode}, or</li>
* <li>{@link LeafSetNode} backed by a {@link LeafListSchemaNode}, or</li>
* <li>{@link MapNode} backed by a {@link ListSchemaNode} with a non-empty
}
static DataSchemaContextNode<?> fromSchemaAndQNameChecked(final DataNodeContainer schema, final QName child) {
- final DataSchemaNode result = findChildSchemaNode(schema, child);
- // We try to look up if this node was added by augmentation
- if (result != null && schema instanceof DataSchemaNode && result.isAugmenting()) {
- return fromAugmentation(schema, (AugmentationTarget) schema, result);
- }
- return lenientOf(result);
+ return lenientOf(findChildSchemaNode(schema, child));
}
// FIXME: this looks like it should be a Predicate on a stream with findFirst()
return null;
}
- /**
- * Create AugmentationIdentifier from an AugmentationSchemaNode.
- *
- * @param schema Augmentation schema
- * @return AugmentationIdentifier for the schema
- * @throws NullPointerException if {@code schema} is null
- */
- public static AugmentationIdentifier augmentationIdentifierFrom(final AugmentationSchemaNode schema) {
- return new AugmentationIdentifier(schema.getChildNodes().stream().map(DataSchemaNode::getQName)
- .collect(Collectors.toSet()));
- }
-
static @NonNull DataSchemaContextNode<?> of(final @NonNull DataSchemaNode schema) {
if (schema instanceof ContainerLike containerLike) {
return new ContainerContextNode(containerLike);
}
}
- /**
- * Returns a DataContextNodeOperation for provided child node
- *
- * <p>
- * If supplied child is added by Augmentation this operation returns a DataSchemaContextNode for augmentation,
- * otherwise returns a DataSchemaContextNode for child as call for {@link #lenientOf(DataSchemaNode)}.
- */
- static @Nullable DataSchemaContextNode<?> fromAugmentation(final DataNodeContainer parent,
- final AugmentationTarget parentAug, final DataSchemaNode child) {
- for (AugmentationSchemaNode aug : parentAug.getAvailableAugmentations()) {
- if (aug.dataChildByName(child.getQName()) != null) {
- return new AugmentationContextNode(aug, parent);
- }
- }
- return lenientOf(child);
- }
-
private static @NonNull DataSchemaContextNode<?> fromListSchemaNode(final ListSchemaNode potential) {
var keyDefinition = potential.getKeyDefinition();
if (keyDefinition.isEmpty()) {
package org.opendaylight.yangtools.yang.data.util;
import com.google.common.annotations.Beta;
-import java.util.HashSet;
import java.util.Optional;
-import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
}
public static Optional<CaseSchemaNode> detectCase(final ChoiceSchemaNode schema, final DataContainerChild child) {
- if (child instanceof AugmentationNode augment) {
- return detectCase(schema, augment);
- }
-
final QName childId = child.getIdentifier().getNodeType();
for (final CaseSchemaNode choiceCaseNode : schema.getCases()) {
if (choiceCaseNode.dataChildByName(childId) != null) {
return Optional.empty();
}
- public static Optional<CaseSchemaNode> detectCase(final ChoiceSchemaNode schema, final AugmentationNode child) {
- final AugmentationIdentifier childId = child.getIdentifier();
- for (final CaseSchemaNode choiceCaseNode : schema.getCases()) {
- if (belongsToCaseAugment(choiceCaseNode, childId)) {
- return Optional.of(choiceCaseNode);
- }
- }
- return Optional.empty();
- }
-
- private static boolean belongsToCaseAugment(final CaseSchemaNode caseNode,
- final AugmentationIdentifier childToProcess) {
- for (final AugmentationSchemaNode augmentationSchema : caseNode.getAvailableAugmentations()) {
-
- final Set<QName> currentAugmentChildNodes = new HashSet<>();
- for (final DataSchemaNode dataSchemaNode : augmentationSchema.getChildNodes()) {
- currentAugmentChildNodes.add(dataSchemaNode.getQName());
- }
-
- if (childToProcess.getPossibleChildNames().equals(currentAugmentChildNodes)) {
- return true;
- }
- }
-
- return false;
- }
-
/**
* Tries to find in {@code parent} which is dealed as augmentation target node with QName as {@code child}. If such
* node is found then it is returned, else null.
import java.util.Deque;
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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;
enterMetadataNode(name);
}
- @Override
- public void startAugmentationNode(final AugmentationIdentifier identifier) throws IOException {
- super.startAugmentationNode(identifier);
- enterMetadataNode(identifier);
- }
-
@Override
public boolean startAnyxmlNode(final NodeIdentifier name, final Class<?> objectModel) throws IOException {
final boolean ret = super.startAnyxmlNode(name, objectModel);
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
-import com.google.common.collect.Iterables;
import java.io.IOException;
import java.util.ArrayDeque;
import java.util.Deque;
-import java.util.Set;
-import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
-import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerLike;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.stmt.RpcEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
-import org.opendaylight.yangtools.yang.model.util.EffectiveAugmentationSchema;
import org.opendaylight.yangtools.yang.model.util.LeafrefResolver;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
}
return ret;
}
-
- public AugmentationSchemaNode startAugmentationNode(final AugmentationIdentifier identifier) {
- LOG.debug("Enter augmentation {}", identifier);
- Object parent = getParent();
-
- checkArgument(parent instanceof AugmentationTarget, "Augmentation not allowed under %s", parent);
- if (parent instanceof ChoiceSchemaNode choice) {
- final QName name = Iterables.get(identifier.getPossibleChildNames(), 0);
- parent = findCaseByChild(choice, name);
- }
- checkArgument(parent instanceof DataNodeContainer, "Augmentation allowed only in DataNodeContainer", parent);
- final AugmentationSchemaNode schema = findSchemaForAugment((AugmentationTarget) parent,
- identifier.getPossibleChildNames());
- final AugmentationSchemaNode resolvedSchema = new EffectiveAugmentationSchema(schema,
- (DataNodeContainer) parent);
- schemaStack.push(resolvedSchema);
- return resolvedSchema;
- }
-
- // FIXME: 7.0.0: can we get rid of this?
- private static @NonNull AugmentationSchemaNode findSchemaForAugment(final AugmentationTarget schema,
- final Set<QName> qnames) {
- for (final AugmentationSchemaNode augment : schema.getAvailableAugmentations()) {
- if (qnames.equals(augment.getChildNodes().stream()
- .map(DataSchemaNode::getQName)
- .collect(Collectors.toUnmodifiableSet()))) {
- return augment;
- }
- }
-
- throw new IllegalStateException(
- "Unknown augmentation node detected, identified by: " + qnames + ", in: " + schema);
- }
-
- // FIXME: 7.0.0: can we get rid of this?
- private static SchemaNode findCaseByChild(final ChoiceSchemaNode parent, final QName qname) {
- for (final CaseSchemaNode caze : parent.getCases()) {
- if (caze.dataChildByName(qname) != null) {
- return caze;
- }
- }
- return null;
- }
}
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
-import java.util.Set;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ContainerEffectiveStatement;
final var one = assertInstanceOf(ContainerContextNode.class, CONTEXT.getRoot().enterChild(stack, ONE));
assertInstanceOf(ContainerEffectiveStatement.class, stack.currentStatement());
- final var augment = assertInstanceOf(AugmentationContextNode.class, one.enterChild(FIVE, stack));
- assertInstanceOf(ContainerEffectiveStatement.class, stack.currentStatement());
-
- final var five = assertInstanceOf(UnkeyedListMixinContextNode.class, augment.enterChild(FIVE, stack));
+ final var five = assertInstanceOf(UnkeyedListMixinContextNode.class, one.enterChild(FIVE, stack));
assertInstanceOf(ListEffectiveStatement.class, stack.currentStatement());
assertInstanceOf(UnkeyedListItemContextNode.class, five.enterChild(FIVE, stack));
void testEnterAugmentPath() {
final var result = CONTEXT.enterPath(YangInstanceIdentifier.create(
new NodeIdentifier(ONE),
- new AugmentationIdentifier(Set.of(FIVE)),
new NodeIdentifier(FIVE),
new NodeIdentifier(FIVE)))
.orElseThrow();
Code Review / yangtools.git / commitdiff