@Override
protected TreeNode applyWrite(final ModifiedNode modification, final NormalizedNode newValue,
final Optional<? extends TreeNode> currentMeta, final Version version) {
- final TreeNode newValueMeta = TreeNode.of(newValue, version);
-
- if (modification.getChildren().isEmpty()) {
+ final var newValueMeta = TreeNode.of(newValue, version);
+ if (modification.isEmpty()) {
return newValueMeta;
}
* of writes needs to be charged to the code which originated this, not to the code which is attempting
* to make it visible.
*/
- final MutableTreeNode mutable = newValueMeta.mutable();
+ final var mutable = newValueMeta.mutable();
mutable.setSubtreeVersion(version);
- @SuppressWarnings("rawtypes")
- final NormalizedNodeContainerBuilder dataBuilder = support.createBuilder(newValue);
- final TreeNode result = mutateChildren(mutable, dataBuilder, version, modification.getChildren());
+ final var result = mutateChildren(mutable, support.createBuilder(newValue), version,
+ modification.getChildren());
// We are good to go except one detail: this is a single logical write, but
// we have a result TreeNode which has been forced to materialized, e.g. it
@Override
final void mergeIntoModifiedNode(final ModifiedNode modification, final NormalizedNode value,
final Version version) {
- final Collection<? extends NormalizedNode> children = ((DistinctNodeContainer<?, ?>)value).body();
+ final var valueChildren = ((DistinctNodeContainer<?, ?>) value).body();
switch (modification.getOperation()) {
case NONE:
// Fresh node, just record a MERGE with a value
return;
case TOUCH:
- mergeChildrenIntoModification(modification, children, version);
+ mergeChildrenIntoModification(modification, valueChildren, version);
// We record empty merge value, since real children merges are already expanded. This is needed to
// satisfy non-null for merge original merge value can not be used since it mean different order of
// operation - parent changes are always resolved before children ones, and having node in TOUCH means
case MERGE:
// Merging into an existing node. Merge data children modifications (maybe recursively) and mark
// as MERGE, invalidating cached snapshot
- mergeChildrenIntoModification(modification, children, version);
+ mergeChildrenIntoModification(modification, valueChildren, version);
modification.updateOperationType(LogicalOperation.MERGE);
return;
case DELETE:
// we are really performing a write. One thing that ruins that are any child modifications. If there
// are any, we will perform a read() to get the current state of affairs, turn this into into a WRITE
// and then append any child entries.
- if (!modification.getChildren().isEmpty()) {
+ if (!modification.isEmpty()) {
// Version does not matter here as we'll throw it out
- final Optional<? extends TreeNode> current = apply(modification, modification.getOriginal(),
- Version.initial());
+ final var current = apply(modification, modification.getOriginal(), Version.initial());
if (current.isPresent()) {
modification.updateValue(LogicalOperation.WRITE, current.orElseThrow().getData());
- mergeChildrenIntoModification(modification, children, version);
+ mergeChildrenIntoModification(modification, valueChildren, version);
return;
}
}
case WRITE:
// We are augmenting a previous write. We'll just walk value's children, get the corresponding
// ModifiedNode and run recursively on it
- mergeChildrenIntoModification(modification, children, version);
+ mergeChildrenIntoModification(modification, valueChildren, version);
modification.updateOperationType(LogicalOperation.WRITE);
return;
default:
* - do not collect useless garbage.
* It also means the ModificationType is UNMODIFIED.
*/
- final Collection<ModifiedNode> children = modification.getChildren();
- if (!children.isEmpty()) {
- @SuppressWarnings("rawtypes")
- final NormalizedNodeContainerBuilder dataBuilder = support.createBuilder(currentMeta.getData());
- final MutableTreeNode newMeta = currentMeta.mutable();
+ if (!modification.isEmpty()) {
+ final var dataBuilder = support.createBuilder(currentMeta.getData());
+ final var newMeta = currentMeta.mutable();
newMeta.setSubtreeVersion(version);
- final TreeNode ret = mutateChildren(newMeta, dataBuilder, version, children);
+ final var children = modification.getChildren();
+ final var ret = mutateChildren(newMeta, dataBuilder, version, children);
/*
* It is possible that the only modifications under this node were empty merges, which were turned into
*
* Let's do precisely that, stopping as soon we find a different result.
*/
- for (final ModifiedNode child : children) {
+ for (var child : children) {
if (child.getModificationType() != ModificationType.UNMODIFIED) {
modification.resolveModificationType(ModificationType.SUBTREE_MODIFIED);
return ret;
import static com.google.common.base.Preconditions.checkState;
import static java.util.Objects.requireNonNull;
-import java.util.Collection;
import java.util.Iterator;
import org.opendaylight.yangtools.yang.data.tree.impl.node.Version;
final ModificationApplyOperation operation) {
this.children = requireNonNull(children);
this.node = requireNonNull(node);
- this.op = requireNonNull(operation);
+ op = requireNonNull(operation);
}
static AbstractReadyIterator create(final ModifiedNode root, final ModificationApplyOperation operation) {
// been modified. If a child has children, we need to iterate
// through it via re-entering this method on the child iterator.
while (children.hasNext()) {
- final ModifiedNode child = children.next();
- final ModificationApplyOperation childOp = op.childByArg(child.getIdentifier());
- checkState(childOp != null, "Schema for child %s is not present.", child.getIdentifier());
- final Collection<ModifiedNode> grandChildren = child.getChildren();
+ final var child = children.next();
+ final var childId = child.getIdentifier();
+ final var childOp = op.childByArg(childId);
+ checkState(childOp != null, "Schema for child %s is not present.", childId);
- if (grandChildren.isEmpty()) {
+ if (child.isEmpty()) {
// The child is empty, seal it
child.seal(childOp, version);
if (child.getOperation() == LogicalOperation.NONE) {
children.remove();
}
} else {
- return new NestedReadyIterator(this, child, grandChildren.iterator(), childOp);
+ return new NestedReadyIterator(this, child, child.getChildren().iterator(), childOp);
}
}
Code Review / yangtools.git / commitdiff