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=4896711e7d51805bdf583e174c9e5d4f1c107651;hb=3aeb76da594293aa97caa1d7a55f12770ef78033;hp=175969cc614425c1a9246f0e069aec80abb8daa5;hpb=9bd760d3fffdaca67bfcdf9d3202a6870830006d;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 175969cc61..4896711e7d 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,18 +7,20 @@ */ 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; import com.google.common.collect.Collections2; +import com.google.common.collect.ImmutableSet; import com.google.common.collect.Maps; import com.google.common.collect.Sets; +import java.util.Collection; 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; @@ -26,35 +28,80 @@ import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; 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; public final class SchemaUtils { + private static final Function QNAME_FUNCTION = new Function() { + @Override + public QName apply(@Nonnull final DataSchemaNode input) { + return input.getQName(); + } + }; + private SchemaUtils() { + throw new UnsupportedOperationException(); } + /** + * @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) { @@ -71,7 +118,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()) { @@ -105,7 +152,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()) { @@ -123,24 +170,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); } } } @@ -197,8 +244,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); } @@ -210,8 +257,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; } @@ -234,8 +281,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) { @@ -265,9 +312,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())); } @@ -288,7 +335,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, @@ -318,17 +365,25 @@ public final class SchemaUtils { return false; } - public static YangInstanceIdentifier.AugmentationIdentifier getNodeIdentifierForAugmentation(final AugmentationSchema schema) { - return new YangInstanceIdentifier.AugmentationIdentifier(getChildQNames(schema)); - } - - public static Set getChildQNames(final AugmentationSchema schema) { - Set qnames = Sets.newHashSet(); - - for (DataSchemaNode dataSchemaNode : schema.getChildNodes()) { - qnames.add(dataSchemaNode.getQName()); + /** + * 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. + */ + public static AugmentationSchema findCorrespondingAugment(final DataSchemaNode parent, final DataSchemaNode child) { + if (parent instanceof AugmentationTarget && !(parent instanceof ChoiceSchemaNode)) { + for (AugmentationSchema augmentation : ((AugmentationTarget) parent).getAvailableAugmentations()) { + DataSchemaNode childInAugmentation = augmentation.getDataChildByName(child.getQName()); + if (childInAugmentation != null) { + return augmentation; + } + } } + return null; + } - return qnames; + public static YangInstanceIdentifier.AugmentationIdentifier getNodeIdentifierForAugmentation(final AugmentationSchema schema) { + final Collection qnames = Collections2.transform(schema.getChildNodes(), QNAME_FUNCTION); + return new YangInstanceIdentifier.AugmentationIdentifier(ImmutableSet.copyOf(qnames)); } + }