--- /dev/null
+/*
+ * Copyright (c) 2014 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.controller.md.sal.dom.store.impl.tree;
+
+public enum ModificationType {
+
+ /**
+ *
+ * Node is unmodified
+ *
+ *
+ */
+ UNMODIFIED,
+ /**
+ *
+ * Child of tree node was modified
+ *
+ */
+ SUBTREE_MODIFIED,
+ /**
+ * Tree node was replaced with new value / subtree
+ *
+ */
+ WRITE,
+ /**
+ *
+ * Tree node is to be deleted.
+ *
+ */
+ DELETE
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 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.controller.md.sal.dom.store.impl.tree;
+
+import static com.google.common.base.Preconditions.checkState;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.opendaylight.yangtools.concepts.Identifiable;
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+
+import com.google.common.base.Optional;
+
+/**
+ * Node Modification Node and Tree
+ *
+ * Tree which structurally resembles data tree and captures client modifications
+ * to the data store tree.
+ *
+ * This tree is lazily created and populated via {@link #modifyChild(PathArgument)}
+ * and {@link StoreMetadataNode} which represents original state {@link #getOriginal()}.
+ *
+ */
+public class NodeModification implements StoreTreeNode<NodeModification>, Identifiable<PathArgument> {
+
+ private final PathArgument identifier;
+ private ModificationType modificationType = ModificationType.UNMODIFIED;
+
+
+ private final Optional<StoreMetadataNode> original;
+
+ private NormalizedNode<?, ?> value;
+
+ private StoreMetadataNode snapshotCache;
+
+ private final Map<PathArgument, NodeModification> childModification;
+
+ private boolean sealed = false;
+
+ protected NodeModification(final PathArgument identifier, final Optional<StoreMetadataNode> original) {
+ this.identifier = identifier;
+ this.original = original;
+ childModification = new LinkedHashMap<>();
+ }
+
+ /**
+ *
+ *
+ * @return
+ */
+ public NormalizedNode<?, ?> getWritenValue() {
+ return value;
+ }
+
+ @Override
+ public PathArgument getIdentifier() {
+ return identifier;
+ }
+
+ /**
+ *
+ * Returns original store metadata
+ * @return original store metadata
+ */
+ public final Optional<StoreMetadataNode> getOriginal() {
+ return original;
+ }
+
+ /**
+ * Returns modification type
+ *
+ * @return modification type
+ */
+ public final ModificationType getModificationType() {
+ return modificationType;
+ }
+
+ /**
+ *
+ * Returns child modification if child was modified
+ *
+ * @return Child modification if direct child or it's subtree
+ * was modified.
+ *
+ */
+ @Override
+ public Optional<NodeModification> getChild(final PathArgument child) {
+ return Optional.<NodeModification> fromNullable(childModification.get(child));
+ }
+
+ /**
+ *
+ * Returns child modification if child was modified, creates {@link NodeModification}
+ * for child otherwise.
+ *
+ * If this node's {@link ModificationType} is {@link ModificationType#UNMODIFIED}
+ * changes modification type to {@link ModificationType#SUBTREE_MODIFIED}
+ *
+ * @param child
+ * @return {@link NodeModification} for specified child, with {@link #getOriginal()}
+ * containing child metadata if child was present in original data.
+ */
+ public synchronized NodeModification modifyChild(final PathArgument child) {
+ checkSealed();
+ if(modificationType == ModificationType.UNMODIFIED) {
+ updateModificationType(ModificationType.SUBTREE_MODIFIED);
+ }
+ final NodeModification potential = childModification.get(child);
+ if (potential != null) {
+ return potential;
+ }
+ Optional<StoreMetadataNode> currentMetadata = Optional.absent();
+ if(original.isPresent()) {
+ currentMetadata = original.get().getChild(child);
+ }
+ NodeModification newlyCreated = new NodeModification(child,currentMetadata);
+ childModification.put(child, newlyCreated);
+ return newlyCreated;
+ }
+
+ /**
+ *
+ * Returns all recorded direct child modification
+ *
+ * @return all recorded direct child modifications
+ */
+ public Iterable<NodeModification> getModifications() {
+ return childModification.values();
+ }
+
+
+ /**
+ *
+ * Records a delete for associated node.
+ *
+ */
+ public synchronized void delete() {
+ checkSealed();
+ updateModificationType(ModificationType.DELETE);
+ childModification.clear();
+ this.value = null;
+ }
+
+ /**
+ *
+ * Records a write for associated node.
+ *
+ * @param value
+ */
+ public synchronized void write(final NormalizedNode<?, ?> value) {
+ checkSealed();
+ updateModificationType(ModificationType.WRITE);
+ childModification.clear();
+ this.value = value;
+ }
+
+ private void checkSealed() {
+ checkState(!sealed, "Node Modification is sealed. No further changes allowed.");
+ }
+
+ public synchronized void seal() {
+ sealed = true;
+ for(NodeModification child : childModification.values()) {
+ child.seal();
+ }
+ }
+
+ private void clearSnapshot() {
+ snapshotCache = null;
+ }
+
+ public boolean hasAdditionalModifications() {
+ return !childModification.isEmpty();
+ }
+
+ public void updateModificationType(final ModificationType type) {
+ modificationType = type;
+ clearSnapshot();
+ }
+
+ @Override
+ public String toString() {
+ return "NodeModification [identifier=" + identifier + ", modificationType="
+ + modificationType + ", value=" + value + ", childModification=" + childModification + "]";
+ }
+
+ public static NodeModification createUnmodified(final StoreMetadataNode metadataTree) {
+ return new NodeModification(metadataTree.getIdentifier(), Optional.of(metadataTree));
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 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.controller.md.sal.dom.store.impl.tree;
+
+import static com.google.common.base.Preconditions.checkState;
+
+import java.util.Map;
+
+import org.opendaylight.yangtools.concepts.Identifiable;
+import org.opendaylight.yangtools.concepts.Immutable;
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+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.primitives.UnsignedLong;
+
+public class StoreMetadataNode implements Immutable, Identifiable<PathArgument>, StoreTreeNode<StoreMetadataNode> {
+
+ private final UnsignedLong nodeVersion;
+ private final UnsignedLong subtreeVersion;
+ private final NormalizedNode<?, ?> data;
+
+ private final Map<PathArgument, StoreMetadataNode> children;
+
+ 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);
+
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ public UnsignedLong getNodeVersion() {
+ return this.nodeVersion;
+ }
+
+ @Override
+ public PathArgument getIdentifier() {
+ return data.getIdentifier();
+ }
+
+ public UnsignedLong getSubtreeVersion() {
+ return subtreeVersion;
+ }
+
+ public NormalizedNode<?, ?> getData() {
+ return this.data;
+ }
+
+ public Iterable<StoreMetadataNode> getChildren() {
+ return children.values();
+ }
+
+ @Override
+ public Optional<StoreMetadataNode> getChild(final PathArgument key) {
+ return Optional.fromNullable(children.get(key));
+ }
+
+ @Override
+ public String toString() {
+ return "StoreMetadataNode [identifier=" + getIdentifier() + ", nodeVersion=" + nodeVersion + "]";
+ }
+
+ public static Optional<UnsignedLong> getVersion(final Optional<StoreMetadataNode> currentMetadata) {
+ if (currentMetadata.isPresent()) {
+ return Optional.of(currentMetadata.get().getNodeVersion());
+ }
+ return Optional.absent();
+ }
+
+ public static Optional<StoreMetadataNode> getChild(final Optional<StoreMetadataNode> parent, final PathArgument child) {
+ if (parent.isPresent()) {
+ return parent.get().getChild(child);
+ }
+ return Optional.absent();
+ }
+
+ public static final StoreMetadataNode createRecursivelly(final NormalizedNode<?, ?> node, final UnsignedLong version) {
+ Builder builder = builder() //
+ .setNodeVersion(version) //
+ .setSubtreeVersion(version) //
+ .setData(node);
+ if(node instanceof NormalizedNodeContainer<?, ?, ?>) {
+
+ @SuppressWarnings("unchecked")
+ NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>> nodeContainer = (NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>>) node;
+ for(NormalizedNode<?, ?> subNode : nodeContainer.getValue()) {
+ builder.add(createRecursivelly(subNode, version));
+ }
+ }
+ return builder.build();
+ }
+
+ public static class Builder {
+
+ private Builder() {
+
+ }
+
+ UnsignedLong nodeVersion = UnsignedLong.valueOf(0);
+ UnsignedLong subtreeVersion = UnsignedLong.valueOf(0);
+ NormalizedNode<?, ?> data;
+
+ final ImmutableMap.Builder<PathArgument, StoreMetadataNode> children = ImmutableMap.builder();
+
+ public UnsignedLong getVersion() {
+ return nodeVersion;
+
+ }
+
+ public Builder setNodeVersion(final UnsignedLong version) {
+ this.nodeVersion = version;
+ return this;
+ }
+
+ public Builder setSubtreeVersion(final UnsignedLong version) {
+ this.subtreeVersion = version;
+ return this;
+ }
+
+ public Builder setData(final NormalizedNode<?,?> data) {
+ this.data = data;
+ return this;
+ }
+
+ public Builder add(final StoreMetadataNode node) {
+ children.put(node.getIdentifier(), node);
+ 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());
+ }
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 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.controller.md.sal.dom.store.impl.tree;
+
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.NormalizedNodeContainerBuilder;
+
+/**
+ *
+ * Helper builder
+ *
+ *
+ */
+@SuppressWarnings("rawtypes")
+public class StoreNodeCompositeBuilder {
+
+ private final StoreMetadataNode.Builder metadata;
+
+ private final NormalizedNodeContainerBuilder data;
+
+
+ private StoreNodeCompositeBuilder(final NormalizedNodeContainerBuilder nodeBuilder) {
+ this.metadata = StoreMetadataNode.builder();
+ this.data = nodeBuilder;
+ }
+
+ @SuppressWarnings("unchecked")
+ public StoreNodeCompositeBuilder add(final StoreMetadataNode node) {
+ metadata.add(node);
+ data.addChild(node.getData());
+ return this;
+ }
+
+
+ public StoreMetadataNode build() {
+ return metadata.setData(data.build()).build();
+ }
+
+
+ public static StoreNodeCompositeBuilder from(final NormalizedNodeContainerBuilder nodeBuilder) {
+ return new StoreNodeCompositeBuilder(nodeBuilder);
+ }
+
+ public static StoreNodeCompositeBuilder from(final StoreMetadataNode previous, final NormalizedNodeContainerBuilder nodeBuilder) {
+
+ return new StoreNodeCompositeBuilder(nodeBuilder);
+ }
+
+ public StoreNodeCompositeBuilder setIdentifier(final PathArgument identifier) {
+ data.withNodeIdentifier(identifier);
+ return this;
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 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.controller.md.sal.dom.store.impl.tree;
+
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+
+import com.google.common.base.Optional;
+/**
+ *
+ * Tree node which contains references to it's leafs
+ *
+ * @param <C> Final node type
+ */
+public interface StoreTreeNode<C extends StoreTreeNode<C>> {
+
+ /**
+ *
+ * Returns direct child of the node
+ *
+ * @param child Identifier of child
+ * @return Optional with node if the child is existing, {@link Optional#absent()} otherwise.
+ */
+ Optional<C> getChild(PathArgument child);
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 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.controller.md.sal.dom.store.impl.tree;
+
+import java.util.AbstractMap.SimpleEntry;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+
+import com.google.common.base.Optional;
+
+public class TreeNodeUtils {
+
+ /**
+ * Finds a node in tree
+ *
+ * @param tree Data Tree
+ * @param path Path to the node
+ * @return Optional with node if the node is present in tree, {@link Optional#absent()} otherwise.
+ *
+ */
+ public static <T extends StoreTreeNode<T>> Optional<T> findNode(final T tree, final InstanceIdentifier path) {
+ Optional<T> current = Optional.<T> of(tree);
+ Iterator<PathArgument> pathIter = path.getPath().iterator();
+ while (current.isPresent() && pathIter.hasNext()) {
+ current = current.get().getChild(pathIter.next());
+ }
+ return current;
+ }
+
+ /**
+ * Finds a node or closest parent in the tree
+ *
+ * @param tree Data Tree
+ * @param path Path to the node
+ * @return Map.Entry Entry with key which is path to closest parent and value is parent node.
+ *
+ */
+ public static <T extends StoreTreeNode<T>> Map.Entry<InstanceIdentifier, T> findClosest(final T tree, final InstanceIdentifier path) {
+ Optional<T> parent = Optional.<T>of(tree);
+ Optional<T> current = Optional.<T> of(tree);
+
+ int nesting = 0;
+ Iterator<PathArgument> pathIter = path.getPath().iterator();
+ while (current.isPresent() && pathIter.hasNext()) {
+ parent = current;
+ current = current.get().getChild(pathIter.next());
+ nesting++;
+ }
+ if(current.isPresent()) {
+ final InstanceIdentifier currentPath = new InstanceIdentifier(path.getPath().subList(0, nesting));
+ return new SimpleEntry<InstanceIdentifier,T>(currentPath,current.get());
+ }
+ // Nesting minus one is safe, since current is allways present when nesting = 0
+ // so this prat of code is never triggered, in cases nesting == 0;
+ final InstanceIdentifier parentPath = new InstanceIdentifier(path.getPath().subList(0, nesting - 1));
+ return new SimpleEntry<InstanceIdentifier,T>(parentPath,parent.get());
+ }
+
+}
Code Review / controller.git / commitdiff