import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.binding.Augmentation;
-import org.opendaylight.yangtools.yang.binding.BindingObject;
+import org.opendaylight.yangtools.yang.binding.BindingContract;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
*
* @param <T> DataContainer type
*/
-public interface BindingDataContainerCodecTreeNode<T extends BindingObject & DataContainer>
- extends BindingObjectCodecTreeNode<T>, BindingDataObjectCodecTreeParent<Empty> {
+public non-sealed interface BindingDataContainerCodecTreeNode<T extends DataContainer>
+ extends BindingObjectCodecTreeNode, BindingDataObjectCodecTreeParent<Empty> {
/**
* Returns binding class of interface which represents API of current schema node. The result is same as invoking
- * {@link DataContainer#implementedInterface()} on instance of data.
+ * {@link BindingContract#implementedInterface()} on instance of data.
*
* @return interface which defines API of binding representation of data.
*/
import com.google.common.annotations.Beta;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.binding.BindingObject;
@Beta
-public interface BindingObjectCodecTreeNode<T extends BindingObject> extends BindingCodecTreeNode {
+public sealed interface BindingObjectCodecTreeNode extends BindingCodecTreeNode
+ permits BindingDataContainerCodecTreeNode, BindingOpaqueObjectCodecTreeNode, BindingTypeObjectCodecTreeNode {
/**
* Returns binding class which represents API of current schema node.
*
* @return interface which defines API of binding representation of data.
*/
- @NonNull Class<T> getBindingClass();
+ @NonNull Class<?> getBindingClass();
}
package org.opendaylight.mdsal.binding.dom.codec.api;
import com.google.common.annotations.Beta;
+import org.opendaylight.yangtools.yang.binding.BindingContract;
import org.opendaylight.yangtools.yang.binding.OpaqueObject;
@Beta
-public interface BindingOpaqueObjectCodecTreeNode<T extends OpaqueObject<T>> extends BindingObjectCodecTreeNode<T>,
- BindingNormalizedNodeCodec<T> {
-
+public non-sealed interface BindingOpaqueObjectCodecTreeNode<T extends OpaqueObject<T>>
+ extends BindingObjectCodecTreeNode, BindingNormalizedNodeCodec<T> {
+ /**
+ * Returns binding class of interface which represents API of current schema node. The result is same as invoking
+ * {@link BindingContract#implementedInterface()} on instance of data.
+ *
+ * @return interface which defines API of binding representation of data.
+ */
+ @Override
+ Class<T> getBindingClass();
}
import org.opendaylight.yangtools.yang.binding.TypeObject;
@Beta
-public interface BindingTypeObjectCodecTreeNode<T extends TypeObject> extends BindingObjectCodecTreeNode<T>,
- BindingNormalizedNodeCodec<T> {
-
+public non-sealed interface BindingTypeObjectCodecTreeNode<T extends TypeObject>
+ extends BindingObjectCodecTreeNode, BindingNormalizedNodeCodec<T> {
+ @Override
+ Class<T> getBindingClass();
}
*/
public interface BindingYangDataCodecTreeNode<T extends YangData<T>>
extends BindingDataContainerCodecTreeNode<T>, BindingYangDataCodec<T> {
- // Just a combination of thwo interfaces
+ // just a class hierarchy thing
}
}
});
- private final ImmutableSet<Class<? extends BindingObject>> cacheSpec;
+ private final ImmutableSet<Class<?>> cacheSpec;
- AbstractBindingNormalizedNodeCacheHolder(final ImmutableSet<Class<? extends BindingObject>> cacheSpec) {
+ AbstractBindingNormalizedNodeCacheHolder(final ImmutableSet<Class<?>> cacheSpec) {
this.cacheSpec = requireNonNull(cacheSpec);
}
@SuppressWarnings("unchecked")
- <T extends BindingObject, C extends CodecContext & BindingObjectCodecTreeNode<?>>
+ <T extends BindingObject, C extends CodecContext & BindingObjectCodecTreeNode>
AbstractBindingNormalizedNodeCache<T, C> getCachingSerializer(final C childCtx) {
return isCached(childCtx.getBindingClass()) ? caches.getUnchecked(childCtx) : null;
}
- final boolean isCached(final Class<? extends BindingObject> type) {
+ final boolean isCached(final Class<?> type) {
return cacheSpec.contains(type);
}
}
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeCachingCodec;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeCodec;
-import org.opendaylight.yangtools.yang.binding.BindingObject;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
extends AbstractBindingNormalizedNodeCacheHolder implements BindingNormalizedNodeCachingCodec<D> {
private final @NonNull C context;
- CachingNormalizedNodeCodec(final C context, final ImmutableSet<Class<? extends BindingObject>> cacheSpec) {
+ CachingNormalizedNodeCodec(final C context, final ImmutableSet<Class<?>> cacheSpec) {
super(cacheSpec);
this.context = requireNonNull(context);
}
@Override
public NormalizedNode serialize(final D data) {
// Serialize data using stream writer with child cache enable or using the cache if it is available
- final AbstractBindingNormalizedNodeCache<D, ?> cache = getCachingSerializer(context);
+ final var cache = getCachingSerializer(context);
return cache == null ? CachingNormalizedNodeSerializer.serializeUsingStreamWriter(this, context, data)
: cache.get(data);
}
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-abstract sealed class DataContainerCodecContext<D extends BindingObject & DataContainer, T extends CompositeRuntimeType>
+abstract sealed class DataContainerCodecContext<D extends DataContainer, T extends CompositeRuntimeType>
extends CodecContext implements BindingDataContainerCodecTreeNode<D>
permits CommonDataObjectCodecContext {
private static final Logger LOG = LoggerFactory.getLogger(DataContainerCodecContext.class);