*/
package org.opendaylight.mdsal.binding.api;
-import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableSet;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.yangtools.concepts.ObjectRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.Action;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
* and implementations can be invoked dynamically at runtime, via {@link ActionService}. Implementations registered
* with this interface may throw {@link IllegalArgumentException}s when they encounter inconsistent input data and
* {@link IllegalStateException} in they are unable to service the request.
- *
- * @author Robert Varga
*/
-@Beta
public interface ActionProviderService extends BindingService {
/**
* Register an implementation of an action, potentially constrained to a set of nodes.
* @param datastore {@link LogicalDatastoreType} on which the implementation operates
* @param validNodes Set of nodes this implementation is constrained to, empty if this implementation can handle
* any target node.
- * @return An {@link ObjectRegistration}
+ * @return A {@link Registration}
* @throws NullPointerException if any of the arguments is null
* @throws IllegalArgumentException if any of the {@code validNodes} does not match {@code datastore}
* @throws UnsupportedOperationException if this service cannot handle requested datastore
*/
- <P extends DataObject, A extends Action<? extends InstanceIdentifier<P>, ?, ?>, S extends A>
- @NonNull ObjectRegistration<S> registerImplementation(@NonNull ActionSpec<A, P> spec, @NonNull S implementation,
+ <P extends DataObject, A extends Action<? extends InstanceIdentifier<P>, ?, ?>>
+ @NonNull Registration registerImplementation(@NonNull ActionSpec<A, P> spec, @NonNull A implementation,
@NonNull LogicalDatastoreType datastore, @NonNull Set<? extends InstanceIdentifier<P>> validNodes);
- default <P extends DataObject, T extends Action<? extends InstanceIdentifier<P>, ?, ?>, S extends T>
- @NonNull ObjectRegistration<S> registerImplementation(final @NonNull ActionSpec<T, P> spec,
- final @NonNull S implementation, final @NonNull LogicalDatastoreType datastore) {
+ default <P extends DataObject, A extends Action<? extends InstanceIdentifier<P>, ?, ?>>
+ @NonNull Registration registerImplementation(final @NonNull ActionSpec<A, P> spec,
+ final @NonNull A implementation, final @NonNull LogicalDatastoreType datastore) {
return registerImplementation(spec, implementation, datastore, ImmutableSet.of());
}
- default <P extends DataObject, T extends Action<? extends InstanceIdentifier<P>, ?, ?>, S extends T>
- @NonNull ObjectRegistration<S> registerImplementation(final @NonNull ActionSpec<T, P> spec,
- final @NonNull S implementation) {
+ default <P extends DataObject, A extends Action<? extends InstanceIdentifier<P>, ?, ?>>
+ @NonNull Registration registerImplementation(final @NonNull ActionSpec<A, P> spec,
+ final @NonNull A implementation) {
return registerImplementation(spec, implementation, LogicalDatastoreType.OPERATIONAL);
}
}
*/
package org.opendaylight.mdsal.binding.api;
-import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableSet;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
/**
* Provides access to registered {@code action} implementations. Each action is defined in a YANG model,
* and implementations are added dynamically at runtime, via {@link ActionProviderService}.
- *
- * @author Robert Varga
*/
-@Beta
@NonNullByDefault
public interface ActionService extends BindingService {
/**
package org.opendaylight.mdsal.binding.api;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.concepts.ObjectRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.DataObject;
/**
- * Commit Cohort registry.
- *
- * <p>
- * See {@link DataTreeCommitCohort} for more details.
- *
- * @author Tony Tkacik <ttkacik@cisco.com>
+ * Commit Cohort registry. See {@link DataTreeCommitCohort} for more details.
*/
public interface DataTreeCommitCohortRegistry {
/**
- * Register commit cohort which will participate in three-phase commit protocols of write
- * transaction in data broker associated with this instance of extension.
+ * Register commit cohort which will participate in three-phase commit protocols of write transaction in data broker
+ * associated with this instance of extension.
*
* @param subtree Subtree path on which commit cohort operates.
* @param cohort Commit cohort
- * @return Registaration object for DOM Data Three Commit cohort.
+ * @return Registration object for DOM Data Three Commit cohort.
*/
- <D extends DataObject, T extends DataTreeCommitCohort<D>> @NonNull ObjectRegistration<T> registerCommitCohort(
- @NonNull DataTreeIdentifier<D> subtree, @NonNull T cohort);
+ <D extends DataObject> @NonNull Registration registerCommitCohort(@NonNull DataTreeIdentifier<D> subtree,
+ @NonNull DataTreeCommitCohort<D> cohort);
}
import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
import org.opendaylight.mdsal.dom.api.DOMService;
import org.opendaylight.mdsal.dom.spi.SimpleDOMActionResult;
-import org.opendaylight.yangtools.concepts.AbstractObjectRegistration;
-import org.opendaylight.yangtools.concepts.ObjectRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.Action;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
}
@Override
- public <P extends DataObject, A extends Action<? extends InstanceIdentifier<P>, ?, ?>, S extends A>
- ObjectRegistration<S> registerImplementation(final ActionSpec<A, P> spec, final S implementation,
+ public <P extends DataObject, A extends Action<? extends InstanceIdentifier<P>, ?, ?>>
+ Registration registerImplementation(final ActionSpec<A, P> spec, final A implementation,
final LogicalDatastoreType datastore, final Set<? extends InstanceIdentifier<P>> validNodes) {
final CurrentAdapterSerializer serializer = currentSerializer();
final Absolute actionPath = serializer.getActionPath(spec);
.collect(Collectors.toUnmodifiableSet()));
- final ObjectRegistration<?> reg = getDelegate().registerActionImplementation(impl, instance);
-
- return new AbstractObjectRegistration<>(implementation) {
- @Override
- protected void removeRegistration() {
- reg.close();
- }
- };
+ return getDelegate().registerActionImplementation(impl, instance);
}
private static final class Impl implements DOMActionImplementation {
import org.opendaylight.mdsal.binding.api.DataTreeCommitCohortRegistry;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry;
-import org.opendaylight.yangtools.concepts.ObjectRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.DataObject;
}
@Override
- public <D extends DataObject, T extends DataTreeCommitCohort<D>> ObjectRegistration<T> registerCommitCohort(
- final DataTreeIdentifier<D> subtree, final T cohort) {
+ public <D extends DataObject> Registration registerCommitCohort(final DataTreeIdentifier<D> subtree,
+ final DataTreeCommitCohort<D> cohort) {
final var target = subtree.path().getTargetType();
final var adapter = new BindingDOMDataTreeCommitCohortAdapter<>(adapterContext(), cohort,
Augmentation.class.isAssignableFrom(target) ? target : null);
final var domPath = currentSerializer().toDOMDataTreeIdentifier(subtree);
- final var domReg = getDelegate().registerCommitCohort(domPath, adapter);
- return new ObjectRegistration<>() {
- @Override
- public T getInstance() {
- return cohort;
- }
-
- @Override
- public void close() {
- domReg.close();
- }
- };
+ return getDelegate().registerCommitCohort(domPath, adapter);
}
}
import org.opendaylight.mdsal.binding.api.ActionProviderService;
import org.opendaylight.mdsal.binding.api.ActionSpec;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.yangtools.concepts.ObjectRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.Action;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
}
@Override
- public <P extends DataObject, A extends Action<? extends InstanceIdentifier<P>, ?, ?>, S extends A>
- ObjectRegistration<S> registerImplementation(final ActionSpec<A, P> spec, final S implementation,
- final LogicalDatastoreType datastore, final Set<? extends InstanceIdentifier<P>> validNodes) {
+ public <P extends DataObject, A extends Action<? extends InstanceIdentifier<P>, ?, ?>>
+ Registration registerImplementation(final ActionSpec<A, P> spec, final A implementation,
+ final LogicalDatastoreType datastore, final Set<? extends InstanceIdentifier<P>> validNodes) {
return delegate.registerImplementation(spec, implementation, datastore, validNodes);
}
}
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import static org.junit.jupiter.api.Assertions.assertSame;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
import com.google.common.util.concurrent.MoreExecutors;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
import org.opendaylight.mdsal.binding.api.DataTreeCommitCohort;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.opendaylight.mdsal.binding.dom.adapter.test.util.BindingBrokerTestFactory;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+@ExtendWith(MockitoExtension.class)
public class BindingDOMDataTreeCommitCohortRegistryAdapterTest {
+ @Mock
+ private DOMDataTreeCommitCohortRegistry cohortRegistry;
+ @Mock
+ private Registration cohortRegistration;
+ @Mock
+ private DataTreeCommitCohort<Top> dataTreeCommitCohort;
+
@Test
void basicTest() {
final var bindingBrokerTestFactory = new BindingBrokerTestFactory();
final var bindingTestContext = bindingBrokerTestFactory.getTestContext();
bindingTestContext.start();
- final var cohortRegistry = mock(DOMDataTreeCommitCohortRegistry.class);
- final var cohortRegistration = mock(Registration.class);
doReturn(cohortRegistration).when(cohortRegistry).registerCommitCohort(any(), any());
doNothing().when(cohortRegistration).close();
final var registryAdapter = new BindingDOMDataTreeCommitCohortRegistryAdapter(bindingTestContext.getCodec(),
final var dataTreeIdentifier = DataTreeIdentifier.of(LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.create(Top.class));
- final DataTreeCommitCohort<Top> dataTreeCommitCohort = mock(DataTreeCommitCohort.class);
- try (var objectRegistration = registryAdapter.registerCommitCohort(dataTreeIdentifier, dataTreeCommitCohort)) {
- assertSame(dataTreeCommitCohort, objectRegistration.getInstance());
+ try (var reg = registryAdapter.registerCommitCohort(dataTreeIdentifier, dataTreeCommitCohort)) {
+ // Nothing else
}
- verify(cohortRegistration).close();
}
}
\ No newline at end of file
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.runtime.api.ModuleInfoSnapshot;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
-import org.opendaylight.yangtools.concepts.AbstractObjectRegistration;
+import org.opendaylight.yangtools.concepts.AbstractRegistration;
import org.opendaylight.yangtools.concepts.Mutable;
-import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.DataRoot;
import org.opendaylight.yangtools.yang.binding.YangFeature;
return ctxResolver.registerSupportedFeatures(BindingReflections.getQNameModule(module), features);
}
- public synchronized List<ObjectRegistration<YangModuleInfo>> registerModuleInfos(
- final Iterable<? extends YangModuleInfo> moduleInfos) {
- final var ret = new ArrayList<ObjectRegistration<YangModuleInfo>>();
+ public synchronized List<Registration> registerModuleInfos(final Iterable<? extends YangModuleInfo> moduleInfos) {
+ final var ret = new ArrayList<Registration>();
for (var moduleInfo : moduleInfos) {
ret.add(register(requireNonNull(moduleInfo)));
}
}
@Holding("this")
- private ObjectRegistration<YangModuleInfo> register(final @NonNull YangModuleInfo moduleInfo) {
+ private Registration register(final @NonNull YangModuleInfo moduleInfo) {
final var regInfos = flatDependencies(moduleInfo).stream()
.map(this::registerModuleInfo)
.collect(ImmutableList.toImmutableList());
- return new AbstractObjectRegistration<>(moduleInfo) {
+ return new AbstractRegistration() {
@Override
protected void removeRegistration() {
unregister(regInfos);
*/
package org.opendaylight.mdsal.dom.api;
-import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableSet;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.opendaylight.yangtools.concepts.ObjectRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
/**
* A {@link DOMService} which allows registration of action implementations with a conceptual router. The client
* counterpart of this service is {@link DOMActionService}.
*/
-@Beta
@NonNullByDefault
public interface DOMActionProviderService
extends DOMService<DOMActionProviderService, DOMActionProviderService.Extension> {
*
* @param implementation action implementation, must not be null
* @param instances Set of supported operation identifiers. Must not be null, empty, or contain a null element.
- * @return A {@link ObjectRegistration} object, guaranteed to be non-null.
+ * @return A {@link Registration} object, guaranteed to be non-null.
* @throws NullPointerException if {@code implementation} or {@code instances} is null, or if {@code instances}
* contains a null element.
* @throws IllegalArgumentException if {@code instances} is empty
*/
- <T extends DOMActionImplementation> ObjectRegistration<T> registerActionImplementation(T implementation,
- Set<DOMActionInstance> instances);
+ Registration registerActionImplementation(DOMActionImplementation implementation, Set<DOMActionInstance> instances);
/**
* Register an {@link DOMActionImplementation} object with this service, servicing specified action instance.
*
* @param implementation action implementation, must not be null
* @param instance supported operation identifier. Must not be null.
- * @return A {@link ObjectRegistration} object, guaranteed to be non-null.
+ * @return A {@link Registration} object, guaranteed to be non-null.
* @throws NullPointerException if any argument is null
*/
- default <T extends DOMActionImplementation> ObjectRegistration<T> registerActionImplementation(
- final T implementation, final DOMActionInstance instance) {
+ default Registration registerActionImplementation(final DOMActionImplementation implementation,
+ final DOMActionInstance instance) {
return registerActionImplementation(implementation, ImmutableSet.of(instance));
}
*
* @param implementation action implementation, must not be null
* @param instances Set of supported operation identifiers. Must not be null, empty, or contain a null element.
- * @return A {@link ObjectRegistration} object, guaranteed to be non-null.
+ * @return A {@link Registration} object, guaranteed to be non-null.
* @throws NullPointerException if {@code implementation} or {@code instances} is null, or if {@code instances}
* contains a null element.
* @throws IllegalArgumentException if {@code instances} is empty
*/
- default <T extends DOMActionImplementation> ObjectRegistration<T> registerActionImplementation(
- final T implementation, final DOMActionInstance... instances) {
+ default Registration registerActionImplementation(final DOMActionImplementation implementation,
+ final DOMActionInstance... instances) {
return registerActionImplementation(implementation, ImmutableSet.copyOf(instances));
}
}
*/
package org.opendaylight.mdsal.dom.broker;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMultimap;
import org.opendaylight.mdsal.dom.api.DOMNotificationPublishDemandExtension.DemandListener;
import org.opendaylight.mdsal.dom.api.DOMNotificationPublishService;
import org.opendaylight.mdsal.dom.api.DOMNotificationService;
-import org.opendaylight.yangtools.concepts.AbstractObjectRegistration;
import org.opendaylight.yangtools.concepts.AbstractRegistration;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.util.ObjectRegistry;
}
@VisibleForTesting
- abstract static sealed class Reg extends AbstractObjectRegistration<DOMNotificationListener> {
+ abstract static sealed class Reg extends AbstractRegistration {
+ private final @NonNull DOMNotificationListener listener;
+
Reg(final @NonNull DOMNotificationListener listener) {
- super(listener);
+ this.listener = requireNonNull(listener);
}
}
private static void deliverEvents(final Reg reg, final ImmutableList<DOMNotificationRouterEvent> events) {
if (reg.notClosed()) {
- final var listener = reg.getInstance();
+ final var listener = reg.listener;
for (var event : events) {
event.deliverTo(listener);
}
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
import org.opendaylight.mdsal.dom.api.DOMRpcService;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
-import org.opendaylight.yangtools.concepts.AbstractObjectRegistration;
import org.opendaylight.yangtools.concepts.AbstractRegistration;
-import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
private final @NonNull DOMRpcService rpcService = new RpcServiceFacade();
@GuardedBy("this")
- private ImmutableList<RegImpl> listeners = ImmutableList.of();
+ private ImmutableList<RpcAvailReg> listeners = ImmutableList.of();
@GuardedBy("this")
- private ImmutableList<ActionRegistration> actionListeners = ImmutableList.of();
+ private ImmutableList<ActionAvailReg> actionListeners = ImmutableList.of();
private volatile DOMRpcRoutingTable routingTable = DOMRpcRoutingTable.EMPTY;
listenerNotifier.execute(() -> notifyActionChanged(newTable, implementation));
}
- private synchronized void removeListener(final RegImpl reg) {
+ private synchronized void removeListener(final RpcAvailReg reg) {
listeners = ImmutableList.copyOf(Collections2.filter(listeners, input -> !reg.equals(input)));
}
- private synchronized void removeActionListener(final ActionRegistration reg) {
+ private synchronized void removeActionListener(final ActionAvailReg reg) {
actionListeners = ImmutableList.copyOf(Collections2.filter(actionListeners, input -> !reg.equals(input)));
}
return routingTable;
}
- private static final class RegImpl extends AbstractObjectRegistration<DOMRpcAvailabilityListener> {
+ private static final class RpcAvailReg extends AbstractRegistration {
+ private final DOMRpcAvailabilityListener listener;
+
private Map<QName, Set<YangInstanceIdentifier>> prevRpcs;
private DOMRpcRouter router;
- RegImpl(final DOMRpcRouter router, final DOMRpcAvailabilityListener listener,
+ RpcAvailReg(final DOMRpcRouter router, final DOMRpcAvailabilityListener listener,
final Map<QName, Set<YangInstanceIdentifier>> rpcs) {
- super(listener);
+ this.listener = requireNonNull(listener);
this.router = requireNonNull(router);
prevRpcs = requireNonNull(rpcs);
}
added.addAll(Collections2.transform(e.getValue(), i -> DOMRpcIdentifier.create(e.getKey(), i)));
}
if (!added.isEmpty()) {
- getInstance().onRpcAvailable(added);
+ listener.onRpcAvailable(added);
}
}
void addRpc(final DOMRpcRoutingTable newTable, final DOMRpcImplementation impl) {
- final var l = getInstance();
- if (!l.acceptsImplementation(impl)) {
+ if (!listener.acceptsImplementation(impl)) {
return;
}
- final Map<QName, Set<YangInstanceIdentifier>> rpcs = verifyNotNull(newTable.getOperations(l));
+ final Map<QName, Set<YangInstanceIdentifier>> rpcs = verifyNotNull(newTable.getOperations(listener));
final MapDifference<QName, Set<YangInstanceIdentifier>> diff = Maps.difference(prevRpcs, rpcs);
final List<DOMRpcIdentifier> added = new ArrayList<>();
prevRpcs = rpcs;
if (!added.isEmpty()) {
- l.onRpcAvailable(added);
+ listener.onRpcAvailable(added);
}
}
void removeRpc(final DOMRpcRoutingTable newTable, final DOMRpcImplementation impl) {
- final var l = getInstance();
- if (!l.acceptsImplementation(impl)) {
+ if (!listener.acceptsImplementation(impl)) {
return;
}
- final Map<QName, Set<YangInstanceIdentifier>> rpcs = verifyNotNull(newTable.getOperations(l));
+ final Map<QName, Set<YangInstanceIdentifier>> rpcs = verifyNotNull(newTable.getOperations(listener));
final MapDifference<QName, Set<YangInstanceIdentifier>> diff = Maps.difference(prevRpcs, rpcs);
final List<DOMRpcIdentifier> removed = new ArrayList<>();
prevRpcs = rpcs;
if (!removed.isEmpty()) {
- l.onRpcUnavailable(removed);
+ listener.onRpcUnavailable(removed);
}
}
}
- private static final class ActionRegistration extends AbstractObjectRegistration<AvailabilityListener> {
+ private static final class ActionAvailReg extends AbstractRegistration {
+ private final AvailabilityListener listener;
+
private Map<Absolute, Set<DOMDataTreeIdentifier>> prevActions;
private DOMRpcRouter router;
- ActionRegistration(final DOMRpcRouter router, final AvailabilityListener listener,
+ ActionAvailReg(final DOMRpcRouter router, final AvailabilityListener listener,
final Map<Absolute, Set<DOMDataTreeIdentifier>> actions) {
- super(listener);
+ this.listener = requireNonNull(listener);
this.router = requireNonNull(router);
prevActions = requireNonNull(actions);
}
added.addAll(Collections2.transform(e.getValue(), i -> DOMActionInstance.of(e.getKey(), i)));
}
if (!added.isEmpty()) {
- getInstance().onActionsChanged(ImmutableSet.of(), ImmutableSet.copyOf(added));
+ listener.onActionsChanged(ImmutableSet.of(), ImmutableSet.copyOf(added));
}
}
void actionChanged(final DOMActionRoutingTable newTable, final DOMActionImplementation impl) {
- final var l = getInstance();
- if (!l.acceptsImplementation(impl)) {
+ if (!listener.acceptsImplementation(impl)) {
return;
}
- final Map<Absolute, Set<DOMDataTreeIdentifier>> actions = verifyNotNull(newTable.getOperations(l));
+ final Map<Absolute, Set<DOMDataTreeIdentifier>> actions = verifyNotNull(newTable.getOperations(listener));
final MapDifference<Absolute, Set<DOMDataTreeIdentifier>> diff = Maps.difference(prevActions, actions);
final Set<DOMActionInstance> removed = new HashSet<>();
prevActions = actions;
if (!removed.isEmpty() || !added.isEmpty()) {
- l.onActionsChanged(removed, added);
+ listener.onActionsChanged(removed, added);
}
}
}
@Override
public Registration registerAvailabilityListener(final AvailabilityListener listener) {
synchronized (DOMRpcRouter.this) {
- final var ret = new ActionRegistration(DOMRpcRouter.this, listener,
+ final var ret = new ActionAvailReg(DOMRpcRouter.this, listener,
actionRoutingTable.getOperations(listener));
- actionListeners = ImmutableList.<ActionRegistration>builder()
+ actionListeners = ImmutableList.<ActionAvailReg>builder()
.addAll(actionListeners)
.add(ret)
.build();
@NonNullByDefault
private final class ActionProviderServiceFacade implements DOMActionProviderService {
@Override
- public <T extends DOMActionImplementation> ObjectRegistration<T> registerActionImplementation(
- final T implementation, final Set<DOMActionInstance> instances) {
+ public Registration registerActionImplementation(final DOMActionImplementation implementation,
+ final Set<DOMActionInstance> instances) {
checkArgument(!instances.isEmpty(), "Instances must not be empty");
synchronized (DOMRpcRouter.this) {
listenerNotifier.execute(() -> notifyActionChanged(newTable, implementation));
}
- return new AbstractObjectRegistration<>(implementation) {
+ return new AbstractRegistration() {
@Override
protected void removeRegistration() {
- removeActionImplementation(getInstance(), instances);
+ removeActionImplementation(implementation, instances);
}
};
}
@Override
public Registration registerRpcListener(final DOMRpcAvailabilityListener listener) {
synchronized (DOMRpcRouter.this) {
- final var ret = new RegImpl(DOMRpcRouter.this, listener, routingTable.getOperations(listener));
- listeners = ImmutableList.<RegImpl>builder().addAll(listeners).add(ret).build();
+ final var ret = new RpcAvailReg(DOMRpcRouter.this, listener, routingTable.getOperations(listener));
+ listeners = ImmutableList.<RpcAvailReg>builder().addAll(listeners).add(ret).build();
listenerNotifier.execute(ret::initialTable);
return ret;
import org.opendaylight.mdsal.binding.runtime.api.ModuleInfoSnapshot;
import org.opendaylight.mdsal.binding.runtime.spi.ModuleInfoSnapshotResolver;
import org.opendaylight.yangtools.concepts.AbstractRegistration;
-import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.DataRoot;
import org.opendaylight.yangtools.yang.binding.YangFeatureProvider;
@Override
protected void removeRegistration() {
featureRegs.forEach(Registration::close);
- infoRegs.forEach(ObjectRegistration::close);
+ infoRegs.forEach(Registration::close);
}
};
}
*/
package org.opendaylight.mdsal.dom.spi;
-import com.google.common.annotations.Beta;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.mdsal.dom.api.DOMActionImplementation;
import org.opendaylight.mdsal.dom.api.DOMActionInstance;
import org.opendaylight.mdsal.dom.api.DOMActionProviderService;
-import org.opendaylight.yangtools.concepts.ObjectRegistration;
+import org.opendaylight.yangtools.concepts.Registration;
-@Beta
@NonNullByDefault
public abstract class ForwardingDOMActionProviderService
extends ForwardingDOMService<DOMActionProviderService, DOMActionProviderService.Extension>
implements DOMActionProviderService {
@Override
- public <T extends DOMActionImplementation> ObjectRegistration<T> registerActionImplementation(
- final T implementation, final Set<DOMActionInstance> instances) {
+ public Registration registerActionImplementation(final DOMActionImplementation implementation,
+ final Set<DOMActionInstance> instances) {
return delegate().registerActionImplementation(implementation, instances);
}
}