X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=binding%2Fmdsal-binding-dom-codec%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fmdsal%2Fbinding%2Fdom%2Fcodec%2Fimpl%2FChoiceCodecContext.java;h=8454de4f25a283c49e07ded78f501b23ad5e5429;hb=f3be50ed801e5de305eb46b824e6bc3c6075e4bc;hp=c73a47f6915d69062e38e5b10cb3dff03b083e06;hpb=495c2da92260f4ad22529ce5d3c343bb9f6956c4;p=mdsal.git diff --git a/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/ChoiceCodecContext.java b/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/ChoiceCodecContext.java index c73a47f691..8454de4f25 100644 --- a/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/ChoiceCodecContext.java +++ b/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/ChoiceCodecContext.java @@ -9,7 +9,6 @@ package org.opendaylight.mdsal.binding.dom.codec.impl; import static com.google.common.base.Preconditions.checkArgument; -import com.google.common.collect.ImmutableCollection; import com.google.common.collect.ImmutableListMultimap; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; @@ -17,30 +16,27 @@ import com.google.common.collect.Iterables; import com.google.common.collect.Lists; import com.google.common.collect.MultimapBuilder.SetMultimapBuilder; import com.google.common.collect.Multimaps; -import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; import java.util.ArrayList; import java.util.Comparator; import java.util.HashMap; import java.util.HashSet; import java.util.LinkedList; +import java.util.List; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import org.eclipse.jdt.annotation.NonNull; -import org.opendaylight.mdsal.binding.dom.codec.api.BindingDataObjectCodecTreeNode; -import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeCachingCodec; +import org.opendaylight.mdsal.binding.dom.codec.api.BindingChoiceCodecTreeNode; 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.yangtools.yang.binding.BindingObject; +import org.opendaylight.yangtools.yang.binding.ChoiceIn; import org.opendaylight.yangtools.yang.binding.DataContainer; import org.opendaylight.yangtools.yang.binding.DataObject; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.Item; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.binding.contract.Naming; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; -import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates; import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; @@ -95,30 +91,32 @@ import org.slf4j.LoggerFactory; * ambiguous reference and issue warn once when they are encountered -- tracking warning information in * {@link #ambiguousByCaseChildWarnings}. */ -final class ChoiceCodecContext extends DataContainerCodecContext - implements BindingDataObjectCodecTreeNode { +final class ChoiceCodecContext> + extends DataContainerCodecContext> + implements BindingChoiceCodecTreeNode { private static final Logger LOG = LoggerFactory.getLogger(ChoiceCodecContext.class); - private final ImmutableListMultimap, DataContainerCodecPrototype> ambiguousByCaseChildClass; - private final ImmutableMap, DataContainerCodecPrototype> byCaseChildClass; + private final ImmutableListMultimap, CommonDataObjectCodecPrototype> ambiguousByCaseChildClass; + private final ImmutableMap, CommonDataObjectCodecPrototype> byCaseChildClass; private final ImmutableMap byYangCaseChild; - private final ImmutableMap, DataContainerCodecPrototype> byClass; + private final ImmutableMap, CommonDataObjectCodecPrototype> byClass; private final Set> ambiguousByCaseChildWarnings; - ChoiceCodecContext(final Class cls, final ChoiceRuntimeType type, final CodecContextFactory factory) { - this(new ChoiceCodecPrototype(Item.of(cls), type, factory)); + ChoiceCodecContext(final Class javaClass, final ChoiceRuntimeType runtimeType, + final CodecContextFactory contextFactory) { + this(new ChoiceCodecPrototype<>(contextFactory, runtimeType, javaClass)); } - ChoiceCodecContext(final ChoiceCodecPrototype prototype) { + ChoiceCodecContext(final ChoiceCodecPrototype prototype) { super(prototype); final var byYangCaseChildBuilder = new HashMap(); - final var byClassBuilder = new HashMap, DataContainerCodecPrototype>(); + final var byClassBuilder = new HashMap, CommonDataObjectCodecPrototype>(); final var childToCase = SetMultimapBuilder.hashKeys().hashSetValues() - ., DataContainerCodecPrototype>build(); + ., CommonDataObjectCodecPrototype>build(); // 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 choiceType = prototype.runtimeType(); + final var factory = prototype.contextFactory(); final var localCases = new HashSet(); for (var caseType : choiceType.validCaseChildren()) { @SuppressWarnings("unchecked") @@ -142,14 +140,14 @@ final class ChoiceCodecContext extends DataContainerCodecC byYangCaseChild = ImmutableMap.copyOf(byYangCaseChildBuilder); // Move unambiguous child->case mappings to byCaseChildClass, removing them from childToCase - final var ambiguousByCaseBuilder = ImmutableListMultimap., DataContainerCodecPrototype>builder(); - final var unambiguousByCaseBuilder = ImmutableMap., DataContainerCodecPrototype>builder(); + final var ambiguousByCaseBuilder = ImmutableListMultimap., CommonDataObjectCodecPrototype>builder(); + final var unambiguousByCaseBuilder = ImmutableMap., CommonDataObjectCodecPrototype>builder(); for (var entry : Multimaps.asMap(childToCase).entrySet()) { final var cases = entry.getValue(); if (cases.size() != 1) { // Sort all possibilities by their FQCN to retain semi-predictable results final var list = new ArrayList<>(entry.getValue()); - list.sort(Comparator.comparing(proto -> proto.getBindingClass().getCanonicalName())); + list.sort(Comparator.comparing(proto -> proto.javaClass().getCanonicalName())); ambiguousByCaseBuilder.putAll(entry.getKey(), list); } else { unambiguousByCaseBuilder.put(entry.getKey(), cases.iterator().next()); @@ -170,7 +168,7 @@ final class ChoiceCodecContext extends DataContainerCodecC * 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. */ - final var bySubstitutionBuilder = new HashMap, DataContainerCodecPrototype>(); + final var bySubstitutionBuilder = new HashMap, CommonDataObjectCodecPrototype>(); final var context = factory.getRuntimeContext(); for (var caseType : context.getTypes().allCaseChildren(choiceType)) { final var caseName = caseType.getIdentifier(); @@ -205,20 +203,12 @@ final class ChoiceCodecContext extends DataContainerCodecC @Override public WithStatus getSchema() { // FIXME: Bad cast, we should be returning an EffectiveStatement perhaps? - return (WithStatus) type().statement(); + return (WithStatus) prototype().runtimeType().statement(); } @Override - public DataContainerCodecContext getStreamChild(final Class childClass) { - return childNonNull(streamChild(childClass), childClass, - "Supplied class %s is not valid case in %s", childClass, bindingArg()); - } - - @SuppressWarnings("unchecked") - @Override - public DataContainerCodecContext streamChild(final Class childClass) { - final var child = byClass.get(childClass); - return child == null ? null : (DataContainerCodecContext) child.get(); + CommonDataObjectCodecPrototype streamChildPrototype(final Class childClass) { + return byClass.get(childClass); } Iterable> getCaseChildrenClasses() { @@ -227,61 +217,47 @@ final class ChoiceCodecContext extends DataContainerCodecC @Override public CodecContext yangPathArgumentChild(final YangInstanceIdentifier.PathArgument arg) { - final DataContainerCodecPrototype cazeProto; - if (arg instanceof NodeIdentifierWithPredicates) { - cazeProto = byYangCaseChild.get(new NodeIdentifier(arg.getNodeType())); - } else { - cazeProto = byYangCaseChild.get(arg); - } - - return childNonNull(cazeProto, arg, "Argument %s is not valid child of %s", arg, getSchema()).get() - .yangPathArgumentChild(arg); + return ((CaseCodecContext) super.yangPathArgumentChild(arg)).yangPathArgumentChild(arg); } @Override - @SuppressWarnings("unchecked") - @SuppressFBWarnings(value = "NP_NONNULL_RETURN_VIOLATION", justification = "See FIXME below") - public D deserialize(final NormalizedNode data) { - final var casted = checkDataArgument(ChoiceNode.class, data); - final var first = Iterables.getFirst(casted.body(), null); - - if (first == null) { - // FIXME: this needs to be sorted out - return null; - } - final var caze = byYangCaseChild.get(first.name()); - return ((CaseCodecContext) caze.get()).deserialize(data); + CodecContextSupplier yangChildSupplier(final NodeIdentifier arg) { + return byYangCaseChild.get(arg); } @Override - public NormalizedNode serialize(final D data) { - return serializeImpl(data); - } - - @Override - protected Object deserializeObject(final NormalizedNode normalizedNode) { - return deserialize(normalizedNode); - } + protected T deserializeObject(final NormalizedNode normalizedNode) { + final var casted = checkDataArgument(ChoiceNode.class, normalizedNode); + final var it = casted.body().iterator(); + if (!it.hasNext()) { + // FIXME: can this reasonably happen? Empty choice nodes do not have semantics, or do they? + return null; + } - @Override - public PathArgument deserializePathArgument(final YangInstanceIdentifier.PathArgument arg) { - checkArgument(getDomPathArgument().equals(arg)); - return null; + final var childName = it.next().name(); + final var caze = childNonNull(byYangCaseChild.get(childName), childName, "%s is not a valid case child of %s", + childName, this); + return (T) caze.getCodecContext().deserializeObject(casted); } @Override - public YangInstanceIdentifier.PathArgument serializePathArgument(final PathArgument arg) { - // FIXME: check for null, since binding container is null. - return getDomPathArgument(); - } + public CommonDataObjectCodecContext bindingPathArgumentChild(final PathArgument arg, + final List builder) { + final var caseType = arg.getCaseType(); + final var type = arg.getType(); + final DataContainerCodecContext caze; + if (caseType.isPresent()) { + // Non-ambiguous addressing this should not pose any problems + caze = getStreamChild(caseType.orElseThrow()); + } else { + caze = getCaseByChildClass(type); + } - @Override - public BindingNormalizedNodeCachingCodec createCachingCodec( - final ImmutableCollection> cacheSpecifier) { - return createCachingCodec(this, cacheSpecifier); + caze.addYangPathArgument(arg, builder); + return caze.bindingPathArgumentChild(arg, builder); } - DataContainerCodecContext getCaseByChildClass(final @NonNull Class type) { + private DataContainerCodecContext getCaseByChildClass(final @NonNull Class type) { var result = byCaseChildClass.get(type); if (result == null) { // We have not found an unambiguous result, try ambiguous ones @@ -294,13 +270,14 @@ final class ChoiceCodecContext extends DataContainerCodecC Ambiguous reference {} to child of {} resolved to {}, the first case in {} This mapping is \ not guaranteed to be stable and is subject to variations based on runtime circumstances. \ Please see the stack trace for hints about the source of ambiguity.""", - type, bindingArg(), result.getBindingClass(), - Lists.transform(inexact, DataContainerCodecPrototype::getBindingClass), new Throwable()); + type, getBindingClass(), result.javaClass(), + Lists.transform(inexact, CommonDataObjectCodecPrototype::javaClass), new Throwable()); } } } - return childNonNull(result, type, "Class %s is not child of any cases for %s", type, bindingArg()).get(); + return childNonNull(result, type, "Class %s is not child of any cases for %s", type, getBindingClass()) + .getCodecContext(); } /** @@ -317,10 +294,8 @@ final class ChoiceCodecContext extends DataContainerCodecC checkArgument(DataContainer.class.isAssignableFrom(type), "Supplied type must be derived from DataContainer"); final var ret = new LinkedList>(); for (var method : type.getMethods()) { - final var entity = getYangModeledReturnType(method, Naming.GETTER_PREFIX); - if (entity.isPresent()) { - ret.add((Class) entity.orElseThrow()); - } + DataContainerAnalysis.getYangModeledReturnType(method, Naming.GETTER_PREFIX) + .ifPresent(entity -> ret.add((Class) entity)); } return ret; }