X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-data-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fdata%2Fimpl%2Fschema%2FImmutableNodes.java;h=5a96515d13da23583dae2dcaee0ee40d7f65f3d9;hb=bb60da5fe2d1928defb46ed92b290cfff93dcd81;hp=089901aeed3295d77f28b38cea00607cca23b54b;hpb=faaf2c84f0f1304e0f8837992014557c47dd9379;p=yangtools.git diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ImmutableNodes.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ImmutableNodes.java index 089901aeed..5a96515d13 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ImmutableNodes.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/ImmutableNodes.java @@ -7,20 +7,24 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema; -import com.google.common.base.Optional; -import com.google.common.base.Preconditions; -import java.util.Map; +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.ModifyAction; 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.NodeIdentifierWithPredicates; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; 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.MapEntryNode; import org.opendaylight.yangtools.yang.data.api.schema.MapNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode; +import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode; import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableChoiceNodeBuilder; @@ -28,109 +32,222 @@ import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableCo import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafNodeBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapEntryNodeBuilder; import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableMapNodeBuilder; +import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableOrderedMapNodeBuilder; +import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableUnkeyedListNodeBuilder; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaContext; public final class ImmutableNodes { + // FIXME: YANGTOOLS-1074: we do not want this name + private static final NodeIdentifier SCHEMACONTEXT_NAME = NodeIdentifier.create(SchemaContext.NAME); private ImmutableNodes() { - throw new UnsupportedOperationException("Utilities class should not be instantiated"); + // Hidden on purpose } - public static CollectionNodeBuilder mapNodeBuilder() { + public static @NonNull CollectionNodeBuilder mapNodeBuilder() { return ImmutableMapNodeBuilder.create(); } - public static CollectionNodeBuilder mapNodeBuilder(final QName name) { - return ImmutableMapNodeBuilder.create().withNodeIdentifier(NodeIdentifier.create(name)); + public static @NonNull CollectionNodeBuilder mapNodeBuilder(final QName name) { + return mapNodeBuilder(NodeIdentifier.create(name)); + } + + public static @NonNull CollectionNodeBuilder mapNodeBuilder(final NodeIdentifier name) { + return ImmutableMapNodeBuilder.create().withNodeIdentifier(name); + } + + /** + * Create an immutable map node. + * + * @param name QName which will be used as node identifier + * @return An unordered Map node + */ + public static @NonNull MapNode mapNode(final QName name) { + return mapNode(NodeIdentifier.create(name)); + } + + /** + * Create an immutable map node. + * + * @param name QName which will be used as node identifier + * @return An unordered Map node + */ + public static @NonNull MapNode mapNode(final NodeIdentifier name) { + return mapNodeBuilder(name).build(); } /** - * Construct immutable leaf node + * Create immutable ordered map node. + * + * @param name QName which will be used as node identifier + * @return An ordered Map node + */ + public static @NonNull OrderedMapNode orderedMapNode(final QName name) { + return orderedMapNode(NodeIdentifier.create(name)); + } + + /** + * Create immutable ordered map node. + * + * @param name Node identifier + * @return An ordered Map node + */ + public static @NonNull OrderedMapNode orderedMapNode(final NodeIdentifier name) { + return ImmutableOrderedMapNodeBuilder.create().withNodeIdentifier(name).build(); + } + + /** + * Construct immutable leaf node. * * @param name Identifier of leaf node * @param value Value of leaf node + * @param Type of leaf node value * @return Leaf node with supplied identifier and value */ - public static LeafNode leafNode(final NodeIdentifier name, final T value) { - return ImmutableLeafNodeBuilder.create() - .withNodeIdentifier(name) - .withValue(value) - .build(); + public static @NonNull LeafNode leafNode(final NodeIdentifier name, final T value) { + return ImmutableLeafNodeBuilder.createNode(name, value); } /** - * Construct immutable leaf node + * Construct immutable leaf node. * * @param name QName which will be used as node identifier * @param value Value of leaf node. + * @param Type of leaf node value * @return Leaf node with supplied identifier and value */ - public static LeafNode leafNode(final QName name,final T value) { + public static @NonNull LeafNode leafNode(final QName name, final T value) { return leafNode(NodeIdentifier.create(name), value); } - public static DataContainerNodeBuilder mapEntryBuilder(final QName nodeName, final QName keyName, final Object keyValue) { + public static @NonNull DataContainerNodeBuilder mapEntryBuilder( + final QName nodeName, final QName keyName, final Object keyValue) { return ImmutableMapEntryNodeBuilder.create() - .withNodeIdentifier(new NodeIdentifierWithPredicates(nodeName, keyName, keyValue)) + .withNodeIdentifier(NodeIdentifierWithPredicates.of(nodeName, keyName, keyValue)) .withChild(leafNode(keyName, keyValue)); } - public static MapEntryNode mapEntry(final QName nodeName,final QName keyName,final Object keyValue) { + public static @NonNull DataContainerNodeBuilder mapEntryBuilder() { + return ImmutableMapEntryNodeBuilder.create(); + } + + public static @NonNull MapEntryNode mapEntry(final QName nodeName, final QName keyName, final Object keyValue) { return mapEntryBuilder(nodeName, keyName, keyValue).build(); } - public static DataContainerNodeBuilder mapEntryBuilder() { - return ImmutableMapEntryNodeBuilder.create(); + /** + * Create an immutable container node. + * + * @param name QName which will be used as node identifier + * @return A container node + */ + public static @NonNull ContainerNode containerNode(final QName name) { + return containerNode(NodeIdentifier.create(name)); } - public static ContainerNode containerNode(final QName name) { - return ImmutableContainerNodeBuilder.create().withNodeIdentifier(NodeIdentifier.create(name)).build(); + /** + * Create an immutable container node. + * + * @param name Node identifier + * @return A container node + */ + public static @NonNull ContainerNode containerNode(final NodeIdentifier name) { + return ImmutableContainerNodeBuilder.create().withNodeIdentifier(name).build(); } - public static ChoiceNode choiceNode(final QName name) { - return ImmutableChoiceNodeBuilder.create().withNodeIdentifier(NodeIdentifier.create(name)).build(); + /** + * Create an immutable choice node. + * + * @param name QName which will be used as node identifier + * @return A choice node + */ + public static @NonNull ChoiceNode choiceNode(final QName name) { + return choiceNode(NodeIdentifier.create(name)); } /** - * Convert YangInstanceIdentifier into a normalized node structure + * Create an immutable choice node. + * + * @param name Node identifier + * @return A choice node + */ + public static @NonNull ChoiceNode choiceNode(final NodeIdentifier name) { + return ImmutableChoiceNodeBuilder.create().withNodeIdentifier(name).build(); + } + + /** + * Create an immutable list node. + * + * @param name QName which will be used as node identifier + * @return An unkeyed list node + */ + public static @NonNull UnkeyedListNode listNode(final QName name) { + return listNode(NodeIdentifier.create(name)); + } + + /** + * Create an immutable list node. + * + * @param name Node identifier + * @return An unkeyed list node + */ + public static @NonNull UnkeyedListNode listNode(final NodeIdentifier name) { + return ImmutableUnkeyedListNodeBuilder.create().withNodeIdentifier(name).build(); + } + + /** + * 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 * @return serialized normalized node for provided instance Id */ - public static NormalizedNode fromInstanceId(final SchemaContext ctx, final YangInstanceIdentifier id) { - return fromInstanceId(ctx, id, Optional.>absent(), Optional.>absent()); + public static @NonNull NormalizedNode fromInstanceId(final SchemaContext ctx, + final YangInstanceIdentifier id) { + return fromInstanceId(ctx, id, Optional.empty()); } /** - * Convert YangInstanceIdentifier into a normalized node structure + * 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 Id + * @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. */ - public static NormalizedNode fromInstanceId(final SchemaContext ctx, final YangInstanceIdentifier id, final NormalizedNode deepestElement) { - return fromInstanceId(ctx, id, Optional.>of(deepestElement), Optional.>absent()); + public static @NonNull NormalizedNode fromInstanceId(final SchemaContext ctx, final YangInstanceIdentifier id, + final NormalizedNode deepestElement) { + return fromInstanceId(ctx, id, Optional.of(deepestElement)); } /** - * Convert YangInstanceIdentifier into a normalized node structure + * 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 Id - * @param operation modify operation attribute to be added to the deepest child. QName is the operation attribute key and ModifyAction is the value. - * @return serialized normalized node for provided instance Id with (optionally) overridden last child and (optionally) marked with specific operation attribute. + * @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. */ - public static NormalizedNode fromInstanceId(final SchemaContext ctx, final YangInstanceIdentifier id, final Optional> deepestElement, final Optional> operation) { - Preconditions.checkNotNull(ctx); - Preconditions.checkNotNull(id); - final YangInstanceIdentifier.PathArgument topLevelElement = id.getPathArguments().get(0); - final DataSchemaNode dataChildByName = ctx.getDataChildByName(topLevelElement.getNodeType()); - Preconditions.checkNotNull(dataChildByName, "Cannot find %s node in schema context. Instance identifier has to start from root", topLevelElement); - final InstanceIdToNodes instanceIdToNodes = InstanceIdToNodes.fromSchemaAndQNameChecked(ctx, topLevelElement.getNodeType()); - return instanceIdToNodes.create(id, deepestElement, operation); + public static @NonNull NormalizedNode fromInstanceId(final SchemaContext ctx, final YangInstanceIdentifier id, + final Optional> deepestElement) { + final PathArgument topLevelElement; + final InstanceIdToNodes instanceIdToNodes; + final Iterator it = id.getPathArguments().iterator(); + if (it.hasNext()) { + topLevelElement = it.next(); + final DataSchemaNode dataChildByName = ctx.dataChildByName(topLevelElement.getNodeType()); + checkNotNull(dataChildByName, + "Cannot find %s node in schema context. Instance identifier has to start from root", topLevelElement); + instanceIdToNodes = InstanceIdToNodes.fromSchemaAndQNameChecked(ctx, topLevelElement.getNodeType()); + } else { + topLevelElement = SCHEMACONTEXT_NAME; + instanceIdToNodes = InstanceIdToNodes.fromDataSchemaNode(ctx); + } + + return instanceIdToNodes.create(topLevelElement, it, deepestElement); } }