import static com.google.common.base.Preconditions.checkNotNull;
import java.util.Iterator;
-import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
* @return serialized normalized node for provided instance Id
*/
public static @NonNull NormalizedNode fromInstanceId(final SchemaContext ctx, final YangInstanceIdentifier id) {
- return fromInstanceIdImpl(ctx, id, Optional.empty());
- }
-
- /**
- * Convert YangInstanceIdentifier into a normalized node structure.
- *
- * @param ctx schema context to used during serialization
- * @param id instance identifier to convert to node structure starting from root
- * @param deepestElement pre-built deepest child that will be inserted at the last path argument of provided
- * instance identifier
- * @return serialized normalized node for provided instance Id with overridden last child.
- * @deprecated This method is a historic hack, which has only a single downstream user. It is scheduled for removal
- * without a replacement.
- */
- @Deprecated(since = "7.0.12", forRemoval = true)
- public static @NonNull NormalizedNode fromInstanceId(final SchemaContext ctx, final YangInstanceIdentifier id,
- final NormalizedNode deepestElement) {
- return fromInstanceIdImpl(ctx, id, Optional.of(deepestElement));
- }
-
- /**
- * Convert YangInstanceIdentifier into a normalized node structure.
- *
- * @param ctx schema context to used during serialization
- * @param id instance identifier to convert to node structure starting from root
- * @param deepestElement pre-built deepest child that will be inserted at the last path argument of provided
- * instance identifier
- * @return serialized normalized node for provided instance Id with (optionally) overridden last child
- * and (optionally) marked with specific operation attribute.
- * @deprecated This method is a historic hack, which has only a single downstream user. It is scheduled for removal
- * without a replacement.
- */
- @Deprecated(since = "7.0.12", forRemoval = true)
- public static @NonNull NormalizedNode fromInstanceId(final SchemaContext ctx, final YangInstanceIdentifier id,
- final Optional<NormalizedNode> deepestElement) {
- return fromInstanceIdImpl(ctx, id, deepestElement);
- }
-
- private static @NonNull NormalizedNode fromInstanceIdImpl(final SchemaContext ctx, final YangInstanceIdentifier id,
- final Optional<NormalizedNode> deepestElement) {
final PathArgument topLevelElement;
final InstanceIdToNodes<?> instanceIdToNodes;
final Iterator<PathArgument> it = id.getPathArguments().iterator();
instanceIdToNodes = InstanceIdToNodes.fromDataSchemaNode(ctx);
}
- return instanceIdToNodes.create(topLevelElement, it, deepestElement);
+ return instanceIdToNodes.create(topLevelElement, it);
}
}
import static com.google.common.base.Verify.verify;
import static java.util.Objects.requireNonNull;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
-import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.util.ImmutableOffsetMap;
@Override
@SuppressWarnings("unchecked")
- final NormalizedNode create(final PathArgument first, final Iterator<PathArgument> others,
- final Optional<NormalizedNode> lastChild) {
+ final NormalizedNode create(final PathArgument first, final Iterator<PathArgument> others) {
if (!isMixin()) {
final QName type = getIdentifier().getNodeType();
if (type != null) {
if (others.hasNext()) {
final PathArgument childPath = others.next();
final InstanceIdToNodes<?> childOp = getChildOperation(childPath);
- builder.addChild(childOp.create(childPath, others, lastChild));
- } else if (lastChild.isPresent()) {
- builder.withValue(ImmutableList.copyOf((Collection<?>) lastChild.get().body()));
+ builder.addChild(childOp.create(childPath, others));
}
return builder.build();
UnorderedMapMixinNormalization(final ListSchemaNode list) {
super(NodeIdentifier.create(list.getQName()));
- this.innerNode = new MapEntryNormalization(list);
+ innerNode = new MapEntryNormalization(list);
}
@Override
package org.opendaylight.yangtools.yang.data.impl.schema;
import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkState;
import com.google.common.collect.Iterables;
import java.util.Iterator;
import java.util.List;
import java.util.Optional;
-import javax.xml.transform.dom.DOMSource;
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.NodeIdentifier;
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.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
import org.opendaylight.yangtools.yang.data.api.schema.builder.CollectionNodeBuilder;
-import org.opendaylight.yangtools.yang.data.api.schema.builder.NormalizedNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
/**
* Convert instance identifier into a NormalizedNode structure.
*
- * @param instanceId Instance identifier to transform into NormalizedNodes
- * @param deepestChild Optional normalized node to be inserted as the last child
- * @param operation Optional modify operation to be set on the last child
+ * @param first First path argument
+ * @param others Subsequent path arguments
* @return NormalizedNode structure corresponding to submitted instance ID
*/
- abstract @NonNull NormalizedNode create(PathArgument first, Iterator<PathArgument> others,
- Optional<NormalizedNode> deepestChild);
+ abstract @NonNull NormalizedNode create(PathArgument first, Iterator<PathArgument> others);
abstract boolean isMixin();
UnkeyedListMixinNormalization(final ListSchemaNode list) {
super(NodeIdentifier.create(list.getQName()));
- this.innerNode = new UnkeyedListItemNormalization(list);
+ innerNode = new UnkeyedListItemNormalization(list);
}
@Override
}
}
- private abstract static class AbstractOpaqueNormalization extends InstanceIdToNodes<NodeIdentifier> {
- AbstractOpaqueNormalization(final DataSchemaNode schema) {
- super(NodeIdentifier.create(schema.getQName()));
+ private static final class OpaqueNormalization extends InstanceIdToNodes<NodeIdentifier> {
+ private OpaqueNormalization(final QName qname) {
+ super(NodeIdentifier.create(qname));
}
- @Override
- final InstanceIdToNodes<?> getChild(final PathArgument child) {
- return null;
+ OpaqueNormalization(final AnydataSchemaNode schema) {
+ this(schema.getQName());
}
- @Override
- final boolean isMixin() {
- return false;
- }
- }
-
- private static final class AnydataNormalization extends AbstractOpaqueNormalization {
- AnydataNormalization(final AnydataSchemaNode schema) {
- super(schema);
+ OpaqueNormalization(final AnyxmlSchemaNode schema) {
+ this(schema.getQName());
}
@Override
- NormalizedNode create(final PathArgument first, final Iterator<PathArgument> others,
- final Optional<NormalizedNode> deepestChild) {
- checkState(deepestChild.isPresent(), "Cannot instantiate anydata node without a value");
- final NormalizedNode child = deepestChild.get();
- checkState(child instanceof AnydataNode, "Invalid child %s", child);
- return createAnydata((AnydataNode<?>) child);
- }
-
- private <T> AnydataNode<T> createAnydata(final AnydataNode<T> child) {
- return Builders.anydataBuilder(child.bodyObjectModel()).withValue(child.body())
- .withNodeIdentifier(getIdentifier()).build();
+ InstanceIdToNodes<?> getChild(final PathArgument child) {
+ return null;
}
- }
- private static final class AnyXmlNormalization extends AbstractOpaqueNormalization {
- AnyXmlNormalization(final AnyxmlSchemaNode schema) {
- super(schema);
+ @Override
+ boolean isMixin() {
+ return false;
}
@Override
- NormalizedNode create(final PathArgument first, final Iterator<PathArgument> others,
- final Optional<NormalizedNode> deepestChild) {
- final NormalizedNodeBuilder<NodeIdentifier, DOMSource, DOMSourceAnyxmlNode> builder =
- Builders.anyXmlBuilder()
- .withNodeIdentifier(getIdentifier());
- if (deepestChild.isPresent()) {
- final NormalizedNode child = deepestChild.get();
- checkState(child instanceof DOMSourceAnyxmlNode, "Invalid child %s", child);
- builder.withValue(((DOMSourceAnyxmlNode) child).body());
- }
-
- return builder.build();
+ NormalizedNode create(final PathArgument first, final Iterator<PathArgument> others) {
+ throw new IllegalStateException("Cannot instantiate opaque node without a value");
}
}
} else if (potential instanceof LeafListSchemaNode) {
return fromLeafListSchemaNode((LeafListSchemaNode) potential);
} else if (potential instanceof AnydataSchemaNode) {
- return new AnydataNormalization((AnydataSchemaNode) potential);
+ return new OpaqueNormalization((AnydataSchemaNode) potential);
} else if (potential instanceof AnyxmlSchemaNode) {
- return new AnyXmlNormalization((AnyxmlSchemaNode) potential);
+ return new OpaqueNormalization((AnyxmlSchemaNode) potential);
}
return null;
}
import static com.google.common.base.Preconditions.checkArgument;
import java.util.Iterator;
-import java.util.Optional;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
}
@Override
- final NormalizedNode create(final PathArgument first, final Iterator<PathArgument> others,
- final Optional<NormalizedNode> deepestChild) {
- final NormalizedNodeBuilder<? extends PathArgument, Object, ? extends NormalizedNode> builder =
- getBuilder(first);
-
- if (deepestChild.isPresent()) {
- builder.withValue(deepestChild.orElseThrow().body());
- }
-
- return builder.build();
+ final NormalizedNode create(final PathArgument first, final Iterator<PathArgument> others) {
+ return getBuilder(first).build();
}
@Override
import static org.junit.Assert.assertEquals;
import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import java.util.Map;
import org.junit.AfterClass;
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.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
private static EffectiveModelContext ctx;
private final NodeIdentifier rootContainer = new NodeIdentifier(QName.create(NS, REVISION, "test"));
- private final NodeIdentifier outerContainer = new NodeIdentifier(QName.create(NS, REVISION, "outer-container"));
- private final NodeIdentifier augmentedLeaf = new NodeIdentifier(QName.create(NS, REVISION, "augmented-leaf"));
- private final AugmentationIdentifier augmentation = new AugmentationIdentifier(
- ImmutableSet.of(augmentedLeaf.getNodeType()));
-
private final NodeIdentifier outerList = new NodeIdentifier(QName.create(NS, REVISION, "outer-list"));
private final NodeIdentifierWithPredicates outerListWithKey = NodeIdentifierWithPredicates.of(
QName.create(NS, REVISION, "outer-list"), ID, 1);
- private final NodeIdentifier choice = new NodeIdentifier(QName.create(NS, REVISION, "outer-choice"));
- private final NodeIdentifier leafFromCase = new NodeIdentifier(QName.create(NS, REVISION, "one"));
private final NodeIdentifier leafList = new NodeIdentifier(QName.create(NS, REVISION, "ordered-leaf-list"));
private final NodeWithValue<?> leafListWithValue = new NodeWithValue<>(leafList.getNodeType(), "abcd");
ctx = null;
}
- @Test
- @Deprecated(since = "7.0.12", forRemoval = true)
- public void testInAugment() {
- final LeafNode<?> leaf = Builders.leafBuilder().withNodeIdentifier(augmentedLeaf).withValue("").build();
- final ContainerNode expectedFilter = Builders
- .containerBuilder()
- .withNodeIdentifier(rootContainer)
- .withChild(
- Builders.containerBuilder()
- .withNodeIdentifier(outerContainer)
- .withChild(
- Builders.augmentationBuilder()
- .withNodeIdentifier(augmentation)
- .withChild(
- leaf).build()).build()).build();
-
- final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(rootContainer, outerContainer, augmentation, augmentedLeaf), leaf);
- assertEquals(expectedFilter, filter);
- }
-
- @Test
- @Deprecated(since = "7.0.12", forRemoval = true)
- public void testInAugmentLeafOverride() {
- final LeafNode<Object> lastLeaf = Builders.leafBuilder().withNodeIdentifier(augmentedLeaf)
- .withValue("randomValue").build();
-
- final ContainerNode expectedFilter = Builders
- .containerBuilder()
- .withNodeIdentifier(rootContainer)
- .withChild(
- Builders.containerBuilder()
- .withNodeIdentifier(outerContainer)
- .withChild(
- Builders.augmentationBuilder().withNodeIdentifier(augmentation)
- .withChild(lastLeaf).build()).build()).build();
-
- final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(rootContainer, outerContainer, augmentation, augmentedLeaf), lastLeaf);
- assertEquals(expectedFilter, filter);
- }
-
- @Test
- @Deprecated(since = "7.0.12", forRemoval = true)
- public void testListChoice() {
- final LeafNode<?> leaf = Builders.leafBuilder().withNodeIdentifier(leafFromCase).withValue("").build();
- final ContainerNode expectedFilter = Builders
- .containerBuilder()
- .withNodeIdentifier(rootContainer)
- .withChild(
- Builders.mapBuilder()
- .withNodeIdentifier(outerList)
- .withChild(
- Builders.mapEntryBuilder()
- .withNodeIdentifier(outerListWithKey)
- .withChild(
- Builders.leafBuilder()
- .withNodeIdentifier(
- new NodeIdentifier(ID))
- .withValue(1).build())
- .withChild(
- Builders.choiceBuilder()
- .withNodeIdentifier(choice)
- .withChild(leaf)
- .build())
- .build())
- .build())
- .build();
-
- final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey, choice, leafFromCase), leaf);
- assertEquals(expectedFilter, filter);
- }
-
- @Test
- @Deprecated(since = "7.0.12", forRemoval = true)
- public void testTopContainerLastChildOverride() {
- final ContainerNode expectedStructure = Builders
- .containerBuilder()
- .withNodeIdentifier(rootContainer)
- .withChild(
- Builders.mapBuilder()
- .withNodeIdentifier(outerList)
- .withChild(
- Builders.mapEntryBuilder()
- .withNodeIdentifier(outerListWithKey)
- .withChild(
- Builders.leafBuilder()
- .withNodeIdentifier(
- new NodeIdentifier(ID))
- .withValue(1).build())
- .withChild(
- Builders.choiceBuilder()
- .withNodeIdentifier(choice)
- .withChild(
- Builders.leafBuilder()
- .withNodeIdentifier(leafFromCase)
- .withValue("")
- .build()).build()).build()).build())
- .build();
-
- final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(rootContainer), expectedStructure);
- assertEquals(expectedStructure, filter);
- }
-
@Test
public void testListLastChildOverride() {
- final MapEntryNode outerListEntry = Builders
- .mapEntryBuilder()
- .withNodeIdentifier(outerListWithKey)
- .withChild(
- Builders.leafBuilder().withNodeIdentifier(new NodeIdentifier(ID))
- .withValue(1).build()).build();
- final MapNode lastChild = Builders.mapBuilder().withNodeIdentifier(outerList).withChild(outerListEntry)
- .build();
- final ContainerNode expectedStructure = Builders.containerBuilder().withNodeIdentifier(rootContainer)
- .withChild(lastChild).build();
-
- NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey), outerListEntry);
- assertEquals(expectedStructure, filter);
- filter = ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey));
- assertEquals(expectedStructure, filter);
+ assertEquals(Builders.containerBuilder()
+ .withNodeIdentifier(rootContainer)
+ .withChild(Builders.mapBuilder()
+ .withNodeIdentifier(outerList)
+ .withChild(Builders.mapEntryBuilder()
+ .withNodeIdentifier(outerListWithKey)
+ .withChild(Builders.leafBuilder()
+ .withNodeIdentifier(new NodeIdentifier(ID))
+ .withValue(1)
+ .build())
+ .build())
+ .build())
+ .build(),
+ ImmutableNodes.fromInstanceId(ctx,
+ YangInstanceIdentifier.create(rootContainer, outerList, outerListWithKey)));
}
@Test
public void testLeafList() {
- final ContainerNode expectedFilter = Builders
- .containerBuilder()
- .withNodeIdentifier(rootContainer)
- .withChild(
- Builders.orderedLeafSetBuilder()
- .withNodeIdentifier(leafList)
- .withChild(
- Builders.leafSetEntryBuilder().withNodeIdentifier(leafListWithValue)
- .withValue(leafListWithValue.getValue()).build()).build()).build();
-
- final NormalizedNode filter = ImmutableNodes.fromInstanceId(ctx,
- YangInstanceIdentifier.create(rootContainer, leafList, leafListWithValue));
- assertEquals(expectedFilter, filter);
+ assertEquals(Builders.containerBuilder()
+ .withNodeIdentifier(rootContainer)
+ .withChild(Builders.orderedLeafSetBuilder()
+ .withNodeIdentifier(leafList)
+ .withChild(Builders.leafSetEntryBuilder()
+ .withNodeIdentifier(leafListWithValue)
+ .withValue(leafListWithValue.getValue())
+ .build())
+ .build())
+ .build(),
+ ImmutableNodes.fromInstanceId(ctx,
+ YangInstanceIdentifier.create(rootContainer, leafList, leafListWithValue)));
}
@Test
Code Review / yangtools.git / commitdiff