}
@Override
- protected TreeNode applyWrite(final ModifiedNode modification,
+ protected TreeNode applyWrite(final ModifiedNode modification, final NormalizedNode<?, ?> newValue,
final Optional<TreeNode> currentMeta, final Version version) {
- final NormalizedNode<?, ?> newValue = modification.getWrittenValue();
final TreeNode newValueMeta = TreeNodeFactory.createTreeNode(newValue, version);
if (modification.getChildren().isEmpty()) {
protected final TreeNode applyMerge(final ModifiedNode modification, final TreeNode currentMeta,
final Version version) {
// Just overwrite whatever was there, but be sure to run validation
- verifyStructure(modification.getWrittenValue(), true);
+ final NormalizedNode<?, ?> newValue = modification.getWrittenValue();
+ verifyStructure(newValue, true);
modification.resolveModificationType(ModificationType.WRITE);
- return applyWrite(modification, null, version);
+ return applyWrite(modification, newValue, null, version);
}
@Override
- protected final TreeNode applyWrite(final ModifiedNode modification,
+ protected final TreeNode applyWrite(final ModifiedNode modification, final NormalizedNode<?, ?> newValue,
final Optional<TreeNode> currentMeta, final Version version) {
- return TreeNodeFactory.createTreeNode(modification.getWrittenValue(), version);
+ return TreeNodeFactory.createTreeNode(newValue, version);
}
@Override
@Override
Optional<TreeNode> apply(final ModifiedNode modification, final Optional<TreeNode> storeMeta,
final Version version) {
- return AutomaticLifecycleMixin.apply(super::apply, emptyNode, modification, storeMeta, version);
+ return AutomaticLifecycleMixin.apply(super::apply, this::applyWrite, emptyNode, modification, storeMeta,
+ version);
}
@Override
Optional<TreeNode> apply(ModifiedNode modification, Optional<TreeNode> storeMeta, Version version);
}
+ /**
+ * This is a capture of
+ * {@link SchemaAwareApplyOperation#applyWrite(ModifiedNode, NormalizedNode, Optional, Version)}.
+ */
+ @FunctionalInterface
+ interface ApplyWrite {
+ TreeNode applyWrite(ModifiedNode modification, NormalizedNode<?, ?> newValue, Optional<TreeNode> storeMeta,
+ Version version);
+ }
+
/**
* This is a capture of
* {@link ModificationApplyOperation#checkApplicable(ModificationPath, NodeModification, Optional, Version)}.
}
- static Optional<TreeNode> apply(final Apply delegate, final NormalizedNode<?, ?> emptyNode,
- final ModifiedNode modification, final Optional<TreeNode> storeMeta, final Version version) {
- final Optional<TreeNode> ret;
- if (modification.getOperation() == LogicalOperation.TOUCH && !storeMeta.isPresent()) {
- // Container is not present, let's take care of the 'magically appear' part of our job
- ret = delegate.apply(modification, fakeMeta(emptyNode, version), version);
-
- // Fake container got removed: that is a no-op
- if (!ret.isPresent()) {
- modification.resolveModificationType(ModificationType.UNMODIFIED);
- return ret;
- }
-
- // If the delegate indicated SUBTREE_MODIFIED, account for the fake and report APPEARED
- if (modification.getModificationType() == ModificationType.SUBTREE_MODIFIED) {
- modification.resolveModificationType(ModificationType.APPEARED);
- }
- } else {
- // Container is present, run normal apply operation
- ret = delegate.apply(modification, storeMeta, version);
-
- // Container was explicitly deleted, no magic required
- if (!ret.isPresent()) {
- return ret;
+ static Optional<TreeNode> apply(final Apply delegate, final ApplyWrite writeDelegate,
+ final NormalizedNode<?, ?> emptyNode, final ModifiedNode modification, final Optional<TreeNode> storeMeta,
+ final Version version) {
+ // The only way a tree node can disappear is through delete (which we handle here explicitly) or through
+ // actions of disappearResult(). It is therefore safe to perform Optional.get() on the results of
+ // delegate.apply()
+ final TreeNode ret;
+ if (modification.getOperation() == LogicalOperation.DELETE) {
+ if (modification.getChildren().isEmpty()) {
+ return delegate.apply(modification, storeMeta, version);
}
- }
-
- /*
- * At this point ret is guaranteed to be present. We need to take care of the 'magically disappear' part of
- * our job. Check if there are any child nodes left. If there are none, remove this container and turn the
- * modification into a DISAPPEARED.
- */
- final NormalizedNode<?, ?> data = ret.get().getData();
- final boolean empty;
- if (data instanceof NormalizedNodeContainer) {
- empty = ((NormalizedNodeContainer<?, ?, ?>) data).getValue().isEmpty();
- } else if (data instanceof OrderedNodeContainer) {
- empty = ((OrderedNodeContainer<?>) data).getSize() == 0;
+ // Delete with children, implies it really is an empty write
+ ret = writeDelegate.applyWrite(modification, emptyNode, storeMeta, version);
+ } else if (modification.getOperation() == LogicalOperation.TOUCH && !storeMeta.isPresent()) {
+ ret = applyTouch(delegate, emptyNode, modification, storeMeta, version);
} else {
- throw new IllegalStateException("Unhandled data " + data);
+ // No special handling required here, run normal apply operation
+ ret = delegate.apply(modification, storeMeta, version).get();
}
- if (empty) {
- modification.resolveModificationType(ModificationType.DISAPPEARED);
- return Optional.empty();
- }
- return ret;
+ return disappearResult(modification, ret, storeMeta);
}
static void checkApplicable(final CheckApplicable delegate, final NormalizedNode<?, ?> emptyNode,
}
}
+ private static TreeNode applyTouch(final Apply delegate, final NormalizedNode<?, ?> emptyNode,
+ final ModifiedNode modification, final Optional<TreeNode> storeMeta, final Version version) {
+ // Container is not present, let's take care of the 'magically appear' part of our job
+ final Optional<TreeNode> ret = delegate.apply(modification, fakeMeta(emptyNode, version), version);
+
+ // If the delegate indicated SUBTREE_MODIFIED, account for the fake and report APPEARED
+ if (modification.getModificationType() == ModificationType.SUBTREE_MODIFIED) {
+ modification.resolveModificationType(ModificationType.APPEARED);
+ }
+ return ret.get();
+ }
+
+ private static Optional<TreeNode> disappearResult(final ModifiedNode modification, final TreeNode result,
+ final Optional<TreeNode> storeMeta) {
+ // Check if the result is in fact empty before pulling any tricks
+ if (!isEmpty(result)) {
+ return Optional.of(result);
+ }
+
+ // We are pulling the 'disappear' trick, but what we report can be three different things
+ final ModificationType finalType;
+ if (!storeMeta.isPresent()) {
+ // ... there was nothing in the datastore, no change
+ finalType = ModificationType.UNMODIFIED;
+ } else if (modification.getModificationType() == ModificationType.WRITE) {
+ // ... this was an empty write, possibly originally a delete
+ finalType = ModificationType.DELETE;
+ } else {
+ // ... it really disappeared
+ finalType = ModificationType.DISAPPEARED;
+ }
+ modification.resolveModificationType(finalType);
+ return Optional.empty();
+ }
+
private static Optional<TreeNode> fakeMeta(final NormalizedNode<?, ?> emptyNode, final Version version) {
return Optional.of(TreeNodeFactory.createTreeNode(emptyNode, version));
}
+
+ private static boolean isEmpty(final TreeNode treeNode) {
+ final NormalizedNode<?, ?> data = treeNode.getData();
+ if (data instanceof NormalizedNodeContainer) {
+ return ((NormalizedNodeContainer<?, ?, ?>) data).getValue().isEmpty();
+ }
+ if (data instanceof OrderedNodeContainer) {
+ return ((OrderedNodeContainer<?>) data).getSize() == 0;
+ }
+ throw new IllegalStateException("Unhandled data " + data);
+ }
}
emptyNode = ImmutableNodes.choiceNode(schema.getQName());
}
-
@Override
Optional<TreeNode> apply(final ModifiedNode modification, final Optional<TreeNode> storeMeta,
final Version version) {
- return AutomaticLifecycleMixin.apply(super::apply, emptyNode, modification, storeMeta, version);
+ return AutomaticLifecycleMixin.apply(super::apply, this::applyWrite, emptyNode, modification, storeMeta,
+ version);
}
@Override
}
@Override
- protected TreeNode applyWrite(final ModifiedNode modification, final Optional<TreeNode> currentMeta,
- final Version version) {
- final TreeNode ret = super.applyWrite(modification, currentMeta, version);
+ protected TreeNode applyWrite(final ModifiedNode modification, final NormalizedNode<?, ?> newValue,
+ final Optional<TreeNode> currentMeta, final Version version) {
+ final TreeNode ret = super.applyWrite(modification, newValue, currentMeta, version);
enforceCases(ret);
return ret;
}
}
@Override
- protected TreeNode applyWrite(final ModifiedNode modification, final Optional<TreeNode> currentMeta,
- final Version version) {
- final TreeNode ret = super.applyWrite(modification, currentMeta, version);
+ protected TreeNode applyWrite(final ModifiedNode modification, final NormalizedNode<?, ?> newValue,
+ final Optional<TreeNode> currentMeta, final Version version) {
+ final TreeNode ret = super.applyWrite(modification, newValue, currentMeta, version);
enforcer.enforceOnTreeNode(ret);
return ret;
}
*/
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
+import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
import com.google.common.base.MoreObjects;
*
* @return Currently-written value
*/
+ @Nonnull
NormalizedNode<?, ?> getWrittenValue() {
- return value;
+ return verifyNotNull(value);
}
/**
@Override
Optional<TreeNode> apply(final ModifiedNode modification, final Optional<TreeNode> storeMeta,
final Version version) {
- return AutomaticLifecycleMixin.apply(super::apply, emptyNode, modification, storeMeta, version);
+ return AutomaticLifecycleMixin.apply(super::apply, this::applyWrite, emptyNode, modification, storeMeta,
+ version);
}
@Override
}
@Override
- protected TreeNode applyWrite(final ModifiedNode modification, final Optional<TreeNode> currentMeta,
- final Version version) {
- final TreeNode ret = super.applyWrite(modification, currentMeta, version);
+ protected TreeNode applyWrite(final ModifiedNode modification, final NormalizedNode<?, ?> newValue,
+ final Optional<TreeNode> currentMeta, final Version version) {
+ final TreeNode ret = super.applyWrite(modification, newValue, currentMeta, version);
enforcer.enforceOnTreeNode(ret);
return ret;
}
package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Verify.verifyNotNull;
import java.util.List;
import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
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.tree.ConflictingModificationAppliedException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
// structure is usually verified when the transaction is sealed. To preserve correctness, we have
// to run that validation here.
modification.resolveModificationType(ModificationType.WRITE);
- result = applyWrite(modification, currentMeta, version);
+ result = applyWrite(modification, modification.getWrittenValue(), currentMeta, version);
verifyStructure(result.getData(), true);
} else {
result = applyMerge(modification, currentMeta.get(), version);
return modification.setSnapshot(Optional.of(result));
case WRITE:
modification.resolveModificationType(ModificationType.WRITE);
- return modification.setSnapshot(Optional.of(applyWrite(modification, currentMeta, version)));
+ return modification.setSnapshot(Optional.of(applyWrite(modification,
+ verifyNotNull(modification.getWrittenValue()), currentMeta, version)));
case NONE:
modification.resolveModificationType(ModificationType.UNMODIFIED);
return currentMeta;
*/
protected abstract TreeNode applyMerge(ModifiedNode modification, TreeNode currentMeta, Version version);
- protected abstract TreeNode applyWrite(ModifiedNode modification, Optional<TreeNode> currentMeta, Version version);
+ protected abstract TreeNode applyWrite(ModifiedNode modification, NormalizedNode<?, ?> newValue,
+ Optional<TreeNode> currentMeta, Version version);
/**
* Apply a nested operation. Since there may not actually be a nested operation
@Override
Optional<TreeNode> apply(final ModifiedNode modification, final Optional<TreeNode> storeMeta,
final Version version) {
- return AutomaticLifecycleMixin.apply(super::apply, emptyNode, modification, storeMeta, version);
+ return AutomaticLifecycleMixin.apply(super::apply, this::applyWrite, emptyNode, modification, storeMeta,
+ version);
}
@Override
@Override
Optional<TreeNode> apply(final ModifiedNode modification, final Optional<TreeNode> storeMeta,
final Version version) {
- return AutomaticLifecycleMixin.apply(super::apply, emptyNode, modification, storeMeta, version);
+ return AutomaticLifecycleMixin.apply(super::apply, this::applyWrite, emptyNode, modification, storeMeta,
+ version);
}
@Override
}
@Override
- protected TreeNode applyTouch(final ModifiedNode modification,
- final TreeNode currentMeta, final Version version) {
+ protected TreeNode applyTouch(final ModifiedNode modification, final TreeNode currentMeta, final Version version) {
throw new UnsupportedOperationException("UnkeyedList does not support subtree change.");
}
@Override
- protected TreeNode applyWrite(final ModifiedNode modification,
+ protected TreeNode applyWrite(final ModifiedNode modification, final NormalizedNode<?, ?> newValue,
final Optional<TreeNode> currentMeta, final Version version) {
- final NormalizedNode<?, ?> newValue = modification.getWrittenValue();
final TreeNode newValueMeta = TreeNodeFactory.createTreeNode(newValue, version);
-
if (modification.getChildren().isEmpty()) {
return newValueMeta;
}
@Override
Optional<TreeNode> apply(final ModifiedNode modification, final Optional<TreeNode> storeMeta,
final Version version) {
- return AutomaticLifecycleMixin.apply(super::apply, emptyNode, modification, storeMeta, version);
+ return AutomaticLifecycleMixin.apply(super::apply, this::applyWrite, emptyNode, modification, storeMeta,
+ version);
}
@Override
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
public class Bug2690Test extends AbstractTestModelTest {
+ private static final YangInstanceIdentifier NAME_PATH = YangInstanceIdentifier.of(TestModel.NON_PRESENCE_QNAME)
+ .node(TestModel.NAME_QNAME);
+
private DataTree inMemoryDataTree;
@Before
final MapEntryNode fooEntryNode = ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 1);
final MapEntryNode barEntryNode = ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 2);
final MapNode mapNode1 = ImmutableNodes.mapNodeBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.OUTER_LIST_QNAME))
+ .withNodeIdentifier(new NodeIdentifier(TestModel.OUTER_LIST_QNAME))
.withChild(fooEntryNode).build();
final MapNode mapNode2 = ImmutableNodes.mapNodeBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.OUTER_LIST_QNAME))
+ .withNodeIdentifier(new NodeIdentifier(TestModel.OUTER_LIST_QNAME))
.withChild(barEntryNode).build();
final ContainerNode cont1 = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
+ .withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
.withChild(mapNode1).build();
final ContainerNode cont2 = Builders.containerBuilder()
- .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
+ .withNodeIdentifier(new NodeIdentifier(TestModel.TEST_QNAME))
.withChild(mapNode2).build();
final DataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
modificationTree.write(TestModel.TEST_PATH, cont1);
modificationTree.merge(TestModel.TEST_PATH, cont2);
- modificationTree.ready();
-
- inMemoryDataTree.validate(modificationTree);
- final DataTreeCandidate prepare = inMemoryDataTree.prepare(modificationTree);
- inMemoryDataTree.commit(prepare);
+ commit(modificationTree);
final DataTreeSnapshot snapshotAfterTx = inMemoryDataTree.takeSnapshot();
final DataTreeModification modificationAfterTx = snapshotAfterTx.newModification();
assertTrue(readNode.isPresent());
assertEquals(2, ((NormalizedNodeContainer<?,?,?>)readNode.get()).getValue().size());
}
+
+ @Test
+ public void testDeleteStructuralAndWriteChild() throws DataValidationFailedException {
+ final DataTreeModification modificationTree = setupTestDeleteStructuralAndWriteChild();
+ verifyTestDeleteStructuralAndWriteChild(modificationTree);
+ }
+
+ @Test
+ public void testDeleteStructuralAndWriteChildWithCommit() throws DataValidationFailedException {
+ final DataTreeModification modificationTree = setupTestDeleteStructuralAndWriteChild();
+ commit(modificationTree);
+ verifyTestDeleteStructuralAndWriteChild(inMemoryDataTree.takeSnapshot());
+ }
+
+ private DataTreeModification setupTestDeleteStructuralAndWriteChild() {
+ final DataTreeModification modificationTree = inMemoryDataTree.takeSnapshot().newModification();
+ modificationTree.delete(YangInstanceIdentifier.of(TestModel.NON_PRESENCE_QNAME));
+ modificationTree.write(NAME_PATH, Builders.leafBuilder()
+ .withNodeIdentifier(new NodeIdentifier(TestModel.NAME_QNAME)).withValue("abc").build());
+ return modificationTree;
+ }
+
+ private static void verifyTestDeleteStructuralAndWriteChild(final DataTreeSnapshot snapshot) {
+ final Optional<NormalizedNode<?, ?>> readNode = snapshot.readNode(NAME_PATH);
+ assertTrue(readNode.isPresent());
+ }
+
+ private void commit(final DataTreeModification modificationTree) throws DataValidationFailedException {
+ modificationTree.ready();
+
+ inMemoryDataTree.validate(modificationTree);
+ final DataTreeCandidate prepare = inMemoryDataTree.prepare(modificationTree);
+ inMemoryDataTree.commit(prepare);
+ }
}
Code Review / yangtools.git / commitdiff