<T extends DataObject> void put(@NonNull LogicalDatastoreType store, @NonNull InstanceIdentifier<T> path,
@NonNull 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.
- *
- * <p>
- * 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 {@link #merge} instead.
- *
- * <b>WARNING:</b> 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 {@link #put(LogicalDatastoreType, InstanceIdentifier, DataObject)} and should only be used
- * when absolutely necessary.
- *
- * @param store the logical data store which should be modified
- * @param path the data object path
- * @param data the data object to be written to the specified path
- * @param createMissingParents if {@link #CREATE_MISSING_PARENTS}, any missing parent nodes will be automatically
- * created using a merge operation. <b>WARNING:</b> 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
- * @throws NullPointerException if any of the arguments is null
- * @deprecated Use {@link #put(LogicalDatastoreType, InstanceIdentifier, DataObject)} or
- * {@link #mergeParentStructurePut(LogicalDatastoreType, InstanceIdentifier, DataObject)}
- * instead.
- */
- @Deprecated(forRemoval = true)
- default <T extends DataObject> void put(@NonNull LogicalDatastoreType store, @NonNull InstanceIdentifier<T> path,
- @NonNull T data, boolean createMissingParents) {
- if (createMissingParents) {
- mergeParentStructurePut(store, path, data);
- } else {
- put(store, path, 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
<T extends DataObject> void merge(@NonNull LogicalDatastoreType store, @NonNull InstanceIdentifier<T> path,
@NonNull 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.
- *
- * <p>
- * If you require an explicit replace operation, use {@link #put} instead.
- *
- * @param store the logical data store which should be modified
- * @param path the data object path
- * @param data the data object to be merged to the specified path
- * @param createMissingParents if {@link #CREATE_MISSING_PARENTS}, any missing parent nodes will be automatically
- * created using a merge operation. <b>WARNING:</b> 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
- * @throws NullPointerException if any of the arguments is null
- * @deprecated Use {@link #merge(LogicalDatastoreType, InstanceIdentifier, DataObject)} or
- * {@link #mergeParentStructureMerge(LogicalDatastoreType, InstanceIdentifier, DataObject)}
- * instead.
- */
- @Deprecated(forRemoval = true)
- default <T extends DataObject> void merge(@NonNull LogicalDatastoreType store, @NonNull InstanceIdentifier<T> path,
- @NonNull T data, boolean createMissingParents) {
- if (createMissingParents) {
- mergeParentStructureMerge(store, path, data);
- } else {
- merge(store, path, 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
* @throws IllegalStateException if the transaction was committed or canceled.
*/
void delete(@NonNull LogicalDatastoreType store, @NonNull InstanceIdentifier<?> path);
-
- /**
- * Flag value indicating that missing parents should be created.
- *
- * <p>
- * <b>WARNING:</b> 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 {@link #FAIL_ON_MISSING_PARENTS} and should only be used when absolutely necessary.
- *
- * @deprecated To be removed with {@link #merge(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean)}
- * and {@link #put(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean)}.
- */
- @Deprecated(forRemoval = true)
- boolean CREATE_MISSING_PARENTS = true;
-
- /**
- * Flag value indicating that missing parents should cause an error.
- *
- * @deprecated To be removed with {@link #merge(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean)}
- * and {@link #put(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean)}.
- */
- @Deprecated(forRemoval = true)
- boolean FAIL_ON_MISSING_PARENTS = false;
}
delegate.put(store, path, data);
}
- @Override
- @Deprecated
- public <T extends DataObject> void put(final LogicalDatastoreType store, final InstanceIdentifier<T> path,
- final T data, final boolean createMissingParents) {
- delegate.put(store, path, data, createMissingParents);
- }
-
@Override
public <T extends DataObject> void mergeParentStructurePut(final LogicalDatastoreType store,
final InstanceIdentifier<T> path, final T data) {
delegate.merge(store, path, data);
}
- @Override
- @Deprecated
- public <T extends DataObject> void merge(final LogicalDatastoreType store, final InstanceIdentifier<T> path,
- final T data, final boolean createMissingParents) {
- delegate.merge(store, path, data, createMissingParents);
- }
-
@Override
public <T extends DataObject> void mergeParentStructureMerge(final LogicalDatastoreType store,
final InstanceIdentifier<T> path, final T data) {
delegate.put(store, path, data);
}
- @Override
- @Deprecated
- public <T extends DataObject> void put(final LogicalDatastoreType store, final InstanceIdentifier<T> path,
- final T data, final boolean createMissingParents) {
- delegate.put(store, path, data, createMissingParents);
- }
-
@Override
public <T extends DataObject> void mergeParentStructurePut(final LogicalDatastoreType store,
final InstanceIdentifier<T> path, final T data) {
delegate.merge(store, path, data);
}
- @Override
- @Deprecated
- public <T extends DataObject> void merge(final LogicalDatastoreType store, final InstanceIdentifier<T> path,
- final T data, final boolean createMissingParents) {
- delegate.merge(store, path, data, createMissingParents);
- }
-
@Override
public <T extends DataObject> void mergeParentStructureMerge(final LogicalDatastoreType store,
final InstanceIdentifier<T> path, final T data) {
delegate.put(path, data);
}
- @Override
- @Deprecated
- public <T extends DataObject> void put(final LogicalDatastoreType store, final InstanceIdentifier<T> path,
- final T data, final boolean createMissingParents) {
- checkStore(store);
- delegate.put(path, data, createMissingParents);
- }
-
@Override
public <T extends DataObject> void mergeParentStructurePut(final LogicalDatastoreType store,
final InstanceIdentifier<T> path, final T data) {
delegate.merge(path, data);
}
- @Override
- @Deprecated
- public <T extends DataObject> void merge(final LogicalDatastoreType store, final InstanceIdentifier<T> path,
- final T data, final boolean createMissingParents) {
- checkStore(store);
- delegate.merge(path, data, createMissingParents);
- }
-
@Override
public <T extends DataObject> void mergeParentStructureMerge(final LogicalDatastoreType store,
final InstanceIdentifier<T> path, final T data) {
*/
<T extends DataObject> void put(InstanceIdentifier<T> path, T data);
- /**
- * Writes an object to the given path, creating missing parents if requested.
- *
- * @see WriteOperations#put(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean)
- *
- * @param path The path to write to.
- * @param data The object to write.
- * @param createMissingParents {@link WriteOperations#CREATE_MISSING_PARENTS} to create missing parents,
- * {@link WriteOperations#FAIL_ON_MISSING_PARENTS} to fail if parents are missing.
- * @param <T> The type of the provided object.
- * @deprecated Use {@link #put(InstanceIdentifier, DataObject)} or
- * {@link #mergeParentStructurePut(InstanceIdentifier, DataObject)} instead.
- */
- @Deprecated
- default <T extends DataObject> void put(final InstanceIdentifier<T> path, final T data,
- final boolean createMissingParents) {
- if (createMissingParents) {
- mergeParentStructurePut(path, data);
- } else {
- put(path, data);
- }
- }
-
/**
* Writes an object to the given path, creating significant parents, like presence containers and list entries,
* if needed.
*/
<T extends DataObject> void merge(InstanceIdentifier<T> path, T data);
- /**
- * Merges an object with the data already present at the given path, creating significant parents, like presence
- * containers and list entries, if needed.
- *
- * @see WriteOperations#merge(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean)
- *
- * @param path The path to write to.
- * @param data The object to merge.
- * @param createMissingParents {@link WriteOperations#CREATE_MISSING_PARENTS} to create missing parents,
- * {@link WriteOperations#FAIL_ON_MISSING_PARENTS} to fail if parents are missing.
- * @param <T> The type of the provided object.
- * @deprecated Use {@link #merge(InstanceIdentifier, DataObject)} or
- * {@link #mergeParentStructureMerge(InstanceIdentifier, DataObject)} instead.
- */
- @Deprecated
- default <T extends DataObject> void merge(final InstanceIdentifier<T> path, final T data,
- final boolean createMissingParents) {
- if (createMissingParents) {
- mergeParentStructureMerge(path, data);
- } else {
- merge(path, data);
- }
- }
-
/**
* Merges an object with the data already present at the given path, creating missing parents if requested.
*
- * @see WriteOperations#merge(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean)
+ * @see WriteOperations#merge(LogicalDatastoreType, InstanceIdentifier, DataObject)
*
* @param path The path to write to.
* @param data The object to merge.
postOperation();
}
- @Override
- @Deprecated
- public final <T extends DataObject> void put(final InstanceIdentifier<T> path, final T data,
- final boolean createMissingParents) {
- delegate().put(getDatastoreType(), path, data, createMissingParents);
- postOperation();
- }
-
@Override
public final <T extends DataObject> void mergeParentStructurePut(final InstanceIdentifier<T> path,
final T data) {
postOperation();
}
- @Override
- @Deprecated
- public final <T extends DataObject> void merge(final InstanceIdentifier<T> path, final T data,
- final boolean createMissingParents) {
- delegate().merge(getDatastoreType(), path, data, createMissingParents);
- postOperation();
- }
-
@Override
public final <T extends DataObject> void mergeParentStructureMerge(final InstanceIdentifier<T> path,
final T data) {
written = true;
}
- @Override
- @Deprecated
- public <T extends DataObject> void put(final LogicalDatastoreType store, final InstanceIdentifier<T> path,
- final T data, final boolean createMissingParents) {
- super.put(store, path, data, createMissingParents);
- written = true;
- }
-
@Override
public <T extends DataObject> void mergeParentStructurePut(final LogicalDatastoreType store,
final InstanceIdentifier<T> path, final T data) {
written = true;
}
- @Override
- @Deprecated
- public <T extends DataObject> void merge(final LogicalDatastoreType store, final InstanceIdentifier<T> path,
- final T data, final boolean createMissingParents) {
- super.merge(store, path, data, createMissingParents);
- written = true;
- }
-
@Override
public <T extends DataObject> void mergeParentStructureMerge(final LogicalDatastoreType store,
final InstanceIdentifier<T> path, final T data) {
// This is only ever read *after* changes to the transaction are complete
private boolean written;
- WriteTrackingWriteTransaction(WriteTransaction delegate) {
+ WriteTrackingWriteTransaction(final WriteTransaction delegate) {
super(delegate);
}
@Override
- public <T extends DataObject> void put(LogicalDatastoreType store, InstanceIdentifier<T> path, T data) {
+ public <T extends DataObject> void put(final LogicalDatastoreType store, final InstanceIdentifier<T> path,
+ final T data) {
super.put(store, path, data);
written = true;
}
@Override
- public <T extends DataObject> void put(LogicalDatastoreType store, InstanceIdentifier<T> path, T data,
- boolean createMissingParents) {
- super.put(store, path, data, createMissingParents);
- written = true;
- }
-
- @Override
- public <T extends DataObject> void merge(LogicalDatastoreType store, InstanceIdentifier<T> path, T data) {
+ public <T extends DataObject> void merge(final LogicalDatastoreType store, final InstanceIdentifier<T> path,
+ final T data) {
super.merge(store, path, data);
written = true;
}
@Override
- public <T extends DataObject> void merge(LogicalDatastoreType store, InstanceIdentifier<T> path, T data,
- boolean createMissingParents) {
- super.merge(store, path, data, createMissingParents);
- written = true;
- }
-
- @Override
- public void delete(LogicalDatastoreType store, InstanceIdentifier<?> path) {
+ public void delete(final LogicalDatastoreType store, final InstanceIdentifier<?> path) {
super.delete(store, path);
written = true;
}