package org.opendaylight.controller.md.sal.dom.store.impl.tree.data;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.TreeNode;
+import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.Version;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
import com.google.common.base.Optional;
-import com.google.common.primitives.UnsignedLong;
/**
* An implementation of apply operation which fails to do anything,
final class AlwaysFailOperation implements ModificationApplyOperation {
@Override
public Optional<TreeNode> apply(final ModifiedNode modification,
- final Optional<TreeNode> storeMeta, final UnsignedLong subtreeVersion) {
+ final Optional<TreeNode> storeMeta, final Version subtreeVersion) {
throw new IllegalStateException("Schema Context is not available.");
}
rwLock.writeLock().lock();
try {
- final Optional<TreeNode> newRoot = m.getStrategy().apply(m.getRootModification(), Optional.<TreeNode>of(rootNode), StoreUtils.increase(rootNode.getSubtreeVersion()));
+ final Optional<TreeNode> newRoot = m.getStrategy().apply(m.getRootModification(),
+ Optional.<TreeNode>of(rootNode), rootNode.getSubtreeVersion().next());
Preconditions.checkState(newRoot.isPresent(), "Apply strategy failed to produce root node");
return new InMemoryDataTreeCandidate(PUBLIC_ROOT_PATH, root, rootNode, newRoot.get());
} finally {
import org.opendaylight.controller.md.sal.dom.store.impl.tree.DataTreeFactory;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.TreeNodeFactory;
+import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.Version;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import com.google.common.primitives.UnsignedLong;
-
/**
* A factory for creating in-memory data trees.
*/
final NodeIdentifier root = new NodeIdentifier(SchemaContext.NAME);
final NormalizedNode<?, ?> data = Builders.containerBuilder().withNodeIdentifier(root).build();
- return new InMemoryDataTree(TreeNodeFactory.createTreeNode(data, UnsignedLong.ZERO), null);
+ return new InMemoryDataTree(TreeNodeFactory.createTreeNode(data, Version.initial()), null);
}
/**
import javax.annotation.concurrent.GuardedBy;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.DataTreeModification;
-import org.opendaylight.controller.md.sal.dom.store.impl.tree.StoreUtils;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.TreeNodeUtils;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.TreeNode;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
try {
return resolveModificationStrategy(path).apply(modification, modification.getOriginal(),
- StoreUtils.increase(snapshot.getRootNode().getSubtreeVersion()));
+ snapshot.getRootNode().getSubtreeVersion().next());
} catch (Exception e) {
LOG.error("Could not create snapshot for {}:{}", path,modification,e);
throw e;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.DataPreconditionFailedException;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.StoreTreeNode;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.TreeNode;
+import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.Version;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
import com.google.common.base.Optional;
-import com.google.common.primitives.UnsignedLong;
/**
*
* node, {@link Optional#absent()} if {@link ModifiedNode}
* resulted in deletion of this node.
*/
- Optional<TreeNode> apply(ModifiedNode modification, Optional<TreeNode> storeMeta, UnsignedLong subtreeVersion);
+ Optional<TreeNode> apply(ModifiedNode modification, Optional<TreeNode> storeMeta, Version subtreeVersion);
/**
*
import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.MutableTreeNode;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.TreeNode;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.TreeNodeFactory;
+import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.Version;
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.NodeIdentifierWithPredicates;
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
-import com.google.common.primitives.UnsignedLong;
abstract class NormalizedNodeContainerModificationStrategy extends SchemaAwareApplyOperation {
@Override
protected TreeNode applyWrite(final ModifiedNode modification,
- final Optional<TreeNode> currentMeta, final UnsignedLong subtreeVersion) {
- final UnsignedLong nodeVersion;
+ final Optional<TreeNode> currentMeta, final Version subtreeVersion) {
+ final Version nodeVersion;
if (currentMeta.isPresent()) {
- nodeVersion = StoreUtils.increase(currentMeta.get().getVersion());
+ nodeVersion = currentMeta.get().getVersion().next();
} else {
nodeVersion = subtreeVersion;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
private TreeNode mutateChildren(final MutableTreeNode meta, final NormalizedNodeContainerBuilder data,
- final UnsignedLong nodeVersion, final Iterable<ModifiedNode> modifications) {
+ final Version nodeVersion, final Iterable<ModifiedNode> modifications) {
for (ModifiedNode mod : modifications) {
final PathArgument id = mod.getIdentifier();
@Override
protected TreeNode applyMerge(final ModifiedNode modification, final TreeNode currentMeta,
- final UnsignedLong subtreeVersion) {
+ final Version subtreeVersion) {
// For Node Containers - merge is same as subtree change - we only replace children.
return applySubtreeChange(modification, currentMeta, subtreeVersion);
}
@Override
public TreeNode applySubtreeChange(final ModifiedNode modification,
- final TreeNode currentMeta, final UnsignedLong subtreeVersion) {
+ final TreeNode currentMeta, final Version subtreeVersion) {
// Bump subtree version to its new target
- final UnsignedLong updatedSubtreeVersion = StoreUtils.increase(currentMeta.getSubtreeVersion());
+ final Version updatedSubtreeVersion = currentMeta.getSubtreeVersion().next();
final MutableTreeNode newMeta = currentMeta.mutable();
newMeta.setSubtreeVersion(updatedSubtreeVersion);
package org.opendaylight.controller.md.sal.dom.store.impl.tree.data;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.TreeNode;
+import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.Version;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import com.google.common.base.Optional;
-import com.google.common.primitives.UnsignedLong;
final class OperationWithModification {
return applyOperation;
}
- public Optional<TreeNode> apply(final Optional<TreeNode> data, final UnsignedLong subtreeVersion) {
+ public Optional<TreeNode> apply(final Optional<TreeNode> data, final Version subtreeVersion) {
return applyOperation.apply(modification, data, subtreeVersion);
}
import org.opendaylight.controller.md.sal.dom.store.impl.tree.data.ValueNodeModificationStrategy.LeafModificationStrategy;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.TreeNode;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.TreeNodeFactory;
+import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.Version;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import com.google.common.primitives.UnsignedLong;
abstract class SchemaAwareApplyOperation implements ModificationApplyOperation {
private static final Logger LOG = LoggerFactory.getLogger(SchemaAwareApplyOperation.class);
@Override
public final Optional<TreeNode> apply(final ModifiedNode modification,
- final Optional<TreeNode> currentMeta, final UnsignedLong subtreeVersion) {
+ final Optional<TreeNode> currentMeta, final Version subtreeVersion) {
switch (modification.getType()) {
case DELETE:
}
protected abstract TreeNode applyMerge(ModifiedNode modification,
- TreeNode currentMeta, UnsignedLong subtreeVersion);
+ TreeNode currentMeta, Version subtreeVersion);
protected abstract TreeNode applyWrite(ModifiedNode modification,
- Optional<TreeNode> currentMeta, UnsignedLong subtreeVersion);
+ Optional<TreeNode> currentMeta, Version subtreeVersion);
protected abstract TreeNode applySubtreeChange(ModifiedNode modification,
- TreeNode currentMeta, UnsignedLong subtreeVersion);
+ TreeNode currentMeta, Version subtreeVersion);
protected abstract void checkSubtreeModificationApplicable(InstanceIdentifier path, final NodeModification modification,
final Optional<TreeNode> current) throws DataPreconditionFailedException;
@Override
protected TreeNode applyMerge(final ModifiedNode modification, final TreeNode currentMeta,
- final UnsignedLong subtreeVersion) {
+ final Version subtreeVersion) {
return applyWrite(modification, Optional.of(currentMeta), subtreeVersion);
}
@Override
protected TreeNode applySubtreeChange(final ModifiedNode modification,
- final TreeNode currentMeta, final UnsignedLong subtreeVersion) {
+ final TreeNode currentMeta, final Version subtreeVersion) {
throw new UnsupportedOperationException("UnkeyedList does not support subtree change.");
}
@Override
protected TreeNode applyWrite(final ModifiedNode modification,
- final Optional<TreeNode> currentMeta, final UnsignedLong subtreeVersion) {
+ final Optional<TreeNode> currentMeta, final Version subtreeVersion) {
return TreeNodeFactory.createTreeNode(modification.getWrittenValue(), subtreeVersion);
}
import org.opendaylight.controller.md.sal.dom.store.impl.tree.DataPreconditionFailedException;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.TreeNode;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.TreeNodeFactory;
+import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.Version;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import com.google.common.base.Optional;
-import com.google.common.primitives.UnsignedLong;
abstract class ValueNodeModificationStrategy<T extends DataSchemaNode> extends SchemaAwareApplyOperation {
@Override
protected TreeNode applySubtreeChange(final ModifiedNode modification,
- final TreeNode currentMeta, final UnsignedLong subtreeVersion) {
+ final TreeNode currentMeta, final Version subtreeVersion) {
throw new UnsupportedOperationException("Node " + schema.getPath()
+ "is leaf type node. Subtree change is not allowed.");
}
@Override
protected TreeNode applyMerge(final ModifiedNode modification, final TreeNode currentMeta,
- final UnsignedLong subtreeVersion) {
+ final Version subtreeVersion) {
// Just overwrite whatever was there
return applyWrite(modification, null, subtreeVersion);
}
@Override
protected TreeNode applyWrite(final ModifiedNode modification,
- final Optional<TreeNode> currentMeta, final UnsignedLong subtreeVersion) {
+ final Optional<TreeNode> currentMeta, final Version subtreeVersion) {
return TreeNodeFactory.createTreeNode(modification.getWrittenValue(), subtreeVersion);
}
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import com.google.common.base.Preconditions;
-import com.google.common.primitives.UnsignedLong;
/*
* A very basic data tree node.
*/
abstract class AbstractTreeNode implements TreeNode {
private final NormalizedNode<?, ?> data;
- private final UnsignedLong version;
+ private final Version version;
- protected AbstractTreeNode(final NormalizedNode<?, ?> data, final UnsignedLong version) {
+ protected AbstractTreeNode(final NormalizedNode<?, ?> data, final Version version) {
this.data = Preconditions.checkNotNull(data);
this.version = Preconditions.checkNotNull(version);
}
}
@Override
- public final UnsignedLong getVersion() {
+ public final Version getVersion() {
return version;
}
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import com.google.common.primitives.UnsignedLong;
/**
* A TreeNode capable of holding child nodes. The fact that any of the children
*/
final class ContainerNode extends AbstractTreeNode {
private final Map<PathArgument, TreeNode> children;
- private final UnsignedLong subtreeVersion;
+ private final Version subtreeVersion;
- protected ContainerNode(final NormalizedNode<?, ?> data, final UnsignedLong version,
- final Map<PathArgument, TreeNode> children, final UnsignedLong subtreeVersion) {
+ protected ContainerNode(final NormalizedNode<?, ?> data, final Version version,
+ final Map<PathArgument, TreeNode> children, final Version subtreeVersion) {
super(data, version);
this.children = Preconditions.checkNotNull(children);
this.subtreeVersion = Preconditions.checkNotNull(subtreeVersion);
}
@Override
- public UnsignedLong getSubtreeVersion() {
+ public Version getSubtreeVersion() {
return subtreeVersion;
}
private static final class Mutable implements MutableTreeNode {
private final Map<PathArgument, TreeNode> children;
- private final UnsignedLong version;
+ private final Version version;
private NormalizedNode<?, ?> data;
- private UnsignedLong subtreeVersion;
+ private Version subtreeVersion;
private Mutable(final ContainerNode parent) {
this.data = parent.getData();
}
@Override
- public void setSubtreeVersion(final UnsignedLong subtreeVersion) {
+ public void setSubtreeVersion(final Version subtreeVersion) {
this.subtreeVersion = Preconditions.checkNotNull(subtreeVersion);
}
}
}
- private static ContainerNode create(final UnsignedLong version, final NormalizedNode<?, ?> data, final Iterable<NormalizedNode<?, ?>> children) {
+ private static ContainerNode create(final Version version, final NormalizedNode<?, ?> data,
+ final Iterable<NormalizedNode<?, ?>> children) {
final Map<PathArgument, TreeNode> map = new HashMap<>();
for (NormalizedNode<?, ?> child : children) {
return new ContainerNode(data, version, map, version);
}
- public static ContainerNode create(final UnsignedLong version, final NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>> container) {
+ public static ContainerNode create(final Version version, final NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>> container) {
return create(version, container, container.getValue());
}
- public static ContainerNode create(final UnsignedLong version, final OrderedNodeContainer<NormalizedNode<?, ?>> container) {
+ public static ContainerNode create(final Version version, final OrderedNodeContainer<NormalizedNode<?, ?>> container) {
return create(version, container, container.getValue());
}
}
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import com.google.common.primitives.UnsignedLong;
-
public interface MutableTreeNode extends StoreTreeNode<TreeNode> {
void setData(NormalizedNode<?, ?> data);
- void setSubtreeVersion(UnsignedLong subtreeVersion);
+ void setSubtreeVersion(Version subtreeVersion);
void addChild(TreeNode child);
void removeChild(PathArgument id);
TreeNode seal();
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import com.google.common.primitives.UnsignedLong;
-
/*
* A very basic data tree node. It has a version (when it was last modified),
* a subtree version (when any of its children were modified) and some read-only
*
* @return Current data node version.
*/
- UnsignedLong getVersion();
+ Version getVersion();
/**
* Get the subtree version.
*
* @return Current subtree version.
*/
- UnsignedLong getSubtreeVersion();
+ Version getSubtreeVersion();
/**
* Get a read-only view of the underlying data.
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import org.opendaylight.yangtools.yang.data.api.schema.OrderedNodeContainer;
-import com.google.common.primitives.UnsignedLong;
-
public final class TreeNodeFactory {
private TreeNodeFactory() {
throw new UnsupportedOperationException("Utility class should not be instantiated");
* @param version data node version
* @return new AbstractTreeNode instance, covering the data tree provided
*/
- public static final TreeNode createTreeNode(final NormalizedNode<?, ?> data, final UnsignedLong version) {
+ public static final TreeNode createTreeNode(final NormalizedNode<?, ?> data, final Version version) {
if (data instanceof NormalizedNodeContainer<?, ?, ?>) {
@SuppressWarnings("unchecked")
NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>> container = (NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>>) data;
import org.slf4j.LoggerFactory;
import com.google.common.base.Optional;
-import com.google.common.primitives.UnsignedLong;
final class ValueNode extends AbstractTreeNode {
private static final Logger LOG = LoggerFactory.getLogger(ValueNode.class);
- protected ValueNode(final NormalizedNode<?, ?> data, final UnsignedLong version) {
+ protected ValueNode(final NormalizedNode<?, ?> data, final Version version) {
super(data, version);
}
}
@Override
- public UnsignedLong getSubtreeVersion() {
+ public Version getSubtreeVersion() {
return getVersion();
}
--- /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.spi;
+
+/**
+ * The concept of a version, either node version, or a subtree version. The
+ * only interface contract this class has is that no two versions are the
+ * same.
+ */
+public final class Version {
+ private Version() {
+
+ }
+
+ /**
+ * Create a new version, distinct from any other version.
+ *
+ * @return a new version.
+ */
+ public Version next() {
+ return new Version();
+ }
+
+ /**
+ * Create an initial version.
+ *
+ * @return a new version.
+ */
+ public static final Version initial() {
+ return new Version();
+ }
+}
import org.opendaylight.controller.md.sal.dom.store.impl.tree.DataTree;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.DataTreeModification;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.TreeNodeFactory;
+import org.opendaylight.controller.md.sal.dom.store.impl.tree.spi.Version;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import com.google.common.base.Optional;
-import com.google.common.primitives.UnsignedLong;
/**
*
@Test
public void basicReadWrites() {
DataTreeModification modificationTree = new InMemoryDataTreeModification(new InMemoryDataTreeSnapshot(schemaContext,
- TreeNodeFactory.createTreeNode(createDocumentOne(), UnsignedLong.valueOf(5)), applyOper),
+ TreeNodeFactory.createTreeNode(createDocumentOne(), Version.initial()), applyOper),
new SchemaAwareApplyOperationRoot(schemaContext));
Optional<NormalizedNode<?, ?>> originalBarNode = modificationTree.readNode(OUTER_LIST_2_PATH);
assertTrue(originalBarNode.isPresent());