import com.google.common.collect.MultimapBuilder.SetMultimapBuilder;
import com.google.common.collect.Multimaps;
import com.google.common.collect.SetMultimap;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeContext;
+import org.opendaylight.mdsal.binding.runtime.api.CaseRuntimeType;
+import org.opendaylight.mdsal.binding.runtime.api.ChoiceRuntimeType;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextNode;
import org.opendaylight.yangtools.yang.data.util.NormalizedNodeSchemaUtils;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* ambiguous reference and issue warn once when they are encountered -- tracking warning information in
* {@link #ambiguousByCaseChildWarnings}.
*/
-final class ChoiceNodeCodecContext<D extends DataObject> extends DataContainerCodecContext<D, ChoiceSchemaNode> {
+final class ChoiceNodeCodecContext<D extends DataObject> extends DataContainerCodecContext<D, ChoiceRuntimeType> {
private static final Logger LOG = LoggerFactory.getLogger(ChoiceNodeCodecContext.class);
private final ImmutableMap<YangInstanceIdentifier.PathArgument, DataContainerCodecPrototype<?>> byYangCaseChild;
private final ImmutableMap<Class<?>, DataContainerCodecPrototype<?>> byClass;
private final Set<Class<?>> ambiguousByCaseChildWarnings;
- ChoiceNodeCodecContext(final DataContainerCodecPrototype<ChoiceSchemaNode> prototype) {
+ ChoiceNodeCodecContext(final DataContainerCodecPrototype<ChoiceRuntimeType> prototype) {
super(prototype);
final Map<YangInstanceIdentifier.PathArgument, DataContainerCodecPrototype<?>> byYangCaseChildBuilder =
new HashMap<>();
final Map<Class<?>, DataContainerCodecPrototype<?>> byClassBuilder = new HashMap<>();
final SetMultimap<Class<?>, DataContainerCodecPrototype<?>> childToCase =
SetMultimapBuilder.hashKeys().hashSetValues().build();
- final Set<Class<?>> potentialSubstitutions = new HashSet<>();
- // Walks all cases for supplied choice in current runtime context
- for (final Class<?> caze : factory().getRuntimeContext().getCases(getBindingClass())) {
- // We try to load case using exact match thus name
- // and original schema must equals
- final DataContainerCodecPrototype<CaseSchemaNode> cazeDef = loadCase(caze);
- // If we have case definition, this case is instantiated
- // at current location and thus is valid in context of parent choice
- if (cazeDef != null) {
- byClassBuilder.put(cazeDef.getBindingClass(), cazeDef);
- // Updates collection of case children
- @SuppressWarnings("unchecked")
- final Class<? extends DataObject> cazeCls = (Class<? extends DataObject>) caze;
- for (final Class<? extends DataObject> cazeChild : BindingReflections.getChildrenClasses(cazeCls)) {
- childToCase.put(cazeChild, cazeDef);
- }
- // Updates collection of YANG instance identifier to case
- for (final DataSchemaNode cazeChild : cazeDef.getSchema().getChildNodes()) {
+
+ // Load case statements valid in this choice and keep track of their names
+ final var choiceType = prototype.getType();
+ final var factory = prototype.getFactory();
+ final var localCases = new HashSet<JavaTypeName>();
+ for (var caseType : choiceType.validCaseChildren()) {
+ final var cazeDef = loadCase(factory, caseType);
+ localCases.add(caseType.getIdentifier());
+ byClassBuilder.put(cazeDef.getBindingClass(), cazeDef);
+
+ // Updates collection of case children
+ @SuppressWarnings("unchecked")
+ final Class<? extends DataObject> cazeCls = (Class<? extends DataObject>) cazeDef.getBindingClass();
+ for (final Class<? extends DataObject> cazeChild : BindingReflections.getChildrenClasses(cazeCls)) {
+ childToCase.put(cazeChild, cazeDef);
+ }
+ // Updates collection of YANG instance identifier to case
+ for (var stmt : cazeDef.getType().statement().effectiveSubstatements()) {
+ if (stmt instanceof DataSchemaNode) {
+ final DataSchemaNode cazeChild = (DataSchemaNode) stmt;
if (cazeChild.isAugmenting()) {
- final AugmentationSchemaNode augment =
- NormalizedNodeSchemaUtils.findCorrespondingAugment(cazeDef.getSchema(), cazeChild);
+ final AugmentationSchemaNode augment = NormalizedNodeSchemaUtils.findCorrespondingAugment(
+ // FIXME: bad cast
+ (DataSchemaNode) cazeDef.getType().statement(), cazeChild);
if (augment != null) {
byYangCaseChildBuilder.put(DataSchemaContextNode.augmentationIdentifierFrom(augment),
cazeDef);
}
byYangCaseChildBuilder.put(NodeIdentifier.create(cazeChild.getQName()), cazeDef);
}
- } else {
- /*
- * If case definition is not available, we store it for
- * later check if it could be used as substitution of existing one.
- */
- potentialSubstitutions.add(caze);
}
}
byYangCaseChild = ImmutableMap.copyOf(byYangCaseChildBuilder);
ambiguousByCaseChildWarnings = ambiguousByCaseChildClass.isEmpty() ? ImmutableSet.of()
: ConcurrentHashMap.newKeySet();
- final Map<Class<?>, DataContainerCodecPrototype<?>> bySubstitutionBuilder = new HashMap<>();
/*
- * Walks all cases which are not directly instantiated and
- * tries to match them to instantiated cases - represent same data as instantiated case,
- * only case name or schema path is different. This is required due property of
- * binding specification, that if choice is in grouping schema path location is lost,
- * and users may use incorrect case class using copy builders.
+ * Choice/Case mapping across groupings is compile-time unsafe and we therefore need to also track any
+ * CaseRuntimeTypes added to the choice in other contexts. This is necessary to discover when a case represents
+ * equivalent data in a different instantiation context.
+ *
+ * This is required due property of binding specification, that if choice is in grouping schema path location is
+ * lost, and users may use incorrect case class using copy builders.
*/
- for (final Class<?> substitution : potentialSubstitutions) {
- search: for (final Entry<Class<?>, DataContainerCodecPrototype<?>> real : byClassBuilder.entrySet()) {
- if (BindingReflections.isSubstitutionFor(substitution, real.getKey())) {
- bySubstitutionBuilder.put(substitution, real.getValue());
- break search;
+ final Map<Class<?>, DataContainerCodecPrototype<?>> bySubstitutionBuilder = new HashMap<>();
+ final var context = factory.getRuntimeContext();
+ for (var caseType : context.getTypes().allCaseChildren(choiceType)) {
+ final var caseName = caseType.getIdentifier();
+ if (!localCases.contains(caseName)) {
+ // FIXME: do not rely on class loading here, the check we are performing should be possible on
+ // GeneratedType only -- or it can be provided by BindingRuntimeTypes -- i.e. rather than
+ // 'allCaseChildren()' it would calculate additional mappings we can use off-the-bat.
+ final Class<?> substitution = loadCase(context, caseType);
+
+ search: for (final Entry<Class<?>, DataContainerCodecPrototype<?>> real : byClassBuilder.entrySet()) {
+ if (BindingReflections.isSubstitutionFor(substitution, real.getKey())) {
+ bySubstitutionBuilder.put(substitution, real.getValue());
+ break search;
+ }
}
}
}
+
byClassBuilder.putAll(bySubstitutionBuilder);
byClass = ImmutableMap.copyOf(byClassBuilder);
}
+ private static DataContainerCodecPrototype<CaseRuntimeType> loadCase(final CodecContextFactory factory,
+ final CaseRuntimeType caseType) {
+ return DataContainerCodecPrototype.from(loadCase(factory.getRuntimeContext(), caseType), caseType, factory);
+ }
+
+ private static Class<?> loadCase(final BindingRuntimeContext context, final CaseRuntimeType caseType) {
+ final var className = caseType.getIdentifier();
+ try {
+ return context.loadClass(className);
+ } catch (ClassNotFoundException e) {
+ throw new LinkageError("Failed to load class for " + className, e);
+ }
+ }
+
+ @Override
+ public WithStatus getSchema() {
+ // FIXME: Bad cast, we should be returning an EffectiveStatement perhaps?
+ return (WithStatus) getType().statement();
+ }
+
@SuppressWarnings("unchecked")
@Override
public <C extends DataObject> DataContainerCodecContext<C, ?> streamChild(final Class<C> childClass) {
return Iterables.concat(byCaseChildClass.keySet(), ambiguousByCaseChildClass.keySet());
}
- protected DataContainerCodecPrototype<CaseSchemaNode> loadCase(final Class<?> childClass) {
- final Optional<CaseSchemaNode> childSchema = factory().getRuntimeContext().getCaseSchemaDefinition(getSchema(),
- childClass);
- if (childSchema.isPresent()) {
- return DataContainerCodecPrototype.from(childClass, childSchema.get(), factory());
- }
-
- LOG.debug("Supplied class {} is not valid case in schema {}", childClass, getSchema());
- return null;
- }
-
@Override
public NodeCodecContext yangPathArgumentChild(final YangInstanceIdentifier.PathArgument arg) {
final DataContainerCodecPrototype<?> cazeProto;
.yangPathArgumentChild(arg);
}
- @SuppressWarnings("unchecked")
@Override
+ @SuppressWarnings("unchecked")
+ @SuppressFBWarnings(value = "NP_NONNULL_RETURN_VIOLATION", justification = "See FIXME below")
public D deserialize(final NormalizedNode data) {
checkArgument(data instanceof ChoiceNode);
final ChoiceNode casted = (ChoiceNode) data;
Code Review / mdsal.git / blobdiff