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%2FAbstractModifiedNodeBasedCandidateNode.java;h=02d961eed3c05d1fb0dd1dfd802623b01dfa4252;hb=1eb87c819cc6881ca7be74917a5d0bb7a9cad41f;hp=93e0e671eda7e72ac8a4d73efa53f4ebb2e39fd4;hpb=2f2338abee4e4dbfe0ad7d28362fd8aa511494aa;p=yangtools.git diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractModifiedNodeBasedCandidateNode.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractModifiedNodeBasedCandidateNode.java index 93e0e671ed..02d961eed3 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractModifiedNodeBasedCandidateNode.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/AbstractModifiedNodeBasedCandidateNode.java @@ -1,18 +1,18 @@ /* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. + * Copyright (c) 2015, 2016 Cisco Systems, Inc. and others. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ package org.opendaylight.yangtools.yang.data.impl.schema.tree; -import com.google.common.base.Function; import com.google.common.base.Optional; import com.google.common.base.Preconditions; import com.google.common.base.Verify; import com.google.common.collect.Collections2; +import com.google.common.collect.ImmutableList; import java.util.Collection; -import java.util.Collections; +import javax.annotation.Nonnull; import javax.annotation.Nullable; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; @@ -22,20 +22,12 @@ import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType; import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode; abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandidateNode { - - private static final Function, DataTreeCandidateNode> TO_UNMODIFIED_NODES = new Function, DataTreeCandidateNode>() { - @Override - public DataTreeCandidateNode apply(final NormalizedNode input) { - return AbstractRecursiveCandidateNode.unmodifiedNode(input); - } - }; - private final ModifiedNode mod; private final TreeNode newMeta; private final TreeNode oldMeta; - protected AbstractModifiedNodeBasedCandidateNode(final ModifiedNode mod, - final TreeNode oldMeta, final TreeNode newMeta) { + protected AbstractModifiedNodeBasedCandidateNode(final ModifiedNode mod, final TreeNode oldMeta, + final TreeNode newMeta) { this.newMeta = newMeta; this.oldMeta = oldMeta; this.mod = Preconditions.checkNotNull(mod); @@ -53,12 +45,8 @@ abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandida return oldMeta; } - private static final TreeNode childMeta(final TreeNode parent, final PathArgument id) { - if (parent != null) { - return parent.getChild(id).orNull(); - } else { - return null; - } + private static TreeNode childMeta(final TreeNode parent, final PathArgument id) { + return parent == null ? null : parent.getChild(id).orNull(); } private static boolean canHaveChildren(@Nullable final TreeNode oldMeta, @Nullable final TreeNode newMeta) { @@ -82,80 +70,81 @@ abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandida } @Override + @Nonnull public Collection getChildNodes() { switch (mod.getModificationType()) { + case APPEARED: + case DISAPPEARED: case SUBTREE_MODIFIED: - return Collections2.transform(mod.getChildren(), new Function() { - @Override - public DataTreeCandidateNode apply(final ModifiedNode input) { - return childNode(input); - } - }); + return Collections2.transform(mod.getChildren(), this::childNode); case UNMODIFIED: // Unmodified node, but we still need to resolve potential children. canHaveChildren returns // false if both arguments are null. - if (canHaveChildren(oldMeta, newMeta)) { - return Collections2.transform(getContainer(newMeta != null ? newMeta : oldMeta).getValue(), TO_UNMODIFIED_NODES); - } else { - return Collections.emptyList(); + if (!canHaveChildren(oldMeta, newMeta)) { + return ImmutableList.of(); } + + return Collections2.transform(getContainer(newMeta != null ? newMeta : oldMeta).getValue(), + AbstractRecursiveCandidateNode::unmodifiedNode); case DELETE: case WRITE: // This is unusual, the user is requesting we follow into an otherwise-terminal node. // We need to fudge things based on before/after data to correctly fake the expectations. - if (canHaveChildren(oldMeta, newMeta)) { - return AbstractDataTreeCandidateNode.deltaChildren(getContainer(oldMeta), getContainer(newMeta)); - } else { - return Collections.emptyList(); + if (!canHaveChildren(oldMeta, newMeta)) { + return ImmutableList.of(); } + return AbstractDataTreeCandidateNode.deltaChildren(getContainer(oldMeta), getContainer(newMeta)); default: throw new IllegalArgumentException("Unhandled modification type " + mod.getModificationType()); } } @Override + @Nonnull public ModificationType getModificationType() { return Verify.verifyNotNull(mod.getModificationType(), "Node %s does not have resolved modification type", mod); } - private Optional> optionalData(final TreeNode meta) { - if (meta != null) { - return Optional.>of(meta.getData()); - } else { - return Optional.absent(); - } + private static Optional> optionalData(final TreeNode meta) { + return meta == null ? Optional.absent() : Optional.of(meta.getData()); } @Override - public Optional> getDataAfter() { + @Nonnull + public final Optional> getDataAfter() { return optionalData(newMeta); } @Override - public Optional> getDataBefore() { + @Nonnull + public final Optional> getDataBefore() { return optionalData(oldMeta); } @Override - public DataTreeCandidateNode getModifiedChild(final PathArgument identifier) { + public final DataTreeCandidateNode getModifiedChild(final PathArgument identifier) { switch (mod.getModificationType()) { + case APPEARED: + case DISAPPEARED: case SUBTREE_MODIFIED: final Optional childMod = mod.getChild(identifier); if (childMod.isPresent()) { return childNode(childMod.get()); } return null; - case DELETE: case UNMODIFIED: + if (!canHaveChildren(oldMeta, newMeta)) { + return null; + } + final Optional> maybeChild = getContainer(newMeta != null ? newMeta : oldMeta) + .getChild(identifier); + return maybeChild.isPresent() ? AbstractRecursiveCandidateNode.unmodifiedNode(maybeChild.get()) : null; + case DELETE: case WRITE: - // FIXME: this is a linear walk. We need a Map of these in order to - // do something like getChildMap().get(identifier); - for (DataTreeCandidateNode c : getChildNodes()) { - if (identifier.equals(c.getIdentifier())) { - return c; - } + if (!canHaveChildren(oldMeta, newMeta)) { + return null; } - return null; + return AbstractDataTreeCandidateNode.deltaChild(getContainer(oldMeta), getContainer(newMeta), identifier); default: throw new IllegalArgumentException("Unhandled modification type " + mod.getModificationType()); } @@ -167,8 +156,15 @@ abstract class AbstractModifiedNodeBasedCandidateNode implements DataTreeCandida } @Override + @Nonnull public PathArgument getIdentifier() { return getMod().getIdentifier(); } } -} \ No newline at end of file + + @Override + public String toString() { + return this.getClass().getSimpleName() + "{mod = " + this.mod + ", oldMeta = " + this.oldMeta + ", newMeta = " + + this.newMeta + "}"; + } +}