X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-model-util%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fmodel%2Futil%2FSchemaContextUtil.java;h=3c367be6427e953795c183ff203e92f5fa077baf;hb=9549a6b25d1a39cae42e34c32b0a1114e673a91d;hp=57ed8fdd1da3ebdd47b89f690b6e1571114ef06b;hpb=56702f96932afadd61d8b77a4081f913e3b545bd;p=yangtools.git diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/SchemaContextUtil.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/SchemaContextUtil.java index 57ed8fdd1d..3c367be642 100644 --- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/SchemaContextUtil.java +++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/SchemaContextUtil.java @@ -7,21 +7,30 @@ */ package org.opendaylight.yangtools.yang.model.util; -import com.google.common.base.Function; +import com.google.common.annotations.Beta; +import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Preconditions; import com.google.common.base.Splitter; import com.google.common.collect.Iterables; +import java.util.HashSet; import java.util.Iterator; import java.util.LinkedList; import java.util.List; +import java.util.Optional; import java.util.Set; +import java.util.regex.Pattern; +import javax.annotation.Nonnull; +import javax.annotation.Nullable; import org.opendaylight.yangtools.yang.common.QName; 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.ContainerSchemaNode; +import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode; import org.opendaylight.yangtools.yang.model.api.GroupingDefinition; -import org.opendaylight.yangtools.yang.model.api.ListSchemaNode; +import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode; +import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; import org.opendaylight.yangtools.yang.model.api.Module; import org.opendaylight.yangtools.yang.model.api.ModuleImport; import org.opendaylight.yangtools.yang.model.api.NotificationDefinition; @@ -30,6 +39,11 @@ import org.opendaylight.yangtools.yang.model.api.RpcDefinition; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.api.TypeDefinition; +import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition; +import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier; +import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -54,17 +68,16 @@ public final class SchemaContextUtil { * the end of the SchemaPath. If the DataSchemaNode is not present in the * Schema Context the method will return null.
* In case that Schema Context or Schema Path are not specified correctly - * (i.e. contains null values) the method will return + * (i.e. contains null values) the method will throw * IllegalArgumentException. * - * @throws IllegalArgumentException - * * @param context * Schema Context * @param schemaPath * Schema Path to search for * @return SchemaNode from the end of the Schema Path or null * if the Node is not present. + * @throws IllegalArgumentException if context or schemaPath is not correct. */ public static SchemaNode findDataSchemaNode(final SchemaContext context, final SchemaPath schemaPath) { Preconditions.checkArgument(context != null, "Schema Context reference cannot be NULL"); @@ -98,8 +111,6 @@ public final class SchemaContextUtil { * method will return specified Data Schema Node, otherwise the operation * will fail and method will return null. * - * @throws IllegalArgumentException - * * @param context * Schema Context * @param module @@ -110,16 +121,18 @@ public final class SchemaContextUtil { * Non-conditional Revision Aware XPath, or null if the * DataSchemaNode is not present in Schema Context. */ - public static SchemaNode findDataSchemaNode(final SchemaContext context, final Module module, final RevisionAwareXPath nonCondXPath) { + public static SchemaNode findDataSchemaNode(final SchemaContext context, final Module module, + final RevisionAwareXPath nonCondXPath) { Preconditions.checkArgument(context != null, "Schema Context reference cannot be NULL"); Preconditions.checkArgument(module != null, "Module reference cannot be NULL"); Preconditions.checkArgument(nonCondXPath != null, "Non Conditional Revision Aware XPath cannot be NULL"); - String strXPath = nonCondXPath.toString(); + final String strXPath = nonCondXPath.toString(); if (strXPath != null) { - Preconditions.checkArgument(strXPath.indexOf('[') == -1, "Revision Aware XPath may not contain a condition"); + Preconditions.checkArgument(strXPath.indexOf('[') == -1, + "Revision Aware XPath may not contain a condition"); if (nonCondXPath.isAbsolute()) { - List qnamedPath = xpathToQNamePath(context, module, strXPath); + final List qnamedPath = xpathToQNamePath(context, module, strXPath); if (qnamedPath != null) { return findNodeInSchemaContext(context, qnamedPath); } @@ -153,8 +166,6 @@ public final class SchemaContextUtil { * the method will return specified Data Schema Node, otherwise the * operation will fail and method will return null. * - * @throws IllegalArgumentException - * * @param context * Schema Context * @param module @@ -177,9 +188,9 @@ public final class SchemaContextUtil { "Revision Aware XPath MUST be relative i.e. MUST contains ../, " + "for non relative Revision Aware XPath use findDataSchemaNode method"); - SchemaPath actualNodePath = actualSchemaNode.getPath(); + final SchemaPath actualNodePath = actualSchemaNode.getPath(); if (actualNodePath != null) { - Iterable qnamePath = resolveRelativeXPath(context, module, relativeXPath, actualSchemaNode); + final Iterable qnamePath = resolveRelativeXPath(context, module, relativeXPath, actualSchemaNode); if (qnamePath != null) { return findNodeInSchemaContext(context, qnamePath); @@ -195,15 +206,12 @@ public final class SchemaContextUtil { * If Schema Context or Schema Node contains null references * the method will throw IllegalArgumentException * - * @throws IllegalArgumentException - * * @param context * Schema Context * @param schemaNode * Schema Node - * @return Yang Module for specified Schema Context and Schema Node, if - * Schema Node is NOT present, the method will returns - * null + * @return Yang Module for specified Schema Context and Schema Node, if Schema Node is NOT present, the method will + * return null */ public static Module findParentModule(final SchemaContext context, final SchemaNode schemaNode) { Preconditions.checkArgument(context != null, "Schema Context reference cannot be NULL!"); @@ -211,203 +219,236 @@ public final class SchemaContextUtil { Preconditions.checkState(schemaNode.getPath() != null, "Schema Path for Schema Node is not " + "set properly (Schema Path is NULL)"); - final QName qname = Iterables.getFirst(schemaNode.getPath().getPathTowardsRoot(), null); - Preconditions.checkState(qname != null, - "Schema Path contains invalid state of path parts. " + - "The Schema Path MUST contain at least ONE QName which defines namespace and Local name of path."); - return context.findModuleByNamespaceAndRevision(qname.getNamespace(), qname.getRevision()); + final QName qname = schemaNode.getPath().getLastComponent(); + Preconditions.checkState(qname != null, "Schema Path contains invalid state of path parts. " + + "The Schema Path MUST contain at least ONE QName which defines namespace and Local name of path."); + return context.findModule(qname.getModule()).orElse(null); } public static SchemaNode findNodeInSchemaContext(final SchemaContext context, final Iterable path) { final QName current = path.iterator().next(); LOG.trace("Looking up module {} in context {}", current, path); - final Module module = context.findModuleByNamespaceAndRevision(current.getNamespace(), current.getRevision()); - if (module == null) { + final Optional module = context.findModule(current.getModule()); + if (!module.isPresent()) { LOG.debug("Module {} not found", current); return null; } - return findNodeInModule(module, path); + return findNodeInModule(module.get(), path); } - private static SchemaNode findNodeInModule(final Module module, final Iterable path) { - final QName current = path.iterator().next(); - - LOG.trace("Looking for data container {} in module {}", current, module); - SchemaNode parent = module.getDataChildByName(current); - if (parent != null) { - final SchemaNode ret = findNode((DataSchemaNode) parent, nextLevel(path)); - if (ret != null) { - return ret; + /** + * Returns NotificationDefinition from Schema Context. + * + * @param schema SchemaContext in which lookup should be performed. + * @param path Schema Path of notification + * @return Notification schema or null, if notification is not present in schema context. + */ + @Beta + @Nullable + public static NotificationDefinition getNotificationSchema(@Nonnull final SchemaContext schema, + @Nonnull final SchemaPath path) { + Preconditions.checkNotNull(schema, "Schema context must not be null."); + Preconditions.checkNotNull(path, "Schema path must not be null."); + for (final NotificationDefinition potential : schema.getNotifications()) { + if (path.equals(potential.getPath())) { + return potential; } } + return null; + } - LOG.trace("Looking for RPC {} in module {}", current, module); - parent = getRpcByName(module, current); - if (parent != null) { - final SchemaNode ret = findNodeInRpc((RpcDefinition) parent, nextLevel(path)); - if (ret != null) { - return ret; + /** + * Returns RPC Input or Output Data container from RPC definition. + * + * @param schema SchemaContext in which lookup should be performed. + * @param path Schema path of RPC input/output data container + * @return Notification schema or null, if notification is not present in schema context. + */ + @Beta + @Nullable + public static ContainerSchemaNode getRpcDataSchema(@Nonnull final SchemaContext schema, + @Nonnull final SchemaPath path) { + Preconditions.checkNotNull(schema, "Schema context must not be null."); + Preconditions.checkNotNull(path, "Schema path must not be null."); + final Iterator it = path.getPathFromRoot().iterator(); + Preconditions.checkArgument(it.hasNext(), "Rpc must have QName."); + final QName rpcName = it.next(); + Preconditions.checkArgument(it.hasNext(), "input or output must be part of path."); + final QName inOrOut = it.next(); + for (final RpcDefinition potential : schema.getOperations()) { + if (rpcName.equals(potential.getQName())) { + return SchemaNodeUtils.getRpcDataSchema(potential, inOrOut); } } + return null; + } - LOG.trace("Looking for notification {} in module {}", current, module); - parent = getNotificationByName(module, current); - if (parent != null) { - final SchemaNode ret = findNodeInNotification((NotificationDefinition) parent, nextLevel(path)); - if (ret != null) { - return ret; - } - } + /** + * Extract the identifiers of all modules and submodules which were used to create a particular SchemaContext. + * + * @param context SchemaContext to be examined + * @return Set of ModuleIdentifiers. + */ + public static Set getConstituentModuleIdentifiers(final SchemaContext context) { + final Set ret = new HashSet<>(); + + for (Module module : context.getModules()) { + ret.add(moduleToIdentifier(module)); - LOG.trace("Looking for grouping {} in module {}", current, module); - parent = getGroupingByName(module, current); - if (parent != null) { - final SchemaNode ret = findNodeInGrouping((GroupingDefinition) parent, nextLevel(path)); - if (ret != null) { - return ret; + for (Module submodule : module.getSubmodules()) { + ret.add(moduleToIdentifier(submodule)); } } - LOG.debug("No node matching {} found in module {}", path, module); - return null; + return ret; } - private static SchemaNode findNodeInGrouping(final GroupingDefinition grouping, final Iterable path) { - final QName current = Iterables.getFirst(path, null); - if (current == null) { - LOG.debug("Found grouping {}", grouping); - return grouping; - } + private static SourceIdentifier moduleToIdentifier(final Module module) { + return RevisionSourceIdentifier.create(module.getName(), module.getRevision()); + } - LOG.trace("Looking for path {} in grouping {}", path, grouping); - final DataSchemaNode node = grouping.getDataChildByName(current); - if (node == null) { - LOG.debug("No node matching {} found in grouping {}", current, grouping); - return null; - } + private static SchemaNode findNodeInModule(final Module module, final Iterable path) { - return findNode(node, nextLevel(path)); - } + Preconditions.checkArgument(module != null, "Parent reference cannot be NULL"); + Preconditions.checkArgument(path != null, "Path reference cannot be NULL"); - private static SchemaNode findNodeInRpc(final RpcDefinition rpc, final Iterable path) { - final QName current = Iterables.getFirst(path, null); - if (current == null) { - LOG.debug("Found RPC {}", rpc); - return rpc; - } - - LOG.trace("Looking for path {} in rpc {}", path, rpc); - switch (current.getLocalName()) { - case "input": - return findNode(rpc.getInput(), nextLevel(path)); - case "output": - return findNode(rpc.getOutput(), nextLevel(path)); - default: - LOG.debug("Invalid component {} of path {} in RPC {}", current, path, rpc); + if (!path.iterator().hasNext()) { + LOG.debug("No node matching {} found in node {}", path, module); return null; } - } - private static SchemaNode findNodeInNotification(final NotificationDefinition ntf, final Iterable path) { - final QName current = Iterables.getFirst(path, null); - if (current == null) { - LOG.debug("Found notification {}", ntf); - return ntf; - } + final QName current = path.iterator().next(); + LOG.trace("Looking for node {} in module {}", current, module); - LOG.trace("Looking for path {} in notification {}", path, ntf); - DataSchemaNode node = ntf.getDataChildByName(current); - if (node == null) { - LOG.debug("No node matching {} found in notification {}", current, ntf); - return null; - } + SchemaNode foundNode = null; + final Iterable nextPath = nextLevel(path); - return findNode(node, nextLevel(path)); - } + foundNode = module.getDataChildByName(current); + if (foundNode != null && nextPath.iterator().hasNext()) { + foundNode = findNodeIn(foundNode, nextPath); + } - private static SchemaNode findNode(final ChoiceNode parent, final Iterable path) { - final QName current = Iterables.getFirst(path, null); - if (current == null) { - return parent; + if (foundNode == null) { + foundNode = getGroupingByName(module, current); + if (foundNode != null && nextPath.iterator().hasNext()) { + foundNode = findNodeIn(foundNode, nextPath); + } } - ChoiceCaseNode node = parent.getCaseNodeByName(current); - if (node != null) { - return findNodeInCase(node, nextLevel(path)); + + if (foundNode == null) { + foundNode = getRpcByName(module, current); + if (foundNode != null && nextPath.iterator().hasNext()) { + foundNode = findNodeIn(foundNode, nextPath); + } } - return null; - } - private static SchemaNode findNode(final ContainerSchemaNode parent, final Iterable path) { - final QName current = Iterables.getFirst(path, null); - if (current == null) { - return parent; + if (foundNode == null) { + foundNode = getNotificationByName(module, current); + if (foundNode != null && nextPath.iterator().hasNext()) { + foundNode = findNodeIn(foundNode, nextPath); + } } - final DataSchemaNode node = parent.getDataChildByName(current); - if (node == null) { - LOG.debug("Failed to find {} in parent {}", path, parent); - return null; + if (foundNode == null) { + LOG.debug("No node matching {} found in node {}", path, module); } - return findNode(node, nextLevel(path)); + return foundNode; + } - private static SchemaNode findNode(final ListSchemaNode parent, final Iterable path) { - final QName current = Iterables.getFirst(path, null); - if (current == null) { - return parent; - } + private static SchemaNode findNodeIn(final SchemaNode parent, final Iterable path) { + + Preconditions.checkArgument(parent != null, "Parent reference cannot be NULL"); + Preconditions.checkArgument(path != null, "Path reference cannot be NULL"); - DataSchemaNode node = parent.getDataChildByName(current); - if (node == null) { - LOG.debug("Failed to find {} in parent {}", path, parent); + if (!path.iterator().hasNext()) { + LOG.debug("No node matching {} found in node {}", path, parent); return null; } - return findNode(node, nextLevel(path)); - } - private static SchemaNode findNode(final DataSchemaNode parent, final Iterable path) { - final SchemaNode node; - if (!Iterables.isEmpty(path)) { - if (parent instanceof ContainerSchemaNode) { - node = findNode((ContainerSchemaNode) parent, path); - } else if (parent instanceof ListSchemaNode) { - node = findNode((ListSchemaNode) parent, path); - } else if (parent instanceof ChoiceNode) { - node = findNode((ChoiceNode) parent, path); - } else { - throw new IllegalArgumentException( - String.format("Path nesting violation in parent %s path %s", parent, path)); + final QName current = path.iterator().next(); + LOG.trace("Looking for node {} in node {}", current, parent); + + SchemaNode foundNode = null; + final Iterable nextPath = nextLevel(path); + + if (parent instanceof DataNodeContainer) { + final DataNodeContainer parentDataNodeContainer = (DataNodeContainer) parent; + + foundNode = parentDataNodeContainer.getDataChildByName(current); + if (foundNode != null && nextPath.iterator().hasNext()) { + foundNode = findNodeIn(foundNode, nextPath); + } + + if (foundNode == null) { + foundNode = getGroupingByName(parentDataNodeContainer, current); + if (foundNode != null && nextPath.iterator().hasNext()) { + foundNode = findNodeIn(foundNode, nextPath); + } } - } else { - node = parent; } - if (node == null) { - LOG.debug("Failed to find {} in parent {}", path, parent); - return null; + if (foundNode == null && parent instanceof RpcDefinition) { + final RpcDefinition parentRpcDefinition = (RpcDefinition) parent; + + if (current.getLocalName().equals("input")) { + foundNode = parentRpcDefinition.getInput(); + if (foundNode != null && nextPath.iterator().hasNext()) { + foundNode = findNodeIn(foundNode, nextPath); + } + } + + if (current.getLocalName().equals("output")) { + foundNode = parentRpcDefinition.getOutput(); + if (foundNode != null && nextPath.iterator().hasNext()) { + foundNode = findNodeIn(foundNode, nextPath); + } + } + + if (foundNode == null) { + foundNode = getGroupingByName(parentRpcDefinition, current); + if (foundNode != null && nextPath.iterator().hasNext()) { + foundNode = findNodeIn(foundNode, nextPath); + } + } } - return node; - } - private static SchemaNode findNodeInCase(final ChoiceCaseNode parent, final Iterable path) { - final QName current = Iterables.getFirst(path, null); - if (current == null) { - return parent; + if (foundNode == null && parent instanceof ChoiceSchemaNode) { + foundNode = ((ChoiceSchemaNode) parent).getCaseNodeByName(current); + + if (foundNode != null && nextPath.iterator().hasNext()) { + foundNode = findNodeIn(foundNode, nextPath); + } + + if (foundNode == null) { + // fallback that tries to map into one of the child cases + for (final ChoiceCaseNode caseNode : ((ChoiceSchemaNode) parent).getCases().values()) { + final DataSchemaNode maybeChild = caseNode.getDataChildByName(current); + if (maybeChild != null) { + foundNode = findNodeIn(maybeChild, nextPath); + break; + } + } + } } - DataSchemaNode node = parent.getDataChildByName(current); - if (node == null) { - LOG.debug("Failed to find {} in parent {}", path, parent); - return null; + if (foundNode == null) { + LOG.debug("No node matching {} found in node {}", path, parent); } - return findNode(node, nextLevel(path)); + + return foundNode; + + } + + private static Iterable nextLevel(final Iterable path) { + return Iterables.skip(path, 1); } private static RpcDefinition getRpcByName(final Module module, final QName name) { - for (RpcDefinition rpc : module.getRpcs()) { + for (final RpcDefinition rpc : module.getRpcs()) { if (rpc.getQName().equals(name)) { return rpc; } @@ -415,12 +456,8 @@ public final class SchemaContextUtil { return null; } - private static Iterable nextLevel(final Iterable path) { - return Iterables.skip(path, 1); - } - private static NotificationDefinition getNotificationByName(final Module module, final QName name) { - for (NotificationDefinition notification : module.getNotifications()) { + for (final NotificationDefinition notification : module.getNotifications()) { if (notification.getQName().equals(name)) { return notification; } @@ -428,8 +465,17 @@ public final class SchemaContextUtil { return null; } - private static GroupingDefinition getGroupingByName(final Module module, final QName name) { - for (GroupingDefinition grouping : module.getGroupings()) { + private static GroupingDefinition getGroupingByName(final DataNodeContainer dataNodeContainer, final QName name) { + for (final GroupingDefinition grouping : dataNodeContainer.getGroupings()) { + if (grouping.getQName().equals(name)) { + return grouping; + } + } + return null; + } + + private static GroupingDefinition getGroupingByName(final RpcDefinition rpc, final QName name) { + for (final GroupingDefinition grouping : rpc.getGroupings()) { if (grouping.getQName().equals(name)) { return grouping; } @@ -444,8 +490,6 @@ public final class SchemaContextUtil { * If Schema Context, Parent Module or XPath string contains * null values, the method will throws IllegalArgumentException * - * @throws IllegalArgumentException - * * @param context * Schema Context * @param parentModule @@ -453,14 +497,19 @@ public final class SchemaContextUtil { * @param xpath * XPath String * @return return a list of QName + * + * @throws IllegalArgumentException if any arguments are null + * */ - private static List xpathToQNamePath(final SchemaContext context, final Module parentModule, final String xpath) { + private static List xpathToQNamePath(final SchemaContext context, final Module parentModule, + final String xpath) { + // FIXME: 2.0.0: this should throw NPE, not IAE Preconditions.checkArgument(context != null, "Schema Context reference cannot be NULL"); Preconditions.checkArgument(parentModule != null, "Parent Module reference cannot be NULL"); Preconditions.checkArgument(xpath != null, "XPath string reference cannot be NULL"); - List path = new LinkedList(); - for (String pathComponent : SLASH_SPLITTER.split(xpath)) { + final List path = new LinkedList<>(); + for (final String pathComponent : SLASH_SPLITTER.split(xpath)) { if (!pathComponent.isEmpty()) { path.add(stringPathPartToQName(context, parentModule, pathComponent)); } @@ -479,8 +528,6 @@ public final class SchemaContextUtil { * If Schema Context, Parent Module or Prefixed Path Part refers to * null the method will throw IllegalArgumentException * - * @throws IllegalArgumentException - * * @param context * Schema Context * @param parentModule @@ -488,8 +535,11 @@ public final class SchemaContextUtil { * @param prefixedPathPart * Prefixed Path Part string * @return QName from prefixed Path Part String. + * @throws IllegalArgumentException if any arguments are null */ - private static QName stringPathPartToQName(final SchemaContext context, final Module parentModule, final String prefixedPathPart) { + private static QName stringPathPartToQName(final SchemaContext context, final Module parentModule, + final String prefixedPathPart) { + // FIXME: 2.0.0: this should throw NPE, not IAE Preconditions.checkArgument(context != null, "Schema Context reference cannot be NULL"); Preconditions.checkArgument(parentModule != null, "Parent Module reference cannot be NULL"); Preconditions.checkArgument(prefixedPathPart != null, "Prefixed Path Part cannot be NULL!"); @@ -498,15 +548,15 @@ public final class SchemaContextUtil { final Iterator prefixedName = COLON_SPLITTER.split(prefixedPathPart).iterator(); final String modulePrefix = prefixedName.next(); - Module module = resolveModuleForPrefix(context, parentModule, modulePrefix); - Preconditions.checkArgument(module != null, "Failed to resolve xpath: no module found for prefix %s in module %s", - modulePrefix, parentModule.getName()); + final Module module = resolveModuleForPrefix(context, parentModule, modulePrefix); + Preconditions.checkArgument(module != null, + "Failed to resolve xpath: no module found for prefix %s in module %s", modulePrefix, + parentModule.getName()); - // FIXME: Module should have a QNameModule handle - return QName.create(module.getNamespace(), module.getRevision(), prefixedName.next()); - } else { - return QName.create(parentModule.getNamespace(), parentModule.getRevision(), prefixedPathPart); + return QName.create(module.getQNameModule(), prefixedName.next()); } + + return QName.create(parentModule.getNamespace(), parentModule.getRevision(), prefixedPathPart); } /** @@ -522,8 +572,6 @@ public final class SchemaContextUtil { * If Schema Context, Module or Prefix are referring to null * the method will return IllegalArgumentException * - * @throws IllegalArgumentException - * * @param context * Schema Context * @param module @@ -532,8 +580,11 @@ public final class SchemaContextUtil { * Module Prefix * @return Module for given prefix in specified Schema Context if is * present, otherwise returns null + * @throws IllegalArgumentException if any arguments are null */ - private static Module resolveModuleForPrefix(final SchemaContext context, final Module module, final String prefix) { + private static Module resolveModuleForPrefix(final SchemaContext context, final Module module, + final String prefix) { + // FIXME: 2.0.0: this should throw NPE, not IAE Preconditions.checkArgument(context != null, "Schema Context reference cannot be NULL"); Preconditions.checkArgument(module != null, "Module reference cannot be NULL"); Preconditions.checkArgument(prefix != null, "Prefix string cannot be NULL"); @@ -542,17 +593,17 @@ public final class SchemaContextUtil { return module; } - Set imports = module.getImports(); - for (ModuleImport mi : imports) { + final Set imports = module.getImports(); + for (final ModuleImport mi : imports) { if (prefix.equals(mi.getPrefix())) { - return context.findModuleByName(mi.getModuleName(), mi.getRevision()); + return context.findModule(mi.getModuleName(), mi.getRevision()).orElse(null); } } return null; } /** - * @throws IllegalArgumentException + * Resolve a relative XPath into a set of QNames. * * @param context * Schema Context @@ -560,37 +611,206 @@ public final class SchemaContextUtil { * Yang Module * @param relativeXPath * Non conditional Revision Aware Relative XPath - * @param leafrefSchemaPath - * Schema Path for Leafref + * @param actualSchemaNode + * actual schema node * @return list of QName + * @throws IllegalArgumentException if any arguments are null */ private static Iterable resolveRelativeXPath(final SchemaContext context, final Module module, - final RevisionAwareXPath relativeXPath, final SchemaNode leafrefParentNode) { + final RevisionAwareXPath relativeXPath, final SchemaNode actualSchemaNode) { + // FIXME: 2.0.0: this should throw NPE, not IAE Preconditions.checkArgument(context != null, "Schema Context reference cannot be NULL"); Preconditions.checkArgument(module != null, "Module reference cannot be NULL"); Preconditions.checkArgument(relativeXPath != null, "Non Conditional Revision Aware XPath cannot be NULL"); Preconditions.checkState(!relativeXPath.isAbsolute(), "Revision Aware XPath MUST be relative i.e. MUST contains ../, " + "for non relative Revision Aware XPath use findDataSchemaNode method"); - Preconditions.checkState(leafrefParentNode.getPath() != null, + Preconditions.checkState(actualSchemaNode.getPath() != null, "Schema Path reference for Leafref cannot be NULL"); final Iterable xpaths = SLASH_SPLITTER.split(relativeXPath.toString()); // Find out how many "parent" components there are // FIXME: is .contains() the right check here? + // FIXME: case ../../node1/node2/../node3/../node4 int colCount = 0; - for (Iterator it = xpaths.iterator(); it.hasNext() && it.next().contains(".."); ) { + for (final Iterator it = xpaths.iterator(); it.hasNext() && it.next().contains(".."); ) { ++colCount; } - final Iterable parent = leafrefParentNode.getPath().getPathFromRoot(); - return Iterables.concat(Iterables.limit(parent, Iterables.size(parent) - colCount), - Iterables.transform(Iterables.skip(xpaths, colCount), new Function() { - @Override - public QName apply(final String input) { - return stringPathPartToQName(context, module, input); - } - })); + final Iterable schemaNodePath = actualSchemaNode.getPath().getPathFromRoot(); + + if (Iterables.size(schemaNodePath) - colCount >= 0) { + return Iterables.concat(Iterables.limit(schemaNodePath, Iterables.size(schemaNodePath) - colCount), + Iterables.transform(Iterables.skip(xpaths, colCount), + input -> stringPathPartToQName(context, module, input))); + } + return Iterables.concat(schemaNodePath, + Iterables.transform(Iterables.skip(xpaths, colCount), + input -> stringPathPartToQName(context, module, input))); + } + + /** + * Extracts the base type of node on which schema node points to. If target node is again of type + * LeafrefTypeDefinition, methods will be call recursively until it reach concrete type definition. + * + * @param typeDefinition + * type of node which will be extracted + * @param schemaContext + * Schema Context + * @param schema + * Schema Node + * @return recursively found type definition this leafref is pointing to or null if the xpath is incorrect (null + * is there to preserve backwards compatibility) + */ + public static TypeDefinition getBaseTypeForLeafRef(final LeafrefTypeDefinition typeDefinition, + final SchemaContext schemaContext, final SchemaNode schema) { + RevisionAwareXPath pathStatement = typeDefinition.getPathStatement(); + pathStatement = new RevisionAwareXPathImpl(stripConditionsFromXPathString(pathStatement), + pathStatement.isAbsolute()); + + final DataSchemaNode dataSchemaNode; + if (pathStatement.isAbsolute()) { + SchemaNode baseSchema = schema; + while (baseSchema instanceof DerivableSchemaNode) { + final Optional basePotential = ((DerivableSchemaNode) baseSchema).getOriginal(); + if (basePotential.isPresent()) { + baseSchema = basePotential.get(); + } else { + break; + } + } + + Module parentModule = findParentModuleOfReferencingType(schemaContext, baseSchema); + dataSchemaNode = (DataSchemaNode) SchemaContextUtil.findDataSchemaNode(schemaContext, parentModule, + pathStatement); + } else { + Module parentModule = findParentModule(schemaContext, schema); + dataSchemaNode = (DataSchemaNode) SchemaContextUtil.findDataSchemaNodeForRelativeXPath(schemaContext, + parentModule, schema, pathStatement); + } + + // FIXME this is just to preserve backwards compatibility since yangtools do not mind wrong leafref xpaths + // and current expected behaviour for such cases is to just use pure string + // This should throw an exception about incorrect XPath in leafref + if (dataSchemaNode == null) { + return null; + } + + final TypeDefinition targetTypeDefinition = typeDefinition(dataSchemaNode); + + if (targetTypeDefinition instanceof LeafrefTypeDefinition) { + return getBaseTypeForLeafRef((LeafrefTypeDefinition) targetTypeDefinition, schemaContext, dataSchemaNode); + } + + return targetTypeDefinition; + } + + /** + * Returns base type for {@code typeDefinition} which belongs to module specified via {@code qname}. This handle + * the case when leafref type isn't specified as type substatement of leaf or leaf-list but is defined in other + * module as typedef which is then imported to referenced module. + * + *

+ * Because {@code typeDefinition} is definied via typedef statement, only absolute path is meaningful. + */ + public static TypeDefinition getBaseTypeForLeafRef(final LeafrefTypeDefinition typeDefinition, + final SchemaContext schemaContext, final QName qname) { + final RevisionAwareXPath pathStatement = typeDefinition.getPathStatement(); + final RevisionAwareXPath strippedPathStatement = new RevisionAwareXPathImpl( + stripConditionsFromXPathString(pathStatement), pathStatement.isAbsolute()); + if (!strippedPathStatement.isAbsolute()) { + return null; + } + + final Optional parentModule = schemaContext.findModule(qname.getModule()); + Preconditions.checkArgument(parentModule.isPresent(), "Failed to find parent module for %s", qname); + + final DataSchemaNode dataSchemaNode = (DataSchemaNode) SchemaContextUtil.findDataSchemaNode(schemaContext, + parentModule.get(), strippedPathStatement); + final TypeDefinition targetTypeDefinition = typeDefinition(dataSchemaNode); + if (targetTypeDefinition instanceof LeafrefTypeDefinition) { + return getBaseTypeForLeafRef((LeafrefTypeDefinition) targetTypeDefinition, schemaContext, dataSchemaNode); + } + + return targetTypeDefinition; + } + + private static Module findParentModuleOfReferencingType(final SchemaContext schemaContext, + final SchemaNode schemaNode) { + Preconditions.checkArgument(schemaContext != null, "Schema Context reference cannot be NULL!"); + Preconditions.checkArgument(schemaNode instanceof TypedDataSchemaNode, "Unsupported node %s", schemaNode); + + TypeDefinition nodeType = ((TypedDataSchemaNode) schemaNode).getType(); + if (nodeType.getBaseType() != null) { + while (nodeType.getBaseType() != null) { + nodeType = nodeType.getBaseType(); + } + + return schemaContext.findModule(nodeType.getQName().getModule()).orElse(null); + } + + return SchemaContextUtil.findParentModule(schemaContext, schemaNode); + } + + private static final Pattern STRIP_PATTERN = Pattern.compile("\\[[^\\[\\]]*\\]"); + + /** + * Removes conditions from xPath pointed to target node. + * + * @param pathStatement + * xPath to target node + * @return string representation of xPath without conditions + */ + @VisibleForTesting + static String stripConditionsFromXPathString(final RevisionAwareXPath pathStatement) { + return STRIP_PATTERN.matcher(pathStatement.toString()).replaceAll(""); + } + + /** + * Extracts the base type of leaf schema node until it reach concrete type of TypeDefinition. + * + * @param node + * a node representing LeafSchemaNode + * @return concrete type definition of node value + */ + private static TypeDefinition typeDefinition(final LeafSchemaNode node) { + TypeDefinition baseType = node.getType(); + while (baseType.getBaseType() != null) { + baseType = baseType.getBaseType(); + } + return baseType; + } + + /** + * Extracts the base type of leaf schema node until it reach concrete type of TypeDefinition. + * + * @param node + * a node representing LeafListSchemaNode + * @return concrete type definition of node value + */ + private static TypeDefinition typeDefinition(final LeafListSchemaNode node) { + TypeDefinition baseType = node.getType(); + while (baseType.getBaseType() != null) { + baseType = baseType.getBaseType(); + } + return baseType; + } + + /** + * Gets the base type of DataSchemaNode value. + * + * @param node + * a node representing DataSchemaNode + * @return concrete type definition of node value + */ + private static TypeDefinition typeDefinition(final DataSchemaNode node) { + if (node instanceof LeafListSchemaNode) { + return typeDefinition((LeafListSchemaNode) node); + } else if (node instanceof LeafSchemaNode) { + return typeDefinition((LeafSchemaNode) node); + } else { + throw new IllegalArgumentException("Unhandled parameter type: " + node); + } } }