import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
final class CaseNodeCodecContext<D extends DataObject> extends DataObjectCodecContext<D, CaseRuntimeType> {
- CaseNodeCodecContext(final DataContainerCodecPrototype<CaseRuntimeType> prototype) {
+ static final class Prototype extends DataObjectCodecPrototype<CaseRuntimeType> {
+ Prototype(final Class<?> cls, final CaseRuntimeType type, final CodecContextFactory factory) {
+ super(cls, NodeIdentifier.create(type.statement().argument()), type, factory);
+ }
+
+ @Override
+ DataContainerCodecContext<?, CaseRuntimeType> createInstance() {
+ return new CaseNodeCodecContext<>(this);
+ }
+ }
+
+ private CaseNodeCodecContext(final Prototype prototype) {
super(prototype, CodecItemFactory.of(prototype.getBindingClass()));
}
final var factory = prototype.getFactory();
final var localCases = new HashSet<JavaTypeName>();
for (var caseType : choiceType.validCaseChildren()) {
- final var cazeDef = loadCase(factory, caseType);
+ final var caseProto = new CaseNodeCodecContext.Prototype(loadCase(factory.getRuntimeContext(), caseType),
+ caseType, factory);
+
localCases.add(caseType.getIdentifier());
- byClassBuilder.put(cazeDef.getBindingClass(), cazeDef);
+ byClassBuilder.put(caseProto.getBindingClass(), caseProto);
// Updates collection of case children
@SuppressWarnings("unchecked")
- final var cazeCls = (Class<? extends DataObject>) cazeDef.getBindingClass();
+ final var cazeCls = (Class<? extends DataObject>) caseProto.getBindingClass();
for (var cazeChild : getChildrenClasses(cazeCls)) {
- childToCase.put(cazeChild, cazeDef);
+ childToCase.put(cazeChild, caseProto);
}
// Updates collection of YANG instance identifier to case
- for (var stmt : cazeDef.getType().statement().effectiveSubstatements()) {
+ for (var stmt : caseProto.getType().statement().effectiveSubstatements()) {
if (stmt instanceof DataSchemaNode cazeChild) {
- byYangCaseChildBuilder.put(NodeIdentifier.create(cazeChild.getQName()), cazeDef);
+ byYangCaseChildBuilder.put(NodeIdentifier.create(cazeChild.getQName()), caseProto);
}
}
}
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 {
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.dom.codec.impl.NodeCodecContext.CodecContextFactory;
-import org.opendaylight.mdsal.binding.runtime.api.CaseRuntimeType;
import org.opendaylight.mdsal.binding.runtime.api.ChoiceRuntimeType;
import org.opendaylight.mdsal.binding.runtime.api.ContainerLikeRuntimeType;
import org.opendaylight.mdsal.binding.runtime.api.ContainerRuntimeType;
: new ListNodeCodecContext(this);
} else if (type instanceof ChoiceRuntimeType) {
return new ChoiceNodeCodecContext(this);
- } else if (type instanceof CaseRuntimeType) {
- return new CaseNodeCodecContext(this);
}
throw new IllegalArgumentException("Unsupported type " + getBindingClass() + " " + type);
}