*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Predicate;
+import static java.util.Objects.requireNonNull;
+
import java.util.Collection;
import java.util.Map;
+import java.util.Optional;
+import java.util.function.Predicate;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.NotThreadSafe;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
/**
- * Node Modification Node and Tree
+ * Node Modification Node and Tree.
*
+ * <p>
* Tree which structurally resembles data tree and captures client modifications to the data store tree. This tree is
* lazily created and populated via {@link #modifyChild(PathArgument, ModificationApplyOperation, Version)} and
* {@link TreeNode} which represents original state as tracked by {@link #getOriginal()}.
*
+ * <p>
* The contract is that the state information exposed here preserves the temporal ordering of whatever modifications
* were executed. A child's effects pertain to data node as modified by its ancestors. This means that in order to
* reconstruct the effective data node presentation, it is sufficient to perform a depth-first pre-order traversal of
@NotThreadSafe
final class ModifiedNode extends NodeModification implements StoreTreeNode<ModifiedNode> {
static final Predicate<ModifiedNode> IS_TERMINAL_PREDICATE = input -> {
- Preconditions.checkNotNull(input);
+ requireNonNull(input);
switch (input.getOperation()) {
case DELETE:
case MERGE:
case TOUCH:
case NONE:
return false;
+ default:
+ throw new IllegalArgumentException("Unhandled modification type " + input.getOperation());
}
-
- throw new IllegalArgumentException(String.format("Unhandled modification type %s", input.getOperation()));
};
private final Map<PathArgument, ModifiedNode> children;
private Optional<TreeNode> validatedCurrent;
private TreeNode validatedNode;
- private ModifiedNode(final PathArgument identifier, final Optional<TreeNode> original, final ChildTrackingPolicy childPolicy) {
+ private ModifiedNode(final PathArgument identifier, final Optional<TreeNode> original,
+ final ChildTrackingPolicy childPolicy) {
this.identifier = identifier;
this.original = original;
this.children = childPolicy.createMap();
}
/**
+ * Returns child modification if child was modified.
*
- * Returns child modification if child was modified
- *
- * @return Child modification if direct child or it's subtree
- * was modified.
- *
+ * @return Child modification if direct child or it's subtree was modified.
*/
@Override
public Optional<ModifiedNode> getChild(final PathArgument child) {
- return Optional.fromNullable(children.get(child));
+ return Optional.ofNullable(children.get(child));
}
private Optional<TreeNode> metadataFromSnapshot(@Nonnull final PathArgument child) {
- return original.isPresent() ? original.get().getChild(child) : Optional.absent();
+ return original.isPresent() ? original.get().getChild(child) : Optional.empty();
}
private Optional<TreeNode> metadataFromData(@Nonnull final PathArgument child, final Version modVersion) {
*/
private Optional<TreeNode> findOriginalMetadata(@Nonnull final PathArgument child, final Version modVersion) {
switch (operation) {
- case DELETE:
- // DELETE implies non-presence
- return Optional.absent();
- case NONE:
- case TOUCH:
- case MERGE:
- return metadataFromSnapshot(child);
- case WRITE:
- // WRITE implies presence based on written data
- return metadataFromData(child, modVersion);
+ case DELETE:
+ // DELETE implies non-presence
+ return Optional.empty();
+ case NONE:
+ case TOUCH:
+ case MERGE:
+ return metadataFromSnapshot(child);
+ case WRITE:
+ // WRITE implies presence based on written data
+ return metadataFromData(child, modVersion);
+ default:
+ throw new IllegalStateException("Unhandled node operation " + operation);
}
-
- throw new IllegalStateException("Unhandled node operation " + operation);
}
/**
- *
* Returns child modification if child was modified, creates {@link ModifiedNode}
- * for child otherwise.
- *
- * If this node's {@link ModificationType} is {@link ModificationType#UNMODIFIED}
- * changes modification type to {@link ModificationType#SUBTREE_MODIFIED}
+ * for child otherwise. If this node's {@link ModificationType} is {@link ModificationType#UNMODIFIED}
+ * changes modification type to {@link ModificationType#SUBTREE_MODIFIED}.
*
* @param child child identifier, may not be null
* @param childOper Child operation
}
/**
- * Returns all recorded direct child modification
+ * Returns all recorded direct child modifications.
*
* @return all recorded direct child modifications
*/
final LogicalOperation newType;
switch (operation) {
- case DELETE:
- case NONE:
- // We need to record this delete.
- newType = LogicalOperation.DELETE;
- break;
- case MERGE:
- // In case of merge - delete needs to be recored and must not to be changed into
- // NONE, because lazy expansion of parent MERGE node would reintroduce it
- // again.
+ case DELETE:
+ case NONE:
+ // We need to record this delete.
newType = LogicalOperation.DELETE;
break;
- case TOUCH:
- case WRITE:
- /*
- * We are canceling a previous modification. This is a bit tricky,
- * as the original write may have just introduced the data, or it
- * may have modified it.
- *
- * As documented in BUG-2470, a delete of data introduced in this
- * transaction needs to be turned into a no-op.
- */
- newType = original.isPresent() ? LogicalOperation.DELETE : LogicalOperation.NONE;
- break;
- default:
- throw new IllegalStateException("Unhandled deletion of node with " + operation);
+ case MERGE:
+ // In case of merge - delete needs to be recored and must not to be changed into NONE, because lazy
+ // expansion of parent MERGE node would reintroduce it again.
+ newType = LogicalOperation.DELETE;
+ break;
+ case TOUCH:
+ case WRITE:
+ /*
+ * We are canceling a previous modification. This is a bit tricky, as the original write may have just
+ * introduced the data, or it may have modified it.
+ *
+ * As documented in BUG-2470, a delete of data introduced in this transaction needs to be turned into
+ * a no-op.
+ */
+ newType = original.isPresent() ? LogicalOperation.DELETE : LogicalOperation.NONE;
+ break;
+ default:
+ throw new IllegalStateException("Unhandled deletion of node with " + operation);
}
clearSnapshot();
/**
* Records a write for associated node.
*
- * @param value
+ * @param value new value
*/
void write(final NormalizedNode<?, ?> value) {
updateValue(LogicalOperation.WRITE, value);
/**
* Seal the modification node and prune any children which has not been modified.
*
- * @param schema
+ * @param schema associated apply operation
+ * @param version target version
*/
void seal(final ModificationApplyOperation schema, final Version version) {
clearSnapshot();
if (children.isEmpty()) {
updateOperationType(LogicalOperation.NONE);
}
-
break;
case WRITE:
// A WRITE can collapse all of its children
schema.verifyStructure(value, true);
break;
- /*
- * Perform full validation in case of merge operation. This validation is performed during sealing of
- * a ModifiedNode when we run InMemoryDataTreeModification.ready() just as it is in case of write operation
- * above.
- *
- * Some parts of this validation may also be re-done during InMemoryDataTree.prepare() in case when we
- * merge or write a MapEntry directly (e.g. Bug5968MergeTest.mergeValidMapEntryTest()), however in other
- * cases full validation is performed only once just here.
- */
- case MERGE:
- final Optional<TreeNode> result = schema.apply(this, getOriginal(), version);
- if (result.isPresent()) {
- schema.verifyStructure(result.get().getData(), true);
- }
- break;
default:
break;
}
}
Optional<TreeNode> setSnapshot(final Optional<TreeNode> snapshot) {
- snapshotCache = Preconditions.checkNotNull(snapshot);
+ snapshotCache = requireNonNull(snapshot);
return snapshot;
}
* @param value New node value
*/
void updateValue(final LogicalOperation type, final NormalizedNode<?, ?> value) {
- this.value = Preconditions.checkNotNull(value);
+ this.value = requireNonNull(value);
updateOperationType(type);
}
}
void setValidatedNode(final SchemaAwareApplyOperation op, final Optional<TreeNode> current, final TreeNode node) {
- this.validatedOp = Preconditions.checkNotNull(op);
- this.validatedCurrent = Preconditions.checkNotNull(current);
- this.validatedNode = Preconditions.checkNotNull(node);
+ this.validatedOp = requireNonNull(op);
+ this.validatedCurrent = requireNonNull(current);
+ this.validatedNode = requireNonNull(node);
}
TreeNode getValidatedNode(final SchemaAwareApplyOperation op, final Optional<TreeNode> current) {
Code Review / yangtools.git / blobdiff