*/
package org.opendaylight.yangtools.yang.data.impl.schema.builder.impl;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
-
-import org.opendaylight.yangtools.concepts.Immutable;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
-import org.opendaylight.yangtools.yang.data.impl.schema.nodes.AbstractImmutableNormalizedNode;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Iterables;
+import org.opendaylight.yangtools.yang.data.impl.schema.nodes.AbstractImmutableNormalizedValueNode;
+import org.opendaylight.yangtools.yang.data.spi.node.AbstractNormalizedNode;
public class ImmutableUnkeyedListNodeBuilder implements CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> {
-
private List<UnkeyedListEntryNode> value;
- private InstanceIdentifier.NodeIdentifier nodeIdentifier;
- private boolean dirty = false;
+ private NodeIdentifier nodeIdentifier;
+ private boolean dirty;
protected ImmutableUnkeyedListNodeBuilder() {
this.value = new LinkedList<>();
protected ImmutableUnkeyedListNodeBuilder(final ImmutableUnkeyedListNode node) {
this.nodeIdentifier = node.getIdentifier();
+ // FIXME: clean this up, notably reuse unmodified lists
this.value = new LinkedList<>();
- Iterables.addAll(value, node.getValue());
+ Iterables.addAll(value, node.body());
this.dirty = true;
}
return new ImmutableUnkeyedListNodeBuilder();
}
- public static CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> create(final UnkeyedListNode node) {
+ public static CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> create(final int sizeHint) {
+ return new ImmutableUnkeyedListNodeBuilder();
+ }
+
+ public static CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> create(
+ final UnkeyedListNode node) {
if (!(node instanceof ImmutableUnkeyedListNode)) {
throw new UnsupportedOperationException(String.format("Cannot initialize from class %s", node.getClass()));
}
@Override
public CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> withoutChild(
- final InstanceIdentifier.PathArgument key) {
+ final PathArgument key) {
checkDirty();
throw new UnsupportedOperationException("Children does not have identifiers.");
}
@Override
- public CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> withValue(final List<UnkeyedListEntryNode> value) {
+ public CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> withValue(
+ final Collection<UnkeyedListEntryNode> withValue) {
// TODO replace or putAll ?
- for (final UnkeyedListEntryNode UnkeyedListEntryNode : value) {
- withChild(UnkeyedListEntryNode);
+ for (final UnkeyedListEntryNode node : withValue) {
+ withChild(node);
}
return this;
@Override
public CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> withNodeIdentifier(
- final InstanceIdentifier.NodeIdentifier nodeIdentifier) {
- this.nodeIdentifier = nodeIdentifier;
+ final NodeIdentifier withNodeIdentifier) {
+ this.nodeIdentifier = withNodeIdentifier;
return this;
}
@Override
public UnkeyedListNode build() {
dirty = true;
+ if (value.isEmpty()) {
+ return new EmptyImmutableUnkeyedListNode(nodeIdentifier);
+ }
return new ImmutableUnkeyedListNode(nodeIdentifier, ImmutableList.copyOf(value));
}
}
@Override
- public NormalizedNodeContainerBuilder<NodeIdentifier, PathArgument, UnkeyedListEntryNode, UnkeyedListNode> removeChild(
- final PathArgument key) {
+ public NormalizedNodeContainerBuilder<NodeIdentifier, PathArgument, UnkeyedListEntryNode, UnkeyedListNode>
+ removeChild(final PathArgument key) {
return withoutChild(key);
}
- protected static final class ImmutableUnkeyedListNode extends
- AbstractImmutableNormalizedNode<InstanceIdentifier.NodeIdentifier, Iterable<UnkeyedListEntryNode>>
- implements Immutable, UnkeyedListNode {
+ protected static final class EmptyImmutableUnkeyedListNode
+ extends AbstractNormalizedNode<NodeIdentifier, UnkeyedListNode> implements UnkeyedListNode {
+ protected EmptyImmutableUnkeyedListNode(final NodeIdentifier nodeIdentifier) {
+ super(nodeIdentifier);
+ }
- private final ImmutableList<UnkeyedListEntryNode> children;
+ @Override
+ public ImmutableList<UnkeyedListEntryNode> body() {
+ return ImmutableList.of();
+ }
- ImmutableUnkeyedListNode(final InstanceIdentifier.NodeIdentifier nodeIdentifier,
- final ImmutableList<UnkeyedListEntryNode> children) {
- super(nodeIdentifier, children);
- this.children = children;
+ @Override
+ public UnkeyedListEntryNode getChild(final int position) {
+ throw new IndexOutOfBoundsException();
+ }
+
+ @Override
+ public int size() {
+ return 0;
+ }
+
+ @Override
+ protected Class<UnkeyedListNode> implementedType() {
+ return UnkeyedListNode.class;
}
@Override
protected int valueHashCode() {
- return children.hashCode();
+ return 1;
}
@Override
- protected boolean valueEquals(final AbstractImmutableNormalizedNode<?, ?> other) {
- return children.equals(((ImmutableUnkeyedListNode) other).children);
+ protected boolean valueEquals(final UnkeyedListNode other) {
+ return other.isEmpty();
+ }
+ }
+
+ protected static final class ImmutableUnkeyedListNode
+ extends AbstractImmutableNormalizedValueNode<NodeIdentifier, UnkeyedListNode,
+ Collection<@NonNull UnkeyedListEntryNode>>
+ implements UnkeyedListNode {
+
+ private final ImmutableList<UnkeyedListEntryNode> children;
+
+ ImmutableUnkeyedListNode(final NodeIdentifier nodeIdentifier,
+ final ImmutableList<UnkeyedListEntryNode> children) {
+ super(nodeIdentifier, children);
+ this.children = children;
}
@Override
}
@Override
- public int getSize() {
+ public int size() {
return children.size();
}
+
+ @Override
+ protected Class<UnkeyedListNode> implementedType() {
+ return UnkeyedListNode.class;
+ }
+
+ @Override
+ protected int valueHashCode() {
+ return children.hashCode();
+ }
+
+ @Override
+ protected boolean valueEquals(final UnkeyedListNode other) {
+ final Collection<UnkeyedListEntryNode> otherChildren;
+ if (other instanceof ImmutableUnkeyedListNode) {
+ otherChildren = ((ImmutableUnkeyedListNode) other).children;
+ } else {
+ otherChildren = other.body();
+ }
+ return otherChildren instanceof List ? children.equals(otherChildren)
+ : Iterables.elementsEqual(children, otherChildren);
+ }
}
}