Refactor binding-dom-adapter

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

diff --git a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/ActionProviderServiceAdapter.java b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/ActionProviderServiceAdapter.java
index ee4663240b93521a424ebfe5c1e50f641a25e212..a5e9e4bbd247499030c1f6f8dea25b80c0ab9188 100644 (file)
--- a/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/ActionProviderServiceAdapter.java
+++ b/binding/mdsal-binding-dom-adapter/src/main/java/org/opendaylight/mdsal/binding/dom/adapter/ActionProviderServiceAdapter.java
@@ -7,19 +7,17 @@
  */
 package org.opendaylight.mdsal.binding.dom.adapter;
 
+import static com.google.common.base.Verify.verifyNotNull;
 import static java.util.Objects.requireNonNull;
 
-import com.google.common.annotations.Beta;
 import com.google.common.collect.ClassToInstanceMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.util.concurrent.ListenableFuture;
 import java.util.Set;
 import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.mdsal.binding.api.ActionProviderService;
 import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
 import org.opendaylight.mdsal.binding.dom.adapter.BindingDOMAdapterBuilder.Factory;
-import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.mdsal.dom.api.DOMActionImplementation;
 import org.opendaylight.mdsal.dom.api.DOMActionProviderService;
@@ -37,17 +35,18 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdent
 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
 
-@Beta
 @NonNullByDefault
-// FIXME: make this class non-public once the controller user is gone
 public final class ActionProviderServiceAdapter extends AbstractBindingAdapter<DOMActionProviderService>
         implements ActionProviderService {
     private static final class Builder extends BindingDOMAdapterBuilder<ActionProviderService> {
+        Builder(final AdapterContext adapterContext) {
+            super(adapterContext);
+        }
+
         @Override
-        protected ActionProviderService createInstance(final @Nullable BindingToNormalizedNodeCodec codec,
-                final ClassToInstanceMap<DOMService> delegates) {
-            final DOMActionProviderService domAction = delegates.getInstance(DOMActionProviderService.class);
-            return new ActionProviderServiceAdapter(requireNonNull(codec), domAction);
+        protected ActionProviderService createInstance(final ClassToInstanceMap<DOMService> delegates) {
+            return new ActionProviderServiceAdapter(adapterContext(),
+                delegates.getInstance(DOMActionProviderService.class));
         }
 
         @Override
@@ -58,27 +57,20 @@ public final class ActionProviderServiceAdapter extends AbstractBindingAdapter<D
 
     static final Factory<ActionProviderService> BUILDER_FACTORY = Builder::new;
 
-    ActionProviderServiceAdapter(final BindingToNormalizedNodeCodec codec, final DOMActionProviderService delegate) {
-        super(codec, delegate);
-    }
-
-    @Deprecated
-    public static ActionProviderServiceAdapter create(final BindingToNormalizedNodeCodec codec,
-            final DOMActionProviderService delegate) {
-        return new ActionProviderServiceAdapter(codec, delegate);
+    ActionProviderServiceAdapter(final AdapterContext adapterContext, final DOMActionProviderService delegate) {
+        super(adapterContext, delegate);
     }
 
     @Override
-    public <O extends DataObject, P extends InstanceIdentifier<O>,
-        T extends org.opendaylight.yangtools.yang.binding.Action<P, ?, ?>, S extends T>
-        ObjectRegistration<S> registerImplementation(final Class<T> actionInterface, final S implementation,
+    public <O extends DataObject, P extends InstanceIdentifier<O>, T extends Action<P, ?, ?>, S extends T>
+            ObjectRegistration<S> registerImplementation(final Class<T> actionInterface, final S implementation,
                 final LogicalDatastoreType datastore, final Set<DataTreeIdentifier<O>> validNodes) {
-        final SchemaPath path = getCodec().getActionPath(actionInterface);
+        final SchemaPath path = currentSerializer().getActionPath(actionInterface);
         final ObjectRegistration<DOMActionImplementation> reg = getDelegate().registerActionImplementation(
-            new Impl(getCodec(),
+            new Impl(adapterContext(),
                 NodeIdentifier.create(YangConstants.operationOutputQName(path.getLastComponent().getModule())),
                 actionInterface, implementation), ImmutableSet.of());
-        return new AbstractObjectRegistration<S>(implementation) {
+        return new AbstractObjectRegistration<>(implementation) {
             @Override
             protected void removeRegistration() {
                 reg.close();
@@ -88,13 +80,13 @@ public final class ActionProviderServiceAdapter extends AbstractBindingAdapter<D
 
     private static final class Impl implements DOMActionImplementation {
         private final Class<? extends Action<?, ?, ?>> actionInterface;
+        private final AdapterContext adapterContext;
         private final Action implementation;
-        private final BindingNormalizedNodeSerializer codec;
         private final NodeIdentifier outputName;
 
-        Impl(final BindingNormalizedNodeSerializer codec, final NodeIdentifier outputName,
+        Impl(final AdapterContext adapterContext, final NodeIdentifier outputName,
                 final Class<? extends Action<?, ?, ?>> actionInterface, final Action<?, ?, ?> implementation) {
-            this.codec = requireNonNull(codec);
+            this.adapterContext = requireNonNull(adapterContext);
             this.outputName = requireNonNull(outputName);
             this.actionInterface = requireNonNull(actionInterface);
             this.implementation = requireNonNull(implementation);
@@ -104,8 +96,10 @@ public final class ActionProviderServiceAdapter extends AbstractBindingAdapter<D
         @SuppressWarnings({ "rawtypes", "unchecked" })
         public ListenableFuture<? extends DOMActionResult> invokeAction(final SchemaPath type,
                 final DOMDataTreeIdentifier path, final ContainerNode input) {
+            final CurrentAdapterSerializer codec = adapterContext.currentSerializer();
+
             final ListenableFuture<RpcResult<?>> userFuture = implementation.invoke(
-                codec.fromYangInstanceIdentifier(path.getRootIdentifier()),
+                verifyNotNull(codec.fromYangInstanceIdentifier(path.getRootIdentifier())),
                 codec.fromNormalizedNodeActionInput(actionInterface, input));
             if (userFuture instanceof BindingOperationFluentFuture) {
                 // If we are looping back through our future we can skip wrapping. This can happen if application
@@ -113,7 +107,7 @@ public final class ActionProviderServiceAdapter extends AbstractBindingAdapter<D
                 return (BindingOperationFluentFuture) userFuture;
             }
 
-            return new BindingOperationFluentFuture(userFuture, actionInterface, outputName, codec);
+            return new BindingOperationFluentFuture(userFuture, actionInterface, outputName, adapterContext);
         }
     }
 }