X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-dom-broker%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fmd%2Fsal%2Fdom%2Fstore%2Fimpl%2Ftree%2Fdata%2FInMemoryDataTreeModification.java;h=7d0c81e39de8efe564c33925280c9dbb9c71ff22;hp=bedf76172a4fc3d2b74dbf2f42f9dcd3bdde92d4;hb=7206d41640f98943c64da8f8486e5205b279c943;hpb=8d160966fa8752235d01bb8dc57c11391b86f187

diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/InMemoryDataTreeModification.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/InMemoryDataTreeModification.java
index bedf76172a..7d0c81e39d 100644
--- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/InMemoryDataTreeModification.java
+++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/tree/data/InMemoryDataTreeModification.java
@@ -12,9 +12,7 @@ import static com.google.common.base.Preconditions.checkState;
 import java.util.Map.Entry;
 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 
-import org.opendaylight.controller.md.sal.dom.store.impl.OperationWithModification;
 import org.opendaylight.controller.md.sal.dom.store.impl.tree.DataTreeModification;
-import org.opendaylight.controller.md.sal.dom.store.impl.tree.ModificationApplyOperation;
 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.yangtools.yang.data.api.InstanceIdentifier;
@@ -53,18 +51,18 @@ final class InMemoryDataTreeModification implements DataTreeModification {
         return rootNode;
     }
 
-	ModificationApplyOperation getStrategy() {
-		return strategyTree;
-	}
+    ModificationApplyOperation getStrategy() {
+        return strategyTree;
+    }
 
     @Override
-	public void write(final InstanceIdentifier path, final NormalizedNode<?, ?> value) {
+    public void write(final InstanceIdentifier path, final NormalizedNode<?, ?> value) {
         checkSealed();
         resolveModificationFor(path).write(value);
     }
 
     @Override
-	public void merge(final InstanceIdentifier path, final NormalizedNode<?, ?> data) {
+    public void merge(final InstanceIdentifier path, final NormalizedNode<?, ?> data) {
         checkSealed();
         mergeImpl(resolveModificationFor(path),data);
     }
@@ -83,37 +81,39 @@ final class InMemoryDataTreeModification implements DataTreeModification {
     }
 
     @Override
-	public void delete(final InstanceIdentifier path) {
+    public void delete(final InstanceIdentifier path) {
         checkSealed();
         resolveModificationFor(path).delete();
     }
 
     @Override
-	public Optional<NormalizedNode<?, ?>> readNode(final InstanceIdentifier path) {
-        Entry<InstanceIdentifier, NodeModification> modification = TreeNodeUtils.findClosestsOrFirstMatch(rootNode, path, NodeModification.IS_TERMINAL_PREDICATE);
-
-        Optional<StoreMetadataNode> result = resolveSnapshot(modification);
+    public Optional<NormalizedNode<?, ?>> readNode(final InstanceIdentifier path) {
+        /*
+         * Walk the tree from the top, looking for the first node between root and
+         * the requested path which has been modified. If no such node exists,
+         * we use the node itself.
+         */
+        final Entry<InstanceIdentifier, NodeModification> entry = TreeNodeUtils.findClosestsOrFirstMatch(rootNode, path, NodeModification.IS_TERMINAL_PREDICATE);
+        final InstanceIdentifier key = entry.getKey();
+        final NodeModification mod = entry.getValue();
+
+        final Optional<StoreMetadataNode> result = resolveSnapshot(key, mod);
         if (result.isPresent()) {
             NormalizedNode<?, ?> data = result.get().getData();
-            return NormalizedNodeUtils.findNode(modification.getKey(), data, path);
+            return NormalizedNodeUtils.findNode(key, data, path);
+        } else {
+            return Optional.absent();
         }
-        return Optional.absent();
-    }
-
-    private Optional<StoreMetadataNode> resolveSnapshot(
-            final Entry<InstanceIdentifier, NodeModification> keyModification) {
-        InstanceIdentifier path = keyModification.getKey();
-        NodeModification modification = keyModification.getValue();
-        return resolveSnapshot(path, modification);
     }
 
     private Optional<StoreMetadataNode> resolveSnapshot(final InstanceIdentifier path,
             final NodeModification modification) {
+        final Optional<Optional<StoreMetadataNode>> potentialSnapshot = modification.getSnapshotCache();
+        if(potentialSnapshot.isPresent()) {
+            return potentialSnapshot.get();
+        }
+
         try {
-            Optional<Optional<StoreMetadataNode>> potentialSnapshot = modification.getSnapshotCache();
-            if(potentialSnapshot.isPresent()) {
-                return potentialSnapshot.get();
-            }
             return resolveModificationStrategy(path).apply(modification, modification.getOriginal(),
                     StoreUtils.increase(snapshot.getRootNode().getSubtreeVersion()));
         } catch (Exception e) {
@@ -138,7 +138,7 @@ final class InMemoryDataTreeModification implements DataTreeModification {
     }
 
     @Override
-	public void seal() {
+    public void seal() {
         final boolean success = SEALED_UPDATER.compareAndSet(this, 0, 1);
         Preconditions.checkState(success, "Attempted to seal an already-sealed Data Tree.");
         rootNode.seal();
@@ -153,9 +153,9 @@ final class InMemoryDataTreeModification implements DataTreeModification {
         return "MutableDataTree [modification=" + rootNode + "]";
     }
 
-	@Override
-	public DataTreeModification newModification(ModificationApplyOperation applyOper) {
-    	// FIXME: transaction chaining
-    	throw new UnsupportedOperationException("Implement this as part of transaction chaining");
-	}
+    @Override
+    public DataTreeModification newModification() {
+        // FIXME: transaction chaining
+        throw new UnsupportedOperationException("Implement this as part of transaction chaining");
+    }
 }