Move BindingReflections to mdsal-binding-spec-util

[mdsal.git] / binding / mdsal-binding-dom-adapter / src / main / java / org / opendaylight / mdsal / binding / dom / adapter / RpcServiceAdapter.java

diff --git a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/RpcServiceAdapter.java b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/RpcServiceAdapter.java
index 6f92bb1b1917c6e925e0918975b58c12ed222d65..0c36a7f533157f97260d7d72e89a610f0e65a624 100644 (file)
--- a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/RpcServiceAdapter.java
+++ b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/RpcServiceAdapter.java
@@ -5,10 +5,8 @@
  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
  * and is available at http://www.eclipse.org/legal/epl-v10.html
  */
-
 package org.opendaylight.mdsal.binding.dom.adapter;
 
-import com.google.common.base.Function;
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableMap;
@@ -20,6 +18,7 @@ import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.util.Map.Entry;
 import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
+import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
 import org.opendaylight.mdsal.dom.api.DOMRpcService;
 import org.opendaylight.mdsal.dom.spi.RpcRoutingStrategy;
@@ -27,10 +26,9 @@ import org.opendaylight.yangtools.yang.binding.DataContainer;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.binding.RpcService;
-import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.YangConstants;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
@@ -41,7 +39,6 @@ import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 
 class RpcServiceAdapter implements InvocationHandler {
-
     private final ImmutableMap<Method, RpcInvocationStrategy> rpcNames;
     private final Class<? extends RpcService> type;
     private final BindingToNormalizedNodeCodec codec;
@@ -74,6 +71,7 @@ class RpcServiceAdapter implements InvocationHandler {
     }
 
     @Override
+    @SuppressWarnings("checkstyle:hiddenField")
     public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
 
         final RpcInvocationStrategy rpc = rpcNames.get(method);
@@ -87,37 +85,28 @@ class RpcServiceAdapter implements InvocationHandler {
             return rpc.invoke((DataObject) args[0]);
         }
 
-        if (isObjectMethod(method)) {
-            return callObjectMethod(proxy, method, args);
-        }
-        throw new UnsupportedOperationException("Method " + method.toString() + "is unsupported.");
-    }
-
-    private static boolean isObjectMethod(final Method method) {
         switch (method.getName()) {
             case "toString":
-                return method.getReturnType().equals(String.class) && method.getParameterTypes().length == 0;
+                if (method.getReturnType().equals(String.class) && method.getParameterTypes().length == 0) {
+                    return type.getName() + "$Adapter{delegate=" + delegate.toString() + "}";
+                }
+                break;
             case "hashCode":
-                return method.getReturnType().equals(int.class) && method.getParameterTypes().length == 0;
+                if (method.getReturnType().equals(int.class) && method.getParameterTypes().length == 0) {
+                    return System.identityHashCode(proxy);
+                }
+                break;
             case "equals":
-                return method.getReturnType().equals(boolean.class) && method.getParameterTypes().length == 1
-                        && method.getParameterTypes()[0] == Object.class;
+                if (method.getReturnType().equals(boolean.class) && method.getParameterTypes().length == 1
+                        && method.getParameterTypes()[0] == Object.class) {
+                    return proxy == args[0];
+                }
+                break;
             default:
-                return false;
+                break;
         }
-    }
 
-    private Object callObjectMethod(final Object self, final Method method, final Object[] args) {
-        switch (method.getName()) {
-            case "toString":
-                return type.getName() + "$Adapter{delegate=" + delegate.toString() + "}";
-            case "hashCode":
-                return System.identityHashCode(self);
-            case "equals":
-                return self == args[0];
-            default:
-                return null;
-        }
+        throw new UnsupportedOperationException("Method " + method.toString() + "is unsupported.");
     }
 
     private abstract class RpcInvocationStrategy {
@@ -132,7 +121,7 @@ class RpcServiceAdapter implements InvocationHandler {
             return invoke0(rpcName, serialize(input));
         }
 
-        abstract NormalizedNode<?, ?> serialize(DataObject input);
+        abstract ContainerNode serialize(DataObject input);
 
         final ListenableFuture<RpcResult<?>> invokeEmpty() {
             return invoke0(rpcName, null);
@@ -142,30 +131,31 @@ class RpcServiceAdapter implements InvocationHandler {
             return rpcName;
         }
 
-        private ListenableFuture<RpcResult<?>> invoke0(final SchemaPath schemaPath, final NormalizedNode<?, ?> input) {
+        ListenableFuture<RpcResult<?>> invoke0(final SchemaPath schemaPath, final ContainerNode input) {
             final ListenableFuture<DOMRpcResult> result = delegate.invokeRpc(schemaPath, input);
-            if (result instanceof LazyDOMRpcResultFuture) {
-                return ((LazyDOMRpcResultFuture) result).getBindingFuture();
+            if (result instanceof BindingRpcFutureAware) {
+                return ((BindingRpcFutureAware) result).getBindingFuture();
             }
 
             return transformFuture(schemaPath, result, codec.getCodecFactory());
         }
 
         private ListenableFuture<RpcResult<?>> transformFuture(final SchemaPath rpc,
-                final ListenableFuture<DOMRpcResult> domFuture, final BindingNormalizedNodeCodecRegistry codec) {
-            return Futures.transform(domFuture, (Function<DOMRpcResult, RpcResult<?>>) input -> {
+                final ListenableFuture<DOMRpcResult> domFuture, final BindingNormalizedNodeCodecRegistry resultCodec) {
+            return Futures.transform(domFuture, input -> {
                 final NormalizedNode<?, ?> domData = input.getResult();
                 final DataObject bindingResult;
                 if (domData != null) {
-                    final SchemaPath rpcOutput = rpc.createChild(QName.create(rpc.getLastComponent(), "output"));
-                    bindingResult = codec.fromNormalizedNodeRpcData(rpcOutput, (ContainerNode) domData);
+                    final SchemaPath rpcOutput = rpc.createChild(YangConstants.operationOutputQName(
+                        rpc.getLastComponent().getModule()));
+                    bindingResult = resultCodec.fromNormalizedNodeRpcData(rpcOutput, (ContainerNode) domData);
                 } else {
                     bindingResult = null;
                 }
-                return RpcResult.class.cast(RpcResultBuilder.success(bindingResult).build());
+
+                return RpcResultUtil.rpcResultFromDOM(input.getErrors(), bindingResult);
             }, MoreExecutors.directExecutor());
         }
-
     }
 
     private final class NonRoutedStrategy extends RpcInvocationStrategy {
@@ -175,7 +165,7 @@ class RpcServiceAdapter implements InvocationHandler {
         }
 
         @Override
-        NormalizedNode<?, ?> serialize(final DataObject input) {
+        ContainerNode serialize(final DataObject input) {
             return LazySerializedContainerNode.create(getRpcName(), input, codec.getCodecRegistry());
         }
 
@@ -197,7 +187,7 @@ class RpcServiceAdapter implements InvocationHandler {
         }
 
         @Override
-        NormalizedNode<?, ?> serialize(final DataObject input) {
+        ContainerNode serialize(final DataObject input) {
             final InstanceIdentifier<?> bindingII = refExtractor.extract(input);
             if (bindingII != null) {
                 final YangInstanceIdentifier yangII = codec.toYangInstanceIdentifierCached(bindingII);