@Override
public AbstractBindingNormalizedNodeCache load(final CodecContext key) {
// FIXME: Use a switch expression once we have https://openjdk.org/jeps/441
- if (key instanceof DataContainerCodecContext<?, ?> dataContainer) {
+ if (key instanceof DataContainerCodecContext<?, ?, ?> dataContainer) {
return new DataObjectNormalizedNodeCache(AbstractBindingNormalizedNodeCacheHolder.this,
dataContainer);
}
@Override
public final WithStatus getSchema() {
// FIXME: Bad cast, we should be returning an EffectiveStatement perhaps?
- return (WithStatus) type().statement();
+ return (WithStatus) prototype().runtimeType().statement();
}
@Override
final var caseType = arg.getCaseType();
final var type = arg.getType();
- final DataContainerCodecContext<?, ?> caze;
+ final DataContainerCodecContext<?, ?, ?> caze;
if (caseType.isPresent()) {
// Non-ambiguous addressing this should not pose any problems
caze = choice.getStreamChild(caseType.orElseThrow());
@SuppressWarnings("checkstyle:illegalCatch")
@Override
public D filterFrom(final DataContainerNode parentData) {
- for (var childArg : ((AugmentationCodecPrototype) prototype).getChildArgs()) {
+ for (var childArg : ((AugmentationCodecPrototype) prototype()).getChildArgs()) {
if (parentData.childByArg(childArg) != null) {
try {
return (D) proxyConstructor.invokeExact(this, parentData);
return new DataContainerSerializer(BindingCodecContext.this, streamers.get(key));
}
});
- private final LoadingCache<Class<? extends DataObject>, DataContainerCodecContext<?, ?>> childrenByClass =
+ private final LoadingCache<Class<? extends DataObject>, DataContainerCodecContext<?, ?, ?>> childrenByClass =
CacheBuilder.newBuilder().build(new CacheLoader<>() {
@Override
- public DataContainerCodecContext<?, ?> load(final Class<? extends DataObject> key) {
+ public DataContainerCodecContext<?, ?, ?> load(final Class<? extends DataObject> key) {
final var childSchema = context.getTypes().bindingChild(JavaTypeName.create(key));
if (childSchema instanceof ContainerLikeRuntimeType containerLike) {
if (childSchema instanceof ContainerRuntimeType container
});
// FIXME: this could also be a leaf!
- private final LoadingCache<QName, DataContainerCodecContext<?, ?>> childrenByDomArg =
+ private final LoadingCache<QName, DataContainerCodecContext<?, ?, ?>> childrenByDomArg =
CacheBuilder.newBuilder().build(new CacheLoader<>() {
@Override
- public DataContainerCodecContext<?, ?> load(final QName qname) throws ClassNotFoundException {
+ public DataContainerCodecContext<?, ?, ?> load(final QName qname) throws ClassNotFoundException {
final var type = context.getTypes();
final var child = type.schemaTreeChild(qname);
if (child == null) {
return new BindingToNormalizedStreamWriter(getActionCodec(action).output(), domWriter);
}
- @NonNull DataContainerCodecContext<?,?> getCodecContextNode(final InstanceIdentifier<?> binding,
+ @NonNull DataContainerCodecContext<?, ?, ?> getCodecContextNode(final InstanceIdentifier<?> binding,
final List<PathArgument> builder) {
final var it = binding.getPathArguments().iterator();
final var arg = it.next();
- DataContainerCodecContext<?, ?> current;
+ DataContainerCodecContext<?, ?, ?> current;
final var caseType = arg.getCaseType();
if (caseType.isPresent()) {
final @NonNull Class<? extends DataObject> type = caseType.orElseThrow();
private final @NonNull NormalizedNodeStreamWriter delegate;
private final CodecContext rootContext;
- BindingToNormalizedStreamWriter(final DataContainerCodecContext<?, ?> rootContext,
+ BindingToNormalizedStreamWriter(final DataContainerCodecContext<?, ?, ?> rootContext,
final NormalizedNodeStreamWriter delegate) {
this.rootContext = requireNonNull(rootContext);
this.delegate = requireNonNull(delegate);
if (current == null) {
// Entry of first node
next = rootContext;
- } else if (current instanceof DataContainerCodecContext<?, ?> currentContainer) {
+ } else if (current instanceof DataContainerCodecContext<?, ?, ?> currentContainer) {
next = currentContainer.getStreamChild((Class) name);
} else {
throw new IllegalArgumentException("Could not start node " + name + " in non-container " + current);
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
class CachingNormalizedNodeCodec<D extends DataObject,
- C extends DataContainerCodecContext<D, ?> & BindingNormalizedNodeCodec<D>>
+ C extends DataContainerCodecContext<D, ?, ?> & BindingNormalizedNodeCodec<D>>
extends AbstractBindingNormalizedNodeCacheHolder implements BindingNormalizedNodeCachingCodec<D> {
private final @NonNull C context;
private final BindingToNormalizedStreamWriter delegate;
private CachingNormalizedNodeSerializer(final AbstractBindingNormalizedNodeCacheHolder cacheHolder,
- final DataContainerCodecContext<?, ?> subtreeRoot) {
+ final DataContainerCodecContext<?, ?, ?> subtreeRoot) {
this.cacheHolder = requireNonNull(cacheHolder);
delegate = new BindingToNormalizedStreamWriter(subtreeRoot, domWriter);
}
* @return Normalized Node representation of data.
*/
static NormalizedNode serializeUsingStreamWriter(final AbstractBindingNormalizedNodeCacheHolder cacheHolder,
- final DataContainerCodecContext<?, ?> subtreeRoot, final DataObject data) {
+ final DataContainerCodecContext<?, ?, ?> subtreeRoot, final DataObject data) {
final var writer = new CachingNormalizedNodeSerializer(cacheHolder, subtreeRoot);
try {
subtreeRoot.eventStreamSerializer().serialize(data, writer);
private AbstractBindingNormalizedNodeCache<DataObject, ?> getCacheSerializer(
final Class<? extends DataObject> type) {
if (cacheHolder.isCached(type)) {
- final var currentCtx = (DataContainerCodecContext<?, ?>) delegate.current();
+ final var currentCtx = (DataContainerCodecContext<?, ?, ?>) delegate.current();
if (type.equals(currentCtx.getBindingClass())) {
return cacheHolder.getCachingSerializer(currentCtx);
}
@Override
public WithStatus getSchema() {
// FIXME: Bad cast, we should be returning an EffectiveStatement perhaps?
- return (WithStatus) type().statement();
+ return (WithStatus) prototype().runtimeType().statement();
}
@Override
return createCachingCodec(this, cacheSpecifier);
}
- DataContainerCodecContext<?, ?> getCaseByChildClass(final @NonNull Class<? extends DataObject> type) {
+ DataContainerCodecContext<?, ?, ?> getCaseByChildClass(final @NonNull Class<? extends DataObject> type) {
var result = byCaseChildClass.get(type);
if (result == null) {
// We have not found an unambiguous result, try ambiguous ones
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import static java.util.Objects.requireNonNull;
-
-import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.dom.codec.api.CommonDataObjectCodecTreeNode;
import org.opendaylight.mdsal.binding.runtime.api.CompositeRuntimeType;
import org.opendaylight.yangtools.yang.binding.DataObject;
* Base implementation of {@link CommonDataObjectCodecTreeNode}.
*/
abstract sealed class CommonDataObjectCodecContext<D extends DataObject, T extends CompositeRuntimeType>
- extends DataContainerCodecContext<D, T> implements CommonDataObjectCodecTreeNode<D>
+ extends DataContainerCodecContext<D, T, CommonDataObjectCodecPrototype<T>>
+ implements CommonDataObjectCodecTreeNode<D>
permits AbstractDataObjectCodecContext, ChoiceCodecContext {
- final @NonNull CommonDataObjectCodecPrototype<T> prototype;
-
CommonDataObjectCodecContext(final CommonDataObjectCodecPrototype<T> prototype) {
- super(prototype.runtimeType());
- this.prototype = requireNonNull(prototype);
+ super(prototype);
}
@SuppressWarnings("unchecked")
@Override
public final Class<D> getBindingClass() {
- return Class.class.cast(prototype.javaClass());
- }
-
- @Override
- protected final CodecContextFactory factory() {
- return prototype.contextFactory();
- }
-
- @Override
- protected final T type() {
- return prototype.runtimeType();
+ return Class.class.cast(prototype().javaClass());
}
@Override
protected NodeIdentifier getDomPathArgument() {
- return prototype.getYangArg();
+ return prototype().getYangArg();
}
/**
}
protected final PathArgument bindingArg() {
- return prototype.getBindingArg();
+ return prototype().getBindingArg();
}
}
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-abstract sealed class DataContainerCodecContext<D extends DataContainer, T extends CompositeRuntimeType>
+abstract sealed class DataContainerCodecContext<D extends DataContainer, R extends CompositeRuntimeType,
+ P extends DataContainerPrototype<?, R>>
extends CodecContext implements BindingDataContainerCodecTreeNode<D>
permits CommonDataObjectCodecContext {
private static final Logger LOG = LoggerFactory.getLogger(DataContainerCodecContext.class);
}
}
+ private final @NonNull P prototype;
private final @NonNull ChildAddressabilitySummary childAddressabilitySummary;
// Accessed via a VarHandle
@SuppressFBWarnings(value = "UUF_UNUSED_FIELD", justification = "https://github.com/spotbugs/spotbugs/issues/2749")
private volatile DataContainerSerializer eventStreamSerializer;
- DataContainerCodecContext(final T type) {
- childAddressabilitySummary = computeChildAddressabilitySummary(type.statement());
+ DataContainerCodecContext(final P prototype) {
+ this.prototype = requireNonNull(prototype);
+ childAddressabilitySummary = computeChildAddressabilitySummary(prototype.runtimeType().statement());
+ }
+
+ final @NonNull P prototype() {
+ return prototype;
}
@Override
return childAddressabilitySummary;
}
- protected abstract @NonNull CodecContextFactory factory();
-
- protected abstract @NonNull T type();
-
// Non-final for ChoiceCodecContext
@Override
public CodecContext yangPathArgumentChild(final YangInstanceIdentifier.PathArgument arg) {
return getClass().getSimpleName() + " [" + getBindingClass() + "]";
}
- static final <T extends DataObject, C extends DataContainerCodecContext<T, ?> & BindingNormalizedNodeCodec<T>>
+ static final <T extends DataObject, C extends DataContainerCodecContext<T, ?, ?> & BindingNormalizedNodeCodec<T>>
@NonNull BindingNormalizedNodeCachingCodec<T> createCachingCodec(final C context,
final ImmutableCollection<Class<? extends BindingObject>> cacheSpecifier) {
return cacheSpecifier.isEmpty() ? new NonCachingCodec<>(context)
@CheckReturnValue
private IllegalArgumentException childNullException(final QName child, final String message, final Object... args) {
final var module = child.getModule();
- if (!factory().getRuntimeContext().modelContext().findModule(module).isPresent()) {
+ if (!prototype().contextFactory().getRuntimeContext().modelContext().findModule(module).isPresent()) {
return new MissingSchemaException("Module " + module + " is not present in current schema context.");
}
return new IncorrectNestingException(message, args);
@CheckReturnValue
private @NonNull IllegalArgumentException childNullException(final Class<?> childClass, final String message,
final Object... args) {
- return childNullException(factory().getRuntimeContext(), childClass, message, args);
+ return childNullException(prototype().contextFactory().getRuntimeContext(), childClass, message, args);
}
@CheckReturnValue
// Split out to aid inlining
private DataContainerSerializer loadEventStreamSerializer() {
- final DataContainerSerializer loaded = factory().getEventStreamSerializer(getBindingClass());
+ final DataContainerSerializer loaded = prototype().contextFactory().getEventStreamSerializer(getBindingClass());
final Object witness = EVENT_STREAM_SERIALIZER.compareAndExchangeRelease(this, null, loaded);
return witness == null ? loaded : (DataContainerSerializer) witness;
}
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.runtime.api.AugmentRuntimeType;
import org.opendaylight.mdsal.binding.runtime.api.AugmentableRuntimeType;
-import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeContext;
import org.opendaylight.mdsal.binding.runtime.api.CompositeRuntimeType;
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.Augmentation;
// Final bits: generate the appropriate class, As a side effect we identify what Augmentations are possible
final List<AugmentRuntimeType> possibleAugmentations;
+ final var loader = prototype().contextFactory().getLoader();
if (Augmentable.class.isAssignableFrom(bindingClass)) {
// Verify we have the appropriate backing runtimeType
final var runtimeType = prototype.runtimeType();
}
possibleAugmentations = augmentableRuntimeType.augments();
- generatedClass = CodecDataObjectGenerator.generateAugmentable(factory().getLoader(), bindingClass,
- analysis.leafContexts, analysis.daoProperties, keyMethod);
+ generatedClass = CodecDataObjectGenerator.generateAugmentable(loader, bindingClass, analysis.leafContexts,
+ analysis.daoProperties, keyMethod);
} else {
possibleAugmentations = List.of();
- generatedClass = CodecDataObjectGenerator.generate(factory().getLoader(), bindingClass,
- analysis.leafContexts, analysis.daoProperties, keyMethod);
+ generatedClass = CodecDataObjectGenerator.generate(loader, bindingClass, analysis.leafContexts,
+ analysis.daoProperties, keyMethod);
}
// All done: acquire the constructor: it is supposed to be public
}
private boolean belongsToRuntimeContext(final Class<?> cls) {
- final BindingRuntimeContext ctx = factory().getRuntimeContext();
+ final var ctx = prototype().contextFactory().getRuntimeContext();
final Class<?> loaded;
try {
loaded = ctx.loadClass(Type.of(cls));
return null;
}
- final var factory = factory();
+ final var factory = prototype().contextFactory();
final GeneratedType javaType = augment.javaType();
final Class<? extends Augmentation<?>> augClass;
try {
* A cache of NormalizedNodes corresponding to a particular DataObject instantiation.
*/
final class DataObjectNormalizedNodeCache
- extends AbstractBindingNormalizedNodeCache<DataObject, DataContainerCodecContext<?, ?>> {
+ extends AbstractBindingNormalizedNodeCache<DataObject, DataContainerCodecContext<?, ?, ?>> {
private final AbstractBindingNormalizedNodeCacheHolder cacheHolder;
DataObjectNormalizedNodeCache(final AbstractBindingNormalizedNodeCacheHolder cacheHolder,
- final DataContainerCodecContext<?, ?> rootContext) {
+ final DataContainerCodecContext<?, ?, ?> rootContext) {
super(rootContext);
this.cacheHolder = requireNonNull(cacheHolder, "cacheHolder");
}
NotificationCodecContext(final Class<?> notificationClass, final NotificationRuntimeType type,
final CodecContextFactory factory) {
super(new Prototype<>(notificationClass, type, factory));
- final Class<D> bindingClass = getBindingClass();
+ final var bindingClass = getBindingClass();
- final Class<?> awareClass = CodecPackage.EVENT_AWARE.generateClass(factory().getLoader(), bindingClass,
- (loader, fqcn, bindingInterface) -> {
- final Class<?> codecImpl = CodecPackage.CODEC.getGeneratedClass(loader, bindingClass);
+ final var eventAwareClass = CodecPackage.EVENT_AWARE.generateClass(prototype().contextFactory().getLoader(),
+ bindingClass, (loader, fqcn, bindingInterface) -> {
+ final var codecImpl = CodecPackage.CODEC.getGeneratedClass(loader, bindingClass);
return GeneratorResult.of(new ByteBuddy()
.subclass(codecImpl, ConstructorStrategy.Default.NO_CONSTRUCTORS)
final MethodHandle ctor;
try {
- ctor = MethodHandles.publicLookup().findConstructor(awareClass, CONSTRUCTOR_TYPE);
+ ctor = MethodHandles.publicLookup().findConstructor(eventAwareClass, CONSTRUCTOR_TYPE);
} catch (IllegalAccessException | NoSuchMethodException e) {
throw new LinkageError("Failed to acquire constructor", e);
}
Code Review / mdsal.git / commitdiff