org.opendaylight.controller.md.sal.dom.spi

Class ForwardingDOMDataBroker

java.lang.Object

com.google.common.collect.ForwardingObject

org.opendaylight.controller.md.sal.dom.spi.ForwardingDOMDataBroker

All Implemented Interfaces:

AsyncDataBroker<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode<?,?>,DOMDataChangeListener>, AsyncDataTransactionFactory<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode<?,?>>, TransactionChainFactory<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode<?,?>>, DOMDataBroker, DOMExtensibleService<DOMDataBroker,DOMDataBrokerExtension>, DOMService, BrokerService

Direct Known Subclasses:

PingPongDataBroker

public abstract class ForwardingDOMDataBroker
extends com.google.common.collect.ForwardingObject
implements DOMDataBroker

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

Nested Class Summary

Nested classes/interfaces inherited from interface org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker

AsyncDataBroker.DataChangeScope

Constructor Summary

Constructors

Constructor and Description
ForwardingDOMDataBroker()

Method Summary

Modifier and Type	Method and Description
DOMTransactionChain	createTransactionChain(TransactionChainListener listener) Create a new transaction chain.
protected abstract DOMDataBroker	delegate()
Map<Class<? extends DOMDataBrokerExtension>,DOMDataBrokerExtension>	getSupportedExtensions() Return a map of currently-supported extensions, along with accessor services which provide access to the specific functionality bound to this service.
DOMDataReadOnlyTransaction	newReadOnlyTransaction() Allocates a new read-only transaction which provides an immutable snapshot of the data tree.
DOMDataReadWriteTransaction	newReadWriteTransaction() Allocates new read-write transaction which provides a mutable view of the data tree.
DOMDataWriteTransaction	newWriteOnlyTransaction() Allocates new write-only transaction based on latest state of data tree.
org.opendaylight.yangtools.concepts.ListenerRegistration<DOMDataChangeListener>	registerDataChangeListener(LogicalDatastoreType store, org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier path, DOMDataChangeListener listener, AsyncDataBroker.DataChangeScope triggeringScope) Registers a AsyncDataChangeListener to receive notifications when data changes under a given path in the conceptual data tree.

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

ForwardingDOMDataBroker

public ForwardingDOMDataBroker()

Method Detail

delegate

@Nonnull
protected abstract DOMDataBroker delegate()

Specified by:

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

registerDataChangeListener

public org.opendaylight.yangtools.concepts.ListenerRegistration<DOMDataChangeListener> registerDataChangeListener(LogicalDatastoreType store,
                                                                                                                  org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier path,
                                                                                                                  DOMDataChangeListener listener,
                                                                                                                  AsyncDataBroker.DataChangeScope triggeringScope)

Description copied from interface: AsyncDataBroker

Registers a AsyncDataChangeListener to receive notifications when data changes under a given path in the conceptual data tree.

You are able to register for notifications for any node or subtree which can be reached via the supplied path.

If path type P allows it, you may specify paths up to the leaf nodes then it is possible to listen on leaf nodes.

You are able to register for data change notifications for a subtree even if it does not exist. You will receive notification once that node is created.

If there is any preexisting data in data tree on path for which you are registering, you will receive initial data change event, which will contain all preexisting data, marked as created.

You are also able to specify the scope of the changes you want to be notified.

Supported scopes are:

• AsyncDataBroker.DataChangeScope.BASE - notification events will only be triggered when a node referenced by path is created, removed or replaced.
• AsyncDataBroker.DataChangeScope.ONE - notifications events will only be triggered when a node referenced by path is created, removed or replaced, or any or any of its immediate children are created, updated or removed.
• AsyncDataBroker.DataChangeScope.SUBTREE - notification events will be triggered when a node referenced by the path is created, removed or replaced or any of the children in its subtree are created, removed or replaced.

See AsyncDataBroker.DataChangeScope for examples.

This method returns a ListenerRegistration object. To "unregister" your listener for changes call the "close" method on this returned object.

You MUST call close when you no longer need to receive notifications (such as during shutdown or for example if your bundle is shutting down).

Specified by:

registerDataChangeListener in interface AsyncDataBroker<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode<?,?>,DOMDataChangeListener>

Parameters:

store - Logical Data Store - Logical Datastore you want to listen for changes in. For example LogicalDatastoreType.OPERATIONAL or LogicalDatastoreType.CONFIGURATION

path - Path (subtree identifier) on which client listener will be invoked.

listener - Instance of listener which should be invoked on

triggeringScope - Scope of change which triggers callback.

Returns:

Listener registration object, which may be used to unregister your listener using ListenerRegistration.close() to stop delivery of change events.

newReadOnlyTransaction

public DOMDataReadOnlyTransaction newReadOnlyTransaction()

Description copied from interface: DOMDataBroker

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 AsyncDataBroker<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode<?,?>,DOMDataChangeListener>

Specified by:

newReadOnlyTransaction in interface AsyncDataTransactionFactory<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode<?,?>>

Specified by:

newReadOnlyTransaction in interface DOMDataBroker

Returns:

new read-only transaction

newReadWriteTransaction

public DOMDataReadWriteTransaction newReadWriteTransaction()

Description copied from interface: DOMDataBroker

Allocates new read-write transaction which provides a mutable view of the 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 AsyncWriteTransaction.commit() for more details about conflicting and not-conflicting changes and failure scenarios.

Specified by:

newReadWriteTransaction in interface AsyncDataBroker<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode<?,?>,DOMDataChangeListener>

Specified by:

newReadWriteTransaction in interface AsyncDataTransactionFactory<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode<?,?>>

Specified by:

newReadWriteTransaction in interface DOMDataBroker

Returns:

new read-write transaction

newWriteOnlyTransaction

public DOMDataWriteTransaction newWriteOnlyTransaction()

Description copied from interface: DOMDataBroker

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 AsyncWriteTransaction.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 which are exclusive writers (exporters of data) to the subtree they modify. This prevents optimistic lock failures as described in AsyncWriteTransaction.commit().

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

Specified by:

newWriteOnlyTransaction in interface AsyncDataBroker<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode<?,?>,DOMDataChangeListener>

Specified by:

newWriteOnlyTransaction in interface AsyncDataTransactionFactory<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode<?,?>>

Specified by:

newWriteOnlyTransaction in interface DOMDataBroker

Returns:

new write-only transaction

createTransactionChain

public DOMTransactionChain createTransactionChain(TransactionChainListener listener)

Description copied from interface: DOMDataBroker

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 TransactionChainFactory<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode<?,?>>

Specified by:

createTransactionChain in interface DOMDataBroker

Parameters:

listener - Transaction chain event listener

Returns:

A new transaction chain.

getSupportedExtensions

public Map<Class<? extends DOMDataBrokerExtension>,DOMDataBrokerExtension> getSupportedExtensions()

Description copied from interface: DOMExtensibleService

Return a map of currently-supported extensions, along with accessor services which provide access to the specific functionality bound to this service.

Specified by:

getSupportedExtensions in interface DOMExtensibleService<DOMDataBroker,DOMDataBrokerExtension>

Returns:

A map of supported functionality.