org.opendaylight.mdsal.binding.api

Interface WriteOperations

All Known Subinterfaces:

ReadWriteOperations, ReadWriteTransaction, WriteTransaction

All Known Implementing Classes:

ForwardingReadWriteTransaction, ForwardingWriteTransaction

public interface WriteOperations

Write-like operations supported by WriteTransaction and ReadWriteTransaction. This interface defines the operations without a tie-in with lifecycle management.

Field Summary

Fields

Modifier and Type	Field and Description
static boolean	CREATE_MISSING_PARENTS Deprecated. To be removed with merge(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean) and put(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean).
static boolean	FAIL_ON_MISSING_PARENTS Deprecated. To be removed with merge(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean) and put(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean).

Method Summary

Modifier and Type	Method and Description
void	delete(@NonNull LogicalDatastoreType store, @NonNull InstanceIdentifier<?> path) Removes a piece of data from specified path.
<T extends DataObject> void	merge(@NonNull LogicalDatastoreType store, @NonNull InstanceIdentifier<T> path, T data) Merges a piece of data with the existing data at a specified path.
<T extends DataObject> void	merge(@NonNull LogicalDatastoreType store, @NonNull InstanceIdentifier<T> path, T data, boolean createMissingParents) Deprecated. Use merge(LogicalDatastoreType, InstanceIdentifier, DataObject) or mergeParentStructureMerge(LogicalDatastoreType, InstanceIdentifier, DataObject) instead.
default <T extends DataObject> void	mergeParentStructureMerge(@NonNull LogicalDatastoreType store, @NonNull InstanceIdentifier<T> path, T data) Merges a piece of data with the existing data at a specified path.
default <T extends DataObject> void	mergeParentStructurePut(@NonNull LogicalDatastoreType store, @NonNull InstanceIdentifier<T> path, T data) Stores a piece of data at the specified path.
<T extends DataObject> void	put(@NonNull LogicalDatastoreType store, @NonNull InstanceIdentifier<T> path, T data) Stores a piece of data at the specified path.
<T extends DataObject> void	put(@NonNull LogicalDatastoreType store, @NonNull InstanceIdentifier<T> path, T data, boolean createMissingParents) Deprecated. Use put(LogicalDatastoreType, InstanceIdentifier, DataObject) or mergeParentStructurePut(LogicalDatastoreType, InstanceIdentifier, DataObject) instead.

Field Detail

CREATE_MISSING_PARENTS

@Deprecated
static final boolean CREATE_MISSING_PARENTS

Deprecated. To be removed with merge(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean) and put(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean).

Flag value indicating that missing parents should be created.

WARNING: Using this flag may introduce garbage in data store, or recreate nodes, which were deleted by a previous transaction. It is not necessary in most scenarios and also has a significantly higher cost than FAIL_ON_MISSING_PARENTS and should only be used when absolutely necessary.

See Also:

Constant Field Values

FAIL_ON_MISSING_PARENTS

@Deprecated
static final boolean FAIL_ON_MISSING_PARENTS

Deprecated. To be removed with merge(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean) and put(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean).

Flag value indicating that missing parents should cause an error.

See Also:

Constant Field Values

Method Detail

put

<T extends DataObject> void put(@NonNull LogicalDatastoreType store,
                                @NonNull InstanceIdentifier<T> path,
                                T data)

Stores a piece of data at the specified path. This acts as an add / replace operation, which is to say that whole subtree will be replaced by the specified data.

If you need to make sure that a parent object exists but you do not want modify its pre-existing state by using put, consider using merge(org.opendaylight.mdsal.common.api.LogicalDatastoreType, org.opendaylight.yangtools.yang.binding.InstanceIdentifier<T>, T) instead.

Parameters:

store - the logical data store which should be modified

path - the data object path

data - the data object to be written to the specified path

Throws:

IllegalStateException - if the transaction has already been submitted

NullPointerException - if any of the arguments is null

put

@Deprecated
<T extends DataObject> void put(@NonNull LogicalDatastoreType store,
                                            @NonNull InstanceIdentifier<T> path,
                                            T data,
                                            boolean createMissingParents)

Deprecated. Use put(LogicalDatastoreType, InstanceIdentifier, DataObject) or mergeParentStructurePut(LogicalDatastoreType, InstanceIdentifier, DataObject) instead.

Stores a piece of data at the specified path. This acts as an add / replace operation, which is to say that whole subtree will be replaced by the specified data.

If you need to make sure that a parent object exists but you do not want modify its pre-existing state by using put, consider using merge(org.opendaylight.mdsal.common.api.LogicalDatastoreType, org.opendaylight.yangtools.yang.binding.InstanceIdentifier<T>, T) instead. WARNING: Using this method may introduce garbage in data store, or recreate nodes, which were deleted by a previous transaction. It is not necessary in most scenarios and has a significantly higher cost than put(LogicalDatastoreType, InstanceIdentifier, DataObject) and should only be used when absolutely necessary.

Parameters:

store - the logical data store which should be modified

path - the data object path

data - the data object to be written to the specified path

