Do not use ListenerRegistration in mdsal-dom-api

[mdsal.git] / dom / mdsal-dom-broker / src / main / java / org / opendaylight / mdsal / dom / broker / DOMRpcRouter.java

diff --git a/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/DOMRpcRouter.java b/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/DOMRpcRouter.java
index 14bd9cf14183d6840d4e26cf8375f07ccd0f9fd6..3d9544673df06dfd55c3fa161159df37c87da7dc 100644 (file)
--- a/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/DOMRpcRouter.java
+++ b/dom/mdsal-dom-broker/src/main/java/org/opendaylight/mdsal/dom/broker/DOMRpcRouter.java
@@ -12,9 +12,7 @@ import static com.google.common.base.Verify.verifyNotNull;
 import static java.util.Objects.requireNonNull;
 
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.collect.ClassToInstanceMap;
 import com.google.common.collect.Collections2;
-import com.google.common.collect.ImmutableClassToInstanceMap;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableTable;
@@ -49,7 +47,6 @@ import org.opendaylight.mdsal.dom.api.DOMActionNotAvailableException;
 import org.opendaylight.mdsal.dom.api.DOMActionProviderService;
 import org.opendaylight.mdsal.dom.api.DOMActionResult;
 import org.opendaylight.mdsal.dom.api.DOMActionService;
-import org.opendaylight.mdsal.dom.api.DOMActionServiceExtension;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
 import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
 import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
