Since we do not have AugmentationNodes, we now know that all
DistinctNodeContainers backing CodecDataObject are DataContainerNodes.
Sharpen the contract, which gets rid of some ugliness around generic
arguments.
Change-Id: I097e6fda0ca312fc808f2ac2d4e0bbc6ac679315
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
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.YangInstanceIdentifier.PathArgument;
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.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
/**
import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
/**
}
@SuppressWarnings("checkstyle:illegalCatch")
}
@SuppressWarnings("checkstyle:illegalCatch")
- final @NonNull D createBindingProxy(final DistinctNodeContainer<?, ?> node) {
+ final @NonNull D createBindingProxy(final DataContainerNode node) {
try {
return (D) proxyConstructor.invokeExact(this, node);
} catch (final Throwable e) {
try {
return (D) proxyConstructor.invokeExact(this, node);
} catch (final Throwable e) {
return byYang.keySet();
}
return byYang.keySet();
}
- abstract Map<Class<? extends Augmentation<?>>, Augmentation<?>> getAllAugmentationsFrom(
- DistinctNodeContainer<PathArgument, NormalizedNode> data);
+ abstract @NonNull Map<Class<? extends Augmentation<?>>, Augmentation<?>> getAllAugmentationsFrom(
+ DataContainerNode data);
import com.google.common.collect.ImmutableMap;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import com.google.common.collect.ImmutableMap;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer;
/**
* A base class for {@link DataObject}s which are also {@link Augmentable}, backed by {@link DataObjectCodecContext}.
/**
* A base class for {@link DataObject}s which are also {@link Augmentable}, backed by {@link DataObjectCodecContext}.
private volatile ImmutableMap<Class<? extends Augmentation<T>>, Augmentation<T>> cachedAugmentations;
protected AugmentableCodecDataObject(final AbstractDataObjectCodecContext<T, ?> context,
private volatile ImmutableMap<Class<? extends Augmentation<T>>, Augmentation<T>> cachedAugmentations;
protected AugmentableCodecDataObject(final AbstractDataObjectCodecContext<T, ?> context,
- final DistinctNodeContainer<?, ?> data) {
+ final DataContainerNode data) {
// the augmentation the user is requesting -- otherwise a strict receiver would end up with a cryptic
// ClassCastException.
if (augmentationType.isAssignableFrom(augCtx.getBindingClass())) {
// the augmentation the user is requesting -- otherwise a strict receiver would end up with a cryptic
// ClassCastException.
if (augmentationType.isAssignableFrom(augCtx.getBindingClass())) {
- final var augObj = augCtx.filterFrom((DataContainerNode) codecData());
+ final var augObj = augCtx.filterFrom(codecData());
if (augObj != null) {
return augObj;
}
if (augObj != null) {
return augObj;
}
@Override
public final ImmutableMap<Class<? extends Augmentation<T>>, Augmentation<T>> augmentations() {
@Override
public final ImmutableMap<Class<? extends Augmentation<T>>, Augmentation<T>> augmentations() {
- final ImmutableMap<Class<? extends Augmentation<T>>, Augmentation<T>> local = acquireAugmentations();
+ final var local = acquireAugmentations();
return local != null ? local : loadAugmentations();
}
return local != null ? local : loadAugmentations();
}
@SuppressWarnings("unchecked")
private @NonNull ImmutableMap<Class<? extends Augmentation<T>>, Augmentation<T>> loadAugmentations() {
@SuppressWarnings("unchecked")
private @NonNull ImmutableMap<Class<? extends Augmentation<T>>, Augmentation<T>> loadAugmentations() {
- final var ret = ImmutableMap.copyOf(codecContext().getAllAugmentationsFrom(codecData()));
+ @SuppressWarnings("rawtypes")
+ final Map extracted = codecContext().getAllAugmentationsFrom(codecData());
+ final var ret = ImmutableMap.<Class<? extends Augmentation<T>>, Augmentation<T>>copyOf(extracted);
final Object witness = CACHED_AUGMENTATIONS.compareAndExchangeRelease(this, null, ret);
return witness == null ? ret : (ImmutableMap<Class<? extends Augmentation<T>>, Augmentation<T>>) witness;
}
final Object witness = CACHED_AUGMENTATIONS.compareAndExchangeRelease(this, null, ret);
return witness == null ? ret : (ImmutableMap<Class<? extends Augmentation<T>>, Augmentation<T>>) witness;
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
final class AugmentationNodeContext<D extends DataObject & Augmentation<?>>
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
final class AugmentationNodeContext<D extends DataObject & Augmentation<?>>
- Map<Class<? extends Augmentation<?>>, Augmentation<?>> getAllAugmentationsFrom(
- final DistinctNodeContainer<PathArgument, NormalizedNode> data) {
+ Map<Class<? extends Augmentation<?>>, Augmentation<?>> getAllAugmentationsFrom(final DataContainerNode data) {
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
/**
* A base class for {@link DataObject}s backed by {@link DataObjectCodecContext}. While this class is public, it not
/**
* A base class for {@link DataObject}s backed by {@link DataObjectCodecContext}. While this class is public, it not
}
private final @NonNull AbstractDataObjectCodecContext<T, ?> context;
}
private final @NonNull AbstractDataObjectCodecContext<T, ?> context;
- @SuppressWarnings("rawtypes")
- private final @NonNull DistinctNodeContainer data;
+ private final @NonNull DataContainerNode data;
// Accessed via a VarHandle
@SuppressWarnings("unused")
// FIXME: consider using a primitive int-based cache (with 0 being uninit)
private volatile Integer cachedHashcode;
// Accessed via a VarHandle
@SuppressWarnings("unused")
// FIXME: consider using a primitive int-based cache (with 0 being uninit)
private volatile Integer cachedHashcode;
- protected CodecDataObject(final AbstractDataObjectCodecContext<T, ?> context,
- final DistinctNodeContainer<?, ?> data) {
+ protected CodecDataObject(final AbstractDataObjectCodecContext<T, ?> context, final DataContainerNode data) {
this.data = requireNonNull(data, "Data must not be null");
this.context = requireNonNull(context, "Context must not be null");
}
@Override
public final int hashCode() {
this.data = requireNonNull(data, "Data must not be null");
this.context = requireNonNull(context, "Context must not be null");
}
@Override
public final int hashCode() {
- final Integer cached = (Integer) CACHED_HASH_CODE.getAcquire(this);
+ final var cached = (Integer) CACHED_HASH_CODE.getAcquire(this);
return cached != null ? cached : loadHashCode();
}
return cached != null ? cached : loadHashCode();
}
- @SuppressWarnings("rawtypes")
- final @NonNull DistinctNodeContainer codecData() {
+ final @NonNull DataContainerNode codecData() {
return data;
}
// Helper split out of codecMember to aid its inlining
private Object loadMember(final VarHandle handle, final NodeCodecContext childCtx) {
return data;
}
// Helper split out of codecMember to aid its inlining
private Object loadMember(final VarHandle handle, final NodeCodecContext childCtx) {
- @SuppressWarnings("unchecked")
- final NormalizedNode child = data.childByArg(childCtx.getDomPathArgument());
+ final var child = data.childByArg(childCtx.getDomPathArgument());
// We do not want to use Optional.map() here because we do not want to invoke defaultObject() when we have
// normal value because defaultObject() may end up throwing an exception intentionally.
// We do not want to use Optional.map() here because we do not want to invoke defaultObject() when we have
// normal value because defaultObject() may end up throwing an exception intentionally.
import org.opendaylight.yangtools.yang.binding.OpaqueObject;
import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.binding.OpaqueObject;
import org.opendaylight.yangtools.yang.binding.contract.Naming;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
/**
* Analysis of a {@link DataObject} specialization class. The primary point of this class is to separate out creation
/**
* Analysis of a {@link DataObject} specialization class. The primary point of this class is to separate out creation
*/
final class CodecDataObjectAnalysis<R extends CompositeRuntimeType> {
private static final MethodType CONSTRUCTOR_TYPE = MethodType.methodType(void.class,
*/
final class CodecDataObjectAnalysis<R extends CompositeRuntimeType> {
private static final MethodType CONSTRUCTOR_TYPE = MethodType.methodType(void.class,
- AbstractDataObjectCodecContext.class, DistinctNodeContainer.class);
+ AbstractDataObjectCodecContext.class, DataContainerNode.class);
private static final MethodType DATAOBJECT_TYPE = MethodType.methodType(DataObject.class,
private static final MethodType DATAOBJECT_TYPE = MethodType.methodType(DataObject.class,
- AbstractDataObjectCodecContext.class, DistinctNodeContainer.class);
+ AbstractDataObjectCodecContext.class, DataContainerNode.class);
final @NonNull ImmutableMap<Class<?>, DataContainerCodecPrototype<?>> byStreamClass;
final @NonNull ImmutableMap<Class<?>, DataContainerCodecPrototype<?>> byBindingArgClass;
final @NonNull ImmutableMap<Class<?>, DataContainerCodecPrototype<?>> byStreamClass;
final @NonNull ImmutableMap<Class<?>, DataContainerCodecPrototype<?>> byBindingArgClass;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.builder.DataContainerNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
@Override
@SuppressWarnings("unchecked")
@Override
@SuppressWarnings("unchecked")
- Map<Class<? extends Augmentation<?>>, Augmentation<?>> getAllAugmentationsFrom(
- final DistinctNodeContainer<PathArgument, NormalizedNode> data) {
+ Map<Class<? extends Augmentation<?>>, Augmentation<?>> getAllAugmentationsFrom(final DataContainerNode data) {
/**
* Due to augmentation fields are at same level as direct children the data of each augmentation needs to be
* aggregated into own container node, then only deserialized using associated prototype.
/**
* Due to augmentation fields are at same level as direct children the data of each augmentation needs to be
* aggregated into own container node, then only deserialized using associated prototype.
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
static <E extends DataObject> @NonNull List<E> create(final ListNodeCodecContext<E> codec, final int size,
}
static <E extends DataObject> @NonNull List<E> create(final ListNodeCodecContext<E> codec, final int size,
- final Collection<? extends DistinctNodeContainer<?, ?>> entries) {
+ final Collection<? extends DataContainerNode> entries) {
if (size == 1) {
// Do not bother with lazy instantiation in case of a singleton
return List.of(codec.createBindingProxy(entries.iterator().next()));
if (size == 1) {
// Do not bother with lazy instantiation in case of a singleton
return List.of(codec.createBindingProxy(entries.iterator().next()));
}
private static <E extends DataObject> @NonNull List<E> eagerList(final ListNodeCodecContext<E> codec,
}
private static <E extends DataObject> @NonNull List<E> eagerList(final ListNodeCodecContext<E> codec,
- final int size, final Collection<? extends DistinctNodeContainer<?, ?>> entries) {
+ final int size, final Collection<? extends DataContainerNode> entries) {
@SuppressWarnings("unchecked")
final E[] objs = (E[]) new DataObject[size];
int offset = 0;
@SuppressWarnings("unchecked")
final E[] objs = (E[]) new DataObject[size];
int offset = 0;
- for (DistinctNodeContainer<?, ?> node : entries) {
+ for (var node : entries) {
objs[offset++] = codec.createBindingProxy(node);
}
verify(offset == objs.length);
objs[offset++] = codec.createBindingProxy(node);
}
verify(offset == objs.length);
//
// We could do a Class.isInstance() check here, but since the implementation is not marked as final (yet) we
// would be at the mercy of CHA being able to prove this invariant.
//
// We could do a Class.isInstance() check here, but since the implementation is not marked as final (yet) we
// would be at the mercy of CHA being able to prove this invariant.
- return obj.getClass() == codec.generatedClass() ? (E) obj : load(index, (DistinctNodeContainer<?, ?>) obj);
+ return obj.getClass() == codec.generatedClass() ? (E) obj : load(index, (DataContainerNode) obj);
- private @NonNull E load(final int index, final DistinctNodeContainer<?, ?> node) {
+ private @NonNull E load(final int index, final DataContainerNode node) {
final E ret = codec.createBindingProxy(node);
final Object witness;
return (witness = OBJ_AA.compareAndExchangeRelease(objects, index, node, ret)) == node ? ret : (E) witness;
final E ret = codec.createBindingProxy(node);
final Object witness;
return (witness = OBJ_AA.compareAndExchangeRelease(objects, index, node, ret)) == node ? ret : (E) witness;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.EventInstantAware;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.EventInstantAware;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer;
+import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
final class NotificationCodecContext<D extends DataObject & BaseNotification>
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
final class NotificationCodecContext<D extends DataObject & BaseNotification>
}
private static final Generic BB_DOCC = TypeDefinition.Sort.describe(DataObjectCodecContext.class);
}
private static final Generic BB_DOCC = TypeDefinition.Sort.describe(DataObjectCodecContext.class);
- private static final Generic BB_DNC = TypeDefinition.Sort.describe(DistinctNodeContainer.class);
+ private static final Generic BB_DCN = TypeDefinition.Sort.describe(DataContainerNode.class);
private static final Generic BB_I = TypeDefinition.Sort.describe(Instant.class);
private static final MethodType CONSTRUCTOR_TYPE = MethodType.methodType(void.class, DataObjectCodecContext.class,
private static final Generic BB_I = TypeDefinition.Sort.describe(Instant.class);
private static final MethodType CONSTRUCTOR_TYPE = MethodType.methodType(void.class, DataObjectCodecContext.class,
- DistinctNodeContainer.class, Instant.class);
+ DataContainerNode.class, Instant.class);
private static final MethodType NOTIFICATION_TYPE = MethodType.methodType(BaseNotification.class,
NotificationCodecContext.class, ContainerNode.class, Instant.class);
private static final String INSTANT_FIELD = "instant";
private static final MethodType NOTIFICATION_TYPE = MethodType.methodType(BaseNotification.class,
NotificationCodecContext.class, ContainerNode.class, Instant.class);
private static final String INSTANT_FIELD = "instant";
.name(fqcn)
.defineField(INSTANT_FIELD, BB_I, Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC)
.defineConstructor(Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC)
.name(fqcn)
.defineField(INSTANT_FIELD, BB_I, Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC)
.defineConstructor(Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC)
- .withParameters(BB_DOCC, BB_DNC, BB_I)
+ .withParameters(BB_DOCC, BB_DCN, BB_I)
.intercept(ConstructorImplementation.INSTANCE)
.defineMethod(EVENT_INSTANT_NAME, EVENT_INSTANT_RETTYPE, Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC)
.intercept(EventInstantImplementation.INSTANCE)
.intercept(ConstructorImplementation.INSTANCE)
.defineMethod(EVENT_INSTANT_NAME, EVENT_INSTANT_RETTYPE, Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC)
.intercept(EventInstantImplementation.INSTANCE)
try {
LOAD_CTOR_ARGS = MethodVariableAccess.allArgumentsOf(new MethodDescription.ForLoadedConstructor(
AugmentableCodecDataObject.class.getDeclaredConstructor(AbstractDataObjectCodecContext.class,
try {
LOAD_CTOR_ARGS = MethodVariableAccess.allArgumentsOf(new MethodDescription.ForLoadedConstructor(
AugmentableCodecDataObject.class.getDeclaredConstructor(AbstractDataObjectCodecContext.class,
- DistinctNodeContainer.class)));
+ DataContainerNode.class)));
} catch (NoSuchMethodException e) {
throw new ExceptionInInitializerError(e);
}
} catch (NoSuchMethodException e) {
throw new ExceptionInInitializerError(e);
}