*
* @author Michael Vorburger.ch
*/
+@Deprecated
public abstract class AbstractCloseTracked<T extends AbstractCloseTracked<T>> implements CloseTracked<T> {
private final CloseTrackedTrait<T> closeTracker;
*
* @author Michael Vorburger.ch
*/
+@Deprecated
public interface CloseTracked<T extends CloseTracked<T>> {
/**
*
* @author Michael Vorburger.ch
*/
+@Deprecated
public class CloseTrackedRegistry<T extends CloseTracked<T>> {
private final Object anchor;
*
* @author Michael Vorburger.ch
*/
+@Deprecated
public class CloseTrackedRegistryReportEntry<T extends CloseTracked<T>> {
private final CloseTracked<T> exampleCloseTracked;
*
* @author Michael Vorburger.ch
*/
+@Deprecated
public class CloseTrackedTrait<T extends CloseTracked<T>> implements CloseTracked<T> {
// NB: It's important that we keep a Throwable here, and not directly the StackTraceElement[] !
*/
// This generic infra may be moved somewhere else, later
@org.eclipse.jdt.annotation.NonNullByDefault
+@Deprecated
package org.opendaylight.controller.md.sal.trace.closetracker.impl;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
abstract class AbstractTracingWriteTransaction implements DOMDataWriteTransaction {
private final DOMDataWriteTransaction delegate;
* </ul>
*
*/
+@Deprecated
public class TracingBroker implements TracingDOMDataBroker {
@SuppressFBWarnings("SLF4J_LOGGER_SHOULD_BE_PRIVATE")
static final Logger LOG = LoggerFactory.getLogger(TracingBroker.class);
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
class TracingReadOnlyTransaction
extends AbstractCloseTracked<TracingReadOnlyTransaction>
implements DOMDataReadOnlyTransaction {
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
class TracingReadWriteTransaction
extends AbstractTracingWriteTransaction
implements DOMDataReadWriteTransaction, CloseTracked<TracingReadWriteTransaction> {
import org.opendaylight.controller.md.sal.trace.closetracker.impl.AbstractCloseTracked;
import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTrackedRegistry;
+@Deprecated
class TracingTransactionChain extends AbstractCloseTracked<TracingTransactionChain> implements DOMTransactionChain {
private final DOMTransactionChain delegate;
import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTrackedTrait;
import org.opendaylight.mdsal.common.api.CommitInfo;
+@Deprecated
class TracingWriteTransaction extends AbstractTracingWriteTransaction
implements CloseTracked<TracingWriteTransaction> {
import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTrackedRegistry;
import org.opendaylight.controller.md.sal.trace.closetracker.impl.CloseTrackedRegistryReportEntry;
+@Deprecated
public class CloseTrackedRegistryTest {
private static class SomethingClosable extends AbstractCloseTracked<SomethingClosable> implements AutoCloseable {
*
* @author Michael Vorburger.ch
*/
+@Deprecated
public class TracingBrokerTest {
@Test
* and via
* {@link org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ConsumerContext}
*
+ * @deprecated Use {@link BindingService} instead.
*/
+@Deprecated
public interface BindingService extends BindingAwareService {
}
*
* @see TransactionChain
*
+ * @deprecated Use {@link org.opendaylight.mdsal.binding.api.TransactionChain} instead.
*/
+@Deprecated
public interface BindingTransactionChain extends TransactionFactory,
TransactionChain<InstanceIdentifier<?>, DataObject> {
@Override
* @author Thomas Pantelis
*
* @param <T> the DataObject type
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener} instead.
*/
+@Deprecated
public interface ClusteredDataTreeChangeListener<T extends DataObject> extends DataTreeChangeListener<T> {
}
/**
* Represents a modification of DataObject.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.binding.api.DataObjectModification} instead.
*/
+@Deprecated
public interface DataObjectModification<T extends DataObject>
extends org.opendaylight.yangtools.concepts.Identifiable<PathArgument> {
* <p>
* Note: this interface enables notifications only at the leader of the data store, if clustered. If you want
* notifications on all instances in a cluster, use the {@link ClusteredDataTreeChangeListener}.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.binding.api.DataTreeChangeListener} instead.
*/
+@Deprecated
public interface DataTreeChangeListener<T extends DataObject> extends EventListener {
/**
* Invoked when there was data change for the supplied path, which was used
import org.opendaylight.yangtools.yang.binding.DataObject;
/**
- * A {@link BindingService} which allows users to register for changes to a
- * subtree.
+ * A {@link BindingService} which allows users to register for changes to a subtree.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.binding.api.DataTreeChangeService} instead.
*/
+@Deprecated
public interface DataTreeChangeService extends BindingService {
/**
* Registers a {@link DataTreeChangeListener} to receive
/**
* A unique identifier for a particular subtree. It is composed of the logical
* data store type and the instance identifier of the root node.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.binding.api.DataTreeIdentifier} instead.
*/
+@Deprecated
public final class DataTreeIdentifier<T extends DataObject> implements Immutable,
Path<DataTreeIdentifier<?>>, Serializable {
private static final long serialVersionUID = 1L;
*
* @author Tony Tkacik <ttkacik@cisco.com>
*
+ * @deprecated Use {@link org.opendaylight.mdsal.binding.api.DataTreeModification} instead.
*/
+@Deprecated
public interface DataTreeModification<T extends DataObject> {
/**
/**
* Utility {@link DataBroker} implementation which forwards all interface method
* invocation to a delegate instance.
+ *
+ * @deprecated Use org.opendaylight.mdsal.binding.spi.ForwardingDataBroker instead.
*/
+@Deprecated
public abstract class ForwardingDataBroker extends ForwardingObject implements DataBroker {
@Override
/**
* Utility {@link ReadOnlyTransaction} implementation which forwards all interface method
* invocation to a delegate instance.
+ *
+ * @deprecated Use org.opendaylight.mdsal.binding.spi.ForwardingReadTransaction instead.
*/
-@SuppressWarnings("deprecation") // due to CheckedFuture
+@Deprecated
public class ForwardingReadOnlyTransaction extends ForwardingObject implements ReadOnlyTransaction {
private final ReadOnlyTransaction delegate;
/**
* Utility {@link ReadWriteTransaction} implementation which forwards all interface method
* invocation to a delegate instance.
+ *
+ * @deprecated Use org.opendaylight.mdsal.binding.spi.ForwardingReadWriteTransaction instead.
*/
-@SuppressWarnings("deprecation") // due to CheckedFuture & TransactionStatus
+@Deprecated
public class ForwardingReadWriteTransaction extends ForwardingObject implements ReadWriteTransaction {
private final ReadWriteTransaction delegate;
/**
* Utility {@link WriteTransaction} implementation which forwards all interface method
* invocation to a delegate instance.
+ *
+ * @deprecated Use org.opendaylight.mdsal.binding.spi.ForwardingWriteTransaction instead.
*/
-@SuppressWarnings("deprecation") // due to CheckedFuture & TransactionStatus
+@Deprecated
public class ForwardingWriteTransaction extends ForwardingObject implements WriteTransaction {
private final WriteTransaction delegate;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+@Deprecated
public interface MountPoint extends Identifiable<InstanceIdentifier<?>> {
<T extends BindingService> Optional<T> getService(Class<T> service);
}
* <p>
* Expected use: {@link NotificationPublishService}
* </p>
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.binding.api.NotificationRejectedException} instead.
*/
+@Deprecated
public class NotificationRejectedException extends Exception {
private static final long serialVersionUID = 1L;
* <p>
* For more information on usage and examples, please see the documentation in
* {@link org.opendaylight.controller.md.sal.common.api.data.AsyncReadTransaction}.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.binding.api.ReadTransaction} instead.
*/
+@Deprecated
public interface ReadOnlyTransaction extends ReadTransaction, AsyncReadOnlyTransaction<InstanceIdentifier<?>,
DataObject> {
}
*
* <p>
* For more information on usage and examples, please see the documentation in {@link AsyncReadTransaction}.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.binding.api.ReadTransaction} instead.
*/
+@Deprecated
public interface ReadTransaction extends AsyncReadTransaction<InstanceIdentifier<?>, DataObject> {
/**
*
* <p>
* For more information on usage and examples, please see the documentation in {@link AsyncReadWriteTransaction}.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.binding.api.ReadWriteTransaction} instead.
*/
+@Deprecated
public interface ReadWriteTransaction extends ReadTransaction, WriteTransaction,
AsyncReadWriteTransaction<InstanceIdentifier<?>, DataObject> {
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.md.sal.binding.api;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataTransactionFactory;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+@Deprecated
public interface TransactionFactory extends AsyncDataTransactionFactory<InstanceIdentifier<?>, DataObject> {
@Override
ReadOnlyTransaction newReadOnlyTransaction();
*
* <p>
* For more information on usage and examples, please see the documentation in {@link AsyncWriteTransaction}.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.binding.api.WriteTransaction} instead.
*/
+@Deprecated
public interface WriteTransaction extends AsyncWriteTransaction<InstanceIdentifier<?>, DataObject> {
/**
import org.osgi.util.tracker.ServiceTracker;
import org.osgi.util.tracker.ServiceTrackerCustomizer;
+@Deprecated
public abstract class AbstractBrokerAwareActivator implements BundleActivator {
private static final ExecutorService MD_ACTIVATION_POOL = Executors.newCachedThreadPool();
* For more information about session-based access see {@link ConsumerContext}
* and {@link ProviderContext}
*/
+@Deprecated
public interface BindingAwareBroker {
@Deprecated
ConsumerContext registerConsumer(BindingAwareConsumer consumer, BundleContext ctx);
*/
package org.opendaylight.controller.sal.binding.api;
+import org.opendaylight.controller.md.sal.binding.api.BindingService;
+
/**
* Session-specific instance of the broker functionality.
*
* {@link BindingAwareProvider} exposes the necessary supporting functionality
* to implement specific functionality of YANG and to reuse it in the
* development of {@link BindingAwareConsumer}s and {@link BindingAwareProvider}s.
+ *
+ * @deprecated Use {@link BindingService} instead.
*/
+@Deprecated
public interface BindingAwareService {
}
*/
package org.opendaylight.controller.sal.binding.api;
+@Deprecated
public interface RpcAvailabilityListener {
}
import org.opendaylight.yangtools.yang.binding.BaseIdentity;
import org.opendaylight.yangtools.yang.binding.RpcService;
-public final class RpcContextIdentifier implements Immutable {
+@Deprecated
+public final class RpcContextIdentifier implements Immutable {
public final Class<? extends RpcService> rpcService;
public final Class<? extends BaseIdentity> routingContext;
import org.opendaylight.yangtools.yang.binding.BaseIdentity;
import org.opendaylight.yangtools.yang.binding.RpcService;
+@Deprecated
public interface RpcRoutingContext<C extends BaseIdentity,S extends RpcService> {
Class<C> getContextType();
*
* @param <T> Notification type
*/
+@Deprecated
abstract class AbstractNotificationListenerRegistration<T extends Notification>
extends AbstractListenerRegistration<NotificationListener<T>> implements NotificationListenerRegistration<T> {
private final Class<? extends Notification> type;
* @param <N> Notification type
* @param <A> Aggregator type
*/
+@Deprecated
abstract class AggregatedNotificationListenerRegistration<N extends Notification, A>
extends AbstractNotificationListenerRegistration<N> {
private final A aggregator;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.RpcService;
+@Deprecated
final class CompositeRoutedRpcRegistration<T extends RpcService> implements RoutedRpcRegistration<T> {
private final Class<T> type;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.RpcService;
+@Deprecated
final class DelegatedRootRpcRegistration<T extends RpcService> implements RpcRegistration<T> {
private final ObjectRegistration<T> delegate;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.yangtools.yang.binding.Notification;
+@Deprecated
final class FunctionalNotificationListenerAdapter<N extends Notification> implements DOMNotificationListener {
private final BindingNormalizedNodeSerializer codec;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Deprecated
public class HeliumNotificationProviderServiceAdapter extends HeliumNotificationServiceAdapter
implements NotificationProviderService {
private static final Logger LOG = LoggerFactory.getLogger(HeliumNotificationProviderServiceAdapter.class);
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Deprecated
public class HeliumNotificationProviderServiceWithInterestListeners extends HeliumNotificationProviderServiceAdapter {
private static final Logger LOG = LoggerFactory.getLogger(
import org.opendaylight.yangtools.yang.binding.Notification;
import org.opendaylight.yangtools.yang.binding.NotificationListener;
+@Deprecated
public class HeliumNotificationServiceAdapter
implements org.opendaylight.controller.sal.binding.api.NotificationService, AutoCloseable {
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.RpcService;
+@Deprecated
public class HeliumRpcProviderRegistry implements RpcProviderRegistry {
private final RpcConsumerRegistry consumerRegistry;
/**
* An immutable view of the current generation of listeners.
*/
+@Deprecated
final class ListenerMapGeneration {
private static final int CACHE_MAX_ENTRIES = 1000;
import org.opendaylight.yangtools.yang.binding.NotificationListener;
import org.opendaylight.yangtools.yang.common.QName;
+@Deprecated
final class NotificationInvoker
implements org.opendaylight.controller.sal.binding.api.NotificationListener<Notification> {
*
* @param <T> Type of notification
*/
+@Deprecated
interface NotificationListenerRegistration<T extends Notification>
extends ListenerRegistration<NotificationListener<T>> {
/**
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Deprecated
public abstract class AbstractForwardedDataBroker implements Delegator<DOMDataBroker>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(AbstractForwardedDataBroker.class);
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
abstract class AbstractForwardedTransaction<T extends AsyncTransaction<YangInstanceIdentifier, NormalizedNode<?, ?>>>
implements Delegator<T>, Identifiable<Object> {
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Deprecated
public class AbstractReadWriteTransaction extends AbstractWriteTransaction<DOMDataReadWriteTransaction> {
private static final Logger LOG = LoggerFactory.getLogger(AbstractReadWriteTransaction.class);
/**
* Abstract Base Transaction for transactions which are backed by {@link DOMDataWriteTransaction}.
*/
+@Deprecated
public abstract class AbstractWriteTransaction<T extends DOMDataWriteTransaction> extends
AbstractForwardedTransaction<T> {
*
* @author Michael Vorburger.ch, partially based on refactored code originally by Thomas Pantelis
*/
+@Deprecated
public class BindingBrokerWiring implements AutoCloseable {
private final BindingToNormalizedNodeCodec bindingToNormalizedNodeCodec;
*
* @author Thomas Pantelis
*/
+@Deprecated
final class BindingClusteredDOMDataTreeChangeListenerAdapter<T extends DataObject>
extends BindingDOMDataTreeChangeListenerAdapter<T> implements ClusteredDOMDataTreeChangeListener {
BindingClusteredDOMDataTreeChangeListenerAdapter(BindingToNormalizedNodeCodec codec,
import org.opendaylight.controller.md.sal.binding.spi.AdapterBuilder;
import org.opendaylight.controller.md.sal.dom.api.DOMService;
+@Deprecated
abstract class BindingDOMAdapterBuilder<T extends BindingService> extends AdapterBuilder<T, DOMService> {
interface Factory<T extends BindingService> {
import org.opendaylight.controller.md.sal.dom.api.DOMService;
import org.opendaylight.controller.sal.binding.api.RpcConsumerRegistry;
+@Deprecated
public abstract class BindingDOMAdapterLoader extends AdapterLoader<BindingService, DOMService> {
private static final Map<Class<?>, BindingDOMAdapterBuilder.Factory<?>> FACTORIES =
ImmutableMap.<Class<?>, BindingDOMAdapterBuilder.Factory<?>>builder()
* Besides this the DataBrokerImpl and it's collaborators also cache data that
* is already transformed from the binding independent to binding aware format
*/
+@Deprecated
public class BindingDOMDataBrokerAdapter extends AbstractForwardedDataBroker
implements DataBroker, DataTreeChangeService {
static final Factory<DataBroker> BUILDER_FACTORY = Builder::new;
* to their Binding equivalent.
*
*/
+@Deprecated
class BindingDOMDataTreeChangeListenerAdapter<T extends DataObject> implements DOMDataTreeChangeListener {
private final BindingToNormalizedNodeCodec codec;
* Each registered {@link DataTreeChangeListener} is wrapped using
* adapter and registered directly to DOM service.
*/
+@Deprecated
final class BindingDOMDataTreeChangeServiceAdapter implements DataTreeChangeService {
private final BindingToNormalizedNodeCodec codec;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Deprecated
final class BindingDOMMountPointListenerAdapter<T extends MountPointListener>
implements ListenerRegistration<T>, DOMMountPointListener {
private static final Logger LOG = LoggerFactory.getLogger(BindingDOMMountPointListenerAdapter.class);
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Deprecated
public class BindingDOMMountPointServiceAdapter implements MountPointService {
private static final Logger LOG = LoggerFactory.getLogger(BindingDOMMountPointServiceAdapter.class);
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+@Deprecated
class BindingDOMNotificationListenerAdapter implements DOMNotificationListener {
private final BindingNormalizedNodeSerializer codec;
import org.opendaylight.controller.md.sal.dom.api.DOMService;
import org.opendaylight.yangtools.yang.binding.Notification;
+@Deprecated
public class BindingDOMNotificationPublishServiceAdapter implements NotificationPublishService, AutoCloseable {
static final Factory<NotificationPublishService> BUILDER_FACTORY = Builder::new;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.NotificationListener;
+@Deprecated
public class BindingDOMNotificationServiceAdapter implements NotificationService, AutoCloseable {
public static final Factory<NotificationService> BUILDER_FACTORY = Builder::new;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+@Deprecated
class BindingDOMReadTransactionAdapter extends AbstractForwardedTransaction<DOMDataReadOnlyTransaction> implements
ReadOnlyTransaction {
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+@Deprecated
class BindingDOMReadWriteTransactionAdapter extends
BindingDOMWriteTransactionAdapter<DOMDataReadWriteTransaction> implements ReadWriteTransaction {
import org.opendaylight.yangtools.concepts.AbstractObjectRegistration;
import org.opendaylight.yangtools.yang.binding.RpcService;
+@Deprecated
class BindingDOMRpcAdapterRegistration<T extends RpcService> extends AbstractObjectRegistration<T> {
private final DOMRpcImplementationRegistration<?> reg;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+@Deprecated
public class BindingDOMRpcImplementationAdapter implements DOMRpcImplementation {
private static final Cache<Class<?>, RpcServiceInvoker> SERVICE_INVOKERS =
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+@Deprecated
public class BindingDOMRpcProviderServiceAdapter {
private static final Set<YangInstanceIdentifier> GLOBAL = ImmutableSet.of(YangInstanceIdentifier.EMPTY);
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yangtools.yang.binding.RpcService;
+@Deprecated
public class BindingDOMRpcServiceAdapter implements RpcConsumerRegistry {
protected static final Factory<RpcConsumerRegistry> BUILDER_FACTORY = Builder::new;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Deprecated
final class BindingDOMTransactionChainAdapter implements BindingTransactionChain, Delegator<DOMTransactionChain> {
private static final Logger LOG = LoggerFactory.getLogger(BindingDOMTransactionChainAdapter.class);
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
+@Deprecated
class BindingDOMWriteTransactionAdapter<T extends DOMDataWriteTransaction> extends
AbstractWriteTransaction<T> implements WriteTransaction {
import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
+@Deprecated
class BindingDataTreeChangeListenerRegistration<L extends DataTreeChangeListener<?>>
extends AbstractListenerRegistration<L> {
import org.opendaylight.controller.md.sal.dom.api.DOMService;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+@Deprecated
public class BindingMountPointAdapter implements MountPoint {
private final InstanceIdentifier<?> identifier;
import org.opendaylight.yangtools.concepts.AbstractObjectRegistration;
import org.opendaylight.yangtools.yang.binding.RpcService;
+@Deprecated
class BindingRpcAdapterRegistration<T extends RpcService> extends AbstractObjectRegistration<T> {
private final DOMRpcImplementationRegistration<?> reg;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
@Beta
+@Deprecated
@NonNullByDefault
public final class BindingToDOMAdapterFactory implements AdapterFactory {
private final BindingToNormalizedNodeCodec codec;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+@Deprecated
@SuppressFBWarnings(value = "NM_SAME_SIMPLE_NAME_AS_SUPERCLASS", justification = "Migration path")
public class BindingToNormalizedNodeCodec
extends org.opendaylight.mdsal.binding.dom.adapter.BindingToNormalizedNodeCodec {
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Deprecated
abstract class ContextReferenceExtractor {
private static final Logger LOG = LoggerFactory.getLogger(ContextReferenceExtractor.class);
private static final ContextReferenceExtractor NULL_EXTRACTOR = new ContextReferenceExtractor() {
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+@Deprecated
final class ControllerActionProviderServiceAdapter implements ActionProviderService {
private static final class Builder extends BindingDOMAdapterBuilder<ActionProviderService> {
@Override
import org.opendaylight.yangtools.yang.binding.Action;
import org.opendaylight.yangtools.yang.binding.DataObject;
+@Deprecated
final class ControllerActionServiceAdapter implements ActionService {
private static final class Builder extends BindingDOMAdapterBuilder<ActionService> {
@Override
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+@Deprecated
final class DirectGetterRouteContextExtractor extends ContextReferenceExtractor {
private static final Lookup PUBLIC_LOOKUP = MethodHandles.publicLookup();
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+@Deprecated
final class GetValueRouteContextExtractor extends ContextReferenceExtractor {
private static final Lookup PUBLIC_LOOKUP = MethodHandles.publicLookup();
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
final class LazyDOMRpcResultFuture implements CheckedFuture<DOMRpcResult, DOMRpcException>, BindingRpcFutureAware {
private final ListenableFuture<RpcResult<?>> bindingFuture;
*
* @param <T> Type of Binding Data Object
*/
+@Deprecated
final class LazyDataObjectModification<T extends DataObject> implements DataObjectModification<T> {
private static final Logger LOG = LoggerFactory.getLogger(LazyDataObjectModification.class);
* which are directly accessed by user of data object modification.
*
*/
+@Deprecated
class LazyDataTreeModification<T extends DataObject> implements DataTreeModification<T> {
private final DataTreeIdentifier<T> path;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
- // FIXME: Should be this moved to binding-data-codec?
+// FIXME: Should be this moved to binding-data-codec?
+@Deprecated
class LazySerializedContainerNode implements ContainerNode, BindingDataAware {
private final NodeIdentifier identifier;
* of notification actually accessed data from notification.
*
*/
+@Deprecated
public final class LazySerializedDOMNotification implements DOMNotification {
private final BindingNormalizedNodeSerializer codec;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+@Deprecated
class RpcServiceAdapter implements InvocationHandler {
private final ImmutableMap<Method, RpcInvocationStrategy> rpcNames;
import java.util.Set;
import org.opendaylight.yangtools.concepts.Builder;
+@Deprecated
public abstract class AdapterBuilder<T,D> implements Builder<T> {
private final ClassToInstanceMap<D> delegates = MutableClassToInstanceMap.create();
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
@Beta
+@Deprecated
@NonNullByDefault
public interface AdapterFactory {
/**
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
+@Deprecated
public abstract class AdapterLoader<T, D> extends CacheLoader<Class<? extends T>, Optional<T>> {
@Override
*
* @author Thomas Pantelis
*/
+@Deprecated
public class BindingDOMDataTreeChangeServiceAdapterTest {
private static final InstanceIdentifier<Top> TOP_PATH = InstanceIdentifier.create(Top.class);
&& yangID.equals(treeId.getRootIdentifier()));
}
+ @Deprecated
private static class TestClusteredDataTreeChangeListener implements ClusteredDataTreeChangeListener<Top> {
@Override
public void onDataTreeChanged(final Collection<DataTreeModification<Top>> changes) {
}
}
+ @Deprecated
private static class TestDataTreeChangeListener implements DataTreeChangeListener<Top> {
@Override
public void onDataTreeChanged(final Collection<DataTreeModification<Top>> changes) {
*/
package org.opendaylight.controller.md.sal.binding.impl;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import com.google.common.base.Optional;
import com.google.common.cache.LoadingCache;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+@Deprecated
public class BindingDOMMountPointServiceAdapterTest {
@Mock
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.util.AbstractSchemaContext;
+@Deprecated
public class BindingNormalizedCodecTest extends AbstractSchemaAwareTest {
private static final TopLevelListKey TOP_FOO_KEY = new TopLevelListKey("foo");
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.rpc.routing.rev140701.RoutedSimpleRouteInputBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+@Deprecated
public final class ContextExtractorTest {
public interface Transitive extends EncapsulatedRouteInGrouping {
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.NotificationListener;
+@Deprecated
public class BackwardsCompatibleNotificationBrokerTest extends AbstractNotificationBrokerTest {
private NotificationProviderService notificationProviderService;
package org.opendaylight.controller.md.sal.binding.impl.test;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+@Deprecated
public class BindingDOMDataBrokerAdapterTest {
@Mock
* Regression test suite for Bug 1125 - Can't detect switch disconnection
* https://bugs.opendaylight.org/show_bug.cgi?id=1125.
*/
+@Deprecated
public class Bug1125RegressionTest extends AbstractDataTreeChangeListenerTest {
private static final InstanceIdentifier<Top> TOP_PATH = InstanceIdentifier
* <p>
* See https://bugs.opendaylight.org/show_bug.cgi?id=1333 for Bug Description
*/
+@Deprecated
public class Bug1333DataChangeListenerTest extends AbstractDataTreeChangeListenerTest {
private static final InstanceIdentifier<Top> TOP_PATH = InstanceIdentifier.create(Top.class);
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
+@Deprecated
public class Bug1418AugmentationTest extends AbstractDataTreeChangeListenerTest {
private static final InstanceIdentifier<Top> TOP = InstanceIdentifier.create(Top.class);
private static final InstanceIdentifier<TopLevelList> TOP_FOO = TOP.child(TopLevelList.class, TOP_FOO_KEY);
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
+@Deprecated
public class Bug2562DeserializedUnkeyedListTest extends AbstractDataTreeChangeListenerTest {
private static final InstanceIdentifier<Root> ROOT_PATH = InstanceIdentifier.create(Root.class);
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
+@Deprecated
public class Bug3090MultiKeyList extends AbstractDataTreeChangeListenerTest {
private static final InstanceIdentifier<Root> ROOT_PATH = InstanceIdentifier.create(Root.class);
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelListKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+@Deprecated
public class Bug4494Test extends AbstractDataBrokerTest {
@Test
public void testDelete() throws Exception {
* Regression test suite for https://bugs.opendaylight.org/show_bug.cgi?id=4513 - Change event is empty when
* Homogeneous composite key is used homogeneous composite key is used.
*/
+@Deprecated
public class Bug4513Test extends AbstractDataBrokerTest {
@SuppressWarnings({ "rawtypes", "unchecked" })
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
+@Deprecated
public class DataTreeChangeListenerTest extends AbstractConcurrentDataBrokerTest {
private static final InstanceIdentifier<Top> TOP_PATH = InstanceIdentifier.create(Top.class);
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Deprecated
public class ForwardedNotificationAdapterTest extends AbstractNotificationBrokerTest {
private static final Logger LOG = LoggerFactory.getLogger(ForwardedNotificationAdapterTest.class);
* which were described in
* https://lists.opendaylight.org/pipermail/controller-dev/2014-July/005541.html.
*/
+@Deprecated
public class ListInsertionDataChangeListenerTest extends AbstractDataTreeChangeListenerTest {
private static final InstanceIdentifier<Top> TOP = InstanceIdentifier.create(Top.class);
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelListKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+@Deprecated
public class WriteTransactionTest extends AbstractConcurrentDataBrokerTest {
private static final InstanceIdentifier<Top> TOP_PATH = InstanceIdentifier.create(Top.class);
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+@Deprecated
public abstract class AbstractBaseDataBrokerTest extends AbstractSchemaAwareTest {
private static final int ASSERT_COMMIT_DEFAULT_TIMEOUT = 5000;
*
* @author Michael Vorburger
*/
+@Deprecated
public abstract class AbstractConcurrentDataBrokerTest extends AbstractBaseDataBrokerTest {
private final boolean useMTDataTreeChangeListenerExecutor;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+@Deprecated
public abstract class AbstractDataBrokerTestCustomizer {
private DOMDataBroker domDataBroker;
*
* @author Thomas Pantelis
*/
+@Deprecated
public class AbstractDataTreeChangeListenerTest extends AbstractConcurrentDataBrokerTest {
protected static final class TestListener<T extends DataObject> implements DataTreeChangeListener<T> {
import org.opendaylight.controller.md.sal.dom.broker.impl.DOMNotificationRouter;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+@Deprecated
public class AbstractNotificationBrokerTest extends AbstractSchemaAwareTest {
private BindingToNormalizedNodeCodec bindingToNormalizedNodeCodec;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+@Deprecated
public abstract class AbstractSchemaAwareTest {
private static final LoadingCache<ClassLoader, Set<YangModuleInfo>> MODULE_INFO_CACHE = CacheBuilder.newBuilder()
.weakKeys().weakValues().build(new CacheLoader<ClassLoader, Set<YangModuleInfo>>() {
import java.util.Map;
import org.junit.Assert;
+@Deprecated
public final class AssertCollections {
private AssertCollections() {
}
*
* @author Michael Vorburger
*/
+@Deprecated
public class ConcurrentDataBrokerTestCustomizer extends AbstractDataBrokerTestCustomizer {
private final ListeningExecutorService dataTreeChangeListenerExecutorSingleton;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
+@Deprecated
public class DataBrokerTestModule {
public static DataBroker dataBroker() {
*
* @author Michael Vorburger
*/
+@Deprecated
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class AbstractDataBrokerTestTest extends AbstractConcurrentDataBrokerTest {
*
* @author Michael Vorburger
*/
+@Deprecated
public class DataBrokerTestModuleTest {
@Test
import org.opendaylight.controller.sal.binding.test.util.BindingBrokerTestFactory;
import org.opendaylight.controller.sal.binding.test.util.BindingTestContext;
+@Deprecated
public abstract class AbstractDataServiceTest {
protected BindingTestContext testContext;
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.Augmentation;
+@Deprecated
public class AugmentationVerifier<T extends Augmentable<T>> {
private final T object;
*/
package org.opendaylight.controller.sal.binding.test;
+@Deprecated
public class BindingTestUtilities {
}
import org.opendaylight.yangtools.yang.binding.NotificationListener;
+@Deprecated
public interface BarListener extends NotificationListener {
void onBarUpdate(BarUpdate notification);
import org.opendaylight.yangtools.yang.binding.Notification;
+@Deprecated
public interface BarUpdate extends Grouping,Notification {
*/
package org.opendaylight.controller.sal.binding.test.mock;
-public interface CompositeListener extends FooListener,BarListener {
+@Deprecated
+public interface CompositeListener extends FooListener, BarListener {
}
import org.opendaylight.yangtools.yang.binding.Notification;
+@Deprecated
public interface FlowDelete extends Notification{
}
import org.opendaylight.yangtools.yang.binding.NotificationListener;
+@Deprecated
public interface FooListener extends NotificationListener {
void onFooUpdate(FooUpdate notification);
package org.opendaylight.controller.sal.binding.test.mock;
import java.util.concurrent.Future;
-
import org.opendaylight.yangtools.yang.binding.RpcService;
import org.opendaylight.yangtools.yang.common.RpcResult;
+@Deprecated
public interface FooService extends RpcService {
Future<RpcResult<Void>> foo();
import org.opendaylight.yangtools.yang.binding.Notification;
+@Deprecated
public interface FooUpdate extends Notification {
}
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.annotations.RoutingContext;
+@Deprecated
public interface Grouping {
@RoutingContext(BaseIdentity.class)
*/
package org.opendaylight.controller.sal.binding.test.mock;
+@Deprecated
public interface InheritedContextInput extends Grouping {
}
import org.opendaylight.yangtools.yang.binding.DataRoot;
import org.opendaylight.yangtools.yang.binding.Identifiable;
-public interface ReferencableObject extends DataObject, Identifiable<ReferencableObjectKey>,ChildOf<DataRoot> {
+@Deprecated
+public interface ReferencableObject extends DataObject, Identifiable<ReferencableObjectKey>, ChildOf<DataRoot> {
+
}
import org.opendaylight.yangtools.yang.binding.Identifier;
+@Deprecated
public class ReferencableObjectKey implements Identifier<ReferencableObject> {
private static final long serialVersionUID = 1L;
final Integer value;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.annotations.RoutingContext;
+@Deprecated
public interface SimpleInput extends DataObject,Augmentable<SimpleInput> {
@RoutingContext(BaseIdentity.class)
import javassist.ClassPool;
@Beta
+@Deprecated
public class BindingBrokerTestFactory {
private static final ClassPool CLASS_POOL = ClassPool.getDefault();
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
@Beta
+@Deprecated
public class BindingTestContext implements AutoCloseable {
private BindingToNormalizedNodeCodec codec;
import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
+@Deprecated
public final class MockSchemaService implements DOMSchemaService, SchemaContextProvider {
private SchemaContext schemaContext;
import org.opendaylight.yangtools.yang.binding.Notification;
import org.opendaylight.yangtools.yang.binding.RpcService;
+@Deprecated
public abstract class AbstractBindingSalConsumerInstance<N extends NotificationService, R extends RpcConsumerRegistry>
implements RpcConsumerRegistry, NotificationService {
import org.opendaylight.yangtools.yang.binding.Notification;
import org.opendaylight.yangtools.yang.binding.RpcService;
+@Deprecated
public abstract class AbstractBindingSalProviderInstance<N extends NotificationProviderService,
R extends RpcProviderRegistry>
extends AbstractBindingSalConsumerInstance<N, R>
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.RpcService;
+@Deprecated
public final class BindingContextUtils {
private BindingContextUtils() {
}
* @param <V> The result type returned by this Future's get method
* @param <X> The checked exception type
*/
+@Deprecated
public final class MappingCheckedFuture<V, X extends Exception> extends AbstractCheckedFuture<V, X> {
private final Function<Exception, X> mapper;
package org.opendaylight.controller.md.sal.common.api;
import java.util.EventListener;
-
import org.opendaylight.yangtools.concepts.Registration;
+@Deprecated
public interface RegistrationListener<T extends Registration> extends EventListener {
void onRegister(T registration);
* @param <D>
* Type of data (payload), which represents data payload
*/
+@Deprecated
public interface AsyncConfigurationCommitCohort<P extends Path<P>, D> {
/**
* @param <D>
* Type of data (payload), which represents data payload
*/
+@Deprecated
public interface AsyncConfigurationCommitCoordinator<P extends Path<P>, D> {
/**
* @param <D>
* Type of data (payload), which represents data payload
*/
+@Deprecated
public interface AsyncConfigurationCommitHandler<P extends Path<P>, D> {
/**
* @param <D>
* Type of data (payload), which represents data payload
*/
+@Deprecated
public interface AsyncDataBroker<P extends Path<P>, D> extends AsyncDataTransactionFactory<P, D> {
@Override
* @param <D>
* Type of data (payload), which represents data payload
*/
+@Deprecated
public interface AsyncDataTransactionFactory<P extends Path<P>, D> {
/**
* @param <D>
* Type of data (payload), which represents data payload
*/
+@Deprecated
public interface AsyncReadOnlyTransaction<P extends Path<P>, D> extends AsyncReadTransaction<P, D>, AutoCloseable {
/**
* @param <D>
* Type of data (payload), which represents data payload
*/
+@Deprecated
public interface AsyncReadTransaction<P extends Path<P>, D> extends AsyncTransaction<P, D> {
}
* @param <D>
* Type of data (payload), which represents data payload
*/
+@Deprecated
public interface AsyncReadWriteTransaction<P extends Path<P>, D> extends AsyncReadTransaction<P, D>,
AsyncWriteTransaction<P, D> {
* @param <P> Type of path (subtree identifier), which represents location in tree
* @param <D> Type of data (payload), which represents data payload
*/
+@Deprecated
public interface AsyncTransaction<P extends Path<P>,D> extends //
Identifiable<Object> {
* @param <D>
* Type of data (payload), which represents data payload
*/
+@Deprecated
public interface AsyncWriteTransaction<P extends Path<P>, D> extends AsyncTransaction<P, D> {
/**
* Cancels the transaction.
/**
* This exception occurs if the datastore is temporarily unavailable.
* A retry of the transaction may succeed after a period of time
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.common.api.DataStoreUnavailableException} instead.
*/
-
+@Deprecated
public class DataStoreUnavailableException extends Exception {
private static final long serialVersionUID = 1L;
public DataStoreUnavailableException(String message, Throwable cause) {
super(message, cause);
}
-
-
}
* failed, because other data submitted via transactions.
*
* <p>
- * Clients usually are not able recover from this error condition by
- * retrieving same transaction, since data introduced by this transaction
- * are invalid.
+ * Clients usually are not able recover from this error condition by
+ * retrieving same transaction, since data introduced by this transaction
+ * are invalid.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.common.api.DataValidationFailedException} instead.
*/
+@Deprecated
public class DataValidationFailedException extends TransactionCommitFailedException {
private static final long serialVersionUID = 1L;
import org.eclipse.jdt.annotation.NonNullByDefault;
+@Deprecated
@NonNullByDefault
public enum LogicalDatastoreType {
/**
* retrieving current state and submitting new updated
* transaction.
*
+ * @deprecated Use {@link org.opendaylight.mdsal.common.api.OptimisticLockFailedException} instead.
*/
+@Deprecated
public class OptimisticLockFailedException extends TransactionCommitFailedException {
private static final long serialVersionUID = 1L;
/**
* An exception for a failed read.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.common.api.ReadFailedException} instead.
*/
+@Deprecated
public class ReadFailedException extends OperationFailedException {
private static final long serialVersionUID = 1L;
* and leads to expected behavior: t2 will always see the data written in t1
* present.
*/
-public interface TransactionChain<P extends Path<P>, D> extends AutoCloseable,
-
AsyncDataTransactionFactory<P, D> {
+@Deprecated
+
public interface TransactionChain<P extends Path<P>, D> extends AutoCloseable, AsyncDataTransactionFactory<P, D> {
/**
* Create a new read only transaction which will continue the chain.
package org.opendaylight.controller.md.sal.common.api.data;
/**
- * Exception thrown when an attempt is made to open a new transaction in a closed
- * chain.
+ * Exception thrown when an attempt is made to open a new transaction in a closed chain.
*/
+@Deprecated
public final class TransactionChainClosedException extends IllegalStateException {
private static final long serialVersionUID = 1L;
/**
* Interface for creating transaction chains.
*/
+@Deprecated
public interface TransactionChainFactory<P extends Path<P>, D> {
/**
/**
* Listener for transaction chain events.
*/
+@Deprecated
public interface TransactionChainListener extends EventListener {
/**
* Invoked if when a transaction in the chain fails. All other transactions are automatically cancelled by the time
* won't occur.
*
* @author Thomas Pantelis
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.common.api.TransactionCommitDeadlockException} instead.
*/
+@Deprecated
public class TransactionCommitDeadlockException extends TransactionCommitFailedException {
private static final long serialVersionUID = 1L;
private static final String DEADLOCK_MESSAGE =
/**
* Failed commit of asynchronous transaction. This exception is raised and returned when transaction commit failed.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.common.api.TransactionCommitFailedException} instead.
*/
+@Deprecated
public class TransactionCommitFailedException extends OperationFailedException {
private static final long serialVersionUID = 1L;
* FIXME: Consider clarification of execution/delivery policy, how it will be
* affected by Actor model and cluster-wide notifications.
*
- * @param <N>
- * the type of notifications
+ * @param <N> the type of notifications
*/
+@Deprecated
public interface NotificationPublishService<N> {
/**
import java.util.EventListener;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
+@Deprecated
public interface NotificationSubscriptionService<T, N, L extends EventListener> {
ListenerRegistration<L> registerNotificationListener(T type, L listener);
* @param <C> Type, which is used to represent Routing context.
* @param <P> Type of data tree path, which is used to identify route.
*/
+@Deprecated
public interface RouteChange<C, P> {
/**
* @param <C> Type, which is used to represent Routing context.
* @param <P> Type of data tree path, which is used to identify route.
*/
+@Deprecated
public interface RouteChangeListener<C, P> extends EventListener {
/**
* @param <C> Type, which is used to represent Routing context.
* @param <P> Type of data tree path, which is used to identify route.
*/
+@Deprecated
public interface RouteChangePublisher<C,P> {
<L extends RouteChangeListener<C,P>> ListenerRegistration<L> registerRouteChangeListener(L listener);
* @param <P> the path identifier type
* @param <S> the RPC implementation type
*/
+@Deprecated
public interface RoutedRegistration<C, P extends Path<P>, S> extends Registration {
/**
package org.opendaylight.controller.md.sal.common.api.routing;
import java.util.Map;
-
import org.opendaylight.yangtools.concepts.Path;
+@Deprecated
public interface RoutingTable<C, P extends Path<P>, T> {
C getIdentifier();
*
* @author Thomas Pantelis
*/
+@Deprecated
public class MappingCheckedFutureTest {
interface FutureInvoker {
*/
package org.opendaylight.controller.md.sal.common.impl.util.compat;
+@Deprecated
public class DataNormalizationException extends Exception {
private static final long serialVersionUID = 1L;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
+@Deprecated
class DataSchemaContainerProxy implements DataNodeContainer {
private final Set<DataSchemaNode> realChildSchemas;
*
* @author Thomas Pantelis
*/
+@Deprecated
public class LegacyDOMStoreAdapter extends ForwardingObject implements DOMStore, AutoCloseable {
private final DistributedDataStoreInterface delegate;
* {@link DOMDataTreeChangeListener} enables notifications only at the leader of the data store.
*
* @author Thomas Pantelis
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.ClusteredDOMDataTreeChangeListener} instead.
*/
+@Deprecated
public interface ClusteredDOMDataTreeChangeListener extends DOMDataTreeChangeListener {
}
package org.opendaylight.controller.md.sal.dom.api;
/**
- * Type capture of a {@link DOMServiceExtension} applicable to {@link DOMDataBroker}
- * implementations.
+ * Type capture of a {@link DOMServiceExtension} applicable to {@link DOMDataBroker} implementations.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMDataBrokerExtension} instead.
*/
+@Deprecated
public interface DOMDataBrokerExtension extends DOMServiceExtension<DOMDataBroker, DOMDataBrokerExtension> {
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
public interface DOMDataReadOnlyTransaction extends DOMDataReadTransaction,
AsyncReadOnlyTransaction<YangInstanceIdentifier, NormalizedNode<?, ?>> {
}
*
* <p>
* For more information on usage and examples, please see the documentation in {@link AsyncReadTransaction}.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMDataTreeReadTransaction} instead.
*/
+@Deprecated
public interface DOMDataReadTransaction extends AsyncReadTransaction<YangInstanceIdentifier, NormalizedNode<?, ?>> {
/**
* Reads data from provided logical data store located at the provided path.
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
public interface DOMDataReadWriteTransaction extends DOMDataReadTransaction, DOMDataWriteTransaction,
AsyncReadWriteTransaction<YangInstanceIdentifier, NormalizedNode<?, ?>> {
}
* <p>
* Note: this interface enables notifications only at the leader of the data store, if clustered. If you want
* notifications on all instances in a cluster, use the {@link ClusteredDOMDataTreeChangeListener}.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMDataTreeChangeListener} instead.
*/
+@Deprecated
public interface DOMDataTreeChangeListener extends EventListener {
/**
* Invoked when there was data change for the supplied path, which was used
import org.opendaylight.yangtools.concepts.ListenerRegistration;
/**
- * A {@link DOMServiceExtension} which allows users to register for changes to a
- * subtree.
+ * A {@link DOMServiceExtension} which allows users to register for changes to a subtree.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMDataTreeChangeService} instead.
*/
+@Deprecated
public interface DOMDataTreeChangeService extends DOMDataBrokerExtension {
/**
* Registers a {@link DOMDataTreeChangeListener} to receive
* Interface for a DOM commit cohort registry.
*
* @author Thomas Pantelis
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry} instead.
*/
+@Deprecated
@SuppressFBWarnings("NM_SAME_SIMPLE_NAME_AS_INTERFACE")
public interface DOMDataTreeCommitCohortRegistry extends DOMDataBrokerExtension,
org.opendaylight.mdsal.dom.api.DOMDataTreeCommitCohortRegistry {
/**
* A unique identifier for a particular subtree. It is composed of the logical
* data store type and the instance identifier of the root node.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier} instead.
*/
+@Deprecated
public final class DOMDataTreeIdentifier implements Immutable,
Path<DOMDataTreeIdentifier>, Serializable, Comparable<DOMDataTreeIdentifier> {
private static final long serialVersionUID = 1L;
*
* <p>
* For more information on usage and examples, please see the documentation in {@link AsyncWriteTransaction}.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction} instead.
*/
+@Deprecated
public interface DOMDataWriteTransaction extends AsyncWriteTransaction<YangInstanceIdentifier, NormalizedNode<?, ?>> {
@Override
/**
* Generic event interface.
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMEvent} instead.
*/
+@Deprecated
@SuppressFBWarnings(value = "NM_SAME_SIMPLE_NAME_AS_INTERFACE", justification = "Migration")
public interface DOMEvent extends org.opendaylight.mdsal.dom.api.DOMEvent {
*
* @param <T> Base {@link DOMService}
* @param <E> Extension type
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMExtensibleService} instead.
*/
+@Deprecated
@Beta
public interface DOMExtensibleService<T extends DOMExtensibleService<T, E>,
E extends DOMServiceExtension<T, E>> extends DOMService {
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.md.sal.dom.api;
import com.google.common.base.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+@Deprecated
public interface DOMMountPoint extends Identifiable<YangInstanceIdentifier> {
<T extends DOMService> Optional<T> getService(Class<T> cls);
/**
* A single YANG notification.
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMNotification} instead.
*/
+@Deprecated
@SuppressFBWarnings(value = "NM_SAME_SIMPLE_NAME_AS_INTERFACE", justification = "Migration")
public interface DOMNotification extends org.opendaylight.mdsal.dom.api.DOMNotification {
}
/**
* Interface implemented by listeners interested in {@link DOMNotification}s.
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMNotificationListener} instead.
*/
+@Deprecated
public interface DOMNotificationListener extends EventListener {
/**
* Invoked whenever a {@link DOMNotification} matching the subscription
*
* <p>
* Expected use: {@link DOMNotificationPublishService}
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMNotificationRejectedException} instead.
*/
+@Deprecated
public class DOMNotificationRejectedException extends Exception {
private static final long serialVersionUID = 1L;
* some other RPC or action, or similar, which can separately fail. If a sub-request fails, such implementations are
* required do report {@link DOMRpcImplementationNotAvailableException} as the invocation result, with the underlying
* failure being linked as a cause.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener} instead.
*/
+@Deprecated
public interface DOMRpcAvailabilityListener extends EventListener {
/**
* Method invoked whenever an RPC type becomes available.
/**
* Base class for failures that can occur during RPC invocation. This covers
* transport and protocol-level failures.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMRpcException} instead.
*/
+@Deprecated
@SuppressFBWarnings(value = "NM_SAME_SIMPLE_NAME_AS_SUPERCLASS", justification = "Migration")
public abstract class DOMRpcException extends org.opendaylight.mdsal.dom.api.DOMRpcException {
private static final long serialVersionUID = 1L;
* always has global context. It allows an RPC to have a instance identifier
* attached, so that there can be multiple implementations bound to different
* contexts concurrently.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMRpcIdentifier} instead.
*/
+@Deprecated
public abstract class DOMRpcIdentifier {
private static final class Global extends DOMRpcIdentifier {
/**
* Interface implemented by an individual RPC implementation. This API allows for dispatch
* implementations, e.g. an individual object handling a multitude of RPCs.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMRpcImplementation} instead.
*/
+@Deprecated
public interface DOMRpcImplementation {
/**
* Initiate invocation of the RPC. Implementations of this method are
/**
* Exception indicating that no implementation of the requested RPC service is available.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException} instead.
*/
+@Deprecated
public class DOMRpcImplementationNotAvailableException extends DOMRpcException {
private static final long serialVersionUID = 1L;
* with a {@link DOMRpcProviderService}.
*
* @param <T> RPC implementation type
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMRpcImplementationRegistration} instead.
*/
+@Deprecated
public interface DOMRpcImplementationRegistration<T extends DOMRpcImplementation> extends ObjectRegistration<T> {
@Override
void close();
/**
* Interface defining a result of an RPC call.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMRpcResult} instead.
*/
+@Deprecated
@SuppressFBWarnings(value = "NM_SAME_SIMPLE_NAME_AS_INTERFACE", justification = "Migration")
public interface DOMRpcResult extends org.opendaylight.mdsal.dom.api.DOMRpcResult {
}
/**
* Marker interface for services which can be obtained from a {@link DOMMountPoint} instance. No further semantics are
* implied.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMService} instead.
*/
+@Deprecated
@SuppressFBWarnings(value = "NM_SAME_SIMPLE_NAME_AS_INTERFACE", justification = "Migration")
public interface DOMService extends org.opendaylight.mdsal.dom.api.DOMService {
import com.google.common.annotations.Beta;
/**
- * Marker interface for services which expose additional functionality on top
- * of some base {@link DOMService}.
+ * Marker interface for services which expose additional functionality on top of some base {@link DOMService}.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMServiceExtension} instead.
*/
@Beta
+@Deprecated
public interface DOMServiceExtension<T extends DOMExtensibleService<T, E>, E extends DOMServiceExtension<T, E>> {
}
*
* <p>
* This interface is type capture of {@link TransactionChain} for DOM Data Contracts.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DOMTransactionChain} instead.
*/
+@Deprecated
public interface DOMTransactionChain extends TransactionChain<YangInstanceIdentifier, NormalizedNode<?, ?>> {
@Override
* Default implementation of DOMRpcException.
*
* @author Thomas Pantelis
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.api.DefaultDOMRpcException} instead.
*/
+@Deprecated
public class DefaultDOMRpcException extends DOMRpcException {
private static final long serialVersionUID = 1L;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Deprecated
public abstract class AbstractDOMDataBroker extends AbstractDOMForwardedTransactionFactory<DOMStore>
implements DOMDataBroker {
private static final Logger LOG = LoggerFactory.getLogger(AbstractDOMDataBroker.class);
* @param <T>
* Subtransaction type
*/
+@Deprecated
abstract class AbstractDOMForwardedCompositeTransaction<K, T extends DOMStoreTransaction> implements
AsyncTransaction<YangInstanceIdentifier, NormalizedNode<?, ?>> {
* @param <T>
* Type of {@link DOMStoreTransactionFactory} factory.
*/
+@Deprecated
abstract class AbstractDOMForwardedTransactionFactory<T extends DOMStoreTransactionFactory> implements AutoCloseable {
@SuppressWarnings("rawtypes")
private static final AtomicIntegerFieldUpdater<AbstractDOMForwardedTransactionFactory> UPDATER =
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+@Deprecated
abstract class AbstractDOMRpcRoutingTableEntry {
private final Map<YangInstanceIdentifier, List<DOMRpcImplementation>> implementations;
private final SchemaPath schemaPath;
* Implementation of blocking three-phase commit-coordination tasks without
* support of cancellation.
*/
+@Deprecated
final class CommitCoordinationTask<T> implements Callable<T> {
private enum Phase {
canCommit,
* by several {@link DOMStoreTransactionChain} differentiated by provided
* {@link org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType} type.
*/
+@Deprecated
final class DOMDataBrokerTransactionChainImpl extends
AbstractDOMForwardedTransactionFactory<DOMStoreTransactionChain> implements DOMTransactionChain {
private enum State {
* {@link LogicalDatastoreType} type parameter in
* {@link #read(LogicalDatastoreType, YangInstanceIdentifier)}.
*/
+@Deprecated
class DOMForwardedReadOnlyTransaction extends
AbstractDOMForwardedCompositeTransaction<LogicalDatastoreType, DOMStoreReadTransaction> implements
DOMDataReadOnlyTransaction {
* for underlying transactions.
*
*/
+@Deprecated
final class DOMForwardedReadWriteTransaction extends DOMForwardedWriteTransaction<DOMStoreReadWriteTransaction>
implements DOMDataReadWriteTransaction {
protected DOMForwardedReadWriteTransaction(final Object identifier,
* @param <T> Subtype of {@link DOMStoreWriteTransaction} which is used as
* subtransaction.
*/
+@Deprecated
class DOMForwardedWriteTransaction<T extends DOMStoreWriteTransaction> extends
AbstractDOMForwardedCompositeTransaction<LogicalDatastoreType, T> implements DOMDataWriteTransaction {
@SuppressWarnings("rawtypes")
* {@link #offerNotification(DOMNotification, long, TimeUnit)}
* is realized by arming a background wakeup interrupt.
*/
+@Deprecated
@SuppressFBWarnings(value = "NP_NONNULL_PARAM_VIOLATION", justification = "Void is the only allowed value")
public final class DOMNotificationRouter extends LegacyDOMNotificationServiceAdapter implements AutoCloseable,
DOMNotificationPublishService, DOMNotificationSubscriptionListenerRegistry {
* A single notification event in the disruptor ringbuffer. These objects are reused,
* so they do have mutable state.
*/
+@Deprecated
final class DOMNotificationRouterEvent {
private static final Logger LOG = LoggerFactory.getLogger(DOMNotificationRouterEvent.class);
public static final EventFactory<DOMNotificationRouterEvent> FACTORY = DOMNotificationRouterEvent::new;
import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+@Deprecated
public final class DOMRpcRouter implements AutoCloseable, DOMRpcService, DOMRpcProviderService, SchemaContextListener {
// This mapping is used to translate mdsal DOMRpcImplementations to their corresponding legacy
// DOMRpcImplementations registered thru this interface when invoking a DOMRpcAvailabilityListener.
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+@Deprecated
final class DOMRpcRoutingTable {
static final DOMRpcRoutingTable EMPTY = new DOMRpcRoutingTable(ImmutableMap.of(), null);
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
+@Deprecated
final class GlobalDOMRpcRoutingTableEntry extends AbstractDOMRpcRoutingTableEntry {
private final DOMRpcIdentifier rpcId;
* guarantee transaction ordering between transactions allocated directly from the broker
* and its transaction chains.
*/
+@Deprecated
public final class PingPongDataBroker extends ForwardingDOMDataBroker implements AutoCloseable,
DOMDataTreeChangeService {
private final DOMDataBroker delegate;
* We never leak this class to the user and have it implement the {@link FutureCallback}
* interface so we have a simple way of propagating the result.
*/
+@Deprecated
final class PingPongTransaction implements FutureCallback<CommitInfo> {
private final DOMDataReadWriteTransaction delegate;
private final SettableFuture<CommitInfo> future;
* counts as an outstanding transaction and the user may not allocate multiple
* read-only transactions at the same time.
*/
+@Deprecated
public final class PingPongTransactionChain implements DOMTransactionChain {
private static final Logger LOG = LoggerFactory.getLogger(PingPongTransactionChain.class);
private final TransactionChainListener listener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Deprecated
final class RoutedDOMRpcRoutingTableEntry extends AbstractDOMRpcRoutingTableEntry {
private static final Logger LOG = LoggerFactory.getLogger(RoutedDOMRpcRoutingTableEntry.class);
private final DOMRpcIdentifier globalRpcId;
* <p>
* This executor does not have an upper bound on subtask timeout.
*/
+@Deprecated
public class SerializedDOMDataBroker extends AbstractDOMDataBroker {
private static final Logger LOG = LoggerFactory.getLogger(SerializedDOMDataBroker.class);
private final DurationStatisticsTracker commitStatsTracker = DurationStatisticsTracker.createConcurrent();
*
* @see ExceptionMapper
*/
+@Deprecated
public final class TransactionCommitFailedExceptionMapper extends ExceptionMapper<TransactionCommitFailedException> {
public static final TransactionCommitFailedExceptionMapper PRE_COMMIT_MAPPER = create("preCommit");
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+@Deprecated
final class UnknownDOMRpcRoutingTableEntry extends AbstractDOMRpcRoutingTableEntry {
private final CheckedFuture<DOMRpcResult, DOMRpcException> unknownRpc;
* and {@link ShardedDOMDataBrokerDelegatingReadTransaction} respectively.
*/
// FIXME try to refactor some of the implementation to abstract class for better reusability
+@Deprecated
public class LegacyShardedDOMDataBrokerAdapter implements DOMDataBroker {
private final org.opendaylight.mdsal.dom.api.DOMDataBroker delegateDataBroker;
* return all relevant data, we cannot guarantee it neither. Best effort is to
* return all data we get from first initial data change event received.
*/
+@Deprecated
class ShardedDOMDataBrokerDelegatingReadTransaction implements DOMDataReadOnlyTransaction {
private final DOMDataTreeReadTransaction delegateTx;
private final Object txIdentifier;
*
*/
// FIXME explicitly enforce just one subtree requirement
+@Deprecated
class ShardedDOMDataBrokerDelegatingReadWriteTransaction implements DOMDataReadWriteTransaction {
private final DOMDataReadOnlyTransaction readTxDelegate;
private final DOMDataWriteTransaction writeTxDelegate;
import org.opendaylight.mdsal.dom.api.DOMTransactionChainListener;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+@Deprecated
class ShardedDOMDataBrokerDelegatingTransactionChain implements DOMTransactionChain, DOMTransactionChainListener {
private final org.opendaylight.mdsal.dom.api.DOMTransactionChain txChainDelegate;
private final SchemaContext schemaContext;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
class ShardedDOMDataBrokerDelegatingWriteTransaction implements DOMDataWriteTransaction {
private final DOMDataTreeWriteTransaction delegateTx;
private final Object txIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+@Deprecated
public class DOMMountPointServiceImpl implements DOMMountPointService {
+ @Deprecated
private abstract static class CompatFactory<M extends org.opendaylight.mdsal.dom.api.DOMService,
C extends DOMService> {
private final Class<C> controllerClass;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
+@Deprecated
public final class SchemaContextProviders {
private SchemaContextProviders() {
/**
* ProxySchema Context for SchemaContextProviders.
*/
+@Deprecated
public class ProxySchemaContext implements SchemaContext {
private final SchemaContextProvider schemaProvider;
* futures ({@link #getFailFuture()} and {@link #getSuccessFuture()} when
* transaction chain event is retrieved.
*/
+@Deprecated
class BlockingTransactionChainListener implements TransactionChainListener {
private final SettableFuture<Throwable> failFuture = SettableFuture.create();
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Deprecated
public class DOMBrokerPerformanceTest {
private static final Logger LOG = LoggerFactory.getLogger(DOMBrokerPerformanceTest.class);
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+@Deprecated
public class DOMBrokerTest {
private SchemaContext schemaContext;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+@Deprecated
public class DOMDataTreeListenerTest {
private SchemaContext schemaContext;
package org.opendaylight.controller.md.sal.dom.broker.impl;
import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;
+@Deprecated
public class DOMForwardedWriteTransactionTest {
@Mock
*
* @author Thomas Pantelis
*/
+@Deprecated
public class DOMNotificationRouterTest {
private static final ContainerNode BODY = ImmutableContainerNodeBuilder.create().withNodeIdentifier(
new NodeIdentifier(QName.create(TestModel.TEST_QNAME.getModule(), "test-notification")))
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.after;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
*
* @author Thomas Pantelis
*/
+@Deprecated
public class DOMRpcRouterTest {
private static final NormalizedNode<?, ?> RPC_INPUT = ImmutableNodes.leafNode(
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+@Deprecated
public class DOMTransactionChainTest {
private SchemaContext schemaContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+@Deprecated
public class MountPointServiceTest {
private DOMMountPointService mountService;
package org.opendaylight.controller.md.sal.dom.broker.impl.legacy.sharded.adapter;
import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.verify;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
+@Deprecated
public class ShardedDOMDataBrokerDelegatingReadWriteTransactionTest {
@Mock
package org.opendaylight.controller.md.sal.dom.broker.impl.legacy.sharded.adapter;
import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.mdsal.dom.api.DOMTransactionChain;
+@Deprecated
public class ShardedDOMDataBrokerDelegatingTransactionChainTest {
@Mock
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
+@Deprecated
public final class TestModel {
private TestModel() {
*
* @author Thomas Pantelis
*/
+@Deprecated
@SuppressWarnings("checkstyle:ClassTypeParameterName")
public abstract class AbstractDOMRpcResultFutureAdapter<T extends DOMRpcResult, F extends DOMRpcResult,
D extends ListenableFuture<F>, E extends DOMRpcException> extends AbstractFuture<T> {
*
* @author Thomas Pantelis
*/
+@Deprecated
public abstract class AbstractLegacyDOMDataBrokerAdapter extends ForwardingObject implements DOMDataBroker {
private static final ExceptionMapper<TransactionCommitFailedException> COMMIT_EX_MAPPER =
new ExceptionMapper<TransactionCommitFailedException>("commit", TransactionCommitFailedException.class) {
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
public class DOMDataTreeReadTransactionAdapter extends ForwardingObject implements DOMDataTreeReadTransaction {
private final DOMDataReadOnlyTransaction delegate;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
public class DOMDataTreeReadWriteTransactionAdapter extends ForwardingObject
implements DOMDataTreeReadWriteTransaction {
private final DOMDataReadWriteTransaction delegate;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
public class DOMDataTreeWriteTransactionAdapter extends ForwardingObject
implements DOMDataTreeWriteTransaction {
private final DOMDataWriteTransaction delegate;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+@Deprecated
public abstract class DOMStoreAdapter<T extends org.opendaylight.mdsal.dom.spi.store.DOMStore
& org.opendaylight.mdsal.dom.spi.store.DOMStoreTreeChangePublisher> extends ForwardingObject
implements DOMStore, DOMStoreTreeChangePublisher {
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
public class DOMStoreReadTransactionAdapter<T extends org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction>
extends ForwardingObject implements DOMStoreReadTransaction {
private final T delegate;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
public class DOMStoreReadWriteTransactionAdapter
extends DOMStoreReadTransactionAdapter<org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction>
implements DOMStoreReadWriteTransaction {
import com.google.common.util.concurrent.ListenableFuture;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
+@Deprecated
public class DOMStoreThreePhaseCommitCohortAdapter extends ForwardingObject implements DOMStoreThreePhaseCommitCohort {
private final org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort delegate;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;
+@Deprecated
public class DOMStoreTransactionChainAdapter extends ForwardingObject implements DOMStoreTransactionChain {
private final org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionChain delegate;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
public class DOMStoreWriteTransactionAdapter extends ForwardingObject implements DOMStoreWriteTransaction {
private final org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction delegate;
*
* @author Thomas Pantelis
*/
+@Deprecated
public class LegacyDOMDataBrokerAdapter extends AbstractLegacyDOMDataBrokerAdapter {
public LegacyDOMDataBrokerAdapter(final org.opendaylight.mdsal.dom.api.DOMDataBroker delegate) {
super(delegate);
*
* @author Thomas Pantelis
*/
+@Deprecated
public class LegacyDOMRpcResultFutureAdapter extends AbstractDOMRpcResultFutureAdapter<DOMRpcResult,
org.opendaylight.mdsal.dom.api.DOMRpcResult, ListenableFuture<org.opendaylight.mdsal.dom.api.DOMRpcResult>,
DOMRpcException> implements CheckedFuture<DOMRpcResult, DOMRpcException> {
* Adapter between the legacy controller API-based DOMDataBroker and the mdsal API-based DOMDataBroker, equivalent
* to PingPongDOMDataBroker.
*/
+@Deprecated
public class LegacyPingPongDOMDataBrokerAdapter extends AbstractLegacyDOMDataBrokerAdapter {
public LegacyPingPongDOMDataBrokerAdapter(final org.opendaylight.mdsal.dom.api.DOMDataBroker delegate) {
super(delegate);
*
* @author Thomas Pantelis
*/
+@Deprecated
public class MdsalDOMRpcResultFutureAdapter extends AbstractDOMRpcResultFutureAdapter<
DOMRpcResult, org.opendaylight.controller.md.sal.dom.api.DOMRpcResult,
CheckedFuture<org.opendaylight.controller.md.sal.dom.api.DOMRpcResult,
*
* @author Thomas Pantelis
*/
+@Deprecated
public final class ReadFailedExceptionAdapter extends ExceptionMapper<ReadFailedException> {
public static final ReadFailedExceptionAdapter INSTANCE = new ReadFailedExceptionAdapter();
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
final class TransactionUtils {
private TransactionUtils() {
* Controller/MDSAL compatibility library. Contains classes useful for bridging Controller's sal-core-{api,spi}
* to MD-SAL's mdsal-dom-{api,spi}.
*/
+@Deprecated
package org.opendaylight.controller.sal.core.compat;
\ No newline at end of file
*
* @author Thomas Pantelis
*/
+@Deprecated
public class LegacyDOMDataBrokerAdapterTest {
public static final QName TEST_QNAME = QName.create("test", "2018-07-11", "test");
private static final YangInstanceIdentifier TEST_PATH = YangInstanceIdentifier.of(TEST_QNAME);
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.controller.md.sal.dom.broker.spi.mount;
import com.google.common.base.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+@Deprecated
public final class SimpleDOMMountPoint implements DOMMountPoint {
private final YangInstanceIdentifier identifier;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+@Deprecated
public abstract class RpcRoutingStrategy implements Identifiable<QName> {
private static final QName CONTEXT_REFERENCE = QName.create("urn:opendaylight:yang:extension:yang-ext",
* of {@link DOMDataTreeChangeListener}.
*
* @param <T> type of listener
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.AbstractDOMDataTreeChangeListenerRegistration} instead.
*/
+@Deprecated
public abstract class AbstractDOMDataTreeChangeListenerRegistration<T extends DOMDataTreeChangeListener>
extends AbstractListenerRegistration<T> {
protected AbstractDOMDataTreeChangeListenerRegistration(final T listener) {
/**
* Abstract base class for {@link DOMRpcImplementationRegistration} implementations.
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.AbstractDOMRpcImplementationRegistration} instead.
*/
+@Deprecated
public abstract class AbstractDOMRpcImplementationRegistration<T extends DOMRpcImplementation>
extends AbstractObjectRegistration<T> implements DOMRpcImplementationRegistration<T> {
protected AbstractDOMRpcImplementationRegistration(final T instance) {
/**
* Convenience abstract base class for {@link DOMRpcProviderService} implementations.
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.AbstractDOMRpcProviderService} instead.
*/
+@Deprecated
public abstract class AbstractDOMRpcProviderService implements DOMRpcProviderService {
@Override
public final <T extends DOMRpcImplementation> DOMRpcImplementationRegistration<T> registerRpcImplementation(
* provides set of notification types for which currently
* subscriptions are in place.
*
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.DOMNotificationSubscriptionListener} instead.
*/
@Beta
+@Deprecated
@SuppressFBWarnings(value = "NM_SAME_SIMPLE_NAME_AS_INTERFACE", justification = "Migration")
public interface DOMNotificationSubscriptionListener
extends org.opendaylight.mdsal.dom.spi.DOMNotificationSubscriptionListener {
* Registry of {@link DOMNotificationSubscriptionListener}
* which listens for changes in notification types.
*
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.DOMNotificationSubscriptionListenerRegistry} instead.
*/
+@Deprecated
@Beta
public interface DOMNotificationSubscriptionListenerRegistry {
/**
* Utility class implementing {@link DefaultDOMRpcResult}.
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult} instead.
*/
+@Deprecated
@Beta
public final class DefaultDOMRpcResult implements DOMRpcResult, Immutable, Serializable {
private static final long serialVersionUID = 1L;
/**
* Utility {@link DOMDataBroker} implementation which forwards all interface
* method invocation to a delegate instance.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.ForwardingDOMDataBroker} instead.
*/
+@Deprecated
public abstract class ForwardingDOMDataBroker extends ForwardingObject implements DOMDataBroker {
@Override
protected abstract @NonNull DOMDataBroker delegate();
/**
* Utility {@link DOMDataReadOnlyTransaction} implementation which forwards all interface
* method invocation to a delegate instance.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.ForwardingDOMDataReadOnlyTransaction} instead.
*/
+@Deprecated
public abstract class ForwardingDOMDataReadOnlyTransaction extends ForwardingObject
implements DOMDataReadOnlyTransaction {
@Override
/**
* Utility {@link DOMDataReadWriteTransaction} implementation which forwards all interface
* method invocation to a delegate instance.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.ForwardingDOMDataReadWriteTransaction} instead.
*/
+@Deprecated
public abstract class ForwardingDOMDataReadWriteTransaction extends ForwardingObject
implements DOMDataReadWriteTransaction {
@Override
/**
* Utility {@link DOMDataWriteTransaction} implementation which forwards all interface
* method invocation to a delegate instance.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.ForwardingDOMDataWriteTransaction} instead.
*/
+@Deprecated
public abstract class ForwardingDOMDataWriteTransaction extends ForwardingObject implements DOMDataWriteTransaction {
@Override
protected abstract @NonNull DOMDataWriteTransaction delegate();
/**
* Utility implementations of {@link DOMNotificationPublishService} which forwards
* all requests to a delegate instance.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.ForwardingDOMNotificationPublishService} instead.
*/
+@Deprecated
public abstract class ForwardingDOMNotificationPublishService extends ForwardingObject
implements DOMNotificationPublishService {
@Override
/**
* Utility implementation of a {@link DOMNotificationService} which forwards all requests
* to a delegate instance.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.ForwardingDOMNotificationService} instead.
*/
+@Deprecated
public abstract class ForwardingDOMNotificationService extends ForwardingObject implements DOMNotificationService {
@Override
protected abstract DOMNotificationService delegate();
/**
* Utility implementation which implements {@link DOMRpcImplementation} by forwarding it to
* a backing delegate.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.ForwardingDOMRpcImplementation} instead.
*/
+@Deprecated
public abstract class ForwardingDOMRpcImplementation extends ForwardingObject implements DOMRpcImplementation {
@Override
protected abstract @NonNull DOMRpcImplementation delegate();
/**
* Utility class which implements {@link DOMRpcProviderService} by forwarding
* requests to a backing instance.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.ForwardingDOMRpcProviderService} instead.
*/
+@Deprecated
public abstract class ForwardingDOMRpcProviderService extends ForwardingObject implements DOMRpcProviderService {
@Override
protected abstract @NonNull DOMRpcProviderService delegate();
/**
* Utility class which implements {@link DOMRpcResult} by forwarding all methods
* to a backing instance.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.ForwardingDOMRpcResult} instead.
*/
+@Deprecated
public abstract class ForwardingDOMRpcResult extends ForwardingObject implements DOMRpcResult {
@Override
protected abstract @NonNull DOMRpcResult delegate();
/**
* Utility {@link DOMRpcService} which forwards all requests to a backing delegate instance.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.ForwardingDOMRpcService} instead.
*/
+@Deprecated
public abstract class ForwardingDOMRpcService extends ForwardingObject implements DOMRpcService {
@Override
protected abstract @NonNull DOMRpcService delegate();
/**
* Utility {@link DOMTransactionChain} implementation which forwards all interface
* method invocation to a delegate instance.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.ForwardingDOMTransactionChain} instead.
*/
+@Deprecated
public abstract class ForwardingDOMTransactionChain extends ForwardingObject implements DOMTransactionChain {
@Override
protected abstract @NonNull DOMTransactionChain delegate();
* It can optionally capture the context where it was allocated.
*
* @param <T> identifier type
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.store.AbstractDOMStoreTransaction} instead.
*/
+@Deprecated
@Beta
public abstract class AbstractDOMStoreTransaction<T> implements DOMStoreTransaction {
private final Throwable debugContext;
/**
* Abstract base class for {@link DOMStoreTreeChangePublisher} implementations.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.store.AbstractDOMStoreTreeChangePublisher} instead.
*/
+@Deprecated
public abstract class AbstractDOMStoreTreeChangePublisher
extends AbstractRegistrationTree<AbstractDOMDataTreeChangeListenerRegistration<?>>
implements DOMStoreTreeChangePublisher {
* supplier and backend commit coordinator.
*
* @param <T> transaction identifier type
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.store.AbstractSnapshotBackedTransactionChain} instead.
*/
+@Deprecated
@Beta
public abstract class AbstractSnapshotBackedTransactionChain<T> extends TransactionReadyPrototype<T>
implements DOMStoreTransactionChain, TransactionClosePrototype<T> {
* {@link #newWriteOnlyTransaction()} and {@link #newReadWriteTransaction()}, or
* by creating {@link org.opendaylight.controller.md.sal.common.api.data.TransactionChain}.
*
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.store.DOMStore} instead.
*/
+@Deprecated
public interface DOMStore extends DOMStoreTransactionFactory {
/**
* Creates new transaction chain.
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
public interface DOMStoreReadTransaction extends DOMStoreTransaction {
/**
/**
* Combination of a {@link DOMStoreReadTransaction} and {@link DOMStoreWriteTransaction}.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction} instead.
*/
+@Deprecated
public interface DOMStoreReadWriteTransaction extends DOMStoreReadTransaction, DOMStoreWriteTransaction {
}
* upon its transition to Ready state. The frontend (DOMStore user) uses this interface to drive the
* commit procedure across potentially multiple DOMStores using the Three-Phase-Commit (3PC) Protocol,
* as described in <a href="https://en.wikipedia.org/wiki/Three-phase_commit">Three-Phase-Commit Protocol</a>.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.store.DOMStoreThreePhaseCommitCohort} instead.
*/
+@Deprecated
public interface DOMStoreThreePhaseCommitCohort {
/**
* @see DOMStoreReadTransaction
* @see DOMStoreWriteTransaction
* @see DOMStoreReadWriteTransaction
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.store.DOMStoreTransaction} instead.
*/
+@Deprecated
public interface DOMStoreTransaction extends AutoCloseable, Identifiable<Object> {
/**
* Unique identifier of the transaction.
* sequence and each transaction must see the effects of previous transactions
* as if they happened. A chain makes no guarantees of atomicity, in fact
* transactions are committed as soon as possible.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionChain} instead.
*/
+@Deprecated
public interface DOMStoreTransactionChain extends DOMStoreTransactionFactory, AutoCloseable {
/**
* between {@link DOMStore} and {@link DOMStoreTransactionChain}, which
* further specify behaviour of returned transactions.
*
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionFactory} instead.
*/
+@Deprecated
public interface DOMStoreTransactionFactory {
/**
/**
* Interface implemented by DOMStore implementations which allow registration
* of {@link DOMDataTreeChangeListener} instances.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.store.DOMStoreTreeChangePublisher} instead.
*/
+@Deprecated
public interface DOMStoreTreeChangePublisher {
/**
* Registers a {@link DOMDataTreeChangeListener} to receive
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
public interface DOMStoreWriteTransaction extends DOMStoreTransaction {
/**
/**
* Abstract base class for {@link DOMStoreThreePhaseCommitCohort} implementations,
* which forward most of their functionality to a backend {@link #delegate()}.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.store.ForwardingDOMStoreThreePhaseCommitCohort} instead.
*/
+@Deprecated
@Beta
public abstract class ForwardingDOMStoreThreePhaseCommitCohort extends ForwardingObject
implements DOMStoreThreePhaseCommitCohort {
* which delegates most of its calls to similar methods provided by underlying snapshot.
*
* @param <T> identifier type
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.store.SnapshotBackedReadTransaction} instead.
*/
+@Deprecated
@Beta
public final class SnapshotBackedReadTransaction<T> extends AbstractDOMStoreTransaction<T>
implements DOMStoreReadTransaction {
* and executed according to {@link TransactionReadyPrototype}.
*
* @param <T> identifier type
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.store.SnapshotBackedReadWriteTransaction} instead.
*/
+@Deprecated
@Beta
public final class SnapshotBackedReadWriteTransaction<T> extends SnapshotBackedWriteTransaction<T>
implements DOMStoreReadWriteTransaction {
/**
* Public utility class for instantiating snapshot-backed transactions.
+ *
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.store.SnapshotBackedTransactions} instead.
*/
+@Deprecated
@Beta
public final class SnapshotBackedTransactions {
private SnapshotBackedTransactions() {
* {@link org.opendaylight.controller.sal.core.spi.data.SnapshotBackedWriteTransaction.TransactionReadyPrototype}.
*
* @param <T> Identifier type
+ * @deprecated Use {@link org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction} instead.
*/
+@Deprecated
@Beta
public class SnapshotBackedWriteTransaction<T> extends AbstractDOMStoreTransaction<T>
implements DOMStoreWriteTransaction {
*
* @param <T> identifier type
*/
+ @Deprecated
public abstract static class TransactionReadyPrototype<T> {
/**
* Called when a transaction is closed without being readied. This is not invoked for
*
* @author Thomas Pantelis
*/
+@Deprecated
public interface DOMStoreStatsTracker {
/**
Code Review / controller.git / commitdiff