import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
-import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.base.Verify;
import java.util.Collection;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
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.ConflictingModificationAppliedException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeConfiguration;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType;
}
}
+ /**
+ * Fake TreeNode version used in
+ * {@link #checkTouchApplicable(ModificationPath, NodeModification, Optional, Version)}
+ * It is okay to use a global constant, as the delegate will ignore it anyway.
+ */
+ private static final Version FAKE_VERSION = Version.initial();
+
private final NormalizedNodeContainerSupport<?, ?> support;
private final boolean verifyChildrenStructure;
final void verifyValueChildren(final NormalizedNode<?, ?> writtenValue) {
if (verifyChildrenStructure) {
final NormalizedNodeContainer<?, ?, ?> container = (NormalizedNodeContainer<?, ?, ?>) writtenValue;
- for (final Object child : container.getValue()) {
- checkArgument(child instanceof NormalizedNode);
- final NormalizedNode<?, ?> castedChild = (NormalizedNode<?, ?>) child;
- final Optional<ModificationApplyOperation> childOp = getChild(castedChild.getIdentifier());
+ for (final NormalizedNode<?, ?> child : container.getValue()) {
+ final Optional<ModificationApplyOperation> childOp = getChild(child.getIdentifier());
if (childOp.isPresent()) {
- childOp.get().fullVerifyStructure(castedChild);
+ childOp.get().fullVerifyStructure(child);
} else {
throw new SchemaValidationFailedException(String.format(
"Node %s is not a valid child of %s according to the schema.",
- castedChild.getIdentifier(), container.getIdentifier()));
+ child.getIdentifier(), container.getIdentifier()));
}
}
@Override
protected final void recursivelyVerifyStructure(final NormalizedNode<?, ?> value) {
final NormalizedNodeContainer<?, ?, ?> container = (NormalizedNodeContainer<?, ?, ?>) value;
- for (final Object child : container.getValue()) {
- checkArgument(child instanceof NormalizedNode);
- final NormalizedNode<?, ?> castedChild = (NormalizedNode<?, ?>) child;
- final Optional<ModificationApplyOperation> childOp = getChild(castedChild.getIdentifier());
+ for (final NormalizedNode<?, ?> child : container.getValue()) {
+ final Optional<ModificationApplyOperation> childOp = getChild(child.getIdentifier());
if (!childOp.isPresent()) {
throw new SchemaValidationFailedException(
String.format("Node %s is not a valid child of %s according to the schema.",
- castedChild.getIdentifier(), container.getIdentifier()));
+ child.getIdentifier(), container.getIdentifier()));
}
- childOp.get().recursivelyVerifyStructure(castedChild);
+ childOp.get().recursivelyVerifyStructure(child);
}
}
@Override
protected TreeNode applyWrite(final ModifiedNode modification, final NormalizedNode<?, ?> newValue,
- final Optional<TreeNode> currentMeta, final Version version) {
+ final Optional<? extends TreeNode> currentMeta, final Version version) {
final TreeNode newValueMeta = TreeNodeFactory.createTreeNode(newValue, version);
if (modification.getChildren().isEmpty()) {
for (final ModifiedNode mod : modifications) {
final PathArgument id = mod.getIdentifier();
- final Optional<TreeNode> cm = meta.getChild(id);
+ final Optional<? extends TreeNode> cm = meta.getChild(id);
- final Optional<TreeNode> result = resolveChildOperation(id).apply(mod, cm, nodeVersion);
+ final Optional<? extends TreeNode> result = resolveChildOperation(id).apply(mod, cm, nodeVersion);
if (result.isPresent()) {
final TreeNode tn = result.get();
meta.addChild(tn);
final NormalizedNode<?, ?> value = modification.getWrittenValue();
Verify.verify(value instanceof NormalizedNodeContainer, "Attempted to merge non-container %s", value);
- @SuppressWarnings({"unchecked", "rawtypes"})
- final Collection<NormalizedNode<?, ?>> children = ((NormalizedNodeContainer) value).getValue();
- for (final NormalizedNode<?, ?> c : children) {
+ for (final NormalizedNode<?, ?> c : ((NormalizedNodeContainer<?, ?, ?>) value).getValue()) {
final PathArgument id = c.getIdentifier();
modification.modifyChild(id, resolveChildOperation(id), version);
}
}
private void mergeChildrenIntoModification(final ModifiedNode modification,
- final Collection<NormalizedNode<?, ?>> children, final Version version) {
+ final Collection<? extends NormalizedNode<?, ?>> children, final Version version) {
for (final NormalizedNode<?, ?> c : children) {
final ModificationApplyOperation childOp = resolveChildOperation(c.getIdentifier());
final ModifiedNode childNode = modification.modifyChild(c.getIdentifier(), childOp, version);
@Override
final void mergeIntoModifiedNode(final ModifiedNode modification, final NormalizedNode<?, ?> value,
final Version version) {
- @SuppressWarnings({ "unchecked", "rawtypes" })
- final Collection<NormalizedNode<?, ?>> children = ((NormalizedNodeContainer)value).getValue();
+ final Collection<? extends NormalizedNode<?, ?>> children =
+ ((NormalizedNodeContainer<?, ?, ?>)value).getValue();
switch (modification.getOperation()) {
case NONE:
// and then append any child entries.
if (!modification.getChildren().isEmpty()) {
// Version does not matter here as we'll throw it out
- final Optional<TreeNode> current = apply(modification, modification.getOriginal(),
+ final Optional<? extends TreeNode> current = apply(modification, modification.getOriginal(),
Version.initial());
if (current.isPresent()) {
modification.updateValue(LogicalOperation.WRITE, current.get().getData());
@Override
protected final void checkTouchApplicable(final ModificationPath path, final NodeModification modification,
- final Optional<TreeNode> current, final Version version) throws DataValidationFailedException {
- if (!modification.getOriginal().isPresent() && !current.isPresent()) {
- final YangInstanceIdentifier id = path.toInstanceIdentifier();
- throw new ModifiedNodeDoesNotExistException(id,
- String.format("Node %s does not exist. Cannot apply modification to its children.", id));
+ final Optional<? extends TreeNode> current, final Version version) throws DataValidationFailedException {
+ final TreeNode currentNode;
+ if (!current.isPresent()) {
+ currentNode = defaultTreeNode();
+ if (currentNode == null) {
+ if (!modification.getOriginal().isPresent()) {
+ final YangInstanceIdentifier id = path.toInstanceIdentifier();
+ throw new ModifiedNodeDoesNotExistException(id,
+ String.format("Node %s does not exist. Cannot apply modification to its children.", id));
+ }
+
+ throw new ConflictingModificationAppliedException(path.toInstanceIdentifier(),
+ "Node was deleted by other transaction.");
+ }
+ } else {
+ currentNode = current.get();
}
- checkConflicting(path, current.isPresent(), "Node was deleted by other transaction.");
- checkChildPreconditions(path, modification, current.get(), version);
+ checkChildPreconditions(path, modification, currentNode, version);
+ }
+
+ /**
+ * Return the default tree node. Default implementation does nothing, but can be overridden to call
+ * {@link #defaultTreeNode(NormalizedNode)}.
+ *
+ * @return Default empty tree node, or null if no default is available
+ */
+ @Nullable TreeNode defaultTreeNode() {
+ // Defaults to no recovery
+ return null;
+ }
+
+ static final TreeNode defaultTreeNode(final NormalizedNode<?, ?> emptyNode) {
+ return TreeNodeFactory.createTreeNode(emptyNode, FAKE_VERSION);
}
@Override
protected final void checkMergeApplicable(final ModificationPath path, final NodeModification modification,
- final Optional<TreeNode> current, final Version version) throws DataValidationFailedException {
+ final Optional<? extends TreeNode> current, final Version version) throws DataValidationFailedException {
if (current.isPresent()) {
checkChildPreconditions(path, modification, current.get(), version);
}
final TreeNode current, final Version version) throws DataValidationFailedException {
for (final NodeModification childMod : modification.getChildren()) {
final PathArgument childId = childMod.getIdentifier();
- final Optional<TreeNode> childMeta = current.getChild(childId);
+ final Optional<? extends TreeNode> childMeta = current.getChild(childId);
path.push(childId);
try {
}
@Override
- public final String toString() {
- return addToStringAttributes(MoreObjects.toStringHelper(this)).toString();
- }
-
ToStringHelper addToStringAttributes(final ToStringHelper helper) {
return helper.add("support", support).add("verifyChildren", verifyChildrenStructure);
}
Code Review / yangtools.git / blobdiff