@@ -81,9 +78,8 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 @Singleton
-@Component(immediate = true, service = DOMRpcRouterServices.class)
-public final class DOMRpcRouter extends AbstractRegistration
-        implements DOMRpcRouterServices, EffectiveModelContextListener {
+@Component(service = DOMRpcRouter.class)
+public final class DOMRpcRouter extends AbstractRegistration implements EffectiveModelContextListener {
     private static final Logger LOG = LoggerFactory.getLogger(DOMRpcRouter.class);
     private static final ThreadFactory THREAD_FACTORY = new ThreadFactoryBuilder().setNameFormat(
             "DOMRpcRouter-listener-%s").setDaemon(true).build();
@@ -131,23 +127,19 @@ public final class DOMRpcRouter extends AbstractRegistration
         close();
     }
 
-    @Override
-    public DOMActionService getActionService() {
+    public @NonNull DOMActionService actionService() {
         return actionService;
     }
 
-    @Override
-    public DOMActionProviderService getActionProviderService() {
+    public @NonNull DOMActionProviderService actionProviderService() {
         return actionProviderService;
     }
 
-    @Override
-    public DOMRpcService getRpcService() {
+    public @NonNull DOMRpcService rpcService() {
         return rpcService;
     }
 
-    @Override
-    public DOMRpcProviderService getRpcProviderService() {
+    public @NonNull DOMRpcProviderService rpcProviderService() {
         return rpcProviderService;
     }
 
@@ -337,6 +329,7 @@ public final class DOMRpcRouter extends AbstractRegistration
         }
     }
 
+    // FIXME: just Registration or ObjectRegistration and without generics
     private static final class ActionRegistration<T extends AvailabilityListener>
         extends AbstractListenerRegistration<T> {
 
@@ -357,8 +350,8 @@ public final class DOMRpcRouter extends AbstractRegistration
         }
 
         void initialTable() {
-            final List<DOMActionInstance> added = new ArrayList<>();
-            for (Entry<Absolute, Set<DOMDataTreeIdentifier>> e : prevActions.entrySet()) {
+            final var added = new ArrayList<DOMActionInstance>();
+            for (var e : prevActions.entrySet()) {
                 added.addAll(Collections2.transform(e.getValue(), i -> DOMActionInstance.of(e.getKey(), i)));
             }
             if (!added.isEmpty()) {
@@ -404,31 +397,10 @@ public final class DOMRpcRouter extends AbstractRegistration
     }
 
     @NonNullByDefault
-    private final class ActionAvailabilityFacade implements DOMActionAvailabilityExtension {
+    private final class ActionServiceFacade implements DOMActionService, DOMActionAvailabilityExtension {
         @Override
-        public <T extends AvailabilityListener> ListenerRegistration<T> registerAvailabilityListener(final T listener) {
-            synchronized (DOMRpcRouter.this) {
-                final ActionRegistration<T> ret = new ActionRegistration<>(DOMRpcRouter.this, listener,
-                    actionRoutingTable.getOperations(listener));
-                actionListeners = ImmutableList.<ActionRegistration<?>>builder()
-                    .addAll(actionListeners)
-                    .add(ret)
-                    .build();
-
-                listenerNotifier.execute(ret::initialTable);
-                return ret;
-            }
-        }
-    }
-
-    @NonNullByDefault
-    private final class ActionServiceFacade implements DOMActionService {
-        private final ClassToInstanceMap<DOMActionServiceExtension> extensions = ImmutableClassToInstanceMap.of(
-            DOMActionAvailabilityExtension.class, new ActionAvailabilityFacade());
-
-        @Override
-        public ClassToInstanceMap<DOMActionServiceExtension> getExtensions() {
-            return extensions;
+        public List<Extension> supportedExtensions() {
+            return List.of(this);
         }
 
         @Override
@@ -442,6 +414,21 @@ public final class DOMRpcRouter extends AbstractRegistration
                 : Futures.immediateFailedFuture(
                     new DOMActionNotAvailableException("No implementation of Action %s available", type));
         }
+
+        @Override
+        public Registration registerAvailabilityListener(final AvailabilityListener listener) {
+            synchronized (DOMRpcRouter.this) {
+                final var ret = new ActionRegistration<>(DOMRpcRouter.this, listener,
+                    actionRoutingTable.getOperations(listener));
+                actionListeners = ImmutableList.<ActionRegistration<?>>builder()
+                    .addAll(actionListeners)
+                    .add(ret)
+                    .build();
+
+                listenerNotifier.execute(ret::initialTable);
+                return ret;
+            }
+        }
     }
 
     @NonNullByDefault
@@ -471,7 +458,7 @@ public final class DOMRpcRouter extends AbstractRegistration
     private final class RpcServiceFacade implements DOMRpcService {
         @Override
         public ListenableFuture<? extends DOMRpcResult> invokeRpc(final QName type, final ContainerNode input) {
-            final AbstractDOMRpcRoutingTableEntry entry = (AbstractDOMRpcRoutingTableEntry) routingTable.getEntry(type);
+            final var entry = (AbstractDOMRpcRoutingTableEntry) routingTable.getEntry(type);
             if (entry == null) {
                 return Futures.immediateFailedFuture(
                     new DOMRpcImplementationNotAvailableException("No implementation of RPC %s available", type));
@@ -481,9 +468,9 @@ public final class DOMRpcRouter extends AbstractRegistration
         }
 
         @Override
-        public <T extends DOMRpcAvailabilityListener> ListenerRegistration<T> registerRpcListener(final T listener) {
+        public Registration registerRpcListener(final DOMRpcAvailabilityListener listener) {
             synchronized (DOMRpcRouter.this) {
-                final RegImpl<T> ret = new RegImpl<>(DOMRpcRouter.this, listener, routingTable.getOperations(listener));
+                final var ret = new RegImpl<>(DOMRpcRouter.this, listener, routingTable.getOperations(listener));
                 listeners = ImmutableList.<RegImpl<?>>builder().addAll(listeners).add(ret).build();
 
                 listenerNotifier.execute(ret::initialTable);
@@ -520,8 +507,7 @@ public final class DOMRpcRouter extends AbstractRegistration
         }
 
         @Override
-        public org.opendaylight.yangtools.concepts.Registration registerRpcImplementations(
-                final Map<DOMRpcIdentifier, DOMRpcImplementation> map) {
+        public Registration registerRpcImplementations(final Map<DOMRpcIdentifier, DOMRpcImplementation> map) {
             checkArgument(!map.isEmpty());
 
             final var builder = ImmutableTable.<QName, YangInstanceIdentifier, DOMRpcImplementation>builder();