# HG changeset patch
# User one
# Date 1416625715 -32400
# Node ID feb2346ace1970cd37db7efb4b9c28fab2b91c52
# Parent  af67dd0b5ba26651a1b6decdb8ee7b1b65163792
refactor ParentIndex

diff -r af67dd0b5ba2 -r feb2346ace19 src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java	Fri Nov 21 12:46:36 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java	Sat Nov 22 12:08:35 2014 +0900
@@ -23,7 +23,7 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Traverser;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.TreeMapOrd;
+import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
 public class DefaultJungle implements Jungle
 {
@@ -85,7 +85,7 @@
 		
 		DefaultTreeNode root = new DefaultTreeNode();
 		TreeMap<String, TreeMap<String, List<TreeNode>>> index = TreeMap.empty(Ord.stringOrd);
-		TreeMap<TreeNode,TreeNode> parentIndex = TreeMap.empty(TreeMapOrd.treeNodeOrd);
+		ParentIndex parentIndex = new ParentIndex();
 		ChangeSet set = new DefaultChangeSet(root,null,list,uuid,name,0,index,parentIndex);
 		DefaultTreeContext tc = new DefaultTreeContext(root,set);
 		JungleTree newTree = new DefaultJungleTree(tc,uuid,journal.getWriter(),editor,new IndexTreeEditor(traverser));
diff -r af67dd0b5ba2 -r feb2346ace19 src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java	Fri Nov 21 12:46:36 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java	Sat Nov 22 12:08:35 2014 +0900
@@ -20,6 +20,7 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.GetOldTreeError;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexManager;
+import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
 public class DefaultJungleTree implements JungleTree {
   private final AtomicReservableReference<TreeContext> repository;
@@ -42,7 +43,7 @@
     DefaultTransactionManager txManager = new DefaultTransactionManager(writer, tc, repository, uuid);
     TreeNode root = tc.getTreeNode();
     TreeMap<String, TreeMap<String, List<TreeNode>>>index = getIndex();
-    TreeMap<TreeNode, TreeNode> parentIndex = getParentIndex();
+    ParentIndex parentIndex = getParentIndex();
     return new DefaultJungleTreeEditor(root, txManager, treeEditor, index,parentIndex);
   }
 
@@ -52,12 +53,12 @@
     DefaultTransactionManager txManager = new DefaultTransactionManager(writer, tc, repository, uuid);
     TreeNode root = tc.getTreeNode();
     TreeMap<String, TreeMap<String, List<TreeNode>>> index = getIndex();
-    TreeMap<TreeNode, TreeNode> parentIndex = getParentIndex();
-    return new IndexJungleTreeEditor(root, txManager, indexTreeEditor, index, parentIndex);
+    ParentIndex parentIndex = getParentIndex();
+    return new IndexJungleTreeEditor(root,root, txManager, indexTreeEditor, index, parentIndex);
   }
 
   @Override
