*/
package org.opendaylight.mdsal.binding.yang.types;
-import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
import static org.opendaylight.mdsal.binding.model.util.BindingTypes.TYPE_OBJECT;
-import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNode;
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNodeForRelativeXPath;
+import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataTreeSchemaNode;
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findParentModule;
import com.google.common.annotations.Beta;
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.RevisionAwareXPath;
+import org.opendaylight.yangtools.yang.model.api.PathExpression;
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.type.StringTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.ModuleDependencySort;
-import org.opendaylight.yangtools.yang.model.util.RevisionAwareXPathImpl;
+import org.opendaylight.yangtools.yang.model.util.PathExpressionImpl;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.type.CompatUtils;
}
private boolean isLeafRefSelfReference(final LeafrefTypeDefinition leafref, final SchemaNode parentNode) {
- final SchemaNode leafRefValueNode;
- final RevisionAwareXPath leafRefXPath = leafref.getPathStatement();
- final RevisionAwareXPath leafRefStrippedXPath = new RevisionAwareXPathImpl(
- GROUPS_PATTERN.matcher(leafRefXPath.toString()).replaceAll(""), leafRefXPath.isAbsolute());
-
- ///// skip leafrefs in augments - they're checked once augments are resolved
- final Iterator<QName> iterator = parentNode.getPath().getPathFromRoot().iterator();
- boolean isAugmenting = false;
+ /*
+ * First check if the leafref is an augment. If that is the case, skip it as it will be checked once augments
+ * are resolved.
+ */
DataNodeContainer current = null;
DataSchemaNode dataChildByName;
-
- while (iterator.hasNext() && !isAugmenting) {
- final QName next = iterator.next();
+ for (QName next : parentNode.getPath().getPathFromRoot()) {
if (current == null) {
dataChildByName = schemaContext.getDataChildByName(next);
} else {
dataChildByName = current.getDataChildByName(next);
}
- if (dataChildByName != null) {
- isAugmenting = dataChildByName.isAugmenting();
- } else {
+ if (dataChildByName == null) {
+ return false;
+ }
+ if (dataChildByName.isAugmenting()) {
return false;
}
if (dataChildByName instanceof DataNodeContainer) {
current = (DataNodeContainer) dataChildByName;
}
}
- if (isAugmenting) {
- return false;
- }
- /////
+ // Then try to look up the expression.
+ final PathExpression leafRefXPath = leafref.getPathStatement();
final Module parentModule = getParentModule(parentNode);
- if (!leafRefStrippedXPath.isAbsolute()) {
- leafRefValueNode = SchemaContextUtil.findDataSchemaNodeForRelativeXPath(schemaContext, parentModule,
- parentNode, leafRefStrippedXPath);
+ final SchemaNode leafRefValueNode;
+ if (leafRefXPath.isAbsolute()) {
+ leafRefValueNode = SchemaContextUtil.findDataTreeSchemaNode(schemaContext, parentModule.getQNameModule(),
+ leafRefXPath);
} else {
- leafRefValueNode = SchemaContextUtil.findDataSchemaNode(schemaContext, parentModule, leafRefStrippedXPath);
+ leafRefValueNode = SchemaContextUtil.findDataSchemaNodeForRelativeXPath(schemaContext, parentModule,
+ parentNode, new PathExpressionImpl(
+ GROUPS_PATTERN.matcher(leafRefXPath.getOriginalString()).replaceAll(""), false));
}
+
return leafRefValueNode != null && leafRefValueNode.equals(parentNode);
}
final boolean inGrouping) {
Preconditions.checkArgument(leafrefType != null, "Leafref Type Definition reference cannot be NULL!");
- final RevisionAwareXPath xpath = leafrefType.getPathStatement();
+ final PathExpression xpath = leafrefType.getPathStatement();
Preconditions.checkArgument(xpath != null, "The Path Statement for Leafref Type Definition cannot be NULL!");
- final String strXPath = verifyNotNull(xpath.toString());
+ final String strXPath = xpath.getOriginalString();
if (strXPath.indexOf('[') != -1) {
// XXX: why are we special-casing this?
return Types.objectType();
final SchemaNode dataNode;
if (xpath.isAbsolute()) {
- dataNode = findDataSchemaNode(schemaContext, module, xpath);
+ dataNode = findDataTreeSchemaNode(schemaContext, module.getQNameModule(), xpath);
} else {
dataNode = findDataSchemaNodeForRelativeXPath(schemaContext, module, parentNode, xpath);
if (dataNode == null && inGrouping) {
returnType = Types.listTypeFor(referencedTypes.get(dataNode.getPath()));
}
if (returnType == null) {
- returnType = resolveTypeFromDataSchemaNode(dataNode);
+ returnType = resolveTypeFromDataSchemaNode(dataNode, inGrouping);
}
Preconditions.checkArgument(returnType != null, "Failed to find leafref target: %s in module %s (%s)",
strXPath, this.getParentModule(parentNode).getName(), parentNode.getQName().getModule(), this);
private static boolean leafContainsEnumDefinition(final SchemaNode dataNode) {
if (dataNode instanceof LeafSchemaNode) {
final LeafSchemaNode leaf = (LeafSchemaNode) dataNode;
- return CompatUtils.compatLeafType(leaf) instanceof EnumTypeDefinition;
+ return CompatUtils.compatType(leaf) instanceof EnumTypeDefinition;
}
return false;
}
* @param dataNode contains information about YANG type
* @return JAVA <code>Type</code> representation of <code>dataNode</code>
*/
- private Type resolveTypeFromDataSchemaNode(final SchemaNode dataNode) {
+ private Type resolveTypeFromDataSchemaNode(final SchemaNode dataNode, final boolean inGrouping) {
Type returnType = null;
if (dataNode != null) {
if (dataNode instanceof LeafSchemaNode) {
final LeafSchemaNode leaf = (LeafSchemaNode) dataNode;
- final TypeDefinition<?> type = CompatUtils.compatLeafType(leaf);
- returnType = javaTypeForSchemaDefinitionType(type, leaf);
+ final TypeDefinition<?> type = CompatUtils.compatType(leaf);
+ returnType = javaTypeForSchemaDefinitionType(type, leaf, inGrouping);
} else if (dataNode instanceof LeafListSchemaNode) {
final LeafListSchemaNode leafList = (LeafListSchemaNode) dataNode;
- returnType = javaTypeForSchemaDefinitionType(leafList.getType(), leafList);
+ returnType = javaTypeForSchemaDefinitionType(leafList.getType(), leafList, inGrouping);
}
}
return returnType;
}
public String getTypeDefaultConstruction(final LeafSchemaNode node, final String defaultValue) {
- final TypeDefinition<?> type = CompatUtils.compatLeafType(node);
+ final TypeDefinition<?> type = CompatUtils.compatType(node);
final QName typeQName = type.getQName();
final TypeDefinition<?> base = baseTypeDefForExtendedType(type);
requireNonNull(type, () -> "Cannot provide default construction for null type of " + node);
Preconditions.checkArgument(leafrefType.getPathStatement() != null,
"The Path Statement for Leafref Type Definition cannot be NULL!");
- final RevisionAwareXPath xpath = leafrefType.getPathStatement();
- final String strXPath = xpath.toString();
+ final PathExpression xpath = leafrefType.getPathStatement();
+ final String strXPath = xpath.getOriginalString();
if (strXPath != null) {
if (strXPath.indexOf('[') == -1) {
if (module != null) {
final SchemaNode dataNode;
if (xpath.isAbsolute()) {
- dataNode = findDataSchemaNode(schemaContext, module, xpath);
+ dataNode = findDataTreeSchemaNode(schemaContext, module.getQNameModule(), xpath);
} else {
dataNode = findDataSchemaNodeForRelativeXPath(schemaContext, module, parentNode, xpath);
}
}
private String unionToDef(final LeafSchemaNode node) {
- final TypeDefinition<?> type = CompatUtils.compatLeafType(node);
+ final TypeDefinition<?> type = CompatUtils.compatType(node);
String parentName;
String className;