import static com.google.common.base.Preconditions.checkState;
+import java.util.Collections;
+import java.util.HashMap;
import java.util.Map;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableMap;
+import com.google.common.base.Preconditions;
import com.google.common.primitives.UnsignedLong;
public class StoreMetadataNode implements Immutable, Identifiable<PathArgument>, StoreTreeNode<StoreMetadataNode> {
private final Map<PathArgument, StoreMetadataNode> children;
+ /**
+ *
+ * @param data
+ * @param nodeVersion
+ * @param subtreeVersion
+ * @param children Map of children, must not be modified externally
+ */
protected StoreMetadataNode(final NormalizedNode<?, ?> data, final UnsignedLong nodeVersion,
final UnsignedLong subtreeVersion, final Map<PathArgument, StoreMetadataNode> children) {
this.nodeVersion = nodeVersion;
this.subtreeVersion = subtreeVersion;
this.data = data;
- this.children = ImmutableMap.copyOf(children);
+ this.children = Preconditions.checkNotNull(children);
+ }
+
+ public static StoreMetadataNode createEmpty(final NormalizedNode<?, ?> data) {
+ return new StoreMetadataNode(data, UnsignedLong.ZERO, UnsignedLong.ZERO,
+ Collections.<PathArgument, StoreMetadataNode>emptyMap());
+ }
+ public StoreMetadataNode(final NormalizedNode<?, ?> data, final UnsignedLong nodeVersion,
+ final UnsignedLong subtreeVersion) {
+ this(data, nodeVersion, subtreeVersion, Collections.<PathArgument, StoreMetadataNode>emptyMap());
}
public static Builder builder() {
return new Builder();
}
+ public static Builder builder(StoreMetadataNode node) {
+ return new Builder(node);
+ }
+
public UnsignedLong getNodeVersion() {
return this.nodeVersion;
}
return this.data;
}
- public Iterable<StoreMetadataNode> getChildren() {
- return children.values();
- }
-
@Override
public Optional<StoreMetadataNode> getChild(final PathArgument key) {
return Optional.fromNullable(children.get(key));
return Optional.absent();
}
- public static final StoreMetadataNode createRecursivelly(final NormalizedNode<?, ?> node,
+ public static final StoreMetadataNode createRecursively(final NormalizedNode<?, ?> node,
final UnsignedLong nodeVersion, final UnsignedLong subtreeVersion) {
Builder builder = builder() //
.setNodeVersion(nodeVersion) //
@SuppressWarnings("unchecked")
NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>> nodeContainer = (NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>>) node;
for (NormalizedNode<?, ?> subNode : nodeContainer.getValue()) {
- builder.add(createRecursivelly(subNode, nodeVersion, subtreeVersion));
+ builder.add(createRecursively(subNode, nodeVersion, subtreeVersion));
}
}
return builder.build();
private UnsignedLong nodeVersion;
private UnsignedLong subtreeVersion;
private NormalizedNode<?, ?> data;
- private final ImmutableMap.Builder<PathArgument, StoreMetadataNode> children = ImmutableMap.builder();
+ private Map<PathArgument, StoreMetadataNode> children;
+ private boolean dirty = false;
- private Builder() {}
+ private Builder() {
+ children = new HashMap<>();
+ }
+ public Builder(StoreMetadataNode node) {
+ children = new HashMap<>(node.children);
+ }
public UnsignedLong getVersion() {
return nodeVersion;
}
public Builder add(final StoreMetadataNode node) {
+ if (dirty) {
+ children = new HashMap<>(children);
+ dirty = false;
+ }
children.put(node.getIdentifier(), node);
return this;
}
+ public Builder remove(final PathArgument id) {
+ if (dirty) {
+ children = new HashMap<>(children);
+ dirty = false;
+ }
+ children.remove(id);
+ return this;
+ }
+
public StoreMetadataNode build() {
checkState(data != null, "Data node should not be null.");
checkState(subtreeVersion.compareTo(nodeVersion) >= 0,
"Subtree version must be equals or greater than node version.");
- return new StoreMetadataNode(data, nodeVersion, subtreeVersion, children.build());
+ dirty = true;
+ return new StoreMetadataNode(data, nodeVersion, subtreeVersion, children);
}
}
- public static StoreMetadataNode createRecursivelly(final NormalizedNode<?, ?> node, final UnsignedLong version) {
- return createRecursivelly(node, version, version);
+ public static StoreMetadataNode createRecursively(final NormalizedNode<?, ?> node, final UnsignedLong version) {
+ return createRecursively(node, version, version);
}
-
}