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=be0ed682adf111f79b9148bdfdb4953fc5045dcc;hb=f3a3253eb4a5033515898723fcee5a9819135729;hp=dd06b890cb367569d8dcefaa10b9452c04fb9513;hpb=f4be08675ce4837517c449ef5888383756fd4902;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 dd06b890cb..be0ed682ad 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 @@ -10,35 +10,36 @@ 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 com.google.common.base.Verify; 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 org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer; 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 * - * 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)} 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) { + public boolean apply(@Nonnull final ModifiedNode input) { Preconditions.checkNotNull(input); switch (input.getOperation()) { case DELETE: @@ -62,32 +63,13 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode value; private ModificationType modType; + // Alternative history introduced in WRITE nodes. Instantiated when we touch any child underneath such a node. + private TreeNode writtenOriginal; + private ModifiedNode(final PathArgument identifier, final Optional original, final ChildTrackingPolicy childPolicy) { this.identifier = identifier; this.original = original; - - 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); - } - } - - /** - * Return the value which was written to this node. - * - * @return Currently-written value - */ - public NormalizedNode getWrittenValue() { - return value; + this.children = childPolicy.createMap(); } @Override @@ -95,14 +77,26 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode getOriginal() { return original; } - @Override - LogicalOperation getOperation() { - return operation; + /** + * 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}. + * + * @return Currently-written value + */ + NormalizedNode getWrittenValue() { + return value; } /** @@ -118,6 +112,47 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode fromNullable(children.get(child)); } + private Optional metadataFromSnapshot(@Nonnull final PathArgument child) { + return original.isPresent() ? original.get().getChild(child) : Optional.absent(); + } + + private Optional metadataFromData(@Nonnull final 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.getChild(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(@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); + } + + throw new IllegalStateException("Unhandled node operation " + operation); + } + /** * * Returns child modification if child was modified, creates {@link ModifiedNode} @@ -128,10 +163,12 @@ 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, childPolicy); + 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 Optional> childData = ((NormalizedNodeContainer)value).getChild(child); + if (childData.isPresent()) { + newlyCreated.updateValue(LogicalOperation.MERGE, childData.get()); + } + } + children.put(child, newlyCreated); return newlyCreated; } @@ -177,6 +221,11 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode value) { - clearSnapshot(); - updateOperationType(LogicalOperation.WRITE); + updateValue(LogicalOperation.WRITE, value); 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 */ - 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).get().getData(); + children.clear(); + } + + schema.verifyStructure(value, true); + break; + default: + break; } } @@ -271,9 +301,12 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode value) { + this.value = Preconditions.checkNotNull(value); + 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) { - /* - * 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; + ModificationType getModificationType() { + return modType; } public static ModifiedNode createUnmodified(final TreeNode metadataTree, final ChildTrackingPolicy childPolicy) {