X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=binding%2Fmdsal-binding-runtime-api%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fmdsal%2Fbinding%2Fruntime%2Fapi%2FAbstractBindingRuntimeContext.java;h=f7587ee913330b56327c010e913263794cc779ba;hb=8f2a259e8bf106c4b33acd8df3a7dbe19aaa43d0;hp=8aee2609a4f600c530d2debfaa6eb6e37fa56f3e;hpb=ecd143269fd7ee4031a3191b0a80a19056f1d8dd;p=mdsal.git diff --git a/binding/mdsal-binding-runtime-api/src/main/java/org/opendaylight/mdsal/binding/runtime/api/AbstractBindingRuntimeContext.java b/binding/mdsal-binding-runtime-api/src/main/java/org/opendaylight/mdsal/binding/runtime/api/AbstractBindingRuntimeContext.java index 8aee2609a4..f7587ee913 100644 --- a/binding/mdsal-binding-runtime-api/src/main/java/org/opendaylight/mdsal/binding/runtime/api/AbstractBindingRuntimeContext.java +++ b/binding/mdsal-binding-runtime-api/src/main/java/org/opendaylight/mdsal/binding/runtime/api/AbstractBindingRuntimeContext.java @@ -26,7 +26,7 @@ import java.util.Map.Entry; import java.util.Optional; import java.util.Set; import org.eclipse.jdt.annotation.NonNull; -import org.opendaylight.mdsal.binding.model.api.DefaultType; +import org.eclipse.jdt.annotation.Nullable; import org.opendaylight.mdsal.binding.model.api.GeneratedType; import org.opendaylight.mdsal.binding.model.api.MethodSignature; import org.opendaylight.mdsal.binding.model.api.ParameterizedType; @@ -34,7 +34,9 @@ import org.opendaylight.mdsal.binding.model.api.Type; import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder; import org.opendaylight.yangtools.yang.binding.Action; import org.opendaylight.yangtools.yang.binding.Augmentation; +import org.opendaylight.yangtools.yang.binding.Notification; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.common.QNameModule; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier; import org.opendaylight.yangtools.yang.model.api.ActionDefinition; import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode; @@ -43,11 +45,10 @@ import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode; import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode; 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.DocumentedNode.WithStatus; import org.opendaylight.yangtools.yang.model.api.SchemaNode; -import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute; import org.opendaylight.yangtools.yang.model.util.EffectiveAugmentationSchema; -import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -79,7 +80,7 @@ public abstract class AbstractBindingRuntimeContext implements BindingRuntimeCon @Override public final > AugmentationSchemaNode getAugmentationDefinition(final Class augClass) { - return getTypes().findAugmentation(DefaultType.of(augClass)).orElse(null); + return getTypes().findAugmentation(Type.of(augClass)).orElse(null); } @Override @@ -87,17 +88,57 @@ public abstract class AbstractBindingRuntimeContext implements BindingRuntimeCon checkArgument(!Augmentation.class.isAssignableFrom(cls), "Supplied class must not be an augmentation (%s is)", cls); checkArgument(!Action.class.isAssignableFrom(cls), "Supplied class must not be an action (%s is)", cls); - return (DataSchemaNode) getTypes().findSchema(DefaultType.of(cls)).orElse(null); + checkArgument(!Notification.class.isAssignableFrom(cls), "Supplied class must not be a notification (%s is)", + cls); + return (DataSchemaNode) getTypes().findSchema(Type.of(cls)).orElse(null); } @Override - public final ActionDefinition getActionDefinition(final Class> cls) { - return (ActionDefinition) getTypes().findSchema(DefaultType.of(cls)).orElse(null); + public final DataSchemaNode findChildSchemaDefinition(final DataNodeContainer parentSchema, + final QNameModule parentNamespace, final Class childClass) { + final DataSchemaNode origDef = getSchemaDefinition(childClass); + if (origDef == null) { + // Weird, the child does not have an associated definition + return null; + } + + // Direct instantiation or use in same module in which grouping was defined. + final QName origName = origDef.getQName(); + final DataSchemaNode sameName = parentSchema.dataChildByName(origName); + if (sameName != null) { + // Check if it is: + // - exactly same schema node, or + // - instantiated node was added via uses statement and is instantiation of same grouping + if (origDef.equals(sameName) || origDef.equals(getRootOriginalIfPossible(sameName))) { + return sameName; + } + + // Node has same name, but clearly is different + return null; + } + + // We are looking for instantiation via uses in other module + final DataSchemaNode potential = parentSchema.dataChildByName(origName.bindTo(parentNamespace)); + // We check if it is really instantiated from same definition as class was derived + if (potential != null && origDef.equals(getRootOriginalIfPossible(potential))) { + return potential; + } + return null; + } + + private static @Nullable SchemaNode getRootOriginalIfPossible(final SchemaNode data) { + SchemaNode previous = null; + SchemaNode next = originalNodeOf(data); + while (next != null) { + previous = next; + next = originalNodeOf(next); + } + return previous; } @Override - public final Absolute getActionIdentifier(final Class> cls) { - return getTypes().findSchemaNodeIdentifier(DefaultType.of(cls)).orElse(null); + public final ActionDefinition getActionDefinition(final Class> cls) { + return (ActionDefinition) getTypes().findSchema(Type.of(cls)).orElse(null); } @Override @@ -157,7 +198,7 @@ public abstract class AbstractBindingRuntimeContext implements BindingRuntimeCon @Override public final Entry getTypeWithSchema(final Class type) { - return getTypeWithSchema(getTypes(), DefaultType.of(type)); + return getTypeWithSchema(getTypes(), Type.of(type)); } private static @NonNull Entry getTypeWithSchema(final BindingRuntimeTypes types, @@ -206,7 +247,7 @@ public abstract class AbstractBindingRuntimeContext implements BindingRuntimeCon @Override public final Set> getCases(final Class choice) { - final Collection cazes = getTypes().findCases(DefaultType.of(choice)); + final Collection cazes = getTypes().findCases(Type.of(choice)); final Set> ret = new HashSet<>(cazes.size()); for (final Type caze : cazes) { try { @@ -236,25 +277,18 @@ public abstract class AbstractBindingRuntimeContext implements BindingRuntimeCon public final ImmutableMap getAvailableAugmentationTypes( final DataNodeContainer container) { if (container instanceof AugmentationTarget) { - final Map identifierToType = new HashMap<>(); - final BindingRuntimeTypes types = getTypes(); - for (final AugmentationSchemaNode augment : ((AugmentationTarget) container).getAvailableAugmentations()) { - // Augmentation must have child nodes if is to be used with Binding classes - AugmentationSchemaNode augOrig = augment; - while (augOrig.getOriginalDefinition().isPresent()) { - augOrig = augOrig.getOriginalDefinition().get(); - } - - if (!augment.getChildNodes().isEmpty()) { - final Optional augType = types.findType(augOrig); - if (augType.isPresent()) { - identifierToType.put(getAugmentationIdentifier(augment), augType.get()); - } + final var augmentations = ((AugmentationTarget) container).getAvailableAugmentations(); + if (!augmentations.isEmpty()) { + final var identifierToType = new HashMap(); + final var types = getTypes(); + for (var augment : augmentations) { + types.findOriginalAugmentationType(augment).ifPresent(augType -> { + identifierToType.put(getAugmentationIdentifier(augment), augType); + }); } + return ImmutableMap.copyOf(identifierToType); } - return ImmutableMap.copyOf(identifierToType); } - return ImmutableMap.of(); } @@ -289,7 +323,7 @@ public abstract class AbstractBindingRuntimeContext implements BindingRuntimeCon private static T getOriginalSchema(final T choice) { @SuppressWarnings("unchecked") - final T original = (T) SchemaNodeUtils.getRootOriginalIfPossible(choice); + final T original = (T) originalNodeOf(choice); if (original != null) { return original; } @@ -303,7 +337,7 @@ public abstract class AbstractBindingRuntimeContext implements BindingRuntimeCon return Optional.of(potential); } if (potential != null) { - SchemaNode potentialRoot = SchemaNodeUtils.getRootOriginalIfPossible(potential); + SchemaNode potentialRoot = originalNodeOf(potential); if (originalDefinition.equals(potentialRoot)) { return Optional.of(potential); } @@ -319,10 +353,14 @@ public abstract class AbstractBindingRuntimeContext implements BindingRuntimeCon // sufficient to uniquelly determine equality of cases // for (CaseSchemaNode caze : instantiatedChoice.findCaseNodes(originalDefinition.getQName().getLocalName())) { - if (originalDefinition.equals(SchemaNodeUtils.getRootOriginalIfPossible(caze))) { + if (originalDefinition.equals(originalNodeOf(caze))) { return Optional.of(caze); } } return Optional.empty(); } + + private static @Nullable SchemaNode originalNodeOf(final SchemaNode node) { + return node instanceof DerivableSchemaNode ? ((DerivableSchemaNode) node).getOriginal().orElse(null) : null; + } }