});
}
+ @Deprecated
private class ForwardedBackwardsCompatibleTransacion extends
AbstractReadWriteTransaction implements DataModificationTransaction {
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+@Deprecated
public abstract class LegacyDataChangeEvent implements
DataChangeEvent<InstanceIdentifier<? extends DataObject>, DataObject> {
import com.google.common.collect.ImmutableMap.Builder;
import com.google.common.collect.Maps;
+@Deprecated
public class DataBrokerImpl extends
AbstractDataBroker<InstanceIdentifier<? extends DataObject>, DataObject, DataChangeListener> //
implements DataProviderService, AutoCloseable {
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+@Deprecated
public class DataTransactionImpl extends AbstractDataTransaction<InstanceIdentifier<? extends DataObject>, DataObject>
implements DataModificationTransaction {
private final ListenerRegistry<DataTransactionListener> listeners = new ListenerRegistry<DataTransactionListener>();
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+@Deprecated
class BindingToDomTransaction implements
DataCommitHandler.DataCommitTransaction<InstanceIdentifier<? extends DataObject>, DataObject> {
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+@Deprecated
class DomToBindingTransaction implements
DataCommitHandler.DataCommitTransaction<YangInstanceIdentifier, CompositeNode> {
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
+@Deprecated
public class MultipleAugmentationPutsTest extends AbstractDataServiceTest implements DataChangeListener {
private static final QName NODE_ID_QNAME = QName.create(Node.QNAME, "id");
updateYangSchema(moduleInfos);
}
- @SuppressWarnings("deprecation")
+ @Deprecated
public DataProviderService getBindingDataBroker() {
return baData;
}
- @SuppressWarnings("deprecation")
+ @Deprecated
public org.opendaylight.controller.sal.core.api.data.DataProviderService getDomDataBroker() {
return biDataLegacyBroker;
}
import org.opendaylight.controller.md.sal.common.api.data.DataReader;
import org.opendaylight.yangtools.concepts.Path;
+@Deprecated
public abstract class AbstractDataModification<P extends Path<P>, D> implements DataModification<P, D> {
private final Map<P, D> operationalOriginal;
* @param <P>
* @param <D>
*/
+@Deprecated
public abstract class AbstractDataReadRouter<P extends Path<P>, D> implements DataReader<P, D> {
Multimap<P, DataReaderRegistration<P, D>> configReaders = Multimaps.synchronizedSetMultimap(HashMultimap.<P, DataReaderRegistration<P, D>>create());
import com.google.common.collect.Multimaps;
import com.google.common.util.concurrent.MoreExecutors;
+@Deprecated
public abstract class AbstractDataBroker<P extends Path<P>, D extends Object, DCL extends DataChangeListener<P, D>>
implements DataModificationTransactionFactory<P, D>, DataReader<P, D>, DataChangePublisher<P, D, DCL>,
DataProvisionService<P, D> {
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Deprecated
public abstract class AbstractDataTransaction<P extends Path<P>, D extends Object> extends
AbstractDataModification<P, D> {
private static final Logger LOG = LoggerFactory.getLogger(AbstractDataTransaction.class);
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.concepts.Path;
+@Deprecated
public class DataChangeEventImpl<P extends Path<P>, D> implements DataChangeEvent<P, D>, Immutable {
private final DataChange<P, D> dataChange;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
+@Deprecated
public final class ImmutableDataChangeEvent<P extends Path<P>, D> implements DataChangeEvent<P,D> {
private final D updatedOperationalSubtree;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.concepts.Path;
+@Deprecated
public class InitialDataChangeEventImpl<P extends Path<P>,D> implements DataChangeEvent<P, D>, Immutable {
private final D updatedOperationalTree;
import com.google.common.base.Predicate;
+@Deprecated
public final class ListenerStateCapture<P extends Path<P>, D, DCL extends DataChangeListener<P, D>> {
final P path;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
+@Deprecated
public class TwoPhaseCommit<P extends Path<P>, D extends Object, DCL extends DataChangeListener<P, D>> implements
Callable<RpcResult<TransactionStatus>> {
private final static Logger log = LoggerFactory.getLogger(TwoPhaseCommit.class);
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
+/**
+ * @deprecated This class provides compatibility between {@link CompositeNode} and {@link NormalizedNode}.
+ * Users of this class should use {@link NormalizedNode}s directly.
+ */
+@Deprecated
public abstract class DataNormalizationOperation<T extends PathArgument> implements Identifiable<T> {
private final T identifier;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
+/**
+ * @deprecated This class provides compatibility between {@link CompositeNode} and {@link NormalizedNode}.
+ * Users of this class should use {@link NormalizedNode}s directly.
+ */
+@Deprecated
public class DataNormalizer {
private final DataNormalizationOperation<?> operation;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
+@Deprecated
public class DataNormalizerTest {
static class NormalizedNodeData {
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+/**
+ * @deprecated Utility class for {@link DataCommitTransaction}, will be removed at the same time.
+ */
+@Deprecated
public class CommitHandlerTransactions {
private static class AllwaysSuccessfulTransaction<P extends Path<P>,D> implements DataCommitTransaction<P, D> {
import org.opendaylight.controller.config.yang.md.sal.dom.impl.Transactions;
import org.opendaylight.controller.sal.dom.broker.DataBrokerImpl;
+@Deprecated
public class DomBrokerRuntimeMXBeanImpl implements
DomBrokerImplRuntimeMXBean {
package org.opendaylight.controller.md.sal.dom.broker.impl.compat;
import javax.annotation.concurrent.ThreadSafe;
-
import org.opendaylight.controller.md.sal.common.api.RegistrationListener;
import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler;
import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandlerRegistration;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
+@Deprecated
@ThreadSafe
public class BackwardsCompatibleDataBroker implements DataProviderService {
package org.opendaylight.controller.md.sal.dom.broker.impl.compat;
import static com.google.common.base.Preconditions.checkNotNull;
-
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.impl.service.AbstractDataTransaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.ListenableFuture;
-
-public abstract class BackwardsCompatibleTransaction<T extends DOMDataReadTransaction> implements
-DataModificationTransaction, Delegator<T> {
+@Deprecated
+public abstract class BackwardsCompatibleTransaction<T extends DOMDataReadTransaction> implements DataModificationTransaction, Delegator<T> {
private static final Logger LOG = LoggerFactory.getLogger(BackwardsCompatibleTransaction.class);
*/
package org.opendaylight.controller.md.sal.dom.broker.impl.compat;
+import com.google.common.collect.Maps;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
-
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.DataChangeEvent;
import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationException;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import com.google.common.collect.Maps;
-
-public abstract class TranslatingDataChangeEvent implements
-DataChangeEvent<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> {
+@Deprecated
+public abstract class TranslatingDataChangeEvent implements DataChangeEvent<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> {
private TranslatingDataChangeEvent() {
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+@Deprecated
abstract class TranslatingListenerInvoker implements AutoCloseable, DOMDataChangeListener, Delegator<DataChangeListener> {
private final DataChangeListener delegate;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
+@Deprecated
public class BackwardsCompatibleMountPoint implements MountProvisionInstance, SchemaContextProvider, SchemaService {
private final DataProviderService dataReader;
import org.opendaylight.yangtools.util.ListenerRegistry;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+@Deprecated
public class BackwardsCompatibleMountPointManager implements MountProvisionService, MountProvisionListener {
private final ListenerRegistry<MountProvisionListener> listeners = ListenerRegistry.create();
import com.google.common.util.concurrent.MoreExecutors;
+@Deprecated
public class DataBrokerImpl extends AbstractDataBroker<YangInstanceIdentifier, CompositeNode, DataChangeListener> implements
DataProviderService, AutoCloseable {
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+@Deprecated
public class DataTransactionImpl extends AbstractDataTransaction<YangInstanceIdentifier, CompositeNode>
implements DataModificationTransaction {
private final ListenerRegistry<DataTransactionListener> listeners = new ListenerRegistry<DataTransactionListener>();
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class DataReaderRouter extends
-AbstractDataReadRouter<YangInstanceIdentifier, CompositeNode> {
+@Deprecated
+public class DataReaderRouter extends AbstractDataReadRouter<YangInstanceIdentifier, CompositeNode> {
private final static Logger LOG = LoggerFactory
.getLogger(DataReaderRouter.class);
private final static URI NETCONF_NAMESPACE = URI
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+@Deprecated
public class DataStoreStatsWrapper implements Delegator<DataStore>, DataStore {
private final DataStore delegate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class SchemaAwareDataStoreAdapter extends AbstractLockableDelegator<DataStore> implements //
-DataStore, //
-SchemaContextListener, //
-AutoCloseable {
+@Deprecated
+public class SchemaAwareDataStoreAdapter extends AbstractLockableDelegator<DataStore> implements DataStore, SchemaContextListener, AutoCloseable {
private final static Logger LOG = LoggerFactory.getLogger(SchemaAwareDataStoreAdapter.class);
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.osgi.framework.ServiceReference;
+@Deprecated
public class DataBrokerServiceProxy extends AbstractBrokerServiceProxy<DataBrokerService> implements DataBrokerService {
public DataBrokerServiceProxy(ServiceReference<DataBrokerService> ref, DataBrokerService delegate) {
public DataModificationTransaction beginTransaction() {
return getDelegate().beginTransaction();
}
-
-
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.osgi.framework.ServiceReference;
-public class DataProviderServiceProxy extends AbstractBrokerServiceProxy<DataProviderService> implements
- DataProviderService {
+@Deprecated
+public class DataProviderServiceProxy extends AbstractBrokerServiceProxy<DataProviderService> implements DataProviderService {
- public DataProviderServiceProxy(ServiceReference<DataProviderService> ref, DataProviderService delegate) {
+ public DataProviderServiceProxy(final ServiceReference<DataProviderService> ref, final DataProviderService delegate) {
super(ref, delegate);
}
- public ListenerRegistration<DataChangeListener> registerDataChangeListener(YangInstanceIdentifier path,
- DataChangeListener listener) {
+ @Override
+ public ListenerRegistration<DataChangeListener> registerDataChangeListener(final YangInstanceIdentifier path,
+ final DataChangeListener listener) {
return addRegistration(getDelegate().registerDataChangeListener(path, listener));
}
- public CompositeNode readConfigurationData(YangInstanceIdentifier path) {
+ @Override
+ public CompositeNode readConfigurationData(final YangInstanceIdentifier path) {
return getDelegate().readConfigurationData(path);
}
- public CompositeNode readOperationalData(YangInstanceIdentifier path) {
+ @Override
+ public CompositeNode readOperationalData(final YangInstanceIdentifier path) {
return getDelegate().readOperationalData(path);
}
+ @Override
public DataModificationTransaction beginTransaction() {
return getDelegate().beginTransaction();
}
@Override
- public void addRefresher(DataStoreIdentifier store, DataRefresher refresher) {
+ public void addRefresher(final DataStoreIdentifier store, final DataRefresher refresher) {
getDelegate().addRefresher(store, refresher);
}
@Override
- public void addValidator(DataStoreIdentifier store, DataValidator validator) {
+ public void addValidator(final DataStoreIdentifier store, final DataValidator validator) {
getDelegate().addValidator(store, validator);
}
@Override
public Registration registerCommitHandler(
- YangInstanceIdentifier path, DataCommitHandler<YangInstanceIdentifier, CompositeNode> commitHandler) {
+ final YangInstanceIdentifier path, final DataCommitHandler<YangInstanceIdentifier, CompositeNode> commitHandler) {
return addRegistration(getDelegate().registerCommitHandler(path, commitHandler));
}
@Override
public Registration registerConfigurationReader(
- YangInstanceIdentifier path, DataReader<YangInstanceIdentifier, CompositeNode> reader) {
+ final YangInstanceIdentifier path, final DataReader<YangInstanceIdentifier, CompositeNode> reader) {
return addRegistration(getDelegate().registerConfigurationReader(path, reader));
}
@Override
public Registration registerOperationalReader(
- YangInstanceIdentifier path, DataReader<YangInstanceIdentifier, CompositeNode> reader) {
+ final YangInstanceIdentifier path, final DataReader<YangInstanceIdentifier, CompositeNode> reader) {
return addRegistration(getDelegate().registerOperationalReader(path, reader));
}
@Override
- public void removeRefresher(DataStoreIdentifier store, DataRefresher refresher) {
+ public void removeRefresher(final DataStoreIdentifier store, final DataRefresher refresher) {
getDelegate().removeRefresher(store, refresher);
}
@Override
- public void removeValidator(DataStoreIdentifier store, DataValidator validator) {
+ public void removeValidator(final DataStoreIdentifier store, final DataValidator validator) {
getDelegate().removeValidator(store, validator);
}
@Override
public ListenerRegistration<RegistrationListener<DataCommitHandlerRegistration<YangInstanceIdentifier, CompositeNode>>> registerCommitHandlerListener(
- RegistrationListener<DataCommitHandlerRegistration<YangInstanceIdentifier, CompositeNode>> commitHandlerListener) {
+ final RegistrationListener<DataCommitHandlerRegistration<YangInstanceIdentifier, CompositeNode>> commitHandlerListener) {
return addRegistration(getDelegate().registerCommitHandlerListener(commitHandlerListener));
}
}
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.osgi.framework.ServiceReference;
+@Deprecated
public class MountProviderServiceProxy extends AbstractBrokerServiceProxy<MountProvisionService> implements MountProvisionService{
return ((T) _createProxyImpl);
}
+ @Deprecated
private static Object _createProxyImpl(final ServiceReference<?> ref,
final DataBrokerService service) {
((ServiceReference<DataBrokerService>) ref), service);
}
+ @Deprecated
private static Object _createProxyImpl(final ServiceReference<?> ref,
final DataProviderService service) {
((ServiceReference<NotificationService>) ref), service);
}
+ @Deprecated
private static Object _createProxyImpl(final ServiceReference<?> ref,
final MountProvisionService service) {
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+@Deprecated
public class YangDataOperations {
public static CompositeNode merge(final DataSchemaNode schema,
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
+@Deprecated
public final class YangDataUtils {
private YangDataUtils() {
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Deprecated
public class BackwardsCompatibleMountPointManagerTest {
private static final Logger log = LoggerFactory.getLogger(BackwardsCompatibleMountPointManagerTest.class);