Convert mdsal-binding-dom-codec to a JPMS module

[mdsal.git] / binding / mdsal-binding-dom-codec / src / main / java / org / opendaylight / mdsal / binding / dom / codec / impl / OpaqueNodeCodecContext.java

diff --git a/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/OpaqueNodeCodecContext.java b/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/OpaqueNodeCodecContext.java
index adbeb2ac8358b510154d037932f7bbcc8dc9055c..cf932f27e52207bbe66a9731af9823b597fb74ba 100644 (file)
--- a/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/OpaqueNodeCodecContext.java
+++ b/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/OpaqueNodeCodecContext.java
@@ -15,37 +15,37 @@ import com.google.common.base.Throwables;
 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 net.bytebuddy.jar.asm.Opcodes;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.mdsal.binding.dom.codec.api.BindingOpaqueObjectCodecTreeNode;
-import org.opendaylight.mdsal.binding.dom.codec.loader.CodecClassLoader;
-import org.opendaylight.mdsal.binding.dom.codec.loader.CodecClassLoader.GeneratorResult;
-import org.opendaylight.yangtools.concepts.Codec;
+import org.opendaylight.mdsal.binding.dom.codec.impl.loader.CodecClassLoader;
+import org.opendaylight.mdsal.binding.dom.codec.impl.loader.CodecClassLoader.GeneratorResult;
+import org.opendaylight.yangtools.concepts.AbstractIllegalArgumentCodec;
+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())
@@ -53,15 +53,15 @@ abstract class OpaqueNodeCodecContext<T extends OpaqueObject<T>> extends ValueNo
         }
 
         @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);
         }
@@ -77,15 +77,15 @@ abstract class OpaqueNodeCodecContext<T extends OpaqueObject<T>> extends ValueNo
         }
     }
 
-    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);
 
-    private final Codec<Object, Object> valueCodec = new Codec<Object, Object>() {
+    private final IllegalArgumentCodec<Object, Object> valueCodec = new AbstractIllegalArgumentCodec<>() {
         @Override
-        public Object serialize(final Object input) {
+        protected Object serializeImpl(final Object input) {
             checkArgument(bindingClass.isInstance(input), "Unexpected input %s", input);
             // FIXME: this works for DOMSource only, for generalization we need to pass down the object model, too
             final OpaqueData<?> opaqueData = bindingClass.cast(input).getValue();
@@ -95,9 +95,9 @@ abstract class OpaqueNodeCodecContext<T extends OpaqueObject<T>> extends ValueNo
         }
 
         @Override
-        public Object deserialize(final Object input) {
+        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);
         }
     };
 
@@ -117,33 +117,33 @@ abstract class OpaqueNodeCodecContext<T extends OpaqueObject<T>> extends ValueNo
     }
 
     @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);
     }
 
     @Override
-    Codec<Object, Object> getValueCodec() {
+    IllegalArgumentCodec<Object, Object> getValueCodec() {
         return valueCodec;
     }
 
-    abstract @NonNull ForeignDataNode<?, ?> serializedData(OpaqueData<?> opaqueData);
+    abstract @NonNull ForeignDataNode<?> serializedData(OpaqueData<?> opaqueData);
 
     @SuppressWarnings("checkstyle:illegalCatch")
     private OpaqueObject<?> createBindingProxy(final OpaqueData<?> data) {
@@ -162,15 +162,9 @@ abstract class OpaqueNodeCodecContext<T extends OpaqueObject<T>> extends ValueNo
                 .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);
         }
     }