org.opendaylight.mdsal.binding.javav2.spi

Class ForwardingDataBroker

java.lang.Object

com.google.common.collect.ForwardingObject

org.opendaylight.mdsal.binding.javav2.spi.ForwardingDataBroker

All Implemented Interfaces:

BindingService, DataBroker, DataTreeProducerFactory, DataTreeService, TransactionFactory

public abstract class ForwardingDataBroker
extends com.google.common.collect.ForwardingObject
implements DataBroker

Utility DataBroker implementation which forwards all interface method invocation to a delegate instance.

Constructor Summary

Constructors

Constructor and Description
ForwardingDataBroker()

Method Summary

Modifier and Type	Method and Description
DataTreeProducer	createProducer(Collection<DataTreeIdentifier<?>> subtrees) Create a producer, which is able to access to a set of trees.
TransactionChain	createTransactionChain(TransactionChainListener listener) Create a new transaction chain.
protected abstract DataBroker	delegate()
ReadTransaction	newReadOnlyTransaction() Allocates a new read-only transaction which provides an immutable snapshot of the data tree.
WriteTransaction	newWriteOnlyTransaction() Allocates new write-only transaction based on latest state of data tree.
<T extends DataTreeListener> org.opendaylight.yangtools.concepts.ListenerRegistration<T>	registerListener(T listener, Collection<DataTreeIdentifier<?>> subtrees, boolean allowRxMerges, Collection<DataTreeProducer> producers) Register a DataTreeListener instance.

Methods inherited from class com.google.common.collect.ForwardingObject

toString

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

ForwardingDataBroker

public ForwardingDataBroker()

Method Detail

delegate

@Nonnull
protected abstract DataBroker delegate()

Specified by:

delegate in class com.google.common.collect.ForwardingObject

newReadOnlyTransaction

public ReadTransaction newReadOnlyTransaction()

Description copied from interface: TransactionFactory

Allocates a new read-only transaction which provides an immutable snapshot of the data tree. The view of data tree is an immutable snapshot of current data tree state when transaction was allocated.

Specified by:

newReadOnlyTransaction in interface TransactionFactory

Returns:

A new read-only transaction

newWriteOnlyTransaction

public WriteTransaction newWriteOnlyTransaction()

Description copied from interface: TransactionFactory

Allocates new write-only transaction based on latest state of data tree.

Preconditions for mutation of data tree are captured from the snapshot of data tree state, when the transaction is allocated. If data was changed during transaction in an incompatible way then the commit of this transaction will fail. See WriteTransaction.commit() for more details about conflicting and not-conflicting changes and failure scenarios.

Since this transaction does not provide a view of the data it SHOULD BE used only by callers who are exclusive writers (exporters of data) to the subtree they modify. This prevents optimistic lock failures as described in WriteTransaction.commit().

Exclusivity of writers to particular subtree SHOULD BE enforced by external locking mechanism.

Specified by:

newWriteOnlyTransaction in interface TransactionFactory

Returns:

new write-only transaction

registerListener

@Nonnull
public <T extends DataTreeListener> org.opendaylight.yangtools.concepts.ListenerRegistration<T> registerListener(@Nonnull
                                                                                                                          T listener,
                                                                                                                          @Nonnull
                                                                                                                          Collection<DataTreeIdentifier<?>> subtrees,
                                                                                                                          boolean allowRxMerges,
                                                                                                                          @Nonnull
                                                                                                                          Collection<DataTreeProducer> producers)
                                                                                                                   throws DataTreeLoopException

Description copied from interface: DataTreeService

Register a DataTreeListener instance. Once registered, the listener will start receiving changes on the selected subtrees. If the listener cannot keep up with the rate of changes, and allowRxMerges is set to true, this service is free to merge the changes, so that a smaller number of them will be reported, possibly hiding some data transitions (like flaps).

If the listener wants to write into any producer, that producer has to be mentioned in the call to this method. Those producers will be bound exclusively to the registration, so that accessing them outside of this listener's callback will trigger an error. Any producers mentioned must be idle, e.g. they may not have an open transaction at the time this method is invoked.

Each listener instance can be registered at most once. Implementations of this interface have to guarantee that the listener's methods will not be invoked concurrently from multiple threads.

Specified by:

registerListener in interface DataTreeService

Type Parameters:

T - listener type

Parameters:

listener - DataTreeListener that is being registered

subtrees - Conceptual subtree identifier of subtrees which should be monitored for changes. May not be null or empty.

allowRxMerges - True if the backend may perform ingress state compression.

producers - DataTreeProducer instances to bind to the listener.

Returns:

A listener registration. Once closed, the listener will no longer be invoked and the producers will be unbound.

Throws:

DataTreeLoopException - if the registration of the listener to the specified subtrees with specified producers would form a feedback loop

createProducer

public DataTreeProducer createProducer(Collection<DataTreeIdentifier<?>> subtrees)

Description copied from interface: DataTreeProducerFactory

Create a producer, which is able to access to a set of trees.

Specified by:

createProducer in interface DataTreeProducerFactory

Parameters:

subtrees - The collection of subtrees the resulting producer should have access to.

Returns:

A DataTreeProducer instance.

createTransactionChain

public TransactionChain createTransactionChain(TransactionChainListener listener)

Description copied from interface: DataBroker

Create a new transaction chain. The chain will be initialized to read from its backing datastore, with no outstanding transaction. Listener will be registered to handle chain-level events.

Specified by:

createTransactionChain in interface DataBroker

Parameters:

listener - Transaction chain event listener

Returns:

A new transaction chain.