-  public TreeMap<TreeNode, TreeNode> getParentIndex() {
+  public ParentIndex getParentIndex() {
     TreeContext tc = repository.get();
     ChangeSet cs = tc.getChangeSet();
     return cs.getParentIndex();
diff -r af67dd0b5ba2 -r feb2346ace19 src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTree.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTree.java	Fri Nov 21 12:46:36 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTree.java	Sat Nov 22 12:08:35 2014 +0900
@@ -9,6 +9,7 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
 public interface JungleTree
 {
@@ -17,7 +18,7 @@
 	public JungleTreeEditor getLocalTreeEditor();
 	public TreeNode getRootNode();
 	public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex();
-	public TreeMap<TreeNode,TreeNode> getParentIndex();
+	public ParentIndex getParentIndex();
 	public IndexJungleTreeEditor getIndexTreeEditor();
 	public Iterable<TreeOperation> getLog();
   public long revision();
diff -r af67dd0b5ba2 -r feb2346ace19 src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/ChangeSet.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/ChangeSet.java	Fri Nov 21 12:46:36 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/ChangeSet.java	Sat Nov 22 12:08:35 2014 +0900
@@ -6,6 +6,7 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
+import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
 public interface ChangeSet
 {
@@ -19,5 +20,5 @@
 	
 	public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex();
 	public Iterable<TreeOperation> getOperations();
-  public TreeMap<TreeNode, TreeNode> getParentIndex();
+  public ParentIndex getParentIndex();
 }
diff -r af67dd0b5ba2 -r feb2346ace19 src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/IndexTreeEditor.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/IndexTreeEditor.java	Fri Nov 21 12:46:36 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/IndexTreeEditor.java	Sat Nov 22 12:08:35 2014 +0900
@@ -1,13 +1,9 @@
 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl;
 
 
-import java.util.Iterator;
 
-import javax.swing.plaf.basic.BasicInternalFrameTitlePane.SystemMenuBar;
 
-import fj.P2;
 import fj.data.List;
-import fj.data.Option;
 import fj.data.TreeMap;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
@@ -19,8 +15,6 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Triple;
-import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexEditor;
 
 public class IndexTreeEditor {
 
@@ -33,7 +27,7 @@
   }
   
   
-  public Either<Error,Triple<LoggingNode, TreeMap<TreeNode, TreeNode>,TreeMap<String,TreeMap<String,List<TreeNode>>>>> edit(TreeNode root,NodePath path,NodeEditor editor,TreeMap<TreeNode, TreeNode> parentIndex, IndexEditor indexEditor)
+  public Either<Error,LoggingNode> edit(TreeNode root,NodePath path,NodeEditor editor)
   {
     DefaultEvaluator e = new DefaultEvaluator(path);
     Either<Error, Traversal> either = traverser.traverse(root,e);
@@ -43,15 +37,14 @@
     }
     
     Traversal t = either.b();
-    Either<Error,Triple<LoggingNode, TreeMap<TreeNode, TreeNode>,TreeMap<String,TreeMap<String,List<TreeNode>>>>> ret = clone(t,editor,parentIndex, indexEditor);
+    Either<Error,LoggingNode> ret = clone(t,editor);
     
     return ret;
   }
   
-  private Either<Error,Triple<LoggingNode, TreeMap<TreeNode, TreeNode>,TreeMap<String,TreeMap<String,List<TreeNode>>>>> clone(Traversal t,NodeEditor editor , TreeMap<TreeNode, TreeNode> parentIndex, IndexEditor indexEditor)
+  private Either<Error,LoggingNode> clone(Traversal t,NodeEditor editor)
   {
     // copying nodes from bottom to root
-    TreeMap<TreeNode, TreeNode> newParentIndex = parentIndex;
     List<Direction<TreeNode>> path = List.nil();
     for (Direction<TreeNode> direction : t) {
       path = path.cons(direction);
@@ -60,14 +53,6 @@
     // target
     Direction<TreeNode> targetDirection = path.head();
     TreeNode target = targetDirection.getTarget();
-    Iterator<TreeNode> targetDeleteChildren = target.getChildren().iterator();
-    IndexEditor alreadyDeleteTargetIndexEditor = indexEditor.delete(target);
-    
-    for (;targetDeleteChildren.hasNext();) {
-      TreeNode targetDeleteChild = targetDeleteChildren.next();
-      newParentIndex = newParentIndex.delete(targetDeleteChild);
-    }
-    
     
     Either<Error, LoggingNode> either = editor.edit(target);
     if (either.isA()) {
@@ -80,26 +65,11 @@
     int pos = targetDirection.getPosition();
     TreeNode child = newWrap.getWrap();
     
-    IndexEditor alreadyEditTargetIndexEditor = alreadyDeleteTargetIndexEditor.edit(child);
-    IndexEditor alreadyAddTargetIndexEditor = alreadyEditTargetIndexEditor.add(child);
-    Iterator<TreeNode> targetPutChildren = child.getChildren().iterator();
-
-    for (; targetPutChildren.hasNext();) {
-      TreeNode targetPutChild = targetPutChildren.next();
-      newParentIndex = newParentIndex.set(targetPutChild, child);
-    }
-
     for (Direction<TreeNode> parentDirection : path.tail()) {
       TreeNode updateTargetNode = parentDirection.getTarget();
       TreeNodeChildren chs = updateTargetNode.getChildren();
       
-      alreadyDeleteTargetIndexEditor = alreadyAddTargetIndexEditor.delete(updateTargetNode);
           
-      Iterator<TreeNode> deleteParentIndexChildren = chs.iterator();
-      for (;deleteParentIndexChildren.hasNext();) {
-        TreeNode deleteParentIndexChild = deleteParentIndexChildren.next();
-        newParentIndex = newParentIndex.delete(deleteParentIndexChild);
-      }
       
       Either<Error, TreeNode> ret = chs.replaceNode(pos, child);
       if (ret.isA()) {
@@ -107,13 +77,6 @@
       }
       
       TreeNode newParent = ret.b();
-      alreadyAddTargetIndexEditor = alreadyDeleteTargetIndexEditor.add(newParent);
-       Iterator<TreeNode> putParentIndexChildren = newParent.getChildren().iterator();
-      
-      for (;putParentIndexChildren.hasNext();) {
-        TreeNode putParentIndexChild = putParentIndexChildren.next();
-        newParentIndex = newParentIndex.set(putParentIndexChild, newParent);
-      }
       
       child = newParent;
       pos = parentDirection.getPosition();
@@ -123,9 +86,7 @@
     LoggingNode logNode = editor.wrap(newRoot, newWrap.getOperationLog());
     
         
-    TreeMap<String,TreeMap<String,List<TreeNode>>> indexList = alreadyAddTargetIndexEditor.getIndex();
-    Triple<LoggingNode, TreeMap<TreeNode, TreeNode>,TreeMap<String,TreeMap<String,List<TreeNode>>>> triple = new Triple<LoggingNode, TreeMap<TreeNode, TreeNode>,TreeMap<String,TreeMap<String,List<TreeNode>>>>(logNode,newParentIndex,indexList);
-    return DefaultEither.newB(triple);
+    return DefaultEither.newB(logNode);
   }
    
 }
diff -r af67dd0b5ba2 -r feb2346ace19 src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultChangeSet.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultChangeSet.java	Fri Nov 21 12:46:36 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultChangeSet.java	Sat Nov 22 12:08:35 2014 +0900
@@ -6,6 +6,7 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
+import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
 public class DefaultChangeSet implements ChangeSet
 {
@@ -16,9 +17,9 @@
 	private final String treeName;
 	private final long revision; 
 	private final TreeMap<String, TreeMap<String, List<TreeNode>>> index;
-	private final TreeMap<TreeNode,TreeNode> parentIndex;
+	private final ParentIndex parentIndex;
 	
-	public DefaultChangeSet(TreeNode _node,ChangeSet _prev,ChangeList _log,String _uuid, String _treeName, long _revision, TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode,TreeNode> parentIndex)
+	public DefaultChangeSet(TreeNode _node,ChangeSet _prev,ChangeList _log,String _uuid, String _treeName, long _revision, TreeMap<String, TreeMap<String, List<TreeNode>>> index,ParentIndex parentIndex)
 	{
 		this.root = _node;
 		this.previous = _prev;
@@ -80,7 +81,7 @@
 
 
   @Override
-  public TreeMap<TreeNode, TreeNode> getParentIndex() {
+  public ParentIndex getParentIndex() {
     return parentIndex;
   }
 
diff -r af67dd0b5ba2 -r feb2346ace19 src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultJungleTreeEditor.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultJungleTreeEditor.java	Fri Nov 21 12:46:36 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultJungleTreeEditor.java	Sat Nov 22 12:08:35 2014 +0900
@@ -24,6 +24,7 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.IterableConverter;
+import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
 public class DefaultJungleTreeEditor implements JungleTreeEditor
 {
@@ -32,21 +33,21 @@
 	private final TreeEditor editor;
 	private final TreeOperationLog log;
 	private final TreeMap<String, TreeMap<String, List<TreeNode>>> index;
-	private final TreeMap<TreeNode,TreeNode> parentIndex;
+	private final ParentIndex parentIndex;
 	
 //	public DefaultJungleTreeEditor(TreeNode root)
 //	{
 //	    this(root,txManager,_editor,new DefaultTreeOperationLog());
 //	}
 
-	public DefaultJungleTreeEditor(TreeNode _root,TransactionManager _txManager,TreeEditor _editor,	TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode,TreeNode> parentIndex)
+	public DefaultJungleTreeEditor(TreeNode _root,TransactionManager _txManager,TreeEditor _editor,	TreeMap<String, TreeMap<String, List<TreeNode>>> index,ParentIndex parentIndex)
 	{
 		this(_root,_txManager,_editor,new DefaultTreeOperationLog(),index,parentIndex);
 	}
 	
 	
 	
-	public DefaultJungleTreeEditor(TreeNode newNode,TransactionManager _txManager,TreeEditor _editor,TreeOperationLog _log,	TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode,TreeNode> parentIndex)
+	public DefaultJungleTreeEditor(TreeNode newNode,TransactionManager _txManager,TreeEditor _editor,TreeOperationLog _log,	TreeMap<String, TreeMap<String, List<TreeNode>>> index,ParentIndex parentIndex)
 	{
 		this.root = newNode;
 		this.txManager = _txManager;
diff -r af67dd0b5ba2 -r feb2346ace19 src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java	Fri Nov 21 12:46:36 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java	Sat Nov 22 12:08:35 2014 +0900
@@ -16,6 +16,7 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultError;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
 public class DefaultTransactionManager implements TransactionManager
 {
@@ -34,7 +35,7 @@
 	}
 	
 	@Override
-	public Either<Error,TransactionManager> commit(TreeNode _newRoot,final TreeOperationLog _log, TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode,TreeNode> parentIndex)
+	public Either<Error,TransactionManager> commit(TreeNode _newRoot,final TreeOperationLog _log, TreeMap<String, TreeMap<String, List<TreeNode>>> index,ParentIndex parentIndex)
 	{
 		ChangeSet cs = tip.getChangeSet();
 		long currentRevision = cs.revision();
diff -r af67dd0b5ba2 -r feb2346ace19 src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/IndexJungleTreeEditor.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/IndexJungleTreeEditor.java	Fri Nov 21 12:46:36 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/IndexJungleTreeEditor.java	Sat Nov 22 12:08:35 2014 +0900
@@ -1,13 +1,16 @@
 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction;
 
 import java.nio.ByteBuffer;
+import java.util.Iterator;
 
+import fj.P2;
 import fj.data.List;
 import fj.data.TreeMap;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.IndexTreeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNodeChildren;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultTreeOperationLog;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog;
@@ -24,50 +27,59 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.IterableConverter;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Triple;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.TreeMapOrd;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.DefaultIndexEditor;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.DeleteChildIndexEditor;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexEditor;
+import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
 public class IndexJungleTreeEditor implements JungleTreeEditor {
   private final TransactionManager txManager;
   private final TreeNode root;
+  private final TreeNode oldRoot;
   private final IndexTreeEditor editor;
   private final TreeOperationLog log;
+  private final TreeOperationLog tmpLog;
   private TreeMap<String, TreeMap<String, List<TreeNode>>> index;
-  private TreeMap<TreeNode, TreeNode> parentIndex;
+  private ParentIndex parentIndex;
 
   public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
     return index;
   }
 
-
-
-  public IndexJungleTreeEditor(TreeNode _root, TransactionManager _txManager, IndexTreeEditor treeEditor,
-      TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode, TreeNode> parentIndex) {
-    this(_root, _txManager, treeEditor, new DefaultTreeOperationLog(), index,parentIndex);
+  public IndexJungleTreeEditor(TreeNode _root, TreeNode oldRoot, TransactionManager _txManager,
+      IndexTreeEditor treeEditor, TreeMap<String, TreeMap<String, List<TreeNode>>> index,
+      ParentIndex parentIndex) {
+    this(_root, oldRoot, _txManager, treeEditor, new DefaultTreeOperationLog(), new DefaultTreeOperationLog(), index, parentIndex);
   }
 
-  public IndexJungleTreeEditor(TreeNode newNode, TransactionManager _txManager, IndexTreeEditor _editor,
-      TreeOperationLog _log, TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode, TreeNode> parentIndex) {
+  public IndexJungleTreeEditor(TreeNode _root, TreeNode oldRoot, TransactionManager _txManager,
+      IndexTreeEditor treeEditor, TreeOperationLog log, TreeMap<String, TreeMap<String, List<TreeNode>>> index,
+      ParentIndex parentIndex) {
+    this(_root, oldRoot, _txManager, treeEditor, log, new DefaultTreeOperationLog(), index, parentIndex);
+  }
+
+  public IndexJungleTreeEditor(TreeNode newNode, TreeNode oldRoot, TransactionManager _txManager,
+      IndexTreeEditor _editor, TreeOperationLog _log, TreeOperationLog tmpLog,
+      TreeMap<String, TreeMap<String, List<TreeNode>>> index, ParentIndex parentIndex) {
     this.root = newNode;
+    this.oldRoot = oldRoot;
     this.txManager = _txManager;
     this.editor = _editor;
     this.log = _log;
     this.index = index;
     this.parentIndex = parentIndex;
+    this.tmpLog = tmpLog;
   }
 
-  
   public Either<Error, IndexJungleTreeEditor> _edit(final NodePath _path, NodeEditor _e, IndexEditor indexEditor) {
-    Either<Error,Triple<LoggingNode, TreeMap<TreeNode, TreeNode>,TreeMap<String,TreeMap<String,List<TreeNode>>>>> either = editor.edit(root, _path, _e, parentIndex, indexEditor);
+    Either<Error, LoggingNode> either = editor.edit(root, _path, _e);
     if (either.isA()) {
       return DefaultEither.newA(either.a());
     }
 
-    LoggingNode newLogging = either.b().getA();
-    TreeMap<TreeNode,TreeNode> newParentIndex = either.b().getB();
-    TreeMap<String,TreeMap<String,List<TreeNode>>> newIndex = either.b().getC();
+    LoggingNode newLogging = either.b();
     OperationLog newLog = newLogging.getOperationLog();
     TreeNode newNode = newLogging.getWrap();
 
@@ -80,8 +92,9 @@
 
     Iterable<TreeOperation> iterable = new IterableConverter<TreeOperation, NodeOperation>(newLog, converter);
     DefaultTreeOperationLog treeOperationLog = new DefaultTreeOperationLog(iterable, newLog.length());
-    TreeOperationLog newTreeOpLog = log.append(treeOperationLog);
-    IndexJungleTreeEditor newIndexTreeEditor = new IndexJungleTreeEditor(newNode, txManager, this.editor,newTreeOpLog, newIndex, newParentIndex);
+    TreeOperationLog newTmpLog = tmpLog.append(treeOperationLog);
+    IndexJungleTreeEditor newIndexTreeEditor = new IndexJungleTreeEditor(newNode, oldRoot, txManager, this.editor, log,
+        newTmpLog, index, parentIndex);
     return DefaultEither.newB(newIndexTreeEditor);
   }
 
@@ -134,17 +147,100 @@
 
   @Override
   public Either<Error, JungleTreeEditor> success() {
-    Either<Error, TransactionManager> either = txManager.commit(root, log, index,parentIndex);
+    ParentIndex newParentIndex = editParentIndex(tmpLog);
+    TreeOperationLog newLog = log.append(tmpLog);
+    Either<Error, TransactionManager> either = txManager.commit(root, newLog, index, newParentIndex);
     if (either.isA()) {
       return DefaultEither.newA(either.a());
     }
 
-    TransactionManager newTxManager = either.b(); 
-    JungleTreeEditor newTreeEditor = new IndexJungleTreeEditor(root, newTxManager, editor, index,parentIndex);
+    TransactionManager newTxManager = either.b();
+    JungleTreeEditor newTreeEditor = new IndexJungleTreeEditor(root, root, newTxManager, editor, index, parentIndex);
 
     return DefaultEither.newB(newTreeEditor);
   }
 
+  private ParentIndex editParentIndex(TreeOperationLog tmpLog) {
+    TreeMap<TreeNode, TreeNode> putParentNodeMap = TreeMap.empty(TreeMapOrd.treeNodeOrd);
+    TreeMap<TreeNode, TreeNode> deleteParentNodeMap = TreeMap.empty(TreeMapOrd.treeNodeOrd);
+    for (TreeOperation log : tmpLog) {
+
+      NodePath targetNodePath = log.getNodePath();
+      putParentNodeMap = getTargetNode(TreeMap.empty(TreeMapOrd.treeNodeOrd), root, targetNodePath);
+      deleteParentNodeMap = getTargetNode(TreeMap.empty(TreeMapOrd.treeNodeOrd), oldRoot, targetNodePath);
+      System.out.println(log.getNodePath().toString());
+    }
+
+    ParentIndex newParentIndex = parentIndex;
+    if (!deleteParentNodeMap.isEmpty())
+      newParentIndex = deleteParentIndex(putParentNodeMap, newParentIndex);
+
+    
+    if (!putParentNodeMap.isEmpty())
+      newParentIndex = putParentIndex(putParentNodeMap,newParentIndex);
+
+    return newParentIndex;
+  }
+
+  private ParentIndex deleteParentIndex(TreeMap<TreeNode, TreeNode> deleteParentNodeMap, ParentIndex editParentIndex) {
+    Iterator<P2<TreeNode, TreeNode>> parentNodeIterator = deleteParentNodeMap.iterator();
+    ParentIndex newParentIndex = editParentIndex;
+
+    for (; parentNodeIterator.hasNext();) {
+      TreeNode parentNode = parentNodeIterator.next()._1();
+      TreeNodeChildren children = parentNode.getChildren();
+      Iterator<TreeNode> childrenIterator = children.iterator();
+
+      for (; childrenIterator.hasNext();) {
+        TreeNode child = childrenIterator.next();
+        newParentIndex = newParentIndex.delete(child);
+      }
+    }
+    return newParentIndex;
+  }
+
+  private ParentIndex putParentIndex(TreeMap<TreeNode, TreeNode> putParentNodeMap,ParentIndex editParentIndex) {
+    Iterator<P2<TreeNode, TreeNode>> parentNodeIterator = putParentNodeMap.iterator();
+    ParentIndex newParentIndex = editParentIndex;
+
+    for (; parentNodeIterator.hasNext();) {
+      TreeNode parentNode = parentNodeIterator.next()._1();
+      TreeNodeChildren children = parentNode.getChildren();
+      Iterator<TreeNode> childrenIterator = children.iterator();
+
+      for (; childrenIterator.hasNext();) {
+        TreeNode child = childrenIterator.next();
+        newParentIndex = newParentIndex.set(child, parentNode);
+      }
+    }
+    return newParentIndex;
+  }
+
+  private TreeMap<TreeNode, TreeNode> getTargetNode(TreeMap<TreeNode, TreeNode> treeNodeMap, TreeNode node,
+      NodePath path) {
+    if (path.size() == 0)
+      return treeNodeMap;
+
+    Pair<Integer, NodePath> pathNode = path.pop();
+
+    if (pathNode.left() == -1) {
+      TreeMap<TreeNode, TreeNode> newTreeNodeMap = treeNodeMap.set(node, node);
+      return getTargetNode(newTreeNodeMap, node, pathNode.right());
+    }
+
+    Either<Error, TreeNode> either = node.getChildren().at(pathNode.left());
+    if (either.isA())
+      return treeNodeMap;
+
+    TreeNode child = either.b();
+    TreeMap<TreeNode, TreeNode> newTreeNodeMap = treeNodeMap.set(child, child);
+    if (pathNode.right().size() == 0)
+      return newTreeNodeMap;
+
+    return getTargetNode(newTreeNodeMap, child, pathNode.right());
+
+  }
+
   @Override
   public String getID() {
     return txManager.getUUID();
diff -r af67dd0b5ba2 -r feb2346ace19 src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/TransactionManager.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/TransactionManager.java	Fri Nov 21 12:46:36 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/TransactionManager.java	Sat Nov 22 12:08:35 2014 +0900
@@ -6,10 +6,11 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
 public interface TransactionManager
 {
-	public Either<Error,TransactionManager> commit(TreeNode _newRoot,TreeOperationLog _log,	TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode,TreeNode> parentIndex);
+	public Either<Error,TransactionManager> commit(TreeNode _newRoot,TreeOperationLog _log,	TreeMap<String, TreeMap<String, List<TreeNode>>> index,ParentIndex parentIndex);
 	public String getUUID();
 	public long getRevision();
 }
diff -r af67dd0b5ba2 -r feb2346ace19 src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DefaultIndexEditor.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DefaultIndexEditor.java	Fri Nov 21 12:46:36 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DefaultIndexEditor.java	Sat Nov 22 12:08:35 2014 +0900
@@ -34,10 +34,7 @@
               newNodeList = newNodeList.cons(indexingNode);
           }
           TreeMap<String, List<TreeNode>> newIndex;
-//          if (newNodeList.isEmpty())
-//            newIndex = index.delete(value);
-//          else
-            newIndex = index.set(value, newNodeList);
+          newIndex = index.set(value, newNodeList);
           newIndexTreeMap = newIndexTreeMap.set(key, newIndex);
         }
 
diff -r af67dd0b5ba2 -r feb2346ace19 src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexManager.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexManager.java	Fri Nov 21 12:46:36 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexManager.java	Sat Nov 22 12:08:35 2014 +0900
@@ -28,7 +28,7 @@
 		String uuid = cs.uuid();
 		String treeName = cs.getTreeName();
 		long revision = cs.revision();
-		TreeMap<TreeNode, TreeNode> parentIndex = cs.getParentIndex();
+		ParentIndex parentIndex = cs.getParentIndex();
  		DefaultChangeSet newCs = new DefaultChangeSet(root, prev, cl, uuid, treeName, revision, index, parentIndex);
 		DefaultTreeContext newTs = new DefaultTreeContext(root, newCs);
 		reservation.set(newTs);
diff -r af67dd0b5ba2 -r feb2346ace19 src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/ParentIndexTest.java
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/ParentIndexTest.java	Fri Nov 21 12:46:36 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/ParentIndexTest.java	Sat Nov 22 12:08:35 2014 +0900
@@ -10,11 +10,11 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
+import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 import junit.framework.Assert;
 
 import org.junit.Test;
 
-import fj.data.List;
 import fj.data.Option;
 import fj.data.TreeMap;
 
@@ -28,14 +28,14 @@
     JungleTreeEditor editor = tree.getIndexTreeEditor();
     DefaultNodePath path = new DefaultNodePath();
     editor = editor.addNewChildAt(path, 0).b();
-    
-    
+
     for (int num = 0; num < 5; num++) {
-      editor = editor.addNewChildAt(path.add(0), num).b().success().b();
-      editor = editor.putAttribute(path.add(0).add(num), "test",ByteBuffer.wrap("test".getBytes())).b().success().b();
+      editor = editor.addNewChildAt(path.add(0), num).b();
+      editor = editor.putAttribute(path.add(0).add(num), "test", ByteBuffer.wrap("test".getBytes())).b();
+      editor = editor.success().b();
     }
-    
-    TreeMap<TreeNode, TreeNode> parentIndex = tree.getParentIndex();
+
+    ParentIndex parentIndex = tree.getParentIndex();
     TreeNode node = tree.getRootNode();
     for (int num = 0; node.getChildren().size() != 0; num++) {
       Iterator<TreeNode> children = node.getChildren().iterator();
@@ -52,9 +52,9 @@
     TreeNode oldNode = oldRoot.getChildren().at(0).b();
     Option<TreeNode> oldParentOp = parentIndex.get(oldNode);
     Assert.assertTrue(oldParentOp.isNone());
-    TreeMap<TreeNode, TreeNode> oldTreeParentIndex = oldTree.getParentIndex();
+    ParentIndex oldTreeParentIndex = oldTree.getParentIndex();
     oldParentOp = oldTreeParentIndex.get(oldNode);
     Assert.assertTrue(oldParentOp.isSome());
-        
+
   }
 }