import org.opendaylight.yangtools.yang.binding.BaseNotification;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.EventInstantAware;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
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>
}
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,
- 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 final MethodHandle eventProxy;
- NotificationCodecContext(final Class<?> key, final NotificationRuntimeType schema,
+ NotificationCodecContext(final Class<?> notificationClass, final NotificationRuntimeType type,
final CodecContextFactory factory) {
- super(DataContainerCodecPrototype.from(key, schema, factory));
- final Class<D> bindingClass = getBindingClass();
+ super(new Prototype<>(notificationClass, type, factory));
+ 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)
.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)
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);
}
return deserialize(normalizedNode);
}
+ /**
+ * Prototype for a {@code notification}. This class only exists because DataContainerCodecContext requires a
+ * prototype.
+ */
+ static final class Prototype<D extends DataObject & BaseNotification>
+ extends DataObjectCodecPrototype<NotificationRuntimeType> {
+ private Prototype(final Class<?> cls, final NotificationRuntimeType type, final CodecContextFactory factory) {
+ super(cls, NodeIdentifier.create(type.statement().argument()), type, factory);
+ }
+
+ @Override
+ NotificationCodecContext<?> createInstance() {
+ throw new UnsupportedOperationException("Should never be invoked");
+ }
+ }
+
private enum ConstructorImplementation implements Implementation {
INSTANCE;
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);
}