package org.opendaylight.mdsal.binding.dom.adapter.osgi;
import static com.google.common.base.Verify.verifyNotNull;
-import static java.util.Objects.requireNonNull;
import java.util.Map;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.mdsal.binding.api.BindingService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
static final @NonNull String DELEGATE =
"org.opendaylight.mdsal.binding.dom.adapter.osgi.AbstractAdaptedService.DELEGATE";
- private final Class<B> bindingService;
+ private final String serviceName;
+ final @NonNull B delegate;
- private @Nullable B delegate;
-
- AbstractAdaptedService(final Class<B> bindingService) {
- this.bindingService = requireNonNull(bindingService);
- }
-
- final void start(final Map<String, ?> properties) {
+ AbstractAdaptedService(final Class<B> bindingService, final Map<String, ?> properties) {
+ serviceName = bindingService.getSimpleName();
delegate = bindingService.cast(verifyNotNull(properties.get(DELEGATE)));
- LOG.info("Binding/DOM adapter for {} activated", bindingService.getSimpleName());
+ LOG.info("Binding/DOM adapter for {} activated", serviceName);
}
final void stop(final int reason) {
- delegate = null;
- LOG.info("Binding/DOM adapter for {} deactivated (reason {})", bindingService.getSimpleName(), reason);
- }
-
- final @NonNull B delegate() {
- return verifyNotNull(delegate);
+ LOG.info("Binding/DOM adapter for {} deactivated (reason {})", serviceName, reason);
}
}
*/
package org.opendaylight.mdsal.binding.dom.adapter.osgi;
-import com.google.common.annotations.Beta;
import java.util.Map;
import java.util.Set;
import org.opendaylight.mdsal.binding.api.ActionProviderService;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
-@Beta
@Component(factory = OSGiActionProviderService.FACTORY_NAME)
public final class OSGiActionProviderService extends AbstractAdaptedService<ActionProviderService>
implements ActionProviderService {
// OSGi DS Component Factory name
static final String FACTORY_NAME = "org.opendaylight.mdsal.binding.dom.adapter.osgi.OSGiActionProviderService";
- public OSGiActionProviderService() {
- super(ActionProviderService.class);
- }
-
- @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) {
- return delegate().registerImplementation(spec, implementation, datastore, validNodes);
- }
-
@Activate
- void activate(final Map<String, ?> properties) {
- start(properties);
+ public OSGiActionProviderService(final Map<String, ?> properties) {
+ super(ActionProviderService.class, properties);
}
@Deactivate
void deactivate(final int reason) {
stop(reason);
}
+
+ @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) {
+ return delegate.registerImplementation(spec, implementation, datastore, validNodes);
+ }
}
*/
package org.opendaylight.mdsal.binding.dom.adapter.osgi;
-import com.google.common.annotations.Beta;
import java.util.Map;
import java.util.Set;
-import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.mdsal.binding.api.ActionService;
import org.opendaylight.mdsal.binding.api.ActionSpec;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
-@Beta
@NonNullByDefault
@Component(factory = OSGiActionService.FACTORY_NAME)
public final class OSGiActionService extends AbstractAdaptedService<ActionService> implements ActionService {
// OSGi DS Component Factory name
static final String FACTORY_NAME = "org.opendaylight.mdsal.binding.dom.adapter.osgi.OSGiActionService";
- public OSGiActionService() {
- super(ActionService.class);
- }
-
- @Override
- public <P extends DataObject, A extends Action<? extends InstanceIdentifier<P>, ?, ?>> A getActionHandle(
- final ActionSpec<A, P> spec, final Set<@NonNull DataTreeIdentifier<P>> validNodes) {
- return delegate().getActionHandle(spec, validNodes);
- }
-
@Activate
- void activate(final Map<String, ?> properties) {
- start(properties);
+ public OSGiActionService(final Map<String, ?> properties) {
+ super(ActionService.class, properties);
}
@Deactivate
void deactivate(final int reason) {
stop(reason);
}
+
+ @Override
+ public <P extends DataObject, A extends Action<? extends InstanceIdentifier<P>, ?, ?>> A getActionHandle(
+ final ActionSpec<A, P> spec, final Set<DataTreeIdentifier<P>> validNodes) {
+ return delegate.getActionHandle(spec, validNodes);
+ }
}
*/
package org.opendaylight.mdsal.binding.dom.adapter.osgi;
-import com.google.common.annotations.Beta;
import java.util.Map;
-import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.mdsal.binding.api.DataBroker;
import org.opendaylight.mdsal.binding.api.DataTreeChangeListener;
import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
-@Beta
+@NonNullByDefault
@Component(factory = OSGiDataBroker.FACTORY_NAME)
public final class OSGiDataBroker extends AbstractAdaptedService<DataBroker> implements DataBroker {
// OSGi DS Component Factory name
static final String FACTORY_NAME = "org.opendaylight.mdsal.binding.dom.adapter.osgi.OSGiDataBroker";
- public OSGiDataBroker() {
- super(DataBroker.class);
+ @Activate
+ public OSGiDataBroker(final Map<String, ?> properties) {
+ super(DataBroker.class, properties);
+ }
+
+ @Deactivate
+ void deactivate(final int reason) {
+ stop(reason);
}
@Override
public ReadTransaction newReadOnlyTransaction() {
- return delegate().newReadOnlyTransaction();
+ return delegate.newReadOnlyTransaction();
}
@Override
public ReadWriteTransaction newReadWriteTransaction() {
- return delegate().newReadWriteTransaction();
+ return delegate.newReadWriteTransaction();
}
@Override
public WriteTransaction newWriteOnlyTransaction() {
- return delegate().newWriteOnlyTransaction();
+ return delegate.newWriteOnlyTransaction();
}
@Override
public <T extends DataObject> Registration registerDataTreeChangeListener(final DataTreeIdentifier<T> treeId,
final DataTreeChangeListener<T> listener) {
- return delegate().registerDataTreeChangeListener(treeId, listener);
+ return delegate.registerDataTreeChangeListener(treeId, listener);
}
@Override
- public TransactionChain createTransactionChain(@NonNull final TransactionChainListener listener) {
- return delegate().createTransactionChain(listener);
+ public TransactionChain createTransactionChain(final TransactionChainListener listener) {
+ return delegate.createTransactionChain(listener);
}
@Override
public TransactionChain createMergingTransactionChain(final TransactionChainListener listener) {
- return delegate().createMergingTransactionChain(listener);
- }
-
- @Activate
- void activate(final Map<String, ?> properties) {
- start(properties);
- }
-
- @Deactivate
- void deactivate(final int reason) {
- stop(reason);
+ return delegate.createMergingTransactionChain(listener);
}
}
*/
package org.opendaylight.mdsal.binding.dom.adapter.osgi;
-import com.google.common.annotations.Beta;
import java.util.Map;
import java.util.Optional;
import org.opendaylight.mdsal.binding.api.MountPoint;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
-@Beta
@Component(factory = OSGiMountPointService.FACTORY_NAME)
public final class OSGiMountPointService extends AbstractAdaptedService<MountPointService>
implements MountPointService {
// OSGi DS Component Factory name
static final String FACTORY_NAME = "org.opendaylight.mdsal.binding.dom.adapter.osgi.OSGiMountPointService";
- public OSGiMountPointService() {
- super(MountPointService.class);
+ @Activate
+ public OSGiMountPointService(final Map<String, ?> properties) {
+ super(MountPointService.class, properties);
+ }
+
+ @Deactivate
+ void deactivate(final int reason) {
+ stop(reason);
}
@Override
public Optional<MountPoint> getMountPoint(final InstanceIdentifier<?> mountPoint) {
- return delegate().getMountPoint(mountPoint);
+ return delegate.getMountPoint(mountPoint);
}
@Override
public Registration registerListener(final InstanceIdentifier<?> path, final MountPointListener listener) {
- return delegate().registerListener(path, listener);
- }
-
- @Activate
- void activate(final Map<String, ?> properties) {
- start(properties);
- }
-
- @Deactivate
- void deactivate(final int reason) {
- stop(reason);
+ return delegate.registerListener(path, listener);
}
}
*/
package org.opendaylight.mdsal.binding.dom.adapter.osgi;
-import com.google.common.annotations.Beta;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
-@Beta
@Component(factory = OSGiNotificationPublishService.FACTORY_NAME)
public final class OSGiNotificationPublishService extends AbstractAdaptedService<NotificationPublishService>
implements NotificationPublishService {
// OSGi DS Component Factory name
static final String FACTORY_NAME = "org.opendaylight.mdsal.binding.dom.adapter.osgi.OSGiNotificationPublishService";
- public OSGiNotificationPublishService() {
- super(NotificationPublishService.class);
+ @Activate
+ public OSGiNotificationPublishService(final Map<String, ?> properties) {
+ super(NotificationPublishService.class, properties);
+ }
+
+ @Deactivate
+ void deactivate(final int reason) {
+ stop(reason);
}
@Override
public void putNotification(final Notification<?> notification) throws InterruptedException {
- delegate().putNotification(notification);
+ delegate.putNotification(notification);
}
@Override
public ListenableFuture<? extends Object> offerNotification(final Notification<?> notification) {
- return delegate().offerNotification(notification);
+ return delegate.offerNotification(notification);
}
@Override
public ListenableFuture<? extends Object> offerNotification(final Notification<?> notification, final int timeout,
final TimeUnit unit) throws InterruptedException {
- return delegate().offerNotification(notification, timeout, unit);
- }
-
- @Activate
- void activate(final Map<String, ?> properties) {
- start(properties);
- }
-
- @Deactivate
- void deactivate(final int reason) {
- stop(reason);
+ return delegate.offerNotification(notification, timeout, unit);
}
}
*/
package org.opendaylight.mdsal.binding.dom.adapter.osgi;
-import com.google.common.annotations.Beta;
import java.util.Map;
import java.util.concurrent.Executor;
import org.opendaylight.mdsal.binding.api.NotificationService;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
-@Beta
@Component(factory = OSGiNotificationService.FACTORY_NAME)
public final class OSGiNotificationService extends AbstractAdaptedService<NotificationService>
implements NotificationService {
// OSGi DS Component Factory name
static final String FACTORY_NAME = "org.opendaylight.mdsal.binding.dom.adapter.osgi.OSGiNotificationService";
- public OSGiNotificationService() {
- super(NotificationService.class);
+ @Activate
+ public OSGiNotificationService(final Map<String, ?> properties) {
+ super(NotificationService.class, properties);
+ }
+
+ @Deactivate
+ void deactivate(final int reason) {
+ stop(reason);
}
@Override
public <N extends Notification<N> & DataObject> Registration registerListener(final Class<N> type,
final NotificationService.Listener<N> listener, final Executor executor) {
- return delegate().registerListener(type, listener, executor);
+ return delegate.registerListener(type, listener, executor);
}
@Override
public Registration registerCompositeListener(final NotificationService.CompositeListener listener,
final Executor executor) {
- return delegate().registerCompositeListener(listener, executor);
- }
-
- @Activate
- void activate(final Map<String, ?> properties) {
- start(properties);
- }
-
- @Deactivate
- void deactivate(final int reason) {
- stop(reason);
+ return delegate.registerCompositeListener(listener, executor);
}
}
*/
package org.opendaylight.mdsal.binding.dom.adapter.osgi;
-import com.google.common.annotations.Beta;
import com.google.common.collect.ClassToInstanceMap;
import java.util.Map;
import java.util.Set;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
-@Beta
@Component(factory = OSGiRpcProviderService.FACTORY_NAME)
public final class OSGiRpcProviderService extends AbstractAdaptedService<RpcProviderService>
implements RpcProviderService {
// OSGi DS Component Factory name
static final String FACTORY_NAME = "org.opendaylight.mdsal.binding.dom.adapter.osgi.OSGiRpcProviderService";
- public OSGiRpcProviderService() {
- super(RpcProviderService.class);
+ @Activate
+ public OSGiRpcProviderService(final Map<String, ?> properties) {
+ super(RpcProviderService.class, properties);
+ }
+
+ @Deactivate
+ void deactivate(final int reason) {
+ stop(reason);
}
@Override
public Registration registerRpcImplementation(final Rpc<?, ?> implementation) {
- return delegate().registerRpcImplementation(implementation);
+ return delegate.registerRpcImplementation(implementation);
}
@Override
public Registration registerRpcImplementation(final Rpc<?, ?> implementation,
final Set<InstanceIdentifier<?>> paths) {
- return delegate().registerRpcImplementation(implementation, paths);
+ return delegate.registerRpcImplementation(implementation, paths);
}
@Override
public Registration registerRpcImplementations(final ClassToInstanceMap<Rpc<?, ?>> implementations) {
- return delegate().registerRpcImplementations(implementations);
+ return delegate.registerRpcImplementations(implementations);
}
@Override
public Registration registerRpcImplementations(final ClassToInstanceMap<Rpc<?, ?>> implementations,
final Set<InstanceIdentifier<?>> paths) {
- return delegate().registerRpcImplementations(implementations, paths);
- }
-
- @Activate
- void activate(final Map<String, ?> properties) {
- start(properties);
- }
-
- @Deactivate
- void deactivate(final int reason) {
- stop(reason);
+ return delegate.registerRpcImplementations(implementations, paths);
}
}
*/
package org.opendaylight.mdsal.binding.dom.adapter.osgi;
-import com.google.common.annotations.Beta;
import java.util.Map;
+import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.mdsal.binding.api.RpcService;
import org.opendaylight.yangtools.yang.binding.Rpc;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
-@Beta
+@NonNullByDefault
@Component(factory = OSGiRpcService.FACTORY_NAME)
public final class OSGiRpcService extends AbstractAdaptedService<RpcService> implements RpcService {
// OSGi DS Component Factory name
static final String FACTORY_NAME = "org.opendaylight.mdsal.binding.dom.adapter.osgi.OSGiRpcConsumerRegistry";
- public OSGiRpcService() {
- super(RpcService.class);
- }
-
- @Override
- public <T extends Rpc<?, ?>> T getRpc(final Class<T> rpcInterface) {
- return delegate().getRpc(rpcInterface);
- }
-
@Activate
- void activate(final Map<String, ?> properties) {
- start(properties);
+ public OSGiRpcService(final Map<String, ?> properties) {
+ super(RpcService.class, properties);
}
@Deactivate
void deactivate(final int reason) {
stop(reason);
}
+
+ @Override
+ public <T extends Rpc<?, ?>> T getRpc(final Class<T> rpcInterface) {
+ return delegate.getRpc(rpcInterface);
+ }
}