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=cae3e94d1c7bdd7aa2dc5a5550cb2e2b0d8166dd;hb=bf405586fc69c3781311cfb8ac19ba93b670ec8d;hp=48a3c4841d87e80032951aa4cd46a0482615879d;hpb=62587988eed19461778ef11bb679fe6142f80c72;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 48a3c4841d..cae3e94d1c 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 @@ -16,18 +16,24 @@ 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 { @@ -57,34 +63,40 @@ 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; this.children = childPolicy.createMap(); } - /** - * Return the value which was written to this node. - * - * @return Currently-written value - */ - public NormalizedNode getWrittenValue() { - return value; - } - @Override public PathArgument getIdentifier() { return identifier; } + @Override + LogicalOperation getOperation() { + return operation; + } + @Override Optional 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; } /** @@ -100,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} @@ -110,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; } @@ -187,50 +249,33 @@ 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. - * + * * @param schema */ - void seal(final ModificationApplyOperation schema) { + void seal(final ModificationApplyOperation schema, final Version version) { clearSnapshot(); + writtenOriginal = null; - // A TOUCH node without any children is a no-op 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: @@ -251,9 +296,12 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode value) { + this.value = Preconditions.checkNotNull(value); + 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 @@ -279,30 +338,6 @@ final class ModifiedNode extends NodeModification implements StoreTreeNode 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); }