import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+// FIXME: 3.0.0 hide this class
public final class LeafRefContext {
private final QName currentNodeQName;
private final Module module;
private final LeafRefPath leafRefTargetPath;
- private final LeafRefPath absoluteLeafRefTargetPath ;
+ private final LeafRefPath absoluteLeafRefTargetPath;
private final String leafRefTargetPathString;
private final boolean isReferencedBy;
private final Map<QName, LeafRefContext> referencedByChilds;
private final Map<QName, LeafRefContext> referencedByLeafRefCtx;
+ // FIXME: this looks like it's related to absoluteLeafRefTargetPath, but the original use in LeafRefValidation
+ // fast path did not make it clear. Analyze the relationship between this field and
+ // absoluteLeafRefTargetPath.
+ private volatile LeafRefPath leafRefNodePath = null;
+
LeafRefContext(final LeafRefContextBuilder leafRefContextBuilder) {
this.currentNodeQName = leafRefContextBuilder.getCurrentNodeQName();
this.currentNodePath = leafRefContextBuilder.getCurrentNodePath();
return referencedByLeafRefCtx;
}
+ LeafRefPath getLeafRefNodePath() {
+ LeafRefPath ret = leafRefNodePath;
+ if (ret == null) {
+ synchronized (this) {
+ ret = leafRefNodePath;
+ if (ret == null) {
+ ret = leafRefNodePath = LeafRefUtils.schemaPathToLeafRefPath(currentNodePath, module);
+ }
+ }
+ }
+ return ret;
+ }
}
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidateNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return;
}
- final Map<QName, LeafRefContext> allReferencedByLeafRefCtxs = referencedByCtx.getAllReferencedByLeafRefCtxs();
- for (final LeafRefContext leafRefContext : allReferencedByLeafRefCtxs.values()) {
+ for (final LeafRefContext leafRefContext : referencedByCtx.getAllReferencedByLeafRefCtxs().values()) {
if (leafRefContext.isReferencing()) {
- final Set<Object> values = new HashSet<>();
-
- final SchemaPath leafRefNodeSchemaPath = leafRefContext.getCurrentNodePath();
- final LeafRefPath leafRefNodePath = LeafRefUtils.schemaPathToLeafRefPath(leafRefNodeSchemaPath,
- leafRefContext.getLeafRefContextModule());
- final Iterable<QNameWithPredicate> pathFromRoot = leafRefNodePath.getPathFromRoot();
- addValues(values, tree.getRootNode().getDataAfter(), pathFromRoot, null, QNameWithPredicate.ROOT);
- leafRefsValues.put(leafRefContext, values);
+ leafRefsValues.put(leafRefContext, extractRootValues(leafRefContext));
}
}
if (!leafRefsValues.isEmpty()) {
- final Set<Object> leafRefTargetNodeValues = new HashSet<>();
- final SchemaPath nodeSchemaPath = referencedByCtx.getCurrentNodePath();
- final LeafRefPath nodePath = LeafRefUtils.schemaPathToLeafRefPath(nodeSchemaPath, referencedByCtx
- .getLeafRefContextModule());
- addValues(leafRefTargetNodeValues, tree.getRootNode().getDataAfter(), nodePath.getPathFromRoot(), null,
- QNameWithPredicate.ROOT);
- leafRefTargetNodeDataLog(leaf, referencedByCtx, modificationType, leafRefsValues,
- leafRefTargetNodeValues);
+ final Set<Object> values = extractRootValues(referencedByCtx);
+ leafRefTargetNodeDataLog(leaf, referencedByCtx, modificationType, leafRefsValues, values);
} else {
leafRefTargetNodeDataLog(leaf, referencedByCtx, modificationType, null, null);
}
validatedLeafRefCtx.add(referencedByCtx);
}
+ private Set<Object> extractRootValues(final LeafRefContext context) {
+ final Set<Object> values = new HashSet<>();
+ addValues(values, tree.getRootNode().getDataAfter(), context.getLeafRefNodePath().getPathFromRoot(), null,
+ QNameWithPredicate.ROOT);
+ return values;
+ }
+
private void leafRefTargetNodeDataLog(final NormalizedNode<?, ?> leaf, final LeafRefContext referencedByCtx,
final ModificationType modificationType, final Map<LeafRefContext, Set<?>> leafRefsValues,
final Set<Object> leafRefTargetNodeValues) {