X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-data-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fdata%2Fimpl%2Fschema%2Ftree%2FModifiedNode.java;h=735418ee59d617dadd21adbe2ad35574a9a25567;hb=970923b5f47f7507ec78021965fa5df1a878af48;hp=448828bd9a0544b7f4e9d152d1f22c6e32aa5087;hpb=f05430b140031a3e9da0c28259076f5f8187c9c9;p=yangtools.git diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ModifiedNode.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ModifiedNode.java index 448828bd9a..735418ee59 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ModifiedNode.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/ModifiedNode.java @@ -7,153 +7,201 @@ */ 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 com.google.common.base.Verify.verifyNotNull; +import static java.util.Objects.requireNonNull; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; +import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; import java.util.Collection; -import java.util.HashMap; -import java.util.Iterator; -import java.util.LinkedHashMap; import java.util.Map; -import javax.annotation.Nonnull; -import javax.annotation.concurrent.NotThreadSafe; +import java.util.Optional; +import java.util.function.Predicate; +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.jdt.annotation.Nullable; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; +import org.opendaylight.yangtools.yang.data.api.schema.DistinctNodeContainer; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType; import org.opendaylight.yangtools.yang.data.api.schema.tree.StoreTreeNode; import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode; +import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNodeFactory; +import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version; /** - * Node Modification Node and Tree + * Node Modification Node and Tree. * - * Tree which structurally resembles data tree and captures client modifications - * to the data store tree. + *

+ * 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()}. * - * This tree is lazily created and populated via {@link #modifyChild(PathArgument)} - * and {@link TreeNode} which represents original state as tracked by {@link #getOriginal()}. + *

+ * 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 + * the tree. */ -@NotThreadSafe final class ModifiedNode extends NodeModification implements StoreTreeNode { - static final Predicate IS_TERMINAL_PREDICATE = new Predicate() { - @Override - public boolean apply(final @Nonnull ModifiedNode input) { - Preconditions.checkNotNull(input); - switch (input.getType()) { + static final Predicate IS_TERMINAL_PREDICATE = input -> { + requireNonNull(input); + switch (input.getOperation()) { case DELETE: case MERGE: case WRITE: return true; - case SUBTREE_MODIFIED: - case UNMODIFIED: + case TOUCH: + case NONE: return false; - } - - throw new IllegalArgumentException(String.format("Unhandled modification type %s", input.getType())); + default: + throw new IllegalArgumentException("Unhandled modification type " + input.getOperation()); } }; private final Map children; - private final Optional original; + private final Optional original; private final PathArgument identifier; - private ModificationType modificationType = ModificationType.UNMODIFIED; + private LogicalOperation operation = LogicalOperation.NONE; private Optional snapshotCache; - private NormalizedNode value; + private NormalizedNode value; + private ModificationType modType; + + // Alternative history introduced in WRITE nodes. Instantiated when we touch any child underneath such a node. + private TreeNode writtenOriginal; + + // Internal cache for TreeNodes created as part of validation + private ModificationApplyOperation validatedOp; + private Optional validatedCurrent; + private Optional validatedNode; - private ModifiedNode(final PathArgument identifier, final Optional original, final boolean isOrdered) { + private ModifiedNode(final PathArgument identifier, final Optional original, + final ChildTrackingPolicy childPolicy) { this.identifier = identifier; this.original = original; + this.children = childPolicy.createMap(); + } - if (isOrdered) { - children = new LinkedHashMap<>(); - } else { - children = new HashMap<>(); - } + @Override + public PathArgument getIdentifier() { + return identifier; } - /** - * Return the value which was written to this node. - * - * @return Currently-written value - */ - public NormalizedNode getWrittenValue() { - return value; + @Override + LogicalOperation getOperation() { + return operation; } @Override - public PathArgument getIdentifier() { - return identifier; + Optional getOriginal() { + return original; } /** + * Return the value which was written to this node. The returned object is only valid for + * {@link LogicalOperation#MERGE} and {@link LogicalOperation#WRITE}. + * operations. It should only be consulted when this modification is going to end up being + * {@link ModificationType#WRITE}. * - * Returns original store metadata - * @return original store metadata + * @return Currently-written value */ - @Override - Optional getOriginal() { - return original; + @NonNull NormalizedNode getWrittenValue() { + return verifyNotNull(value); } /** - * Returns modification type + * Returns child modification if child was modified. * - * @return modification type + * @return Child modification if direct child or it's subtree was modified. */ @Override - ModificationType getType() { - return modificationType; + public ModifiedNode childByArg(final PathArgument arg) { + return children.get(arg); + } + + private Optional metadataFromSnapshot(final @NonNull PathArgument child) { + return original.isPresent() ? original.get().findChildByArg(child) : Optional.empty(); + } + + private Optional metadataFromData(final @NonNull PathArgument child, final Version modVersion) { + if (writtenOriginal == null) { + // Lazy instantiation, as we do not want do this for all writes. We are using the modification's version + // here, as that version is what the SchemaAwareApplyOperation will see when dealing with the resulting + // modifications. + writtenOriginal = TreeNodeFactory.createTreeNode(value, modVersion); + } + + return writtenOriginal.findChildByArg(child); } /** + * Determine the base tree node we are going to apply the operation to. This is not entirely trivial because + * both DELETE and WRITE operations unconditionally detach their descendants from the original snapshot, so we need + * to take the current node's operation into account. * - * Returns child modification if child was modified - * - * @return Child modification if direct child or it's subtree - * was modified. - * + * @param child Child we are looking to modify + * @param modVersion Version allocated by the calling {@link InMemoryDataTreeModification} + * @return Before-image tree node as observed by that child. */ - @Override - public Optional getChild(final PathArgument child) { - return Optional. fromNullable(children.get(child)); + private Optional findOriginalMetadata(final @NonNull PathArgument child, + final Version modVersion) { + switch (operation) { + 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); + } } /** - * * 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 + * @param child child identifier, may not be null + * @param childOper Child operation + * @param modVersion Version allocated by the calling {@link InMemoryDataTreeModification} * @return {@link ModifiedNode} for specified child, with {@link #getOriginal()} * containing child metadata if child was present in original data. */ - ModifiedNode modifyChild(final PathArgument child, final boolean isOrdered) { + ModifiedNode modifyChild(final @NonNull PathArgument child, final @NonNull ModificationApplyOperation childOper, + final @NonNull Version modVersion) { clearSnapshot(); - if (modificationType == ModificationType.UNMODIFIED) { - updateModificationType(ModificationType.SUBTREE_MODIFIED); + if (operation == LogicalOperation.NONE) { + updateOperationType(LogicalOperation.TOUCH); } final ModifiedNode potential = children.get(child); if (potential != null) { return potential; } - final Optional currentMetadata; - if (original.isPresent()) { - final TreeNode orig = original.get(); - currentMetadata = orig.getChild(child); - } else { - currentMetadata = Optional.absent(); + final Optional currentMetadata = findOriginalMetadata(child, modVersion); + final ModifiedNode newlyCreated = new ModifiedNode(child, currentMetadata, childOper.getChildPolicy()); + if (operation == LogicalOperation.MERGE && value != null) { + /* + * We are attempting to modify a previously-unmodified part of a MERGE node. If the + * value contains this component, we need to materialize it as a MERGE modification. + */ + @SuppressWarnings({ "rawtypes", "unchecked" }) + final NormalizedNode childData = ((DistinctNodeContainer)value).childByArg(child); + if (childData != null) { + childOper.mergeIntoModifiedNode(newlyCreated, childData, modVersion); + } } - final ModifiedNode newlyCreated = new ModifiedNode(child, currentMetadata, isOrdered); children.put(child, newlyCreated); return newlyCreated; } /** - * Returns all recorded direct child modification + * Returns all recorded direct child modifications. * * @return all recorded direct child modifications */ @@ -166,93 +214,83 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode value) { - clearSnapshot(); - updateModificationType(ModificationType.WRITE); + void write(final NormalizedNode newValue) { + updateValue(LogicalOperation.WRITE, newValue); children.clear(); - this.value = value; - } - - void merge(final NormalizedNode value) { - clearSnapshot(); - updateModificationType(ModificationType.MERGE); - - /* - * Blind overwrite of any previous data is okay, no matter whether the node - * is simple or complex type. - * - * If this is a simple or complex type with unkeyed children, this merge will - * be turned into a write operation, overwriting whatever was there before. - * - * If this is a container with keyed children, there are two possibilities: - * - if it existed before, this value will never be consulted and the children - * will get explicitly merged onto the original data. - * - if it did not exist before, this value will be used as a seed write and - * children will be merged into it. - * In either case we rely on OperationWithModification to manipulate the children - * before calling this method, so unlike a write we do not want to clear them. - */ - this.value = value; } /** - * Seal the modification node and prune any children which has not been - * modified. + * Seal the modification node and prune any children which has not been modified. + * + * @param schema associated apply operation + * @param version target version */ - void seal() { + void seal(final ModificationApplyOperation schema, final Version version) { clearSnapshot(); - - // Walk all child nodes and remove any children which have not - // been modified. - final Iterator it = children.values().iterator(); - while (it.hasNext()) { - final ModifiedNode child = it.next(); - child.seal(); - - if (child.modificationType == ModificationType.UNMODIFIED) { - it.remove(); - } - } - - // A SUBTREE_MODIFIED node without any children is a no-op - if (modificationType == ModificationType.SUBTREE_MODIFIED && children.isEmpty()) { - updateModificationType(ModificationType.UNMODIFIED); + writtenOriginal = null; + + switch (operation) { + case TOUCH: + // A TOUCH node without any children is a no-op + if (children.isEmpty()) { + updateOperationType(LogicalOperation.NONE); + } + break; + case WRITE: + // A WRITE can collapse all of its children + if (!children.isEmpty()) { + value = schema.apply(this, getOriginal(), version).map(TreeNode::getData).orElse(null); + children.clear(); + } + + if (value == null) { + // The write has ended up being empty, such as a write of an empty list. + updateOperationType(LogicalOperation.DELETE); + } else { + schema.fullVerifyStructure(value); + } + break; + default: + break; } } @@ -265,35 +303,80 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode setSnapshot(final Optional snapshot) { - snapshotCache = Preconditions.checkNotNull(snapshot); + snapshotCache = requireNonNull(snapshot); return snapshot; } - private void updateModificationType(final ModificationType type) { - modificationType = type; + void updateOperationType(final LogicalOperation type) { + operation = type; + modType = null; + + // Make sure we do not reuse previously-instantiated data-derived metadata + writtenOriginal = null; clearSnapshot(); } @Override public String toString() { - return "NodeModification [identifier=" + identifier + ", modificationType=" - + modificationType + ", childModification=" + children + "]"; + final ToStringHelper helper = MoreObjects.toStringHelper(this).omitNullValues() + .add("identifier", identifier).add("operation", operation).add("modificationType", modType); + if (!children.isEmpty()) { + helper.add("childModification", children); + } + return helper.toString(); + } + + void resolveModificationType(final @NonNull ModificationType type) { + modType = type; + } + + /** + * Update this node's value and operation type without disturbing any of its child modifications. + * + * @param type New operation type + * @param newValue New node value + */ + void updateValue(final LogicalOperation type, final NormalizedNode newValue) { + this.value = requireNonNull(newValue); + updateOperationType(type); } /** - * Create a node which will reflect the state of this node, except it will behave as newly-written - * value. This is useful only for merge validation. + * Return the physical modification done to data. May return null if the + * operation has not been applied to the underlying tree. This is different + * from the logical operation in that it can actually be a no-op if the + * operation has no side-effects (like an empty merge on a container). * - * @param value Value associated with the node - * @return An isolated node. This node should never reach a datatree. + * @return Modification type. */ - ModifiedNode asNewlyWritten(final NormalizedNode value) { - final ModifiedNode ret = new ModifiedNode(getIdentifier(), Optional.absent(), false); - ret.write(value); - return ret; + ModificationType getModificationType() { + return modType; } - public static ModifiedNode createUnmodified(final TreeNode metadataTree, final boolean isOrdered) { - return new ModifiedNode(metadataTree.getIdentifier(), Optional.of(metadataTree), isOrdered); + public static ModifiedNode createUnmodified(final TreeNode metadataTree, final ChildTrackingPolicy childPolicy) { + return new ModifiedNode(metadataTree.getIdentifier(), Optional.of(metadataTree), childPolicy); + } + + void setValidatedNode(final ModificationApplyOperation op, final Optional current, + final Optional node) { + this.validatedOp = requireNonNull(op); + this.validatedCurrent = requireNonNull(current); + this.validatedNode = requireNonNull(node); + } + + /** + * Acquire pre-validated node assuming a previous operation and node. This is a counterpart to + * {@link #setValidatedNode(ModificationApplyOperation, Optional, Optional)}. + * + * @param op Currently-executing operation + * @param current Currently-used tree node + * @return {@code null} if there is a mismatch with previously-validated node (if present) or the result of previous + * validation. + */ + @SuppressFBWarnings(value = "NP_OPTIONAL_RETURN_NULL", + justification = "The contract is package-internal and well documented, we do not need a separate wrapper") + @Nullable Optional getValidatedNode(final ModificationApplyOperation op, + final Optional current) { + return op.equals(validatedOp) && current.equals(validatedCurrent) ? validatedNode : null; } }