Centralize AbstractDOMRpcImplementationAdapter.serialize()

The invocation paths between the two specializations are exactly the
same, hence we can peel arguments and just pass down the input. Also
fixup duplicate access to serializer.

JIRA: MDSAL-86
Change-Id: I2df5061b47c63cd2886efdacfe5178acc08239de
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/AbstractDOMRpcImplementationAdapter.java b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/AbstractDOMRpcImplementationAdapter.java
index 2778a0bca0d609223904318262366e703d151dd9..d9532d2059aaa1689b998ac14ae53530d3fed2c7 100644 (file)
--- a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/AbstractDOMRpcImplementationAdapter.java
+++ b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/AbstractDOMRpcImplementationAdapter.java
@@ -21,6 +21,7 @@ import org.opendaylight.mdsal.dom.api.DOMRpcResult;
 import org.opendaylight.yangtools.yang.binding.RpcInput;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.YangConstants;
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
 
@@ -28,10 +29,12 @@ abstract sealed class AbstractDOMRpcImplementationAdapter implements DOMRpcImple
         permits BindingDOMRpcImplementationAdapter, LegacyDOMRpcImplementationAdapter {
     private final AdapterContext adapterContext;
     private final @NonNull QName inputName;
+    private final @NonNull QName rpcName;
 
-    AbstractDOMRpcImplementationAdapter(final AdapterContext adapterContext, @NonNull QName inputName) {
+    AbstractDOMRpcImplementationAdapter(final AdapterContext adapterContext, final QName rpcName) {
         this.adapterContext = requireNonNull(adapterContext);
-        this.inputName = requireNonNull(inputName);
+        this.rpcName = requireNonNull(rpcName);
+        inputName = YangConstants.operationInputQName(rpcName.getModule()).intern();
     }
 
     @Override
@@ -43,23 +46,20 @@ abstract sealed class AbstractDOMRpcImplementationAdapter implements DOMRpcImple
     @Override
     public final ListenableFuture<DOMRpcResult> invokeRpc(final DOMRpcIdentifier rpc, final ContainerNode input) {
         final var serializer = adapterContext.currentSerializer();
-        return LazyDOMRpcResultFuture.create(serializer, invokeRpc(serializer, rpc, input));
+        return LazyDOMRpcResultFuture.create(serializer, invokeRpc(deserialize(serializer, input)));
     }
 
-    abstract @NonNull ListenableFuture<RpcResult<?>> invokeRpc(@NonNull CurrentAdapterSerializer serializer,
-        @NonNull DOMRpcIdentifier rpc, @NonNull ContainerNode input);
+    abstract @NonNull ListenableFuture<RpcResult<?>> invokeRpc(@NonNull RpcInput input);
 
-    final @NonNull RpcInput deserialize(final @NonNull CurrentAdapterSerializer serializer,
-            final @NonNull QName rpcName, final @NonNull ContainerNode input) {
+    private @NonNull RpcInput deserialize(final @NonNull CurrentAdapterSerializer serializer,
+            final @NonNull ContainerNode input) {
         if (ENABLE_CODEC_SHORTCUT && input instanceof BindingLazyContainerNode<?> lazy) {
             return (RpcInput) lazy.getDataObject();
         }
 
-        // TODO: this is a bit inefficient: typically we get the same CurrentAdapterSerializer and the path is also
-        //       constant, hence we should be able to cache this lookup and just have the appropriate
-        //       BindingDataObjectCodecTreeNode and reuse it directly
         checkArgument(inputName.equals(input.getIdentifier().getNodeType()),
             "Unexpected RPC %s input %s", rpcName, input);
+
         // TODO: this is a bit inefficient: typically we get the same CurrentAdapterSerializer and the path is also
         //       constant, hence we should be able to cache this lookup and just have the appropriate
         //       BindingDataObjectCodecTreeNode and reuse it directly

diff --git a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcImplementationAdapter.java b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcImplementationAdapter.java
index 29df8615f59f40fb368096baee19b647d4cc4671..63f0b7d73132ff6e5f0c111f7d612ae0e26ddd60 100644 (file)
--- a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcImplementationAdapter.java
+++ b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcImplementationAdapter.java
@@ -11,28 +11,24 @@ import static java.util.Objects.requireNonNull;
 
 import com.google.common.util.concurrent.ListenableFuture;
 import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
 import org.opendaylight.yangtools.yang.binding.Rpc;
+import org.opendaylight.yangtools.yang.binding.RpcInput;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.common.YangConstants;
-import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 
 final class BindingDOMRpcImplementationAdapter extends AbstractDOMRpcImplementationAdapter {
-    private final @NonNull Rpc<?, ?> delegate;
-    private final @NonNull QName rpcName;
+    @SuppressWarnings("rawtypes")
+    private final @NonNull Rpc delegate;
 
-    BindingDOMRpcImplementationAdapter(final AdapterContext adapterContext, final Rpc<?, ?> delegate,
-            final QName rpcName) {
-        super(adapterContext, YangConstants.operationInputQName(rpcName.getModule()).intern());
+    BindingDOMRpcImplementationAdapter(final AdapterContext adapterContext, final QName rpcName,
+            final Rpc<?, ?> delegate) {
+        super(adapterContext, rpcName);
         this.delegate = requireNonNull(delegate);
-        this.rpcName = requireNonNull(rpcName);
     }
 
     @Override
-    @SuppressWarnings({ "unchecked", "rawtypes" })
-    ListenableFuture<RpcResult<?>> invokeRpc(final CurrentAdapterSerializer serializer, final DOMRpcIdentifier rpc,
-            final ContainerNode input) {
-        return ((Rpc) delegate).invoke(deserialize(serializer, rpcName, input));
+    @SuppressWarnings("unchecked")
+    ListenableFuture<RpcResult<?>> invokeRpc(final RpcInput input) {
+        return delegate.invoke(input);
     }
 }

diff --git a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcProviderServiceAdapter.java b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcProviderServiceAdapter.java
index a6092dfc9983b3e4cb7b87f09a737bb230a3b41d..0300332f7d7d08fc962146d9335f1313b302c50c 100644 (file)
--- a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcProviderServiceAdapter.java
+++ b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/BindingDOMRpcProviderServiceAdapter.java
@@ -17,7 +17,6 @@ import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
 import org.opendaylight.mdsal.binding.api.RpcProviderService;
-import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
 import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementation;
 import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
@@ -27,7 +26,6 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.opendaylight.yangtools.yang.binding.Rpc;
 import org.opendaylight.yangtools.yang.binding.RpcService;
 import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.YangConstants;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 
 @VisibleForTesting
@@ -98,10 +96,10 @@ public class BindingDOMRpcProviderServiceAdapter extends AbstractBindingAdapter<
             if (def == null) {
                 throw new IllegalArgumentException("Cannot resolve YANG definition of " + type);
             }
-            final var name = def.statement().argument();
-            final var impl = new BindingDOMRpcImplementationAdapter(adapterContext(), entry.getValue(), name);
+            final var rpcName  = def.statement().argument();
+            final var impl = new BindingDOMRpcImplementationAdapter(adapterContext(), rpcName, entry.getValue());
 
-            for (var id : createDomRpcIdentifiers(Set.of(name), rpcContextPaths)) {
+            for (var id : createDomRpcIdentifiers(Set.of(rpcName), rpcContextPaths)) {
                 builder.put(id, impl);
             }
         }
@@ -113,15 +111,14 @@ public class BindingDOMRpcProviderServiceAdapter extends AbstractBindingAdapter<
     private <S extends RpcService, T extends S> ObjectRegistration<T> register(
             final CurrentAdapterSerializer serializer, final Class<S> type, final T implementation,
             final Collection<YangInstanceIdentifier> rpcContextPaths) {
-        // FIXME: do not use BindingReflections here
-        final var inputName = YangConstants.operationInputQName(BindingReflections.getQNameModule(type)).intern();
-        final var methodHandles = currentSerializer().getRpcMethods(type);
+        final var methodHandles = serializer.getRpcMethods(type);
         final var builder = ImmutableMap.<DOMRpcIdentifier, DOMRpcImplementation>builderWithExpectedSize(
             methodHandles.size());
         for (var entry : methodHandles.entrySet()) {
-            final var impl = new LegacyDOMRpcImplementationAdapter(adapterContext(), inputName,
+            final var rpcName = entry.getKey();
+            final var impl = new LegacyDOMRpcImplementationAdapter(adapterContext(), rpcName,
                 entry.getValue().bindTo(implementation));
-            for (var id : createDomRpcIdentifiers(Set.of(entry.getKey()), rpcContextPaths)) {
+            for (var id : createDomRpcIdentifiers(Set.of(rpcName), rpcContextPaths)) {
                 builder.put(id, impl);
             }
         }

diff --git a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/LegacyDOMRpcImplementationAdapter.java b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/LegacyDOMRpcImplementationAdapter.java
index 765ec37287c17230d159053a090d4680a69c28f1..5c1dadf81ec83ed9d4bf7fd5353b916110e61339 100644 (file)
--- a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/LegacyDOMRpcImplementationAdapter.java
+++ b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/LegacyDOMRpcImplementationAdapter.java
@@ -12,27 +12,25 @@ import static java.util.Objects.requireNonNull;
 import com.google.common.base.Throwables;
 import com.google.common.util.concurrent.ListenableFuture;
 import java.lang.invoke.MethodHandle;
-import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
+import org.opendaylight.yangtools.yang.binding.RpcInput;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 
 @Deprecated(since = "11.0.0", forRemoval = true)
 final class LegacyDOMRpcImplementationAdapter extends AbstractDOMRpcImplementationAdapter {
     private final MethodHandle handle;
 
-    LegacyDOMRpcImplementationAdapter(final AdapterContext adapterContext, final QName inputName,
+    LegacyDOMRpcImplementationAdapter(final AdapterContext adapterContext, final QName rpcName,
             final MethodHandle handle) {
-        super(adapterContext, inputName);
+        super(adapterContext, rpcName);
         this.handle = requireNonNull(handle);
     }
 
     @Override
     @SuppressWarnings("checkstyle:illegalCatch")
-    ListenableFuture<RpcResult<?>> invokeRpc(final CurrentAdapterSerializer serializer, final DOMRpcIdentifier rpc,
-            final ContainerNode input) {
+    ListenableFuture<RpcResult<?>> invokeRpc(final RpcInput input) {
         try {
-            return (ListenableFuture<RpcResult<?>>) handle.invokeExact(deserialize(serializer, rpc.getType(), input));
+            return (ListenableFuture<RpcResult<?>>) handle.invokeExact(input);
         } catch (Throwable e) {
             Throwables.throwIfUnchecked(e);
             throw new IllegalStateException(e);