createMissingParents - if CREATE_MISSING_PARENTS, any missing parent nodes will be automatically created using a merge operation. WARNING: using this option is not needed in most scenarios and has a significant performance cost and should be avoided whenever possible.

Throws:

IllegalStateException - if the transaction has already been submitted

NullPointerException - if any of the arguments is null

mergeParentStructurePut

@Beta
default <T extends DataObject> void mergeParentStructurePut(@NonNull LogicalDatastoreType store,
                                                                  @NonNull InstanceIdentifier<T> path,
                                                                  T data)

Stores a piece of data at the specified path. This acts as an add / replace operation, which is to say that whole subtree will be replaced by the specified data. Unlike put(LogicalDatastoreType, InstanceIdentifier, DataObject), this method will attempt to create semantically-significant parent nodes, like list entries and presence containers, as indicated by path.

If you need to make sure that a parent object exists but you do not want modify its pre-existing state by using put, consider using merge(org.opendaylight.mdsal.common.api.LogicalDatastoreType, org.opendaylight.yangtools.yang.binding.InstanceIdentifier<T>, T) instead.

WARNING: Using this method may introduce garbage in data store, or recreate nodes, which were deleted by a previous transaction. It also has a significantly higher cost than put(LogicalDatastoreType, InstanceIdentifier, DataObject) and should only be used when absolutely necessary.

Parameters:

store - the logical data store which should be modified

path - the data object path

data - the data object to be written to the specified path

Throws:

IllegalStateException - if the transaction has already been submitted

NullPointerException - if any of the arguments is null

merge

<T extends DataObject> void merge(@NonNull LogicalDatastoreType store,
                                  @NonNull InstanceIdentifier<T> path,
                                  T data)

Merges a piece of data with the existing data at a specified path. Any pre-existing data which is not explicitly overwritten will be preserved. This means that if you store a container, its child lists will be merged.

If you require an explicit replace operation, use put(org.opendaylight.mdsal.common.api.LogicalDatastoreType, org.opendaylight.yangtools.yang.binding.InstanceIdentifier<T>, T) instead.

Parameters:

store - the logical data store which should be modified

path - the data object path

data - the data object to be merged to the specified path

Throws:

IllegalStateException - if the transaction has already been submitted

NullPointerException - if any of the arguments is null

merge

@Deprecated
<T extends DataObject> void merge(@NonNull LogicalDatastoreType store,
                                              @NonNull InstanceIdentifier<T> path,
                                              T data,
                                              boolean createMissingParents)

Deprecated. Use merge(LogicalDatastoreType, InstanceIdentifier, DataObject) or mergeParentStructureMerge(LogicalDatastoreType, InstanceIdentifier, DataObject) instead.

Merges a piece of data with the existing data at a specified path. Any pre-existing data which is not explicitly overwritten will be preserved. This means that if you store a container, its child lists will be merged.

If you require an explicit replace operation, use put(org.opendaylight.mdsal.common.api.LogicalDatastoreType, org.opendaylight.yangtools.yang.binding.InstanceIdentifier<T>, T) instead.

Parameters:

store - the logical data store which should be modified

path - the data object path

data - the data object to be merged to the specified path

createMissingParents - if CREATE_MISSING_PARENTS, any missing parent nodes will be automatically created using a merge operation. WARNING: using this option is not needed in most scenarios and has a significant performance cost and should be avoided whenever possible.

Throws:

IllegalStateException - if the transaction has already been submitted

NullPointerException - if any of the arguments is null

mergeParentStructureMerge

@Beta
default <T extends DataObject> void mergeParentStructureMerge(@NonNull LogicalDatastoreType store,
                                                                    @NonNull InstanceIdentifier<T> path,
                                                                    T data)

Merges a piece of data with the existing data at a specified path. Any pre-existing data which is not explicitly overwritten will be preserved. This means that if you store a container, its child lists will be merged. Unlike merge(LogicalDatastoreType, InstanceIdentifier, DataObject), this method will attempt to create semantically-significant parent nodes, like list entries and presence containers, as indicated by path.

If you require an explicit replace operation, use put(org.opendaylight.mdsal.common.api.LogicalDatastoreType, org.opendaylight.yangtools.yang.binding.InstanceIdentifier<T>, T) instead.

WARNING: Using this method may introduce garbage in data store, or recreate nodes, which were deleted by a previous transaction. It is not necessary in most scenarios and has a significantly higher cost than merge(LogicalDatastoreType, InstanceIdentifier, DataObject). It should only be used when absolutely necessary.

Parameters:

store - the logical data store which should be modified

path - the data object path

data - the data object to be merged to the specified path

Throws:

IllegalStateException - if the transaction has already been submitted

NullPointerException - if any of the arguments is null

delete

void delete(@NonNull LogicalDatastoreType store,
            @NonNull InstanceIdentifier<?> path)

Removes a piece of data from specified path. This operation does not fail if the specified path does not exist.

Parameters:

store - Logical data store which should be modified

path - Data object path

Throws:

IllegalStateException - if the transaction was committed or canceled.