import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
-import java.lang.reflect.Constructor;
import javax.xml.transform.dom.DOMSource;
import net.bytebuddy.ByteBuddy;
import net.bytebuddy.dynamic.DynamicType.Builder;
import org.opendaylight.yangtools.concepts.IllegalArgumentCodec;
import org.opendaylight.yangtools.yang.binding.OpaqueData;
import org.opendaylight.yangtools.yang.binding.OpaqueObject;
-import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.AnydataNode;
+import org.opendaylight.yangtools.yang.data.api.schema.DOMSourceAnyxmlNode;
import org.opendaylight.yangtools.yang.data.api.schema.ForeignDataNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.model.api.AnyDataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
abstract class OpaqueNodeCodecContext<T extends OpaqueObject<T>> extends ValueNodeCodecContext
implements BindingOpaqueObjectCodecTreeNode<T> {
- static final class AnyXml<T extends OpaqueObject<T>> extends OpaqueNodeCodecContext<T> {
- AnyXml(final AnyXmlSchemaNode schema, final String getterName, final Class<T> bindingClass,
+ static final class Anyxml<T extends OpaqueObject<T>> extends OpaqueNodeCodecContext<T> {
+ Anyxml(final AnyxmlSchemaNode schema, final String getterName, final Class<T> bindingClass,
final CodecClassLoader loader) {
super(schema, getterName, bindingClass, loader);
}
@Override
- ForeignDataNode<?, ?> serializedData(final OpaqueData<?> opaqueData) {
+ ForeignDataNode<?> serializedData(final OpaqueData<?> opaqueData) {
final Class<?> model = opaqueData.getObjectModel();
verify(DOMSource.class.isAssignableFrom(model), "Cannot just yet support object model %s", model);
return Builders.anyXmlBuilder().withNodeIdentifier(getDomPathArgument())
}
@Override
- T deserialize(final ForeignDataNode<?, ?> foreignData) {
+ T deserialize(final ForeignDataNode<?> foreignData) {
// Streaming cannot support anything but DOMSource-based AnyxmlNodes.
- verify(foreignData instanceof AnyXmlNode, "Variable node %s not supported yet", foreignData);
+ verify(foreignData instanceof DOMSourceAnyxmlNode, "Variable node %s not supported yet", foreignData);
return super.deserialize(foreignData);
}
}
- static final class AnyData<T extends OpaqueObject<T>> extends OpaqueNodeCodecContext<T> {
- AnyData(final AnyDataSchemaNode schema, final String getterName, final Class<T> bindingClass,
+ static final class Anydata<T extends OpaqueObject<T>> extends OpaqueNodeCodecContext<T> {
+ Anydata(final AnydataSchemaNode schema, final String getterName, final Class<T> bindingClass,
final CodecClassLoader loader) {
super(schema, getterName, bindingClass, loader);
}
}
}
- private static final MethodType CONSTRUCTOR_TYPE = MethodType.methodType(OpaqueObject.class,
- OpaqueData.class);
+ private static final MethodType CTOR_LOOKUP_TYPE = MethodType.methodType(void.class, OpaqueData.class);
+ private static final MethodType CTOR_INVOKE_TYPE = MethodType.methodType(OpaqueObject.class, OpaqueData.class);
@SuppressWarnings("rawtypes")
private static final Builder<CodecOpaqueObject> TEMPLATE = new ByteBuddy().subclass(CodecOpaqueObject.class)
.modifiers(Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC);
@Override
protected Object deserializeImpl(final Object input) {
checkArgument(input instanceof NormalizedNode, "Unexpected input %s", input);
- return OpaqueNodeCodecContext.this.deserializeObject((NormalizedNode<?, ?>) input);
+ return OpaqueNodeCodecContext.this.deserializeObject((NormalizedNode) input);
}
};
}
@Override
- public final T deserialize(final NormalizedNode<?, ?> data) {
+ public final T deserialize(final NormalizedNode data) {
checkArgument(data instanceof ForeignDataNode, "Unexpected value %s", data);
- return deserialize((ForeignDataNode<?, ?>) data);
+ return deserialize((ForeignDataNode<?>) data);
}
- T deserialize(final ForeignDataNode<?, ?> foreignData) {
+ T deserialize(final ForeignDataNode<?> foreignData) {
return bindingClass.cast(createBindingProxy(new ForeignOpaqueData<>(foreignData)));
}
@Override
- public final ForeignDataNode<?, ?> serialize(final T data) {
+ public final ForeignDataNode<?> serialize(final T data) {
final OpaqueData<?> opaqueData = data.getValue();
return opaqueData instanceof ForeignOpaqueData ? ((ForeignOpaqueData<?>) opaqueData).domData()
: serializedData(opaqueData);
}
@Override
- protected final @NonNull Object deserializeObject(final NormalizedNode<?, ?> normalizedNode) {
+ protected final @NonNull Object deserializeObject(final NormalizedNode normalizedNode) {
return deserialize(normalizedNode);
}
return valueCodec;
}
- abstract @NonNull ForeignDataNode<?, ?> serializedData(OpaqueData<?> opaqueData);
+ abstract @NonNull ForeignDataNode<?> serializedData(OpaqueData<?> opaqueData);
@SuppressWarnings("checkstyle:illegalCatch")
private OpaqueObject<?> createBindingProxy(final OpaqueData<?> data) {
.implement(bindingInterface)
.make()));
- Constructor<?> ctor;
try {
- ctor = proxyClass.getDeclaredConstructor(OpaqueData.class);
- } catch (NoSuchMethodException e) {
- throw new LinkageError("Failed to acquire constructor for prototype " + proxyClass, e);
- }
- try {
- return MethodHandles.publicLookup().unreflectConstructor(ctor).asType(CONSTRUCTOR_TYPE);
- } catch (IllegalAccessException e) {
+ return MethodHandles.publicLookup().findConstructor(proxyClass, CTOR_LOOKUP_TYPE).asType(CTOR_INVOKE_TYPE);
+ } catch (IllegalAccessException | NoSuchMethodException e) {
throw new LinkageError("Failed to access constructor for prototype " + proxyClass, e);
}
}