private DataProviderService dataService;
private IForwardingRulesManager manager;
- public Registration<DataCommitHandler<InstanceIdentifier<? extends DataObject>, DataObject>> init() {
+ public Registration init() {
return this.dataService.registerCommitHandler(FRMRuntimeDataProvider.FLOWS_PATH, this);
}
import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
-import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final BlockingQueue<InventoryOperation> queue = new LinkedBlockingDeque<>(QUEUE_DEPTH);
private final NotificationProviderService notificationService;
private final DataProviderService dataService;
- private Registration<?> listenerRegistration;
+ private ListenerRegistration<?> listenerRegistration;
private Thread thread;
FlowCapableInventoryProvider(final DataProviderService dataService, final NotificationProviderService notificationService) {
* @deprecated Data Reader contract is removed from capabilities of MD-SAL and is replaced by replaced by org.opendaylight.controller.sal.core.spi.data.DOMStore contract.
*/
@Deprecated
- Registration<DataReader<InstanceIdentifier<? extends DataObject>,DataObject>> registerDataReader(InstanceIdentifier<? extends DataObject> path,DataReader<InstanceIdentifier<? extends DataObject>,DataObject> reader);
+ Registration registerDataReader(InstanceIdentifier<? extends DataObject> path,DataReader<InstanceIdentifier<? extends DataObject>,DataObject> reader);
}
}
@Override
- public Registration<DataCommitHandler<InstanceIdentifier<? extends DataObject>, DataObject>> registerCommitHandler(
+ public Registration registerCommitHandler(
final InstanceIdentifier<? extends DataObject> path,
final DataCommitHandler<InstanceIdentifier<? extends DataObject>, DataObject> commitHandler) {
}
@Override
- public Registration<DataReader<InstanceIdentifier<? extends DataObject>, DataObject>> registerDataReader(
+ public Registration registerDataReader(
final InstanceIdentifier<? extends DataObject> path,
final DataReader<InstanceIdentifier<? extends DataObject>, DataObject> reader) {
throw new UnsupportedOperationException("Data reader contract is not supported.");
}
@Override
- public Registration<DataReader<InstanceIdentifier<? extends DataObject>, DataObject>> registerConfigurationReader(
+ public Registration registerConfigurationReader(
final InstanceIdentifier<? extends DataObject> path,
final DataReader<InstanceIdentifier<? extends DataObject>, DataObject> reader) {
throw new UnsupportedOperationException("Not supported");
}
@Override
- public Registration<DataReader<InstanceIdentifier<? extends DataObject>, DataObject>> registerOperationalReader(
+ public Registration registerOperationalReader(
final InstanceIdentifier<? extends DataObject> path,
final DataReader<InstanceIdentifier<? extends DataObject>, DataObject> reader) {
throw new UnsupportedOperationException("Not supported");
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import org.opendaylight.controller.md.sal.binding.impl.AbstractForwardedDataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler;
import org.opendaylight.controller.md.sal.common.api.routing.RouteChangePublisher;
import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
private final BindingToDomCommitHandler bindingToDomCommitHandler;
private final DomToBindingCommitHandler domToBindingCommitHandler;
- private Registration<DataCommitHandler<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode>> biCommitHandlerRegistration;
+ private Registration biCommitHandlerRegistration;
private RpcProvisionRegistry biRpcRegistry;
private RpcProviderRegistry baRpcRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SwitchFlowRemoved;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowCookie;
-import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.NotificationListener;
import org.opendaylight.yangtools.yang.binding.RpcService;
private final FlowListener listener1 = new FlowListener();
private final FlowListener listener2 = new FlowListener();
- private Registration<NotificationListener> listener1Reg;
- private Registration<NotificationListener> listener2Reg;
+ private ListenerRegistration<NotificationListener> listener1Reg;
+ private ListenerRegistration<NotificationListener> listener2Reg;
private NotificationProviderService notifyProviderService;
}
@Override
- public Registration<DataReader<InstanceIdentifier<? extends DataObject>, DataObject>> registerDataReader(
+ public Registration registerDataReader(
InstanceIdentifier<? extends DataObject> path,
DataReader<InstanceIdentifier<? extends DataObject>, DataObject> reader) {
return getDataBrokerChecked().registerDataReader(path, reader);
}
@Override
- public Registration<DataCommitHandler<InstanceIdentifier<? extends DataObject>, DataObject>> registerCommitHandler(
+ public Registration registerCommitHandler(
InstanceIdentifier<? extends DataObject> path,
DataCommitHandler<InstanceIdentifier<? extends DataObject>, DataObject> commitHandler) {
return getDataBrokerChecked().registerCommitHandler(path, commitHandler);
import org.opendaylight.yangtools.concepts.Registration;
-public interface RegistrationListener<T extends Registration<?>> extends EventListener {
+public interface RegistrationListener<T extends Registration> extends EventListener {
void onRegister(T registration);
* @param <D>
*/
@Deprecated
-public interface DataCommitHandlerRegistration<P extends Path<P>,D> extends Registration<DataCommitHandler<P, D>>{
+public interface DataCommitHandlerRegistration<P extends Path<P>,D> extends Registration {
P getPath();
}
@Deprecated
public interface DataProvisionService<P extends Path<P> , D> {
- public Registration<DataCommitHandler<P, D>> registerCommitHandler(P path, DataCommitHandler<P, D> commitHandler);
+ public Registration registerCommitHandler(P path, DataCommitHandler<P, D> commitHandler);
public ListenerRegistration<RegistrationListener<DataCommitHandlerRegistration<P, D>>>
registerCommitHandlerListener(RegistrationListener<DataCommitHandlerRegistration<P, D>> commitHandlerListener);
*/
package org.opendaylight.controller.md.sal.common.api.notify;
-import org.opendaylight.yangtools.concepts.Registration;
+import java.util.EventListener;
-public interface NotificationSubscriptionService<T,N,L> {
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
- Registration<L> registerNotificationListener(T type,L listener);
+public interface NotificationSubscriptionService<T,N,L extends EventListener> {
+
+ ListenerRegistration<L> registerNotificationListener(T type,L listener);
}
* @param <P> the path identifier type
* @param <S> the RPC implementation type
*/
-public interface RoutedRegistration<C, P extends Path<P>, S> extends Registration<S> {
+public interface RoutedRegistration<C, P extends Path<P>, S> extends Registration {
/**
* Registers the RPC implementation associated with this registration for the given path
* @param reader Reader instance which is responsible for reading particular subpath.
* @return
*/
- public Registration<DataReader<P, D>> registerOperationalReader(P path, DataReader<P, D> reader) {
+ public Registration registerOperationalReader(P path, DataReader<P, D> reader) {
OperationalDataReaderRegistration<P, D> ret = new OperationalDataReaderRegistration<>(path, reader);
operationalReaders.put(path, ret);
return ret;
}
- public Registration<DataReader<P, D>> registerConfigurationReader(P path, DataReader<P, D> reader) {
+ public Registration registerConfigurationReader(P path, DataReader<P, D> reader) {
ConfigurationDataReaderRegistration<P, D> ret = new ConfigurationDataReaderRegistration<>(path, reader);
configReaders.put(path, ret);
return ret;
}
@Override
- public final Registration<DataCommitHandler<P, D>> registerCommitHandler(final P path,
+ public final Registration registerCommitHandler(final P path,
final DataCommitHandler<P, D> commitHandler) {
synchronized (commitHandler) {
final DataCommitHandlerRegistrationImpl<P, D> registration = new DataCommitHandlerRegistrationImpl<P, D>(
public final CompositeObjectRegistration<DataReader<P, D>> registerDataReader(final P path,
final DataReader<P, D> reader) {
- final Registration<DataReader<P, D>> confReg = getDataReadRouter().registerConfigurationReader(path, reader);
- final Registration<DataReader<P, D>> dataReg = getDataReadRouter().registerOperationalReader(path, reader);
+ final Registration confReg = getDataReadRouter().registerConfigurationReader(path, reader);
+ final Registration dataReg = getDataReadRouter().registerOperationalReader(path, reader);
return new CompositeObjectRegistration<DataReader<P, D>>(reader, Arrays.asList(confReg, dataReg));
}
void removeRefresher(DataStoreIdentifier store, DataRefresher refresher);
- Registration<DataReader<InstanceIdentifier, CompositeNode>> registerConfigurationReader(InstanceIdentifier path, DataReader<InstanceIdentifier, CompositeNode> reader);
+ Registration registerConfigurationReader(InstanceIdentifier path, DataReader<InstanceIdentifier, CompositeNode> reader);
- Registration<DataReader<InstanceIdentifier, CompositeNode>> registerOperationalReader(InstanceIdentifier path, DataReader<InstanceIdentifier, CompositeNode> reader);
+ Registration registerOperationalReader(InstanceIdentifier path, DataReader<InstanceIdentifier, CompositeNode> reader);
public interface DataRefresher extends Provider.ProviderFunctionality {
package org.opendaylight.controller.sal.core.api.notify;
import org.opendaylight.controller.sal.core.api.BrokerService;
-import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.QName;
* @param notification
* @param listener
*/
- Registration<NotificationListener> addNotificationListener(QName notification,
+ ListenerRegistration<NotificationListener> addNotificationListener(QName notification,
NotificationListener listener);
}
}
@Override
- public Registration<DataCommitHandler<InstanceIdentifier, CompositeNode>> registerCommitHandler(
+ public Registration registerCommitHandler(
final InstanceIdentifier path, final DataCommitHandler<InstanceIdentifier, CompositeNode> commitHandler) {
// FIXME Do real forwarding
return new AbstractObjectRegistration<DataCommitHandler<InstanceIdentifier,CompositeNode>>(commitHandler) {
}
@Override
- public Registration<DataReader<InstanceIdentifier, CompositeNode>> registerConfigurationReader(
+ public Registration registerConfigurationReader(
final InstanceIdentifier path, final DataReader<InstanceIdentifier, CompositeNode> reader) {
throw new UnsupportedOperationException("Data Reader contract is not supported.");
}
@Override
- public Registration<DataReader<InstanceIdentifier, CompositeNode>> registerOperationalReader(
+ public Registration registerOperationalReader(
final InstanceIdentifier path, final DataReader<InstanceIdentifier, CompositeNode> reader) {
throw new UnsupportedOperationException("Data Reader contract is not supported.");
}
}
@Override
- public Registration<DataReader<InstanceIdentifier, CompositeNode>> registerConfigurationReader(
+ public Registration registerConfigurationReader(
InstanceIdentifier path, DataReader<InstanceIdentifier, CompositeNode> reader) {
return getDataReadRouter().registerConfigurationReader(path, reader);
}
@Override
- public Registration<DataReader<InstanceIdentifier, CompositeNode>> registerOperationalReader(
+ public Registration registerOperationalReader(
InstanceIdentifier path, DataReader<InstanceIdentifier, CompositeNode> reader) {
return getDataReadRouter().registerOperationalReader(path, reader);
}
private final BundleContext context;
private ServiceTracker<SchemaServiceListener, SchemaServiceListener> listenerTracker;
- private BundleTracker<Iterable<Registration<URL>>> bundleTracker;
+ private BundleTracker<Iterable<Registration>> bundleTracker;
private boolean starting = true;
private static GlobalBundleScanningSchemaServiceImpl instance;
}
}
- private class BundleScanner implements BundleTrackerCustomizer<Iterable<Registration<URL>>> {
+ private class BundleScanner implements BundleTrackerCustomizer<Iterable<Registration>> {
@Override
- public Iterable<Registration<URL>> addingBundle(final Bundle bundle, final BundleEvent event) {
+ public Iterable<Registration> addingBundle(final Bundle bundle, final BundleEvent event) {
if (bundle.getBundleId() == 0) {
return Collections.emptyList();
return Collections.emptyList();
}
- final List<Registration<URL>> urls = new ArrayList<>();
+ final List<Registration> urls = new ArrayList<>();
while (enumeration.hasMoreElements()) {
final URL u = enumeration.nextElement();
try {
}
@Override
- public void modifiedBundle(final Bundle bundle, final BundleEvent event, final Iterable<Registration<URL>> object) {
+ public void modifiedBundle(final Bundle bundle, final BundleEvent event, final Iterable<Registration> object) {
LOG.debug("Modified bundle {} {} {}", bundle, event, object);
}
*/
@Override
- public synchronized void removedBundle(final Bundle bundle, final BundleEvent event, final Iterable<Registration<URL>> urls) {
- for (Registration<URL> url : urls) {
+ public synchronized void removedBundle(final Bundle bundle, final BundleEvent event, final Iterable<Registration> urls) {
+ for (Registration url : urls) {
try {
url.close();
} catch (Exception e) {
}
@Override
- public Registration<NotificationListener> addNotificationListener(final QName notification, final NotificationListener listener) {
+ public ListenerRegistration<NotificationListener> addNotificationListener(final QName notification, final NotificationListener listener) {
return notificationRouter.addNotificationListener(notification, listener);
}
}
@Override
- public Registration<DataReader<InstanceIdentifier, CompositeNode>> registerOperationalReader(
+ public Registration registerOperationalReader(
final InstanceIdentifier path, final DataReader<InstanceIdentifier, CompositeNode> reader) {
return dataReader.registerOperationalReader(path, reader);
}
@Override
- public Registration<DataReader<InstanceIdentifier, CompositeNode>> registerConfigurationReader(
+ public Registration registerConfigurationReader(
final InstanceIdentifier path, final DataReader<InstanceIdentifier, CompositeNode> reader) {
return dataReader.registerConfigurationReader(path, reader);
}
}
@Override
- public Registration<DataCommitHandler<InstanceIdentifier, CompositeNode>> registerCommitHandler(
+ public Registration registerCommitHandler(
final InstanceIdentifier path, final DataCommitHandler<InstanceIdentifier, CompositeNode> commitHandler) {
return dataReader.registerCommitHandler(path, commitHandler);
}
import org.opendaylight.controller.sal.core.api.notify.NotificationListener;
import org.opendaylight.controller.sal.dom.broker.spi.NotificationRouter;
import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
-import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.slf4j.Logger;
public class NotificationRouterImpl implements NotificationRouter {
private static Logger log = LoggerFactory.getLogger(NotificationRouterImpl.class);
- private final Multimap<QName, ListenerRegistration> listeners = Multimaps.synchronizedSetMultimap(HashMultimap.<QName, ListenerRegistration>create());
+ private final Multimap<QName, MyListenerRegistration> listeners = Multimaps.synchronizedSetMultimap(HashMultimap.<QName, MyListenerRegistration>create());
// private Registration<NotificationListener> defaultListener;
private void sendNotification(CompositeNode notification) {
final QName type = notification.getNodeType();
- final Collection<ListenerRegistration> toNotify = listeners.get(type);
+ final Collection<MyListenerRegistration> toNotify = listeners.get(type);
log.trace("Publishing notification " + type);
if ((toNotify == null) || toNotify.isEmpty()) {
return;
}
- for (ListenerRegistration listener : toNotify) {
+ for (MyListenerRegistration listener : toNotify) {
try {
// FIXME: ensure that notification is immutable
listener.getInstance().onNotification(notification);
}
@Override
- public Registration<NotificationListener> addNotificationListener(QName notification, NotificationListener listener) {
- ListenerRegistration ret = new ListenerRegistration(notification, listener);
+ public ListenerRegistration<NotificationListener> addNotificationListener(QName notification, NotificationListener listener) {
+ MyListenerRegistration ret = new MyListenerRegistration(notification, listener);
listeners.put(notification, ret);
return ret;
}
- private class ListenerRegistration extends AbstractListenerRegistration<NotificationListener> {
+ private class MyListenerRegistration extends AbstractListenerRegistration<NotificationListener> {
final QName type;
- public ListenerRegistration(QName type, NotificationListener instance) {
+ public MyListenerRegistration(QName type, NotificationListener instance) {
super(instance);
this.type = type;
}
return reference;
}
- private final Set<Registration<?>> registrations = Collections.synchronizedSet(new HashSet<Registration<?>>());
+ private final Set<Registration> registrations = Collections.synchronizedSet(new HashSet<Registration>());
- protected <R extends Registration<?>> R addRegistration(final R registration) {
+ protected <R extends Registration> R addRegistration(final R registration) {
if (registration != null) {
registrations.add(registration);
}
RuntimeException potentialException = new RuntimeException(
"Uncaught exceptions occured during unregistration");
boolean hasSuppressed = false;
- for (Registration<?> registration : registrations) {
+ for (Registration registration : registrations) {
try {
registration.close();
} catch (Exception e) {
}
@Override
- public Registration<DataCommitHandler<InstanceIdentifier, CompositeNode>> registerCommitHandler(
+ public Registration registerCommitHandler(
InstanceIdentifier path, DataCommitHandler<InstanceIdentifier, CompositeNode> commitHandler) {
return addRegistration(getDelegate().registerCommitHandler(path, commitHandler));
}
@Override
- public Registration<DataReader<InstanceIdentifier, CompositeNode>> registerConfigurationReader(
+ public Registration registerConfigurationReader(
InstanceIdentifier path, DataReader<InstanceIdentifier, CompositeNode> reader) {
return addRegistration(getDelegate().registerConfigurationReader(path, reader));
}
@Override
- public Registration<DataReader<InstanceIdentifier, CompositeNode>> registerOperationalReader(
+ public Registration registerOperationalReader(
InstanceIdentifier path, DataReader<InstanceIdentifier, CompositeNode> reader) {
return addRegistration(getDelegate().registerOperationalReader(path, reader));
}
import org.opendaylight.controller.sal.core.api.notify.NotificationListener;
import org.opendaylight.controller.sal.core.api.notify.NotificationPublishService;
-import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.osgi.framework.ServiceReference;
}
@Override
- public Registration<NotificationListener> addNotificationListener(QName notification, NotificationListener listener) {
+ public ListenerRegistration<NotificationListener> addNotificationListener(QName notification, NotificationListener listener) {
return addRegistration(getDelegate().addNotificationListener(notification, listener));
}
import org.opendaylight.controller.sal.core.api.notify.NotificationListener;
import org.opendaylight.controller.sal.core.api.notify.NotificationService;
-import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.QName;
import org.osgi.framework.ServiceReference;
}
@Override
- public Registration<NotificationListener> addNotificationListener(QName notification, NotificationListener listener) {
+ public ListenerRegistration<NotificationListener> addNotificationListener(QName notification, NotificationListener listener) {
return addRegistration(getDelegate().addNotificationListener(notification, listener));
}
}
package org.opendaylight.controller.sal.dom.broker.spi;
import org.opendaylight.controller.sal.core.api.notify.NotificationListener;
-import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
* @param notification
* @param listener
*/
- Registration<NotificationListener> addNotificationListener(QName notification,
+ ListenerRegistration<NotificationListener> addNotificationListener(QName notification,
NotificationListener listener);
}
import org.opendaylight.controller.sal.binding.api.NotificationService;
import org.opendaylight.controller.sal.binding.api.data.DataBrokerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
-import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.NotificationListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final static Logger _logger = LoggerFactory.getLogger(L2SwitchProvider.class);
- private Registration<NotificationListener> listenerRegistration;
+ private ListenerRegistration<NotificationListener> listenerRegistration;
private AddressTracker addressTracker;
private TopologyLinkDataChangeHandler topologyLinkDataChangeHandler;
import org.opendaylight.controller.sample.kitchen.impl.KitchenServiceImpl;
import org.opendaylight.yang.gen.v1.http.netconfcentral.org.ns.toaster.rev091120.ToastType;
import org.opendaylight.yang.gen.v1.http.netconfcentral.org.ns.toaster.rev091120.ToasterService;
-import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.NotificationListener;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
final KitchenServiceImpl kitchenService = new KitchenServiceImpl(toasterService);
- final Registration<NotificationListener> toasterListenerReg =
+ final ListenerRegistration<NotificationListener> toasterListenerReg =
getNotificationServiceDependency().registerNotificationListener( kitchenService );
final KitchenServiceRuntimeRegistration runtimeReg =
import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.OpendaylightPortStatisticsService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.OpendaylightQueueStatisticsService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.NotificationListener;
import org.slf4j.Logger;
private final StatisticsListener updateCommiter = new StatisticsListener(StatisticsProvider.this);
- private Registration<NotificationListener> listenerRegistration;
+ private ListenerRegistration<NotificationListener> listenerRegistration;
private ListenerRegistration<DataChangeListener> flowCapableTrackerRegistration;
import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
-import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.NotificationListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private DataProviderService dataService;
private NotificationProviderService notificationService;
private final LLDPDiscoveryListener commiter = new LLDPDiscoveryListener(LLDPDiscoveryProvider.this);
- private Registration<NotificationListener> listenerRegistration;
+ private ListenerRegistration<NotificationListener> listenerRegistration;
public DataProviderService getDataService() {
return this.dataService;
}
public void start() {
- Registration<NotificationListener> registerNotificationListener = this.getNotificationService().registerNotificationListener(this.commiter);
+ ListenerRegistration<NotificationListener> registerNotificationListener = this.getNotificationService().registerNotificationListener(this.commiter);
this.listenerRegistration = registerNotificationListener;
LLDPLinkAger.getInstance().setManager(this);
LOG.info("LLDPDiscoveryListener Started.");
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
-import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.NotificationListener;
import org.osgi.framework.BundleContext;
public class FlowCapableTopologyProvider extends AbstractBindingAwareProvider implements AutoCloseable {
private final static Logger LOG = LoggerFactory.getLogger(FlowCapableTopologyProvider.class);
- private Registration<NotificationListener> listenerRegistration;
+ private ListenerRegistration<NotificationListener> listenerRegistration;
private Thread thread;
/**