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=73bd1765d1d0cc121702ee110b85075647bec6e5;hb=bb60da5fe2d1928defb46ed92b290cfff93dcd81;hp=7aa3984334a4b6ac2a44110e05999179ad31d5b3;hpb=c8668229ad6e73d5ae03a52f4b87e8e4d2a67c6e;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 7aa3984334..73bd1765d1 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 @@ -15,41 +15,59 @@ import com.google.common.annotations.Beta; import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Splitter; import com.google.common.collect.Iterables; +import com.google.common.collect.Lists; +import java.util.ArrayDeque; import java.util.ArrayList; +import java.util.Arrays; +import java.util.Deque; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Optional; import java.util.Set; import java.util.regex.Pattern; +import java.util.stream.Collectors; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; +import org.opendaylight.yangtools.yang.common.AbstractQName; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.common.QNameModule; +import org.opendaylight.yangtools.yang.common.UnqualifiedQName; import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer; import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode; import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode; -import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; +import org.opendaylight.yangtools.yang.model.api.ContainerLike; 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.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.ModuleLike; import org.opendaylight.yangtools.yang.model.api.NotificationDefinition; import org.opendaylight.yangtools.yang.model.api.NotificationNodeContainer; import org.opendaylight.yangtools.yang.model.api.OperationDefinition; import org.opendaylight.yangtools.yang.model.api.PathExpression; +import org.opendaylight.yangtools.yang.model.api.PathExpression.DerefSteps; +import org.opendaylight.yangtools.yang.model.api.PathExpression.LocationPathSteps; +import org.opendaylight.yangtools.yang.model.api.PathExpression.Steps; 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.Submodule; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode; +import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition; 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.opendaylight.yangtools.yang.xpath.api.YangLocationPath; +import org.opendaylight.yangtools.yang.xpath.api.YangLocationPath.AxisStep; +import org.opendaylight.yangtools.yang.xpath.api.YangLocationPath.QNameStep; +import org.opendaylight.yangtools.yang.xpath.api.YangLocationPath.Step; +import org.opendaylight.yangtools.yang.xpath.api.YangXPathAxis; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -62,25 +80,24 @@ public final class SchemaContextUtil { private static final Logger LOG = LoggerFactory.getLogger(SchemaContextUtil.class); private static final Splitter COLON_SPLITTER = Splitter.on(':'); private static final Splitter SLASH_SPLITTER = Splitter.on('/').omitEmptyStrings(); + private static final Pattern GROUPS_PATTERN = Pattern.compile("\\[(.*?)\\]"); private SchemaContextUtil() { + // Hidden on purpose } /** - * Method attempts to find DataSchemaNode in Schema Context via specified - * Schema Path. The returned DataSchemaNode from method will be the node at - * 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 throw - * IllegalArgumentException. + * Method attempts to find DataSchemaNode in Schema Context via specified Schema Path. The returned DataSchemaNode + * from method will be the node at the end of the SchemaPath. If the DataSchemaNode is not present in the Schema + * Context the method will return {@code null}. * - * @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. + *

+ * In case that Schema Context or Schema Path are not specified correctly (i.e. contains {@code null} values) the + * method will throw IllegalArgumentException. + * + * @param context Schema Context + * @param schemaPath Schema Path to search for + * @return SchemaNode from the end of the Schema Path or {@code null} if the Node is not present. * @throws NullPointerException if context or schemaPath is null */ public static SchemaNode findDataSchemaNode(final SchemaContext context, final SchemaPath schemaPath) { @@ -94,6 +111,35 @@ public final class SchemaContextUtil { return findNodeInSchemaContext(context, prefixedPath); } + /** + * Attempt to find a DataSchemaNode based on its path from root, similar to + * {@link #findDataSchemaNode(SchemaContext, Module, PathExpression)} without requiring an expression. + * + * @param context Schema Context + * @param path Path to search for + * @return SchemaNode from the end of the Schema Path or {@code null} if the Node is not present. + * @throws NullPointerException if a any argument is null or if the path contains a null element + */ + @Beta + public static SchemaNode findDataSchemaNode(final SchemaContext context, final List path) { + return findTargetNode(context, null, YangLocationPath.absolute( + path.stream().map(YangXPathAxis.CHILD::asStep).collect(Collectors.toList()))); + } + + /** + * Attempt to find a DataSchemaNode based on its path from root, similar to + * {@link #findDataSchemaNode(SchemaContext, Module, PathExpression)} without requiring an expression. + * + * @param context Schema Context + * @param path Path to search for + * @return SchemaNode from the end of the Schema Path or {@code null} if the Node is not present. + * @throws NullPointerException if a any argument is null or if the path contains a null element + */ + @Beta + public static SchemaNode findDataSchemaNode(final SchemaContext context, final QName... path) { + return findDataSchemaNode(context, Arrays.asList(path)); + } + /** * Method attempts to find DataSchemaNode inside of provided Schema Context * and Yang Module accordingly to Non-conditional Revision Aware XPath. The @@ -119,6 +165,8 @@ public final class SchemaContextUtil { * Non-conditional Revision Aware XPath, or null if the * DataSchemaNode is not present in Schema Context. * @throws NullPointerException if any of the arguments is null + * @deprecated Use {@link #findDataTreeSchemaNode(SchemaContext, QNameModule, YangLocationPath)} or + * {@link #findDataTreeSchemaNode(SchemaContext, QNameModule, PathExpression)} instead. */ // FIXME: This entire method is ill-defined, as the resolution process depends on where the XPath is defined -- // notably RPCs, actions and notifications modify the data tree temporarily. See sections 6.4.1 and 9.9.2 @@ -132,6 +180,7 @@ public final class SchemaContextUtil { // // which would then be passed in to a method similar to this one. In static contexts, like MD-SAL codegen, // that feels like an overkill. + @Deprecated public static SchemaNode findDataSchemaNode(final SchemaContext context, final Module module, final PathExpression nonCondXPath) { requireNonNull(context, "context"); @@ -140,16 +189,33 @@ public final class SchemaContextUtil { final String strXPath = nonCondXPath.getOriginalString(); checkArgument(strXPath.indexOf('[') == -1, "Revision Aware XPath may not contain a condition"); if (nonCondXPath.isAbsolute()) { - final List path = xpathToQNamePath(context, module, strXPath); - - // We do not have enough information about resolution context, hence cannot account for actions, RPCs - // and notifications. We therefore attempt to make a best estimate, but this can still fail. - final Optional pureData = context.findDataTreeChild(path); - return pureData.isPresent() ? pureData.get() : findNodeInSchemaContext(context, path); + return findTargetNode(context, xpathToQNamePath(context, module, strXPath)); } return null; } + @Beta + public static SchemaNode findDataTreeSchemaNode(final SchemaContext ctx, final QNameModule localModule, + final YangLocationPath absPath) { + checkArgument(absPath.isAbsolute(), "Unsupported relative path %s", absPath); + return findTargetNode(ctx, localModule, absPath); + } + + @Beta + public static SchemaNode findDataTreeSchemaNode(final SchemaContext ctx, final QNameModule localModule, + final PathExpression absPath) { + final Steps pathSteps = absPath.getSteps(); + if (pathSteps instanceof LocationPathSteps) { + return findDataTreeSchemaNode(ctx, localModule, ((LocationPathSteps) pathSteps).getLocationPath()); + } + + // We would need a reference schema node and no, we do not want to use SchemaContext in its SchemaNode capacity + checkArgument(!(pathSteps instanceof DerefSteps), "No reference node for steps %s", pathSteps); + + // We are missing proper API alignment, if this ever triggers + throw new IllegalStateException("Unsupported path " + pathSteps); + } + /** * Method attempts to find DataSchemaNode inside of provided Schema Context * and Yang Module accordingly to Non-conditional relative Revision Aware @@ -197,17 +263,17 @@ public final class SchemaContextUtil { // // which would then be passed in to a method similar to this one. In static contexts, like MD-SAL codegen, // that feels like an overkill. + // FIXME: YANGTOOLS-1052: this is a static analysis util, move it to a dedicated class public static SchemaNode findDataSchemaNodeForRelativeXPath(final SchemaContext context, final Module module, final SchemaNode actualSchemaNode, final PathExpression relativeXPath) { checkState(!relativeXPath.isAbsolute(), "Revision Aware XPath MUST be relative i.e. MUST contains ../, " + "for non relative Revision Aware XPath use findDataSchemaNode method"); + return resolveRelativeXPath(context, module, removePredicatesFromXpath(relativeXPath.getOriginalString()), + actualSchemaNode); + } - final Iterable qnamePath = resolveRelativeXPath(context, module, relativeXPath, actualSchemaNode); - - // We do not have enough information about resolution context, hence cannot account for actions, RPCs - // and notifications. We therefore attempt to make a best estimate, but this can still fail. - final Optional pureData = context.findDataTreeChild(qnamePath); - return pureData.isPresent() ? pureData.get() : findNodeInSchemaContext(context, qnamePath); + private static String removePredicatesFromXpath(final String xpath) { + return GROUPS_PATTERN.matcher(xpath).replaceAll(""); } /** @@ -269,7 +335,7 @@ public final class SchemaContextUtil { * @return Notification schema or null, if notification is not present in schema context. */ @Beta - public static @Nullable ContainerSchemaNode getRpcDataSchema(final @NonNull SchemaContext schema, + public static @Nullable ContainerLike getRpcDataSchema(final @NonNull SchemaContext schema, final @NonNull SchemaPath path) { requireNonNull(schema, "Schema context must not be null."); requireNonNull(path, "Schema path must not be null."); @@ -298,7 +364,7 @@ public final class SchemaContextUtil { for (Module module : context.getModules()) { ret.add(moduleToIdentifier(module)); - for (Module submodule : module.getSubmodules()) { + for (Submodule submodule : module.getSubmodules()) { ret.add(moduleToIdentifier(submodule)); } } @@ -306,7 +372,7 @@ public final class SchemaContextUtil { return ret; } - private static SourceIdentifier moduleToIdentifier(final Module module) { + private static SourceIdentifier moduleToIdentifier(final ModuleLike module) { return RevisionSourceIdentifier.create(module.getName(), module.getRevision()); } @@ -322,7 +388,7 @@ public final class SchemaContextUtil { SchemaNode foundNode = null; final Iterable nextPath = nextLevel(path); - foundNode = module.getDataChildByName(current); + foundNode = module.dataChildByName(current); if (foundNode != null && nextPath.iterator().hasNext()) { foundNode = findNodeIn(foundNode, nextPath); } @@ -370,7 +436,7 @@ public final class SchemaContextUtil { if (parent instanceof DataNodeContainer) { final DataNodeContainer parentDataNodeContainer = (DataNodeContainer) parent; - foundNode = parentDataNodeContainer.getDataChildByName(current); + foundNode = parentDataNodeContainer.dataChildByName(current); if (foundNode != null && nextPath.iterator().hasNext()) { foundNode = findNodeIn(foundNode, nextPath); } @@ -384,10 +450,10 @@ public final class SchemaContextUtil { } if (foundNode == null && parent instanceof ActionNodeContainer) { - foundNode = ((ActionNodeContainer) parent).getActions().stream() - .filter(act -> current.equals(act.getQName())).findFirst().orElse(null); - if (foundNode != null && nextPath.iterator().hasNext()) { - foundNode = findNodeIn(foundNode, nextPath); + final Optional next = ((ActionNodeContainer) parent).getActions().stream() + .filter(act -> current.equals(act.getQName())).findFirst(); + if (next.isPresent() && nextPath.iterator().hasNext()) { + foundNode = findNodeIn(next.orElseThrow(), nextPath); } } @@ -425,7 +491,7 @@ public final class SchemaContextUtil { } if (foundNode == null && parent instanceof ChoiceSchemaNode) { - foundNode = ((ChoiceSchemaNode) parent).getCaseNodeByName(current); + foundNode = ((ChoiceSchemaNode) parent).findCase(current).orElse(null); if (foundNode != null && nextPath.iterator().hasNext()) { foundNode = findNodeIn(foundNode, nextPath); @@ -433,8 +499,8 @@ public final class SchemaContextUtil { if (foundNode == null) { // fallback that tries to map into one of the child cases - for (final CaseSchemaNode caseNode : ((ChoiceSchemaNode) parent).getCases().values()) { - final DataSchemaNode maybeChild = caseNode.getDataChildByName(current); + for (final CaseSchemaNode caseNode : ((ChoiceSchemaNode) parent).getCases()) { + final DataSchemaNode maybeChild = caseNode.dataChildByName(current); if (maybeChild != null) { foundNode = findNodeIn(maybeChild, nextPath); break; @@ -545,7 +611,7 @@ public final class SchemaContextUtil { return QName.create(module.getQNameModule(), prefixedName.next()); } - return QName.create(parentModule.getNamespace(), parentModule.getRevision(), prefixedPathPart); + return QName.create(parentModule.getQNameModule(), prefixedPathPart); } /** @@ -570,8 +636,7 @@ public final class SchemaContextUtil { return module; } - final Set imports = module.getImports(); - for (final ModuleImport mi : imports) { + for (final ModuleImport mi : module.getImports()) { if (prefix.equals(mi.getPrefix())) { return context.findModule(mi.getModuleName(), mi.getRevision()).orElse(null); } @@ -586,38 +651,149 @@ public final class SchemaContextUtil { * Schema Context * @param module * Yang Module - * @param relativeXPath - * Non conditional Revision Aware Relative XPath + * @param pathStr + * xPath of leafref * @param actualSchemaNode * actual schema node - * @return list of QName + * @return target schema node * @throws IllegalArgumentException if any arguments are null */ - private static Iterable resolveRelativeXPath(final SchemaContext context, final Module module, - final PathExpression relativeXPath, final SchemaNode actualSchemaNode) { - checkState(!relativeXPath.isAbsolute(), "Revision Aware XPath MUST be relative i.e. MUST contains ../, " - + "for non relative Revision Aware XPath use findDataSchemaNode method"); + private static @Nullable SchemaNode resolveRelativeXPath(final SchemaContext context, final Module module, + final String pathStr, final SchemaNode actualSchemaNode) { checkState(actualSchemaNode.getPath() != null, "Schema Path reference for Leafref cannot be NULL"); - List xpaths = new ArrayList<>(); - splitXPath(relativeXPath.getOriginalString(), xpaths); + return pathStr.startsWith("deref(") ? resolveDerefPath(context, module, actualSchemaNode, pathStr) + : findTargetNode(context, resolveRelativePath(context, module, actualSchemaNode, + doSplitXPath(pathStr))); + } + private static Iterable resolveRelativePath(final SchemaContext context, final Module module, + final SchemaNode actualSchemaNode, final List steps) { // Find out how many "parent" components there are and trim them - final int colCount = normalizeXPath(xpaths); - if (colCount != 0) { - xpaths = xpaths.subList(colCount, xpaths.size()); - } + final int colCount = normalizeXPath(steps); + final List xpaths = colCount == 0 ? steps : steps.subList(colCount, steps.size()); - final Iterable schemaNodePath = actualSchemaNode.getPath().getPathFromRoot(); + final List walkablePath = createWalkablePath(actualSchemaNode.getPath().getPathFromRoot(), + context, colCount); - if (Iterables.size(schemaNodePath) - colCount >= 0) { - return Iterables.concat(Iterables.limit(schemaNodePath, Iterables.size(schemaNodePath) - colCount), - Iterables.transform(xpaths, input -> stringPathPartToQName(context, module, input))); + if (walkablePath.size() - colCount >= 0) { + return Iterables.concat(Iterables.limit(walkablePath, walkablePath.size() - colCount), + Iterables.transform(xpaths, input -> stringPathPartToQName(context, module, input))); } - return Iterables.concat(schemaNodePath, + return Iterables.concat(walkablePath, Iterables.transform(xpaths, input -> stringPathPartToQName(context, module, input))); } + /** + * Return List of qNames that are walkable using xPath. When getting a path from schema node it will return path + * with parents like CaseSchemaNode and ChoiceSchemaNode as well if they are parents of the node. We need to get + * rid of these in order to find the node that xPath is pointing to. Also we can not remove any node beyond the + * amount of "../" because we will not be able to find the correct schema node from schema context + * + * @param schemaNodePath list of qNames as a path to the leaf of type leafref + * @param context create schema context + * @param colCount amount of "../" in the xPath expression + * @return list of QNames as a path where we should be able to find referenced node + */ + private static List createWalkablePath(final Iterable schemaNodePath, final SchemaContext context, + final int colCount) { + final List indexToRemove = new ArrayList<>(); + List schemaNodePathRet = Lists.newArrayList(schemaNodePath); + for (int j = 0, i = schemaNodePathRet.size() - 1; i >= 0 && j != colCount; i--, j++) { + final SchemaNode nodeIn = findTargetNode(context, schemaNodePathRet); + if (nodeIn instanceof CaseSchemaNode || nodeIn instanceof ChoiceSchemaNode) { + indexToRemove.add(i); + j--; + } + schemaNodePathRet.remove(i); + } + schemaNodePathRet = Lists.newArrayList(schemaNodePath); + for (int i : indexToRemove) { + schemaNodePathRet.remove(i); + } + return schemaNodePathRet; + } + + private static SchemaNode resolveDerefPath(final SchemaContext context, final Module module, + final SchemaNode actualSchemaNode, final String xpath) { + final int paren = xpath.indexOf(')', 6); + checkArgument(paren != -1, "Cannot find matching parentheses in %s", xpath); + + final String derefArg = xpath.substring(6, paren).strip(); + // Look up the node which we need to reference + final SchemaNode derefTarget = findTargetNode(context, resolveRelativePath(context, module, actualSchemaNode, + doSplitXPath(derefArg))); + checkArgument(derefTarget != null, "Cannot find deref(%s) target node %s in context of %s", derefArg, + actualSchemaNode); + checkArgument(derefTarget instanceof TypedDataSchemaNode, "deref(%s) resolved to non-typed %s", derefArg, + derefTarget); + + // We have a deref() target, decide what to do about it + final TypeDefinition targetType = ((TypedDataSchemaNode) derefTarget).getType(); + if (targetType instanceof InstanceIdentifierTypeDefinition) { + // Static inference breaks down, we cannot determine where this points to + // FIXME: dedicated exception, users can recover from it, derive from IAE + throw new UnsupportedOperationException("Cannot infer instance-identifier reference " + targetType); + } + + // deref() is define only for instance-identifier and leafref types, handle the latter + checkArgument(targetType instanceof LeafrefTypeDefinition, "Illegal target type %s", targetType); + + final PathExpression targetPath = ((LeafrefTypeDefinition) targetType).getPathStatement(); + LOG.debug("Derefencing path {}", targetPath); + + final SchemaNode deref = targetPath.isAbsolute() + ? findTargetNode(context, actualSchemaNode.getQName().getModule(), + ((LocationPathSteps) targetPath.getSteps()).getLocationPath()) + : findDataSchemaNodeForRelativeXPath(context, module, actualSchemaNode, targetPath); + if (deref == null) { + LOG.debug("Path {} could not be derefenced", targetPath); + return null; + } + + checkArgument(deref instanceof LeafSchemaNode, "Unexpected %s reference in %s", deref, targetPath); + + final List qnames = doSplitXPath(xpath.substring(paren + 1).stripLeading()); + return findTargetNode(context, resolveRelativePath(context, module, deref, qnames)); + } + + private static @Nullable SchemaNode findTargetNode(final SchemaContext context, final QNameModule localNamespace, + final YangLocationPath path) { + final Deque ret = new ArrayDeque<>(); + for (Step step : path.getSteps()) { + if (step instanceof AxisStep) { + // We only support parent axis steps + final YangXPathAxis axis = ((AxisStep) step).getAxis(); + checkState(axis == YangXPathAxis.PARENT, "Unexpected axis %s", axis); + ret.removeLast(); + continue; + } + + // This has to be a QNameStep + checkState(step instanceof QNameStep, "Unhandled step %s in %s", step, path); + ret.addLast(resolve(((QNameStep) step).getQName(), localNamespace)); + } + + return findTargetNode(context, ret); + } + + private static @Nullable SchemaNode findTargetNode(final SchemaContext context, final Iterable qnamePath) { + // We do not have enough information about resolution context, hence cannot account for actions, RPCs + // and notifications. We therefore attempt to make a best estimate, but this can still fail. + final Optional pureData = context.findDataTreeChild(qnamePath); + return pureData.isPresent() ? pureData.get() : findNodeInSchemaContext(context, qnamePath); + } + + private static QName resolve(final AbstractQName toResolve, final QNameModule localNamespace) { + if (toResolve instanceof QName) { + return (QName) toResolve; + } else if (toResolve instanceof UnqualifiedQName) { + return ((UnqualifiedQName) toResolve).bindTo(localNamespace); + } else { + throw new IllegalStateException("Unhandled step " + toResolve); + } + } + @VisibleForTesting static int normalizeXPath(final List xpath) { LOG.trace("Normalize {}", xpath); @@ -660,31 +836,12 @@ public final class SchemaContextUtil { return -1; } - private static void splitXPath(final String xpath, final List output) { - // This is a major hack, but should do the trick for now. - final int deref = xpath.indexOf("deref("); - if (deref == -1) { - doSplitXPath(xpath, output); - return; + private static List doSplitXPath(final String xpath) { + final List ret = new ArrayList<>(); + for (String str : SLASH_SPLITTER.split(xpath)) { + ret.add(str); } - - // Interpret leading part - doSplitXPath(xpath.substring(0, deref), output); - - // Find matching parentheses - final int start = deref + 6; - final int paren = xpath.indexOf(')', start); - checkArgument(paren != -1, "Cannot find matching parentheses in %s", xpath); - - // Interpret the argument - doSplitXPath(xpath.substring(start, paren), output); - - // And now the last bit - splitXPath(xpath.substring(paren + 1), output); - } - - private static void doSplitXPath(final String xpath, final List output) { - SLASH_SPLITTER.split(xpath).forEach(output::add); + return ret; } /** @@ -702,9 +859,8 @@ public final class SchemaContextUtil { */ public static TypeDefinition getBaseTypeForLeafRef(final LeafrefTypeDefinition typeDefinition, final SchemaContext schemaContext, final SchemaNode schema) { - PathExpression pathStatement = typeDefinition.getPathStatement(); - pathStatement = new PathExpressionImpl(stripConditionsFromXPathString(pathStatement), - pathStatement.isAbsolute()); + final PathExpression pathStatement = typeDefinition.getPathStatement(); + final String pathStr = stripConditionsFromXPathString(pathStatement); final DataSchemaNode dataSchemaNode; if (pathStatement.isAbsolute()) { @@ -718,13 +874,12 @@ public final class SchemaContextUtil { } } - Module parentModule = findParentModuleOfReferencingType(schemaContext, baseSchema); - dataSchemaNode = (DataSchemaNode) SchemaContextUtil.findDataSchemaNode(schemaContext, parentModule, - pathStatement); + final Module parentModule = findParentModuleOfReferencingType(schemaContext, baseSchema); + dataSchemaNode = (DataSchemaNode) findTargetNode(schemaContext, + xpathToQNamePath(schemaContext, parentModule, pathStr)); } else { Module parentModule = findParentModule(schemaContext, schema); - dataSchemaNode = (DataSchemaNode) SchemaContextUtil.findDataSchemaNodeForRelativeXPath(schemaContext, - parentModule, schema, pathStatement); + dataSchemaNode = (DataSchemaNode) resolveRelativeXPath(schemaContext, parentModule, pathStr, schema); } // FIXME this is just to preserve backwards compatibility since yangtools do not mind wrong leafref xpaths @@ -754,17 +909,15 @@ public final class SchemaContextUtil { public static TypeDefinition getBaseTypeForLeafRef(final LeafrefTypeDefinition typeDefinition, final SchemaContext schemaContext, final QName qname) { final PathExpression pathStatement = typeDefinition.getPathStatement(); - final PathExpression strippedPathStatement = new PathExpressionImpl( - stripConditionsFromXPathString(pathStatement), pathStatement.isAbsolute()); - if (!strippedPathStatement.isAbsolute()) { + if (!pathStatement.isAbsolute()) { return null; } final Optional parentModule = schemaContext.findModule(qname.getModule()); checkArgument(parentModule.isPresent(), "Failed to find parent module for %s", qname); - final DataSchemaNode dataSchemaNode = (DataSchemaNode) SchemaContextUtil.findDataSchemaNode(schemaContext, - parentModule.get(), strippedPathStatement); + final DataSchemaNode dataSchemaNode = (DataSchemaNode) findTargetNode(schemaContext, + xpathToQNamePath(schemaContext, parentModule.get(), stripConditionsFromXPathString(pathStatement))); final TypeDefinition targetTypeDefinition = typeDefinition(dataSchemaNode); if (targetTypeDefinition instanceof LeafrefTypeDefinition) { return getBaseTypeForLeafRef((LeafrefTypeDefinition) targetTypeDefinition, schemaContext, dataSchemaNode); @@ -787,7 +940,7 @@ public final class SchemaContextUtil { return schemaContext.findModule(nodeType.getQName().getModule()).orElse(null); } - return SchemaContextUtil.findParentModule(schemaContext, schemaNode); + return findParentModule(schemaContext, schemaNode); } private static final Pattern STRIP_PATTERN = Pattern.compile("\\[[^\\[\\]]*\\]"); @@ -804,36 +957,6 @@ public final class SchemaContextUtil { return STRIP_PATTERN.matcher(pathStatement.getOriginalString()).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. * @@ -842,12 +965,15 @@ public final class SchemaContextUtil { * @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); + checkArgument(node instanceof TypedDataSchemaNode, "Unhandled parameter type %s", node); + + TypeDefinition current = ((TypedDataSchemaNode) node).getType(); + // TODO: don't we have a utility for this? + TypeDefinition base = current.getBaseType(); + while (base != null) { + current = base; + base = current.getBaseType(); } + return current; } }