final var context = childNonNull(pathChildPrototype(argType), argType,
"Class %s is not valid child of %s", argType, getBindingClass())
.get();
- if (context instanceof ChoiceNodeCodecContext<?> choice) {
+ if (context instanceof ChoiceCodecContext<?> choice) {
choice.addYangPathArgument(arg, builder);
final var caseType = arg.getCaseType();
// We enter list, we do not update current Node yet,
// since we need to verify
currentList = listNode;
- } else if (nextNode instanceof ChoiceNodeCodecContext) {
+ } else if (nextNode instanceof ChoiceCodecContext) {
// We do not add path argument for choice, since
// it is not supported by binding instance identifier.
currentNode = nextNode;
// Algorithm ended in list as whole representation
// we sill need to emit identifier for list
- if (currentNode instanceof ChoiceNodeCodecContext) {
+ if (currentNode instanceof ChoiceCodecContext) {
LOG.debug("Instance identifier targeting a choice is not representable ({})", dom);
return null;
}
* 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, ChoiceRuntimeType>
+final class ChoiceCodecContext<D extends DataObject> extends DataContainerCodecContext<D, ChoiceRuntimeType>
implements BindingDataObjectCodecTreeNode<D> {
- private static final Logger LOG = LoggerFactory.getLogger(ChoiceNodeCodecContext.class);
+ private static final Logger LOG = LoggerFactory.getLogger(ChoiceCodecContext.class);
private final ImmutableMap<NodeIdentifier, DataContainerCodecPrototype<?>> byYangCaseChild;
private final ImmutableListMultimap<Class<?>, DataContainerCodecPrototype<?>> ambiguousByCaseChildClass;
private final ImmutableMap<Class<?>, DataContainerCodecPrototype<?>> byClass;
private final Set<Class<?>> ambiguousByCaseChildWarnings;
- ChoiceNodeCodecContext(final DataContainerCodecPrototype<ChoiceRuntimeType> prototype) {
+ ChoiceCodecContext(final DataContainerCodecPrototype<ChoiceRuntimeType> prototype) {
super(prototype);
final var byYangCaseChildBuilder = new HashMap<NodeIdentifier, DataContainerCodecPrototype<?>>();
final var byClassBuilder = new HashMap<Class<?>, DataContainerCodecPrototype<?>>();
// FIXME: It really feels like we should be specializing DataContainerCodecPrototype so as to ditch
// createInstance() and then we could do an instanceof check instead.
if (childProto.getType() instanceof ChoiceRuntimeType) {
- final var choice = (ChoiceNodeCodecContext<?>) childProto.get();
+ final var choice = (ChoiceCodecContext<?>) childProto.get();
for (var cazeChild : choice.getCaseChildrenClasses()) {
byBindingArgClassBuilder.put(cazeChild, childProto);
}
abstract sealed class DataContainerCodecContext<D extends DataObject, T extends RuntimeTypeContainer>
extends CodecContext implements CommonDataObjectCodecTreeNode<D>
- permits AbstractDataObjectCodecContext, ChoiceNodeCodecContext, RootCodecContext {
+ permits AbstractDataObjectCodecContext, ChoiceCodecContext, RootCodecContext {
private static final Logger LOG = LoggerFactory.getLogger(DataContainerCodecContext.class);
private static final VarHandle EVENT_STREAM_SERIALIZER;
? KeyedListNodeCodecContext.create((DataContainerCodecPrototype<ListRuntimeType>) this)
: new ListNodeCodecContext(this);
} else if (type instanceof ChoiceRuntimeType) {
- return new ChoiceNodeCodecContext(this);
+ return new ChoiceCodecContext(this);
}
throw new IllegalArgumentException("Unsupported type " + getBindingClass() + " " + type);
}
}
});
- private final LoadingCache<Class<? extends DataObject>, ChoiceNodeCodecContext<?>> choicesByClass =
+ private final LoadingCache<Class<? extends DataObject>, ChoiceCodecContext<?>> choicesByClass =
CacheBuilder.newBuilder().build(new CacheLoader<>() {
@Override
- public ChoiceNodeCodecContext<?> load(final Class<? extends DataObject> key) {
+ public ChoiceCodecContext<?> load(final Class<? extends DataObject> key) {
return createChoiceDataContext(key);
}
});
};
}
- ChoiceNodeCodecContext<?> createChoiceDataContext(final Class<? extends DataObject> caseType) {
+ ChoiceCodecContext<?> createChoiceDataContext(final Class<? extends DataObject> caseType) {
final var choiceClass = findCaseChoice(caseType);
if (choiceClass == null) {
throw new IllegalArgumentException(caseType + " is not a valid case representation");
}
final var choice = DataContainerCodecPrototype.from(choiceClass, choiceType, factory()).get();
- verify(choice instanceof ChoiceNodeCodecContext);
- return (ChoiceNodeCodecContext<?>) choice;
+ verify(choice instanceof ChoiceCodecContext);
+ return (ChoiceCodecContext<?>) choice;
}
@Override
Code Review / mdsal.git / commitdiff