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%2FSchemaUtils.java;h=a5c5148548418596d13c1ef26543aa89c527aff4;hb=c4dc5b33e7d24670b59cc81b65e15b37a3268608;hp=84ad453df877a9f7226d8a2e6f218b01c3e7207c;hpb=abf7b7a08245518ba0a01ae0aab1555516ad3069;p=yangtools.git diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/SchemaUtils.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/SchemaUtils.java index 84ad453df8..a5c5148548 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/SchemaUtils.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/SchemaUtils.java @@ -7,7 +7,6 @@ */ package org.opendaylight.yangtools.yang.data.impl.schema; - import com.google.common.base.Function; import com.google.common.base.Optional; import com.google.common.base.Preconditions; @@ -18,14 +17,17 @@ import java.util.Collections; import java.util.HashSet; import java.util.Map; import java.util.Set; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; 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.DataContainerNode; import org.opendaylight.yangtools.yang.model.api.AugmentationSchema; import org.opendaylight.yangtools.yang.model.api.AugmentationTarget; import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode; -import org.opendaylight.yangtools.yang.model.api.ChoiceNode; +import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode; import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; @@ -34,26 +36,63 @@ public final class SchemaUtils { private SchemaUtils() { } + /** + * @param qname - schema node to find + * @param dataSchemaNode - iterable of schemaNodes to look through + * @return - schema node with newest revision or absent if no schema node with matching qname is found + */ public static final Optional findFirstSchema(final QName qname, final Iterable dataSchemaNode) { + DataSchemaNode sNode = null; if (dataSchemaNode != null && qname != null) { for (DataSchemaNode dsn : dataSchemaNode) { if (qname.isEqualWithoutRevision(dsn.getQName())) { - return Optional. of(dsn); - } else if (dsn instanceof ChoiceNode) { - for (ChoiceCaseNode choiceCase : ((ChoiceNode) dsn).getCases()) { + if (sNode == null || sNode.getQName().getRevision().compareTo(dsn.getQName().getRevision()) < 0) { + sNode = dsn; + } + } else if (dsn instanceof ChoiceSchemaNode) { + for (ChoiceCaseNode choiceCase : ((ChoiceSchemaNode) dsn).getCases()) { + + final DataSchemaNode dataChildByName = choiceCase.getDataChildByName(qname); + if (dataChildByName != null) { + return Optional.of(dataChildByName); + } Optional foundDsn = findFirstSchema(qname, choiceCase.getChildNodes()); - if (foundDsn != null && foundDsn.isPresent()) { + if (foundDsn.isPresent()) { return foundDsn; } } } } } - return Optional.absent(); + return Optional.fromNullable(sNode); } + /** + * + * Find child schema node identified by its QName within a provided schema node + * + * @param schema schema for parent node - search root + * @param qname qname(with or without a revision) of a child node to be found in the parent schema + * @return found schema node + * @throws java.lang.IllegalStateException if the child was not found in parent schema node + */ public static DataSchemaNode findSchemaForChild(final DataNodeContainer schema, final QName qname) { - return findSchemaForChild(schema, qname, schema.getChildNodes()); + // Try to find child schema node directly, but use a fallback that compares QNames without revisions and auto-expands choices + final DataSchemaNode dataChildByName = schema.getDataChildByName(qname); + return dataChildByName == null ? findSchemaForChild(schema, qname, schema.getChildNodes()) : dataChildByName; + } + + @Nullable + public static DataSchemaNode findSchemaForChild(final DataNodeContainer schema, final QName qname, final boolean strictMode) { + if (strictMode) { + return findSchemaForChild(schema, qname); + } + + Optional childSchemaOptional = findFirstSchema(qname, schema.getChildNodes()); + if (!childSchemaOptional.isPresent()) { + return null; + } + return childSchemaOptional.get(); } public static DataSchemaNode findSchemaForChild(final DataNodeContainer schema, final QName qname, final Iterable childNodes) { @@ -70,7 +109,7 @@ public final class SchemaUtils { return schemaForAugment.get(); } - public static AugmentationSchema findSchemaForAugment(final ChoiceNode schema, final Set qNames) { + public static AugmentationSchema findSchemaForAugment(final ChoiceSchemaNode schema, final Set qNames) { Optional schemaForAugment = Optional.absent(); for (ChoiceCaseNode choiceCaseNode : schema.getCases()) { @@ -90,7 +129,8 @@ public final class SchemaUtils { HashSet qNamesFromAugment = Sets.newHashSet(Collections2.transform(augment.getChildNodes(), new Function() { @Override - public QName apply(final DataSchemaNode input) { + public QName apply(final @Nonnull DataSchemaNode input) { + Preconditions.checkNotNull(input); return input.getQName(); } })); @@ -103,7 +143,7 @@ public final class SchemaUtils { return Optional.absent(); } - public static DataSchemaNode findSchemaForChild(final ChoiceNode schema, final QName childPartialQName) { + public static DataSchemaNode findSchemaForChild(final ChoiceSchemaNode schema, final QName childPartialQName) { for (ChoiceCaseNode choiceCaseNode : schema.getCases()) { Optional childSchema = findFirstSchema(childPartialQName, choiceCaseNode.getChildNodes()); if (childSchema.isPresent()) { @@ -121,24 +161,24 @@ public final class SchemaUtils { * * @return Map with all child nodes, to their most top augmentation */ - public static Map mapChildElementsFromChoices(final DataNodeContainer schema) { + public static Map mapChildElementsFromChoices(final DataNodeContainer schema) { return mapChildElementsFromChoices(schema, schema.getChildNodes()); } - private static Map mapChildElementsFromChoices(final DataNodeContainer schema, final Iterable childNodes) { - Map mappedChoices = Maps.newLinkedHashMap(); + private static Map mapChildElementsFromChoices(final DataNodeContainer schema, final Iterable childNodes) { + Map mappedChoices = Maps.newLinkedHashMap(); for (final DataSchemaNode childSchema : childNodes) { - if(childSchema instanceof ChoiceNode) { + if (childSchema instanceof ChoiceSchemaNode) { - if(isFromAugment(schema, childSchema)) { + if (isFromAugment(schema, childSchema)) { continue; } - for (ChoiceCaseNode choiceCaseNode : ((ChoiceNode) childSchema).getCases()) { + for (ChoiceCaseNode choiceCaseNode : ((ChoiceSchemaNode) childSchema).getCases()) { for (QName qName : getChildNodesRecursive(choiceCaseNode)) { - mappedChoices.put(qName, (ChoiceNode) childSchema); + mappedChoices.put(qName, (ChoiceSchemaNode) childSchema); } } } @@ -195,8 +235,8 @@ public final class SchemaUtils { for (QName qName : getChildNodesRecursive((DataNodeContainer) child)) { childNodesToAugmentation.put(qName, mostTopAugmentation); } - } else if (child instanceof ChoiceNode) { - for (ChoiceCaseNode choiceCaseNode : ((ChoiceNode) child).getCases()) { + } else if (child instanceof ChoiceSchemaNode) { + for (ChoiceCaseNode choiceCaseNode : ((ChoiceSchemaNode) child).getCases()) { for (QName qName : getChildNodesRecursive(choiceCaseNode)) { childNodesToAugmentation.put(qName, mostTopAugmentation); } @@ -208,8 +248,8 @@ public final class SchemaUtils { } // Choice Node has to map child nodes from all its cases - if (schema instanceof ChoiceNode) { - for (ChoiceCaseNode choiceCaseNode : ((ChoiceNode) schema).getCases()) { + if (schema instanceof ChoiceSchemaNode) { + for (ChoiceCaseNode choiceCaseNode : ((ChoiceSchemaNode) schema).getCases()) { if (!(augments.containsKey(choiceCaseNode.getQName()))) { continue; } @@ -232,8 +272,8 @@ public final class SchemaUtils { Set allChildNodes = Sets.newHashSet(); for (DataSchemaNode childSchema : nodeContainer.getChildNodes()) { - if(childSchema instanceof ChoiceNode) { - for (ChoiceCaseNode choiceCaseNode : ((ChoiceNode) childSchema).getCases()) { + if(childSchema instanceof ChoiceSchemaNode) { + for (ChoiceCaseNode choiceCaseNode : ((ChoiceSchemaNode) childSchema).getCases()) { allChildNodes.addAll(getChildNodesRecursive(choiceCaseNode)); } } else if(childSchema instanceof AugmentationSchema || childSchema instanceof ChoiceCaseNode) { @@ -251,7 +291,7 @@ public final class SchemaUtils { * Retrieves real schemas for augmented child node. * * Schema of the same child node from augment, and directly from target is not the same. - * Schema of child node from augment is incomplete, therefore its useless for xml <-> normalizedNode translation. + * Schema of child node from augment is incomplete, therefore its useless for XML/NormalizedNode translation. * */ public static Set getRealSchemasForAugment(final AugmentationTarget targetSchema, final AugmentationSchema augmentSchema) { @@ -263,9 +303,9 @@ public final class SchemaUtils { if(targetSchema instanceof DataNodeContainer) { realChildNodes = getRealSchemasForAugment((DataNodeContainer)targetSchema, augmentSchema); - } else if(targetSchema instanceof ChoiceNode) { + } else if(targetSchema instanceof ChoiceSchemaNode) { for (DataSchemaNode dataSchemaNode : augmentSchema.getChildNodes()) { - for (ChoiceCaseNode choiceCaseNode : ((ChoiceNode) targetSchema).getCases()) { + for (ChoiceCaseNode choiceCaseNode : ((ChoiceSchemaNode) targetSchema).getCases()) { if(getChildNodesRecursive(choiceCaseNode).contains(dataSchemaNode.getQName())) { realChildNodes.add(choiceCaseNode.getDataChildByName(dataSchemaNode.getQName())); } @@ -286,7 +326,7 @@ public final class SchemaUtils { return realChildNodes; } - public static Optional detectCase(final ChoiceNode schema, final DataContainerChild child) { + public static Optional detectCase(final ChoiceSchemaNode schema, final DataContainerChild child) { for (ChoiceCaseNode choiceCaseNode : schema.getCases()) { if (child instanceof AugmentationNode && belongsToCaseAugment(choiceCaseNode,