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=a2739c5f8ff110703fc2f96f7001480b830d976a;hpb=4a77c660ee0f4f7bb8c45bc24d5d518413e825ef;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 a2739c5f8f..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,39 +7,45 @@ */ 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.Collections; -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.getOperation()) { + static final Predicate IS_TERMINAL_PREDICATE = input -> { + requireNonNull(input); + switch (input.getOperation()) { case DELETE: case MERGE: case WRITE: @@ -47,46 +53,32 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode children; - private final Optional original; + private final Optional original; private final PathArgument identifier; private LogicalOperation operation = LogicalOperation.NONE; private Optional snapshotCache; - private NormalizedNode value; + private NormalizedNode value; private ModificationType modType; - private ModifiedNode(final PathArgument identifier, final Optional original, final ChildTrackingPolicy childPolicy) { - this.identifier = identifier; - this.original = original; + // Alternative history introduced in WRITE nodes. Instantiated when we touch any child underneath such a node. + private TreeNode writtenOriginal; - switch (childPolicy) { - case NONE: - children = Collections.emptyMap(); - break; - case ORDERED: - children = new LinkedHashMap<>(); - break; - case UNORDERED: - children = new HashMap<>(); - break; - default: - throw new IllegalArgumentException("Unsupported child tracking policy " + childPolicy); - } - } + // Internal cache for TreeNodes created as part of validation + private ModificationApplyOperation validatedOp; + private Optional validatedCurrent; + private Optional validatedNode; - /** - * Return the value which was written to this node. - * - * @return Currently-written value - */ - public NormalizedNode getWrittenValue() { - return value; + private ModifiedNode(final PathArgument identifier, final Optional original, + final ChildTrackingPolicy childPolicy) { + this.identifier = identifier; + this.original = original; + this.children = childPolicy.createMap(); } @Override @@ -95,42 +87,92 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode getOriginal() { - return original; + LogicalOperation getOperation() { + return operation; } @Override - LogicalOperation getOperation() { - return operation; + 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 child modification if child was modified - * - * @return Child modification if direct child or it's subtree - * was modified. + * @return Currently-written value + */ + @NonNull NormalizedNode getWrittenValue() { + return verifyNotNull(value); + } + + /** + * Returns child modification if child was modified. * + * @return Child modification if direct child or it's subtree was modified. */ @Override - public Optional getChild(final PathArgument child) { - return Optional. fromNullable(children.get(child)); + 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. * + * @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. + */ + 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 child identifier, may not be null - * @param childPolicy child tracking policy for the node we are looking for + * @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(@Nonnull final PathArgument child, @Nonnull final ChildTrackingPolicy childPolicy) { + ModifiedNode modifyChild(final @NonNull PathArgument child, final @NonNull ModificationApplyOperation childOper, + final @NonNull Version modVersion) { clearSnapshot(); if (operation == LogicalOperation.NONE) { updateOperationType(LogicalOperation.TOUCH); @@ -140,21 +182,26 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode 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, childPolicy); children.put(child, newlyCreated); return newlyCreated; } /** - * Returns all recorded direct child modification + * Returns all recorded direct child modifications. * * @return all recorded direct child modifications */ @@ -170,26 +217,29 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode value) { - clearSnapshot(); - updateOperationType(LogicalOperation.WRITE); + void write(final NormalizedNode newValue) { + updateValue(LogicalOperation.WRITE, newValue); children.clear(); - this.value = value; - } - - void merge(final NormalizedNode value) { - clearSnapshot(); - updateOperationType(LogicalOperation.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(); + writtenOriginal = null; - // 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.operation == LogicalOperation.NONE) { - it.remove(); - } - } - - // A TOUCH node without any children is a no-op - if (operation == LogicalOperation.TOUCH && children.isEmpty()) { - updateOperationType(LogicalOperation.NONE); + 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; } } @@ -266,26 +303,44 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode setSnapshot(final Optional snapshot) { - snapshotCache = Preconditions.checkNotNull(snapshot); + snapshotCache = requireNonNull(snapshot); return snapshot; } - private void updateOperationType(final LogicalOperation 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=" - + operation + ", 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(@Nonnull final ModificationType type) { + 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); + } + /** * Return the physical modification done to data. May return null if the * operation has not been applied to the underlying tree. This is different @@ -298,31 +353,30 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode current, + final Optional node) { + this.validatedOp = requireNonNull(op); + this.validatedCurrent = requireNonNull(current); + this.validatedNode = requireNonNull(node); + } + /** - * 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. + * Acquire pre-validated node assuming a previous operation and node. This is a counterpart to + * {@link #setValidatedNode(ModificationApplyOperation, Optional, Optional)}. * - * @param value Value associated with the node - * @return An isolated node. This node should never reach a datatree. + * @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. */ - ModifiedNode asNewlyWritten(final NormalizedNode value) { - /* - * We are instantiating an "equivalent" of this node. Currently the only callsite does not care - * about the actual iteration order, so we do not have to specify the same tracking policy as - * we were instantiated with. Since this is the only time we need to know that policy (it affects - * only things in constructor), we do not want to retain it (saves some memory on per-instance - * basis). - * - * We could reconstruct it using two instanceof checks (to undo what the constructor has done), - * which would give perfect results. The memory saving would be at most 32 bytes of a short-lived - * object, so let's not bother with that. - */ - final ModifiedNode ret = new ModifiedNode(getIdentifier(), Optional.absent(), ChildTrackingPolicy.UNORDERED); - ret.write(value); - return ret; - } - - public static ModifiedNode createUnmodified(final TreeNode metadataTree, final ChildTrackingPolicy childPolicy) { - return new ModifiedNode(metadataTree.getIdentifier(), Optional.of(metadataTree), childPolicy); + @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; } }