# HG changeset patch
# User one
# Date 1416541768 -32400
# Node ID a2c374a2686b82b0ad30f520412e191b84288fa9
# Parent  af67dd0b5ba26651a1b6decdb8ee7b1b65163792# Parent  0854f9a9e81db5db639f02a126ebabf1d004b98e
Merge with 0854f9a9e81db5db639f02a126ebabf1d004b98e

diff -r 0854f9a9e81d -r a2c374a2686b 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	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java	Fri Nov 21 12:49:28 2014 +0900
@@ -10,17 +10,20 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.Journal;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.NullJournal;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
+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.operations.TreeOperation;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultChangeSet;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeContext;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
+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;
 
 public class DefaultJungle implements Jungle
 {
@@ -28,10 +31,10 @@
 	private ConcurrentHashMap<String,JungleTree> trees;
 	private String uuid;
 	private TreeEditor editor;
-	
+	private Traverser traverser;
 	public static void main(String args[])
 	{
-		DefaultJungle j = new DefaultJungle(null,"hoge",new DefaultTreeEditor(new DefaultTraverser()));
+		DefaultJungle j = new DefaultJungle(null,"hoge",new DefaultTraverser());
 		JungleTree t = j.createNewTree("fuga");
 		
 		JungleTreeEditor e1 = t.getTreeEditor();
@@ -45,12 +48,13 @@
 		e1.success();
 	}
 	
-	public DefaultJungle(Journal journal,String uuid,TreeEditor editor)
+	public DefaultJungle(Journal journal,String uuid,Traverser traverser)
 	{
 		this.journal = new NullJournal();
 		this.trees = new ConcurrentHashMap<String,JungleTree>();
 		this.uuid = uuid;
-		this.editor = editor;
+		this.traverser = traverser;
+		this.editor = new DefaultTreeEditor(traverser);
 	}
 
 	@Override
@@ -80,10 +84,11 @@
 		};
 		
 		DefaultTreeNode root = new DefaultTreeNode();
-		TreeMap<String, TreeMap<String, List<NodePath>>> index = TreeMap.empty(Ord.stringOrd);
-		ChangeSet set = new DefaultChangeSet(root,null,list,uuid,name,0,index);
+		TreeMap<String, TreeMap<String, List<TreeNode>>> index = TreeMap.empty(Ord.stringOrd);
+		TreeMap<TreeNode,TreeNode> parentIndex = TreeMap.empty(TreeMapOrd.treeNodeOrd);
+		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);
+		JungleTree newTree = new DefaultJungleTree(tc,uuid,journal.getWriter(),editor,new IndexTreeEditor(traverser));
 		if(trees.putIfAbsent(name,newTree) != null){
 			return null;
 		}
diff -r 0854f9a9e81d -r a2c374a2686b 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	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java	Fri Nov 21 12:49:28 2014 +0900
@@ -1,12 +1,11 @@
 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle;
 
 import fj.data.List;
-import fj.data.Option;
 import fj.data.TreeMap;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor;
+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.operations.TreeOperation;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference;
@@ -20,20 +19,21 @@
 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.GetOldTreeError;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexManager;
 
 public class DefaultJungleTree implements JungleTree {
   private final AtomicReservableReference<TreeContext> repository;
   private final String uuid;
   private final ChangeListWriter writer;
-  private final TreeEditor editor;
-
-  public DefaultJungleTree(TreeContext tc, String uuid, ChangeListWriter writer, TreeEditor editor) {
+  private final TreeEditor treeEditor;
+  private final IndexTreeEditor indexTreeEditor;
+  
+  public DefaultJungleTree(TreeContext tc, String uuid, ChangeListWriter writer, TreeEditor editor, IndexTreeEditor indexTreeEditor) {
     this.repository = new AtomicReservableReference<TreeContext>(tc);
     this.uuid = uuid;
     this.writer = writer;
-    this.editor = editor;
+    this.treeEditor = editor;
+    this.indexTreeEditor = indexTreeEditor;
   }
 
   @Override
@@ -41,8 +41,9 @@
     TreeContext tc = repository.get();
     DefaultTransactionManager txManager = new DefaultTransactionManager(writer, tc, repository, uuid);
     TreeNode root = tc.getTreeNode();
-    TreeMap<String, TreeMap<String, List<NodePath>>> index = getIndex();
-    return new DefaultJungleTreeEditor(root, txManager, editor, index);
+    TreeMap<String, TreeMap<String, List<TreeNode>>>index = getIndex();
+    TreeMap<TreeNode, TreeNode> parentIndex = getParentIndex();
+    return new DefaultJungleTreeEditor(root, txManager, treeEditor, index,parentIndex);
   }
 
   @Override
@@ -50,8 +51,16 @@
     TreeContext tc = repository.get();
     DefaultTransactionManager txManager = new DefaultTransactionManager(writer, tc, repository, uuid);
     TreeNode root = tc.getTreeNode();
-    TreeMap<String, TreeMap<String, List<NodePath>>> newIndex = getIndex();
-    return new IndexJungleTreeEditor(root, txManager, editor, newIndex);
+    TreeMap<String, TreeMap<String, List<TreeNode>>> index = getIndex();
+    TreeMap<TreeNode, TreeNode> parentIndex = getParentIndex();
+    return new IndexJungleTreeEditor(root, txManager, indexTreeEditor, index, parentIndex);
+  }
+
+  @Override
+  public TreeMap<TreeNode, TreeNode> getParentIndex() {
+    TreeContext tc = repository.get();
+    ChangeSet cs = tc.getChangeSet();
+    return cs.getParentIndex();
   }
 
   @Override
@@ -70,14 +79,14 @@
   public InterfaceTraverser getTraverser() {
     AtomicReservableReference<TreeContext>.Reservation reservation = repository.getReservation();
     IndexManager indexManager = new IndexManager(reservation);
-    TreeMap<String, TreeMap<String, List<NodePath>>> index = getIndex();
+    TreeMap<String, TreeMap<String, List<TreeNode>>> index = getIndex();
     if (index != null)
       return new InterfaceTraverser(getRootNode(), index, indexManager);
     return new InterfaceTraverser(getRootNode(), indexManager);
   }
 
   @Override
-  public TreeMap<String, TreeMap<String, List<NodePath>>> getIndex() {
+  public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
     TreeContext tc = repository.get();
     ChangeSet cs = tc.getChangeSet();
     return cs.getIndex();
@@ -112,7 +121,7 @@
     
     TreeContext oldTc = new DefaultTreeContext(root, cs);
     String oldTreeUuid = uuid + revision;
-    JungleTree oldTree = new DefaultJungleTree(oldTc,oldTreeUuid,writer,editor);
+    JungleTree oldTree = new DefaultJungleTree(oldTc,oldTreeUuid,writer,treeEditor,indexTreeEditor);
     return DefaultEither.newB(oldTree);
   }
   
diff -r 0854f9a9e81d -r a2c374a2686b 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	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTree.java	Fri Nov 21 12:49:28 2014 +0900
@@ -3,7 +3,6 @@
 
 import fj.data.List;
 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.TreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.IndexJungleTreeEditor;
@@ -17,7 +16,8 @@
 	public InterfaceTraverser getTraverser();
 	public JungleTreeEditor getLocalTreeEditor();
 	public TreeNode getRootNode();
-	public TreeMap<String, TreeMap<String, List<NodePath>>> getIndex();
+	public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex();
+	public TreeMap<TreeNode,TreeNode> getParentIndex();
 	public IndexJungleTreeEditor getIndexTreeEditor();
 	public Iterable<TreeOperation> getLog();
   public long revision();
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTreeEditor.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTreeEditor.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTreeEditor.java	Fri Nov 21 12:49:28 2014 +0900
@@ -4,7 +4,6 @@
 
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/App.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/App.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/App.java	Fri Nov 21 12:49:28 2014 +0900
@@ -7,7 +7,6 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
 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.shoshi.jungle.util.Either;
@@ -21,7 +20,7 @@
 {
     public static void main( String[] args )
     {
-    	DefaultJungle jungle = new DefaultJungle(null,"sample",new DefaultTreeEditor(new DefaultTraverser()));
+    	DefaultJungle jungle = new DefaultJungle(null,"sample", new DefaultTraverser());
     	jungle.createNewTree("hoge");
     	JungleTree tree = jungle.getTreeByName("hoge");
     	JungleTreeEditor editor = tree.getTreeEditor();
diff -r 0854f9a9e81d -r a2c374a2686b 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	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/ChangeSet.java	Fri Nov 21 12:49:28 2014 +0900
@@ -6,10 +6,6 @@
 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.shoshi.jungle.transaction.TreeContext;
-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.Pair;
 
 public interface ChangeSet
 {
@@ -21,6 +17,7 @@
 	public String getTreeName();
 	public long revision();
 	
-	public TreeMap<String, TreeMap<String, List<NodePath>>> getIndex();
+	public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex();
 	public Iterable<TreeOperation> getOperations();
+  public TreeMap<TreeNode, TreeNode> getParentIndex();
 }
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/DefaultTreeEditor.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/DefaultTreeEditor.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/DefaultTreeEditor.java	Fri Nov 21 12:49:28 2014 +0900
@@ -16,7 +16,6 @@
 public class DefaultTreeEditor implements TreeEditor
 {
 	private final Traverser traverser;
-	
 	public DefaultTreeEditor(Traverser traverser)
 	{
 		this.traverser = traverser;
@@ -50,7 +49,6 @@
 		// target
 		Direction<TreeNode> targetDirection = path.head();
 		TreeNode target = targetDirection.getTarget();
-		//EditableNodeWrapper<T> wrapper = new EditableNodeWrapper<T>(target);
 		Either<Error,LoggingNode> either = editor.edit(target);
 		if(either.isA()){
 			return DefaultEither.newA(either.a());
@@ -61,9 +59,12 @@
 		// top
 		int pos = targetDirection.getPosition();
 		TreeNode child = newWrap.getWrap();
+	
+		
 		for(Direction<TreeNode> parentDirection : path.tail()){
+		  
 			TreeNodeChildren chs =  parentDirection.getTarget().getChildren();
-					
+			
 			Either<Error,TreeNode> ret = chs.replaceNode(pos,child);
 			if(ret.isA()){
 				return DefaultEither.newA(ret.a());
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/IndexTreeEditor.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/IndexTreeEditor.java	Fri Nov 21 12:49:28 2014 +0900
@@ -0,0 +1,131 @@
+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;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultEvaluator;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Direction;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Traversal;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Traverser;
+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 {
+
+  private final Traverser traverser;
+
+  
+  public IndexTreeEditor(Traverser traverser)
+  {
+    this.traverser = traverser;
+  }
+  
+  
+  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)
+  {
+    DefaultEvaluator e = new DefaultEvaluator(path);
+    Either<Error, Traversal> either = traverser.traverse(root,e);
+    
+    if(either.isA()){
+      return DefaultEither.newA(either.a());
+    }
+    
+    Traversal t = either.b();
+    Either<Error,Triple<LoggingNode, TreeMap<TreeNode, TreeNode>,TreeMap<String,TreeMap<String,List<TreeNode>>>>> ret = clone(t,editor,parentIndex, indexEditor);
+    
+    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)
+  {
+    // 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);
+    }
+
+    // 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()) {
+      return DefaultEither.newA(either.a());
+    }
+
+    LoggingNode newWrap = either.b();
+
+    // top
+    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()) {
+        return DefaultEither.newA(ret.a());
+      }
+      
+      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();
+    }
+
+    TreeNode newRoot = child;
+    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);
+  }
+   
+}
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/TreeNode.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/TreeNode.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/TreeNode.java	Fri Nov 21 12:49:28 2014 +0900
@@ -2,7 +2,7 @@
 
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.AttributesContainer;
 
-public interface TreeNode extends AttributesContainer
+public interface TreeNode extends AttributesContainer 
 {
 	public TreeNodeChildren getChildren();
 	
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/logger/LoggingChildren.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/logger/LoggingChildren.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/logger/LoggingChildren.java	Fri Nov 21 12:49:28 2014 +0900
@@ -1,6 +1,5 @@
 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger;
 
-import java.util.Iterator;
 
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Children;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/logger/LoggingNode.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/logger/LoggingNode.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/logger/LoggingNode.java	Fri Nov 21 12:49:28 2014 +0900
@@ -1,10 +1,6 @@
 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger;
 
-import fj.data.List;
-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.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
 
 
 public class LoggingNode
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/AppendChildAtOperation.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/AppendChildAtOperation.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/AppendChildAtOperation.java	Fri Nov 21 12:49:28 2014 +0900
@@ -4,7 +4,6 @@
 
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
 
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/DeleteAttributeOperation.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/DeleteAttributeOperation.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/DeleteAttributeOperation.java	Fri Nov 21 12:49:28 2014 +0900
@@ -4,8 +4,6 @@
 
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.DeleteAttribute;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
 
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/DeleteChildAtOperation.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/DeleteChildAtOperation.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/DeleteChildAtOperation.java	Fri Nov 21 12:49:28 2014 +0900
@@ -4,8 +4,6 @@
 
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.DeleteChildAt;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
 
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/NodeOperation.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/NodeOperation.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/NodeOperation.java	Fri Nov 21 12:49:28 2014 +0900
@@ -4,7 +4,6 @@
 
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
 
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/PutAttributeOperation.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/PutAttributeOperation.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/PutAttributeOperation.java	Fri Nov 21 12:49:28 2014 +0900
@@ -4,8 +4,6 @@
 
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.PutAttribute;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
 
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/AppendChildAt.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/AppendChildAt.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/AppendChildAt.java	Fri Nov 21 12:49:28 2014 +0900
@@ -1,18 +1,11 @@
 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer;
 
-import fj.data.List;
-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.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultOperationLog;
 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;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.AppendChildAtOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
 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.Pair;
 
 public class AppendChildAt implements NodeEditor
 {
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/DeleteAttribute.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/DeleteAttribute.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/DeleteAttribute.java	Fri Nov 21 12:49:28 2014 +0900
@@ -1,15 +1,12 @@
 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer;
 
-import fj.data.List;
-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.TreeNode;
 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;
 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.Pair;
 
 public class DeleteAttribute implements NodeEditor
 {
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/DeleteChildAt.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/DeleteChildAt.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/DeleteChildAt.java	Fri Nov 21 12:49:28 2014 +0900
@@ -1,18 +1,12 @@
 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer;
 
-import fj.data.List;
-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.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultOperationLog;
 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;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteChildAtOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
 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.Pair;
 
 public class DeleteChildAt implements NodeEditor
 {
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/NodeEditor.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/NodeEditor.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/NodeEditor.java	Fri Nov 21 12:49:28 2014 +0900
@@ -1,15 +1,11 @@
 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer;
 
-import fj.data.List;
-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.TreeNode;
 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;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
 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.Pair;
 
 public interface NodeEditor
 {
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/PutAttribute.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/PutAttribute.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/PutAttribute.java	Fri Nov 21 12:49:28 2014 +0900
@@ -2,21 +2,12 @@
 
 import java.nio.ByteBuffer;
 
-import fj.data.List;
-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.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNodeAttributes;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultOperationLog;
 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;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteChildAtOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation;
 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.Pair;
 
 public class PutAttribute implements NodeEditor
 {
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/AtomicReservableReference.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/AtomicReservableReference.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/AtomicReservableReference.java	Fri Nov 21 12:49:28 2014 +0900
@@ -3,7 +3,6 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
-import sun.security.action.GetBooleanAction;
 
 public class AtomicReservableReference<V>
 {
diff -r 0854f9a9e81d -r a2c374a2686b 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	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultChangeSet.java	Fri Nov 21 12:49:28 2014 +0900
@@ -4,10 +4,8 @@
 import fj.data.TreeMap;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 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.shoshi.jungle.util.Pair;
 
 public class DefaultChangeSet implements ChangeSet
 {
@@ -17,9 +15,10 @@
 	private final String uuid;
 	private final String treeName;
 	private final long revision; 
-	private final TreeMap<String, TreeMap<String, List<NodePath>>> index;
+	private final TreeMap<String, TreeMap<String, List<TreeNode>>> index;
+	private final TreeMap<TreeNode,TreeNode> parentIndex;
 	
-	public DefaultChangeSet(TreeNode _node,ChangeSet _prev,ChangeList _log,String _uuid, String _treeName, long _revision, TreeMap<String, TreeMap<String, List<NodePath>>> index)
+	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)
 	{
 		this.root = _node;
 		this.previous = _prev;
@@ -28,6 +27,7 @@
 		this.treeName = _treeName;
 		this.revision = _revision;
 		this.index = index;
+		this.parentIndex = parentIndex;
 	}
 	
 
@@ -74,8 +74,14 @@
 	}
 
 	@Override
-	public TreeMap<String, TreeMap<String, List<NodePath>>> getIndex() {
+	public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
 		return index;
 	}
 
+
+  @Override
+  public TreeMap<TreeNode, TreeNode> getParentIndex() {
+    return parentIndex;
+  }
+
 }
diff -r 0854f9a9e81d -r a2c374a2686b 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	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultJungleTreeEditor.java	Fri Nov 21 12:49:28 2014 +0900
@@ -24,7 +24,6 @@
 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.Pair;
 
 public class DefaultJungleTreeEditor implements JungleTreeEditor
 {
@@ -32,26 +31,29 @@
 	private final TreeNode root;
 	private final TreeEditor editor;
 	private final TreeOperationLog log;
-	private final TreeMap<String, TreeMap<String, List<NodePath>>> index;
+	private final TreeMap<String, TreeMap<String, List<TreeNode>>> index;
+	private final TreeMap<TreeNode,TreeNode> parentIndex;
+	
 //	public DefaultJungleTreeEditor(TreeNode root)
 //	{
 //	    this(root,txManager,_editor,new DefaultTreeOperationLog());
 //	}
 
-	public DefaultJungleTreeEditor(TreeNode _root,TransactionManager _txManager,TreeEditor _editor,	TreeMap<String, TreeMap<String, List<NodePath>>> index)
+	public DefaultJungleTreeEditor(TreeNode _root,TransactionManager _txManager,TreeEditor _editor,	TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode,TreeNode> parentIndex)
 	{
-		this(_root,_txManager,_editor,new DefaultTreeOperationLog(),index);
+		this(_root,_txManager,_editor,new DefaultTreeOperationLog(),index,parentIndex);
 	}
 	
 	
 	
-	public DefaultJungleTreeEditor(TreeNode newNode,TransactionManager _txManager,TreeEditor _editor,TreeOperationLog _log,	TreeMap<String, TreeMap<String, List<NodePath>>> index)
+	public DefaultJungleTreeEditor(TreeNode newNode,TransactionManager _txManager,TreeEditor _editor,TreeOperationLog _log,	TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode,TreeNode> parentIndex)
 	{
 		this.root = newNode;
 		this.txManager = _txManager;
 		this.editor = _editor;
 		this.log = _log;
 		this.index = index;
+		this.parentIndex = parentIndex;
 	}
 	
 	private Either<Error,JungleTreeEditor> _edit(final NodePath _path,NodeEditor _e)
@@ -76,7 +78,7 @@
 		DefaultTreeOperationLog treeOperationLog = new DefaultTreeOperationLog(iterable,newLog.length());
 		TreeOperationLog newTreeOpLog = log.append(treeOperationLog);
 		
-		JungleTreeEditor newEditor = new DefaultJungleTreeEditor(newNode,txManager,editor,newTreeOpLog,index);
+		JungleTreeEditor newEditor = new DefaultJungleTreeEditor(newNode,txManager,editor,newTreeOpLog,index,parentIndex);
 		return DefaultEither.newB(newEditor);
 	}
 	
@@ -117,13 +119,13 @@
 	@Override
 	public Either<Error,JungleTreeEditor> success()
 	{
-		Either<Error,TransactionManager> either = txManager.commit(root,log,index);
+		Either<Error,TransactionManager> either = txManager.commit(root,log,index,parentIndex);
 		if(either.isA()){
 			return DefaultEither.newA(either.a());
 		}
 		
 		TransactionManager newTxManager = either.b();
-		JungleTreeEditor newTreeEditor = new DefaultJungleTreeEditor(root,newTxManager,editor,index);
+		JungleTreeEditor newTreeEditor = new DefaultJungleTreeEditor(root,newTxManager,editor,index,parentIndex);
 		
 		return DefaultEither.newB(newTreeEditor);
 	}
diff -r 0854f9a9e81d -r a2c374a2686b 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	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java	Fri Nov 21 12:49:28 2014 +0900
@@ -8,7 +8,6 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.Result;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
@@ -35,7 +34,7 @@
 	}
 	
 	@Override
-	public Either<Error,TransactionManager> commit(TreeNode _newRoot,final TreeOperationLog _log, TreeMap<String, TreeMap<String, List<NodePath>>> index)
+	public Either<Error,TransactionManager> commit(TreeNode _newRoot,final TreeOperationLog _log, TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode,TreeNode> parentIndex)
 	{
 		ChangeSet cs = tip.getChangeSet();
 		long currentRevision = cs.revision();
@@ -58,7 +57,7 @@
 
 		};
 		
-		DefaultChangeSet newCs = new DefaultChangeSet(_newRoot,cs,list,uuid, _treeName, nextRevision,index);
+		DefaultChangeSet newCs = new DefaultChangeSet(_newRoot,cs,list,uuid, _treeName, nextRevision,index,parentIndex);
 		DefaultTreeContext newContext = new DefaultTreeContext(_newRoot,newCs);
 		
 		@SuppressWarnings("rawtypes")
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNode.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNode.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNode.java	Fri Nov 21 12:49:28 2014 +0900
@@ -50,5 +50,6 @@
 	{
 		return new DefaultTreeNode(children,attrs);
 	}
+
 	
 }
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeAttribute.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeAttribute.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeAttribute.java	Fri Nov 21 12:49:28 2014 +0900
@@ -11,8 +11,6 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNodeAttributes;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultOperationLog;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteAttributeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditorError;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeChildren.java
diff -r 0854f9a9e81d -r a2c374a2686b 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	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/IndexJungleTreeEditor.java	Fri Nov 21 12:49:28 2014 +0900
@@ -6,7 +6,7 @@
 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.TreeEditor;
+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.logger.DefaultTreeOperationLog;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
@@ -24,157 +24,140 @@
 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.AddNewChildrenIndexEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Triple;
 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.DeleteIndexEditor;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexEditor;
-import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.PutIndexEditor;
+
+public class IndexJungleTreeEditor implements JungleTreeEditor {
+  private final TransactionManager txManager;
+  private final TreeNode root;
+  private final IndexTreeEditor editor;
+  private final TreeOperationLog log;
+  private TreeMap<String, TreeMap<String, List<TreeNode>>> index;
+  private TreeMap<TreeNode, TreeNode> parentIndex;
+
+  public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
+    return index;
+  }
+
 
-public class IndexJungleTreeEditor implements JungleTreeEditor
-{
-	private final TransactionManager txManager;
-	private final TreeNode root;
-	private final TreeEditor editor;
-	private final TreeOperationLog log;
-	private TreeMap<String, TreeMap<String, List<NodePath>>> index;
-	
-//	public DefaultJungleTreeEditor(TreeNode root)
-//	{
-//	    this(root,txManager,_editor,new DefaultTreeOperationLog());
-//	}
+
+  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 TreeMap<String, TreeMap<String, List<NodePath>>> getIndex() {
-		return index;
-	}
-
-	public void setIndex(
-			TreeMap<String, TreeMap<String, List<NodePath>>> index) {
-		this.index = index;
-	}
+  public IndexJungleTreeEditor(TreeNode newNode, TransactionManager _txManager, IndexTreeEditor _editor,
+      TreeOperationLog _log, TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode, TreeNode> parentIndex) {
+    this.root = newNode;
+    this.txManager = _txManager;
+    this.editor = _editor;
+    this.log = _log;
+    this.index = index;
+    this.parentIndex = parentIndex;
+  }
 
-	public IndexJungleTreeEditor(TreeNode _root,TransactionManager _txManager,TreeEditor _editor, TreeMap<String, TreeMap<String, List<NodePath>>> index)
-	{
-		this(_root,_txManager,_editor,new DefaultTreeOperationLog(), index);
-	}
-	
-	public IndexJungleTreeEditor(TreeNode newNode,TransactionManager _txManager,TreeEditor _editor,TreeOperationLog _log, TreeMap<String, TreeMap<String, List<NodePath>>> index)
-	{
-		this.root = newNode;
-		this.txManager = _txManager;
-		this.editor = _editor;
-		this.log = _log;
-		this.index = index;
-	}
-	
-	private Either<Error,IndexJungleTreeEditor> _edit(final NodePath _path,NodeEditor _e, IndexEditor indexEditor)
-	{
-		Either<Error,LoggingNode> either = editor.edit(root,_path,_e);
-		if(either.isA()){
-			return DefaultEither.newA(either.a());
-		}
-		
-		LoggingNode newLogging = either.b();
-		OperationLog newLog = newLogging.getOperationLog();
-		TreeNode newNode = newLogging.getWrap();
-		
-		IterableConverter.Converter<TreeOperation,NodeOperation> converter = new IterableConverter.Converter<TreeOperation,NodeOperation>(){
-			@Override
-			public TreeOperation conv(NodeOperation _b){
-				return new DefaultTreeOperation(_path,_b);
-			}
-		};
-		
-		Iterable<TreeOperation> iterable = new IterableConverter<TreeOperation,NodeOperation>(newLog,converter);
-		DefaultTreeOperationLog treeOperationLog = new DefaultTreeOperationLog(iterable,newLog.length());
-		TreeOperationLog newTreeOpLog = log.append(treeOperationLog);
-		
-		Either<Error, IndexJungleTreeEditor> newEither = indexEditor.edit(newNode,txManager,editor,newTreeOpLog, index);
-		return newEither;
-	}
-	
-	@Override
-	public Either<Error,JungleTreeEditor> addNewChildAt(NodePath _path, int _pos)
-	{
-		AppendChildAt appendChildAt = new AppendChildAt(_pos);
-		AddNewChildrenIndexEditor indexEditor = new AddNewChildrenIndexEditor(_pos, _path);
-		Either<Error,IndexJungleTreeEditor> either = _edit(_path,appendChildAt,indexEditor);
-		Either<Error,JungleTreeEditor> newEither = DefaultEither.newB(either.b());
-		return newEither;
-	}
+  
+  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);
+    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();
+    OperationLog newLog = newLogging.getOperationLog();
+    TreeNode newNode = newLogging.getWrap();
+
+    IterableConverter.Converter<TreeOperation, NodeOperation> converter = new IterableConverter.Converter<TreeOperation, NodeOperation>() {
+      @Override
+      public TreeOperation conv(NodeOperation _b) {
+        return new DefaultTreeOperation(_path, _b);
+      }
+    };
+
+    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);
+    return DefaultEither.newB(newIndexTreeEditor);
+  }
+
+  @Override
+  public Either<Error, JungleTreeEditor> addNewChildAt(NodePath _path, int _pos) {
+    AppendChildAt appendChildAt = new AppendChildAt(_pos);
+    IndexEditor indexEditor = new DefaultIndexEditor(index);
+    Either<Error, IndexJungleTreeEditor> either = _edit(_path, appendChildAt, indexEditor);
+    Either<Error, JungleTreeEditor> newEither = DefaultEither.newB(either.b());
+    return newEither;
+  }
 
-	@Override
-	public Either<Error,JungleTreeEditor> deleteChildAt(NodePath _path, int _pos)
-	{
-		DeleteChildAt deleteChildAt = new DeleteChildAt(_pos);
-		DeleteChildIndexEditor indexEditor = new DeleteChildIndexEditor(_pos, _path);
-		Either<Error,IndexJungleTreeEditor> either = _edit(_path,deleteChildAt, indexEditor);
-		JungleTreeEditor editor = either.b();
-		Either<Error,JungleTreeEditor> newEither = DefaultEither.newB(editor);
-		return newEither;
-	}
+  @Override
+  public Either<Error, JungleTreeEditor> deleteChildAt(NodePath _path, int _pos) {
+    DeleteChildAt deleteChildAt = new DeleteChildAt(_pos);
+    DeleteChildIndexEditor indexEditor = new DeleteChildIndexEditor(_pos, index);
+    Either<Error, IndexJungleTreeEditor> either = _edit(_path, deleteChildAt, indexEditor);
+    JungleTreeEditor editor = either.b();
+    Either<Error, JungleTreeEditor> newEither = DefaultEither.newB(editor);
+    return newEither;
+  }
 
-	@Override
-	public Either<Error,JungleTreeEditor> putAttribute(NodePath _path,String _key,ByteBuffer _value)
-	{
-		PutAttribute putAttribute = new PutAttribute(_key,_value);
-		PutIndexEditor indexEditor = new PutIndexEditor(_key,_value,_path);
-		Either<Error,IndexJungleTreeEditor> either = _edit(_path,putAttribute,indexEditor);
-		JungleTreeEditor editor = either.b();
-		Either<Error,JungleTreeEditor> newEither = DefaultEither.newB(editor);
-		return newEither;
-	}
+  @Override
+  public Either<Error, JungleTreeEditor> putAttribute(NodePath _path, String _key, ByteBuffer _value) {
+    PutAttribute putAttribute = new PutAttribute(_key, _value);
+    IndexEditor indexEditor = new DefaultIndexEditor(index);
+    Either<Error, IndexJungleTreeEditor> either = _edit(_path, putAttribute, indexEditor);
+    JungleTreeEditor editor = either.b();
+    Either<Error, JungleTreeEditor> newEither = DefaultEither.newB(editor);
+    return newEither;
+  }
 
-	@Override
-	public Either<Error,JungleTreeEditor> deleteAttribute(NodePath _path, String _key)
-	{
-		DeleteAttribute deleteAttribute = new DeleteAttribute(_key);
-		DeleteIndexEditor indexEditor = new DeleteIndexEditor(_key,_path,root);
-		Either<Error,IndexJungleTreeEditor> either = _edit(_path,deleteAttribute,indexEditor);
-		Either<Error,JungleTreeEditor> newEither = DefaultEither.newB(either.b());
-		return newEither;
-	}
+  @Override
+  public Either<Error, JungleTreeEditor> deleteAttribute(NodePath _path, String _key) {
+    DeleteAttribute deleteAttribute = new DeleteAttribute(_key);
+    IndexEditor indexEditor = new DefaultIndexEditor(index);
+    Either<Error, IndexJungleTreeEditor> either = _edit(_path, deleteAttribute, indexEditor);
+    Either<Error, JungleTreeEditor> newEither = DefaultEither.newB(either.b());
+    return newEither;
+  }
 
-	@Override
-	public Either<Error,JungleTreeEditor> edit(NodePath _path,NodeEditor _editor)
-	{
-		DefaultIndexEditor indexEditor = new DefaultIndexEditor();
-		Either<Error,IndexJungleTreeEditor> either = _edit(_path,_editor,indexEditor);
-		JungleTreeEditor editor = either.b();
-		Either<Error,JungleTreeEditor> newEither = DefaultEither.newB(editor);
-		return newEither;
-	}
+  @Override
+  public Either<Error, JungleTreeEditor> edit(NodePath _path, NodeEditor _editor) {
+    IndexEditor indexEditor = new DefaultIndexEditor(index);
+    Either<Error, IndexJungleTreeEditor> either = _edit(_path, _editor, indexEditor);
+    JungleTreeEditor editor = either.b();
+    Either<Error, JungleTreeEditor> newEither = DefaultEither.newB(editor);
+    return newEither;
+  }
+
+  @Override
+  public Either<Error, JungleTreeEditor> success() {
+    Either<Error, TransactionManager> either = txManager.commit(root, log, index,parentIndex);
+    if (either.isA()) {
+      return DefaultEither.newA(either.a());
+    }
+
+    TransactionManager newTxManager = either.b(); 
+    JungleTreeEditor newTreeEditor = new IndexJungleTreeEditor(root, newTxManager, editor, index,parentIndex);
 
-	@Override
-	public Either<Error,JungleTreeEditor> success()
-	{
-		Either<Error,TransactionManager> either = txManager.commit(root,log,index);
-		if(either.isA()){
-			return DefaultEither.newA(either.a());
-		}
-		
-		TransactionManager newTxManager = either.b();
-		JungleTreeEditor newTreeEditor = new DefaultJungleTreeEditor(root,newTxManager,editor,index);
-		
-		return DefaultEither.newB(newTreeEditor);
-	}
+    return DefaultEither.newB(newTreeEditor);
+  }
+
+  @Override
+  public String getID() {
+    return txManager.getUUID();
+  }
 
-	@Override
-	public String getID()
-	{
-		return txManager.getUUID();
-	}
+  @Override
+  public String getRevision() {
+    return Long.toString(txManager.getRevision());
+  }
 
-	@Override
-	public String getRevision()
-	{
-		return Long.toString(txManager.getRevision());
-	}
+  @Override
+  public TreeNode getRoot() {
+    return root;
+  }
 
-	@Override
-	public TreeNode getRoot()
-	{
-		return root;
-	}
-	
 }
\ No newline at end of file
diff -r 0854f9a9e81d -r a2c374a2686b 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	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/TransactionManager.java	Fri Nov 21 12:49:28 2014 +0900
@@ -2,7 +2,6 @@
 
 import fj.data.List;
 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.TreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
@@ -10,7 +9,7 @@
 
 public interface TransactionManager
 {
-	public Either<Error,TransactionManager> commit(TreeNode _newRoot,TreeOperationLog _log,	TreeMap<String, TreeMap<String, List<NodePath>>> index);
+	public Either<Error,TransactionManager> commit(TreeNode _newRoot,TreeOperationLog _log,	TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode,TreeNode> parentIndex);
 	public String getUUID();
 	public long getRevision();
 }
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java	Fri Nov 21 12:49:28 2014 +0900
@@ -11,8 +11,6 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NulIterator;
 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.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.PathNodeIterator;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.Query;
@@ -22,7 +20,7 @@
 
   // InterfaceTraverser traverser;
   TreeNode node;
-  TreeMap<String, TreeMap<String, List<NodePath>>> index;
+  TreeMap<String, TreeMap<String, List<TreeNode>>> index;
   IndexManager indexManager;
 
   public InterfaceTraverser(TreeNode _root, IndexManager indexManager) {
@@ -31,7 +29,7 @@
     this.indexManager = indexManager;
   }
 
-  public InterfaceTraverser(TreeNode _root, TreeMap<String, TreeMap<String, List<NodePath>>> index,
+  public InterfaceTraverser(TreeNode _root, TreeMap<String, TreeMap<String, List<TreeNode>>>  index,
       IndexManager indexManager) {
     this.node = _root;
     this.index = index;
@@ -42,11 +40,11 @@
     indexManager.commit(index);
   }
 
-  public TreeMap<String, TreeMap<String, List<NodePath>>> getIndex() {
+  public TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> getIndex() {
     return index;
   }
 
-  public void setIndex(TreeMap<String, TreeMap<String, List<NodePath>>> index) {
+  public void setIndex(TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index) {
     this.index = index;
   }
 
@@ -68,42 +66,26 @@
 
     if (index.get(key).isSome()) {
 
-      TreeMap<String, List<NodePath>> innerIndex = this.index.get(key).some();
+      TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = this.index.get(key).some();
 
-      Option<List<NodePath>> opList = innerIndex.get(searchValue);
+      Option<List<Pair<TreeNode, NodePath>>> opList = innerIndex.get(searchValue);
 
       if (opList.isNone())
         return new NulIterator<Pair<TreeNode, NodePath>>();// 空のIteratorを返す
 
-      List<NodePath> list = opList.some();
+      List<Pair<TreeNode, NodePath>> list = opList.some();
       NodePath targetNodePath = subTree.right();
-
-      return new Iterator<Pair<TreeNode, NodePath>>() {
+      List<Pair<TreeNode, NodePath>> filteredList = List.nil();
 
-        NodePath path;
-        List<NodePath> comparePathList = list; 
-        @Override
-        public boolean hasNext() {
-          for (NodePath comparePath : comparePathList) {
-            this.path = comparePath;
-            comparePathList = comparePathList.tail();
-            if (targetNodePath.compare(path))
-              return true;
-          }
-          return false;
-        }
+      for (Pair<TreeNode, NodePath> pair : list) {
+        NodePath compareNodePath = pair.right();
+        if (targetNodePath.compare(compareNodePath))
+          filteredList = filteredList.cons(pair);
+      }
 
-        @Override
-        public Pair<TreeNode, NodePath> next() {
-          TreeNode targetNode = getTarget(node, path);
-          Pair<TreeNode, NodePath> targetPair = new Pair<TreeNode, NodePath>(targetNode, path);
-          return targetPair;
-        }
-
-      };
+      return filteredList.iterator();
 
     } else {
-
       final PathNodeIterator itNode = new PathNodeIterator(subTree);
       return new Iterator<Pair<TreeNode, NodePath>>() {
 
@@ -162,50 +144,26 @@
 
     if (index.get(key).isSome()) {
 
-      TreeMap<String, List<NodePath>> innerIndex = this.index.get(key).some();
-      Iterator<P2<String, List<NodePath>>> searchValueIterator = innerIndex.iterator();
-      Iterator<P2<String, List<NodePath>>> searchValueIterator2 = innerIndex.iterator();
+      TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = this.index.get(key).some();
+      List<String> searchValues = innerIndex.keys();
+      List<Pair<TreeNode, NodePath>> filteredList = List.nil();
+      NodePath targetNodePath = subTree.right();
 
-      System.out.println("start-----------------------------------------------------------------");
-      for (;searchValueIterator2.hasNext();) {
-       String a = searchValueIterator2.next()._1();
-        System.out.println(a);
-      }
-      NodePath targetNodePath = subTree.right();
-      return new Iterator<Pair<TreeNode, NodePath>>() {
-
-        List<NodePath> pathList = List.nil();
-        NodePath path;
+      for (String searchValue : searchValues) {
+        Option<List<Pair<TreeNode, NodePath>>> opList = innerIndex.get(searchValue);
 
-        @Override
-        public boolean hasNext() {
-          if (!pathList.isEmpty()) {
-            path = pathList.head();
-            pathList = pathList.tail();
-            if (targetNodePath.compare(path))
-              return true;
-            return this.hasNext();
-          }
+        if (opList.isNone())
+          continue;
 
-          if (searchValueIterator.hasNext()) {
-            pathList = searchValueIterator.next()._2();
-            path = pathList.head();
-            pathList = pathList.tail();
-            
-            if (targetNodePath.compare(path))
-              return true;
-            return this.hasNext();
-          }
-          return false;
+        List<Pair<TreeNode, NodePath>> list = opList.some();
+        for (Pair<TreeNode, NodePath> pair : list) {
+          NodePath compareNodePath = pair.right();
+          if (targetNodePath.compare(compareNodePath))
+            filteredList = filteredList.cons(pair);
+
         }
-
-        @Override
-        public Pair<TreeNode, NodePath> next() {
-          TreeNode targetNode = getTarget(node, path);
-          Pair<TreeNode, NodePath> targetPair = new Pair<TreeNode, NodePath>(targetNode, path);
-          return targetPair;
-        }
-      };
+      }
+      return filteredList.iterator();
 
     } else {
       final PathNodeIterator itNode = new PathNodeIterator(subTree);
@@ -250,36 +208,14 @@
 
     if (index.get(key).isSome()) {
 
-      TreeMap<String, List<NodePath>> innerIndex = this.index.get(key).some();
-      Option<List<NodePath>> opList = innerIndex.get(searchValue);
+      TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = this.index.get(key).some();
+      Option<List<Pair<TreeNode, NodePath>>> opList = innerIndex.get(searchValue);
 
       if (opList.isNone())
         return new NulIterator<Pair<TreeNode, NodePath>>();// 空のIteratorを返す
 
-      final List<NodePath> list = opList.some();
-      return new Iterator<Pair<TreeNode, NodePath>>() {
-
-        List<NodePath> pathList = list;
-        NodePath targetPath;
-
-        @Override
-        public boolean hasNext() {
-          if (!pathList.isEmpty()) {
-            targetPath = pathList.head();
-            pathList = pathList.tail();
-            return true;
-          }
-
-          return false;
-        }
-
-        @Override
-        public Pair<TreeNode, NodePath> next() {
-          TreeNode targetNode = getTarget(node, targetPath);
-          Pair<TreeNode, NodePath> targetPair = new Pair<TreeNode, NodePath>(targetNode, targetPath);
-          return targetPair;
-        }
-      };
+      final List<Pair<TreeNode, NodePath>> list = opList.some();
+      return list.iterator();
 
     } else {
       Pair<TreeNode, NodePath> pair = new Pair<TreeNode, NodePath>(node, new DefaultNodePath());
@@ -292,34 +228,33 @@
 
           for (; itNode.hasNext();) {
             Pair<TreeNode, NodePath> pathNode = itNode.next();
-            Iterator<String> valueIterator = pathNode.left().getAttributes().getString(key);
-            Option<TreeMap<String, List<NodePath>>> innerIndexOp = index.get(key);
+            String value = pathNode.left().getAttributes().getString(key);
+            Option<TreeMap<String, List<Pair<TreeNode, NodePath>>>> innerIndexOp = index.get(key);
 
-            for (;valueIterator.hasNext();) {
-              String value = valueIterator.next();
+            if (value != null) {
               if (innerIndexOp.isNone()) {
 
-                TreeMap<String, List<NodePath>> innerIndex = TreeMap.empty(Ord.stringOrd);
-                List<NodePath> list = List.nil();
-                list = list.cons(pathNode.right());
+                TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = TreeMap.empty(Ord.stringOrd);
+                List<Pair<TreeNode, NodePath>> list = List.nil();
+                list = list.cons(pathNode);
                 innerIndex = innerIndex.set(value, list);
                 index = index.set(key, innerIndex);
 
               } else {
 
-                TreeMap<String, List<NodePath>> innerIndex = innerIndexOp.some();
-                Option<List<NodePath>> opList = innerIndex.get(value);
+                TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = innerIndexOp.some();
+                Option<List<Pair<TreeNode, NodePath>>> opList = innerIndex.get(value);
 
                 if (opList.isNone()) {
 
-                  List<NodePath> list = List.nil();
-                  list = list.cons(pathNode.right());
+                  List<Pair<TreeNode, NodePath>> list = List.nil();
+                  list = list.cons(pathNode);
                   innerIndex = innerIndex.set(value, list);
 
                 } else {
 
-                  List<NodePath> list = opList.some();
-                  list = list.cons(pathNode.right());
+                  List<Pair<TreeNode, NodePath>> list = opList.some();
+                  list = list.cons(pathNode);
                   innerIndex = innerIndex.set(value, list);
 
                 }
@@ -362,38 +297,20 @@
 
     if (index.get(key).isSome()) {
 
-      TreeMap<String, List<NodePath>> innerIndex = this.index.get(key).some();
-      Iterator<P2<String, List<NodePath>>> searchValueIterator = innerIndex.iterator();
-
-      return new Iterator<Pair<TreeNode, NodePath>>() {
-
-        List<NodePath> pathList = List.nil();
-        NodePath targetPath;
+      TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = this.index.get(key).some();
+      List<String> searchValues = innerIndex.keys();
+      List<Pair<TreeNode, NodePath>> valueList = List.nil();
 
-        @Override
-        public boolean hasNext() {
-          if (!pathList.isEmpty()) {
-            targetPath = pathList.head();
-            pathList = pathList.tail();
-            return true;
-          }
+      for (String searchValue : searchValues) {
+        Option<List<Pair<TreeNode, NodePath>>> opList = innerIndex.get(searchValue);
 
-          if (searchValueIterator.hasNext()) {
-            pathList = searchValueIterator.next()._2();
-            targetPath = pathList.head();
-            pathList = pathList.tail();
-            return true;
-          }
-          return false;
-        }
+        if (opList.isNone())
+          continue;
 
-        @Override
-        public Pair<TreeNode, NodePath> next() {
-          TreeNode targetNode = getTarget(node, targetPath);
-          Pair<TreeNode, NodePath> targetPair = new Pair<TreeNode, NodePath>(targetNode, targetPath);
-          return targetPair;
-        }
-      };
+        List<Pair<TreeNode, NodePath>> list = opList.some();
+        valueList = valueList.append(list);
+      }
+      return valueList.iterator();
 
     } else {
       Pair<TreeNode, NodePath> pair = new Pair<TreeNode, NodePath>(node, new DefaultNodePath());
@@ -406,34 +323,33 @@
 
           for (; itNode.hasNext();) {
             Pair<TreeNode, NodePath> pathNode = itNode.next();
-            Iterator<String> valueIterator = pathNode.left().getAttributes().getString(key);
-            Option<TreeMap<String, List<NodePath>>> innerIndexOp = index.get(key);
+            String value = pathNode.left().getAttributes().getString(key);
+            Option<TreeMap<String, List<Pair<TreeNode, NodePath>>>> innerIndexOp = index.get(key);
 
-            for (;valueIterator.hasNext();) {
-              String value = valueIterator.next();
+            if (value != null) {
               if (innerIndexOp.isNone()) {
 
-                TreeMap<String, List<NodePath>> innerIndex = TreeMap.empty(Ord.stringOrd);
-                List<NodePath> list = List.nil();
-                list = list.cons(pathNode.right());
+                TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = TreeMap.empty(Ord.stringOrd);
+                List<Pair<TreeNode, NodePath>> list = List.nil();
+                list = list.cons(pathNode);
                 innerIndex = innerIndex.set(value, list);
                 index = index.set(key, innerIndex);
 
               } else {
 
-                TreeMap<String, List<NodePath>> innerIndex = innerIndexOp.some();
-                Option<List<NodePath>> opList = innerIndex.get(value);
+                TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = innerIndexOp.some();
+                Option<List<Pair<TreeNode, NodePath>>> opList = innerIndex.get(value);
 
                 if (opList.isNone()) {
 
-                  List<NodePath> list = List.nil();
-                  list = list.cons(pathNode.right());
+                  List<Pair<TreeNode, NodePath>> list = List.nil();
+                  list = list.cons(pathNode);
                   innerIndex = innerIndex.set(value, list);
 
                 } else {
 
-                  List<NodePath> list = opList.some();
-                  list = list.cons(pathNode.right());
+                  List<Pair<TreeNode, NodePath>> list = opList.some();
+                  list = list.cons(pathNode);
                   innerIndex = innerIndex.set(value, list);
 
                 }
@@ -471,22 +387,4 @@
       };
     }
   }
-
-  public TreeNode getTarget(TreeNode node, NodePath path) {
-    Pair<Integer, NodePath> removeHeadPath = path.pop();
-
-    if (removeHeadPath.left() == -1)
-      return getTarget(node, removeHeadPath.right());
-
-    Either<Error, TreeNode> either = node.getChildren().at(removeHeadPath.left());
-    if (either.isA())
-      return node;
-
-    TreeNode child = either.b();
-    if (removeHeadPath.right().size() == 0)
-      return child;
-
-    TreeNode target = getTarget(child, removeHeadPath.right());
-    return target;
-  }
 }
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/util/TreeMapOrd.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/util/TreeMapOrd.java	Fri Nov 21 12:49:28 2014 +0900
@@ -0,0 +1,25 @@
+package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
+import fj.F;
+import fj.Ord;
+import fj.P;
+import fj.P1;
+
+public class TreeMapOrd {
+
+  private TreeMapOrd(){
+    
+  }
+  
+  private static F<TreeNode, P1<String>> toP1 = new F<TreeNode, P1<String>> () {
+    @Override
+    public P1<String> f(TreeNode node) {
+      return P.p(node.toString());
+    }
+  };
+  
+  private static Ord<P1<String>> ord = Ord.p1Ord(Ord.stringOrd);
+  public static Ord<TreeNode> treeNodeOrd = ord.comap(toP1);
+  
+}
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/query/PathNodeIterator.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/query/PathNodeIterator.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/query/PathNodeIterator.java	Fri Nov 21 12:49:28 2014 +0900
@@ -4,7 +4,6 @@
 import java.util.Stack;
 
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-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.store.impl.TreeNodeChildren;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/query/Query.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/query/Query.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/query/Query.java	Fri Nov 21 12:49:28 2014 +0900
@@ -1,8 +1,6 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query;
 
-import fj.data.List;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
 
 public interface Query {
 	boolean condition(TreeNode _node);
diff -r 0854f9a9e81d -r a2c374a2686b 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	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DefaultIndexEditor.java	Fri Nov 21 12:49:28 2014 +0900
@@ -1,26 +1,97 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index;
 
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNodeAttributes;
+import fj.Ord;
 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.TreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.IndexJungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TransactionManager;
-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;
 
 public class DefaultIndexEditor implements IndexEditor {
 
-	@Override
-	public Either<Error, IndexJungleTreeEditor> edit(TreeNode root,TransactionManager txManager,TreeEditor editor,TreeOperationLog log,TreeMap<String, TreeMap<String, List<NodePath>>> index) {
-		IndexJungleTreeEditor newEditor = new IndexJungleTreeEditor(root,txManager,editor,log, index);
-		Either<Error, IndexJungleTreeEditor> either = DefaultEither.newB(newEditor);
-		return either;
-	}
+  TreeMap<String, TreeMap<String, List<TreeNode>>> indexTreeMap;
+
+  public DefaultIndexEditor(TreeMap<String, TreeMap<String, List<TreeNode>>> indexTreeMap) {
+    this.indexTreeMap = indexTreeMap;
+  }
+
+  @Override
+  public IndexEditor delete(TreeNode node) {
+    TreeNodeAttributes attribute = node.getAttributes();
+    List<String> keys = attribute.getKeys();
+    TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexTreeMap = indexTreeMap;
+    for (String key : keys) {
+      Option<TreeMap<String, List<TreeNode>>> indexOp = indexTreeMap.get(key);
+      if (indexOp.isSome()) {
+        TreeMap<String, List<TreeNode>> index = indexOp.some();
+        String value = attribute.getString(key);
+        Option<List<TreeNode>> nodeListOp = index.get(value);
+        if (nodeListOp.isSome()) {
+          List<TreeNode> nodeList = nodeListOp.some();
+          List<TreeNode> newNodeList = List.nil();
+          for (TreeNode indexingNode : nodeList) {
+            if (indexingNode != node)
+              newNodeList = newNodeList.cons(indexingNode);
+          }
+          TreeMap<String, List<TreeNode>> newIndex;
+//          if (newNodeList.isEmpty())
+//            newIndex = index.delete(value);
+//          else
+            newIndex = index.set(value, newNodeList);
+          newIndexTreeMap = newIndexTreeMap.set(key, newIndex);
+        }
+
+      }
+    }
+
+    return new DefaultIndexEditor(newIndexTreeMap);
+  }
 
+  @Override
+  public IndexEditor add(TreeNode node) {
+    TreeNodeAttributes attribute = node.getAttributes();
+    List<String> keys = attribute.getKeys();
+    TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexTreeMap = indexTreeMap;
+    for (String key : keys) {
+      Option<TreeMap<String, List<TreeNode>>> indexOp = indexTreeMap.get(key);
+      if (indexOp.isSome()) {
+        TreeMap<String, List<TreeNode>> index = indexOp.some();
+        String value = attribute.getString(key);
+        Option<List<TreeNode>> nodeListOp = index.get(value);
+        if (nodeListOp.isSome()) {
+          List<TreeNode> nodeList = nodeListOp.some();
+          List<TreeNode> newNodeList = nodeList.cons(node);
+          TreeMap<String, List<TreeNode>> newIndex = index.set(value, newNodeList);
+          newIndexTreeMap = newIndexTreeMap.set(key, newIndex);
+        } else { // test
+          List<TreeNode> nodeList = List.nil();
+          value = attribute.getString(key);
+          List<TreeNode> newNodeList = nodeList.cons(node);
+          TreeMap<String, List<TreeNode>> newIndex = index.set(value, newNodeList);
+          newIndexTreeMap = newIndexTreeMap.set(key, newIndex);
+        }
 
+      } else { // test
+        TreeMap<String, List<TreeNode>> index = TreeMap.empty(Ord.stringOrd);
+        List<TreeNode> nodeList = List.nil();
+        String value = attribute.getString(key);
+        List<TreeNode> newNodeList = nodeList.cons(node);
+        TreeMap<String, List<TreeNode>> newIndex = index.set(value, newNodeList);
+        newIndexTreeMap = newIndexTreeMap.set(key, newIndex);
+      }
+    }
+
+    return new DefaultIndexEditor(newIndexTreeMap);
+  }
+
+  @Override
+  public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
+    return indexTreeMap;
+  }
+
+  @Override
+  public IndexEditor edit(TreeNode node) {
+    return this;
+  }
 
 }
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DeleteChildIndexEditor.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DeleteChildIndexEditor.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DeleteChildIndexEditor.java	Fri Nov 21 12:49:28 2014 +0900
@@ -1,122 +1,127 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index;
 
-import java.util.Iterator;
-
-import fj.F;
 import fj.Ord;
-import fj.P2;
 import fj.data.List;
 import fj.data.Option;
 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.TreeEditor;
 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.store.impl.logger.TreeOperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.IndexJungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TransactionManager;
-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.store.impl.TreeNodeAttributes;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
+import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.PathNodeIterator;
 
 public class DeleteChildIndexEditor implements IndexEditor {
 
-	NodePath editNodePath;
-
-	public DeleteChildIndexEditor(int pos, NodePath path) {
-		this.editNodePath = path.add(pos);
-	}
+  TreeMap<String, TreeMap<String, List<TreeNode>>> indexTreeMap;
+  int pos;
 
-	@Override
-	public Either<Error, IndexJungleTreeEditor> edit(
-			TreeNode root,
-			TransactionManager txManager,
-			TreeEditor editor,
-			TreeOperationLog log,
-			TreeMap<String, TreeMap<String, List<NodePath>>> index) {
-
-		TreeMap<String, TreeMap<String, List<NodePath>>> newIndex = editIndex(index);
-		IndexJungleTreeEditor newEditor = new IndexJungleTreeEditor(root, txManager, editor, newIndex);
-		return DefaultEither.newB(newEditor);
-	}
-
-	public TreeMap<String, TreeMap<String, List<NodePath>>> editIndex(
-			TreeMap<String, TreeMap<String, List<NodePath>>> index) {
+  public DeleteChildIndexEditor(int pos, TreeMap<String, TreeMap<String, List<TreeNode>>> indexTreeMap) {
+    this.indexTreeMap = indexTreeMap;
+    this.pos = pos;
+  }
 
-		if (!index.isEmpty()) {
-			List<String> keyList = index.keys();
-			TreeMap<String, TreeMap<String, List<NodePath>>> newIndex = TreeMap.empty(Ord.stringOrd);
-			TreeMap<String, List<NodePath>> newInnerIndex = TreeMap.empty(Ord.stringOrd);
-
-			for (String indexKey : keyList) {
-				TreeMap<String, List<NodePath>> innerIndex = index.get(indexKey).some();
-				List<String> innerIndexKeyList = innerIndex.keys();
+  @Override
+  public IndexEditor delete(TreeNode node) {
+    TreeNodeAttributes attribute = node.getAttributes();
+    List<String> keys = attribute.getKeys();
+    TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexTreeMap = indexTreeMap;
+    for (String key : keys) {
+      Option<TreeMap<String, List<TreeNode>>> indexOp = indexTreeMap.get(key);
+      if (indexOp.isSome()) {
+        TreeMap<String, List<TreeNode>> index = indexOp.some();
+        String value = attribute.getString(key);
+        Option<List<TreeNode>> nodeListOp = index.get(value);
+        if (nodeListOp.isSome()) {
+          List<TreeNode> nodeList = nodeListOp.some();
+          List<TreeNode> newNodeList = List.nil();
+          for (TreeNode indexingNode : nodeList) {
+            if (indexingNode != node)
+              newNodeList = newNodeList.cons(indexingNode);
+          }
+          TreeMap<String, List<TreeNode>> newIndex;
+          newIndex = index.set(value, newNodeList);
+          newIndexTreeMap = newIndexTreeMap.set(key, newIndex);
+        }
 
-				for (String innerIndexKey : innerIndexKeyList) {
-					List<NodePath> pairList = innerIndex.get(innerIndexKey).some();
-					List<NodePath> list = checkPath(pairList);
-					if (!list.isEmpty()){
-						newInnerIndex = newInnerIndex.set(innerIndexKey, list);
-					}
-				}
-				newIndex = newIndex.set(indexKey, newInnerIndex);
-			}
-			return newIndex;
-		} else {
-			return index;
-		}
-	}
+      }
+    }
 
-	public List<NodePath> checkPath(List<NodePath> pairList){
+    return new DefaultIndexEditor(newIndexTreeMap);
+  }
 
-		List<NodePath> list = List.nil();
-		for (NodePath path : pairList) {
+  @Override
+  public IndexEditor add(TreeNode node) {
+    TreeNodeAttributes attribute = node.getAttributes();
+    List<String> keys = attribute.getKeys();
+    TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexTreeMap = indexTreeMap;
+    for (String key : keys) {
+      Option<TreeMap<String, List<TreeNode>>> indexOp = indexTreeMap.get(key);
+      if (indexOp.isSome()) {
+        TreeMap<String, List<TreeNode>> index = indexOp.some();
+        String value = attribute.getString(key);
+        Option<List<TreeNode>> nodeListOp = index.get(value);
+        if (nodeListOp.isSome()) {
+          List<TreeNode> nodeList = nodeListOp.some();
+          List<TreeNode> newNodeList = nodeList.cons(node);
+          TreeMap<String, List<TreeNode>> newIndex = index.set(value, newNodeList);
+          newIndexTreeMap = newIndexTreeMap.set(key, newIndex);
+        } else { // test
+          List<TreeNode> nodeList = List.nil();
+          value = attribute.getString(key);
+          List<TreeNode> newNodeList = nodeList.cons(node);
+          TreeMap<String, List<TreeNode>> newIndex = index.set(value, newNodeList);
+          newIndexTreeMap = newIndexTreeMap.set(key, newIndex);
+        }
 
-			System.out.println("oldPath = " + path.toString());
-			NodePath newPath = new DefaultNodePath();
-			
-			if (path.toString().equals(editNodePath.toString())) {
-				continue;
-			}
-			
-			if (editNodePath.size() > path.size()) {
-				list = list.cons(path);
-				continue;
-			}
+      } else { // test
+        TreeMap<String, List<TreeNode>> index = TreeMap.empty(Ord.stringOrd);
+        List<TreeNode> nodeList = List.nil();
+        String value = attribute.getString(key);
+        List<TreeNode> newNodeList = nodeList.cons(node);
+        TreeMap<String, List<TreeNode>> newIndex = index.set(value, newNodeList);
+        newIndexTreeMap = newIndexTreeMap.set(key, newIndex);
+      }
+    }
 
-			Pair<Integer, NodePath> editNodePathCopy = editNodePath.pop();
-			int loopCount = 0;
-
-			for (Integer pathInt : path) {
-				loopCount++;
+    return new DefaultIndexEditor(newIndexTreeMap);
+  }
 
-				if (pathInt == -1)
-					continue;
-				if (editNodePathCopy.right().size() > 0) {
-					
-					editNodePathCopy = editNodePathCopy.right().pop();
-					if (loopCount == editNodePath.size() && editNodePathCopy.left() < pathInt) {
-						newPath = newPath.add(pathInt - 1);
-						continue;
-					}
+  @Override
+  public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
+    return indexTreeMap;
+  }
+
+  @Override
+  public IndexEditor edit(TreeNode node) {
+    PathNodeIterator nodeSearcher = new PathNodeIterator(new Pair<TreeNode, NodePath>(node, new DefaultNodePath()));
+    TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexTreeMap = indexTreeMap;
 
-					if (!(editNodePathCopy.left() == pathInt)) {
-						newPath = path;
-						break;
-					}
-				}
-
-				newPath = newPath.add(pathInt);
+    for (; nodeSearcher.hasNext();) {
+      TreeNode deleteNode = nodeSearcher.next().left();
+      TreeNodeAttributes attribute = deleteNode.getAttributes();
+      List<String> keys = attribute.getKeys();
+      for (String key : keys) {
+        Option<TreeMap<String, List<TreeNode>>> indexOp = newIndexTreeMap.get(key);
+        if (indexOp.isSome()) {
+          TreeMap<String, List<TreeNode>> index = indexOp.some();
+          String value = attribute.getString(key);
+          Option<List<TreeNode>> nodeListOp = index.get(value);
+          if (nodeListOp.isSome()) {
+            List<TreeNode> nodeList = nodeListOp.some();
+            List<TreeNode> newNodeList = List.nil();
+            for (TreeNode indexingNode : nodeList) {
+              if (indexingNode != deleteNode)
+                newNodeList = newNodeList.cons(indexingNode);
+            }
+            TreeMap<String, List<TreeNode>> newIndex = index.set(value, newNodeList);
+            newIndexTreeMap = newIndexTreeMap.set(key, newIndex);
+          }
 
-			}
-
-			System.out.println("newPath = " + newPath.toString());
-			list = list.cons(path);
-		}
-
-		return list;
-	}
+        }
+      }
+    }
+    return null;
+  }
 
 }
diff -r 0854f9a9e81d -r a2c374a2686b src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexEditor.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexEditor.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexEditor.java	Fri Nov 21 12:49:28 2014 +0900
@@ -2,15 +2,12 @@
 
 import fj.data.List;
 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.TreeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.IndexJungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TransactionManager;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
+
 
 public interface IndexEditor {
-	Either<Error, IndexJungleTreeEditor> edit(TreeNode root,TransactionManager txManager, TreeEditor editor,TreeOperationLog log,TreeMap<String, TreeMap<String, List<NodePath>>> index);
+  public IndexEditor add(TreeNode node);
+  public IndexEditor delete(TreeNode node);
+  public IndexEditor edit(TreeNode node);
+  public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex();
 }
diff -r 0854f9a9e81d -r a2c374a2686b 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	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexManager.java	Fri Nov 21 12:49:28 2014 +0900
@@ -5,7 +5,6 @@
 import fj.data.TreeMap;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultChangeSet;
@@ -20,7 +19,7 @@
 		this.reservation = reservation;
 	}
 	
-	public void commit(TreeMap<String, TreeMap<String, List<NodePath>>> index){
+	public void commit(TreeMap<String, TreeMap<String, List<TreeNode>>> index){
 		TreeContext tc = reservation.get();
 		ChangeSet cs = tc.getChangeSet();
 		TreeNode root = cs.getRoot();
@@ -29,7 +28,8 @@
 		String uuid = cs.uuid();
 		String treeName = cs.getTreeName();
 		long revision = cs.revision();
-		DefaultChangeSet newCs = new DefaultChangeSet(root, prev, cl, uuid, treeName, revision, index);
+		TreeMap<TreeNode, TreeNode> 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 0854f9a9e81d -r a2c374a2686b src/test/java/DefaultJungleTreeTest.java
--- a/src/test/java/DefaultJungleTreeTest.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/test/java/DefaultJungleTreeTest.java	Fri Nov 21 12:49:28 2014 +0900
@@ -7,6 +7,7 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
+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.traverser.DefaultTraverser;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
@@ -19,7 +20,7 @@
 {
 	public Jungle instance()
 	{
-		Jungle j = new DefaultJungle(null,"hogehoge",new DefaultTreeEditor(new DefaultTraverser()));
+		Jungle j = new DefaultJungle(null,"hogehoge",new  DefaultTraverser());
 		return j;
 	}
 	
diff -r 0854f9a9e81d -r a2c374a2686b src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/GetOldTreeTest.java
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/GetOldTreeTest.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/GetOldTreeTest.java	Fri Nov 21 12:49:28 2014 +0900
@@ -1,5 +1,6 @@
 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core;
 
+
 import java.nio.ByteBuffer;
 import java.util.Iterator;
 
@@ -11,6 +12,7 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
+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.traverser.DefaultTraverser;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
@@ -21,12 +23,12 @@
 
   @Test
   public void getOldTreeTest() {
-    Jungle jungle = new DefaultJungle(null, "hogehoge", new DefaultTreeEditor(new DefaultTraverser()));
+    Jungle jungle = new DefaultJungle(null, "hogehoge", new DefaultTraverser());
     jungle.createNewTree("tree");
     JungleTree tree = jungle.getTreeByName("tree");
     JungleTreeEditor editor = tree.getTreeEditor();
     DefaultNodePath path = new DefaultNodePath();
-
+   
     for (int num = 0; num < 10; num++) {
       JungleTreeEditor addChildEditor = editor.addNewChildAt(path, num).b();
       JungleTreeEditor putAttributeEditor = addChildEditor.putAttribute(path.add(num), "test", ByteBuffer.wrap("tatsuki".getBytes())).b();
diff -r 0854f9a9e81d -r a2c374a2686b src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/functionaljava/FjTreeMapTest.java
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/functionaljava/FjTreeMapTest.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/functionaljava/FjTreeMapTest.java	Fri Nov 21 12:49:28 2014 +0900
@@ -1,39 +1,66 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.functionaljava;
 
 
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
 
-import org.apache.commons.collections.map.StaticBucketMap;
 import org.junit.Assert;
 import org.junit.Test;
 
+
 import fj.F;
 import fj.Ord;
+import fj.P;
+import fj.P1;
 import fj.data.List;
 import fj.data.Option;
 import fj.data.TreeMap;
 
 public class FjTreeMapTest<A> {
-	
-	@Test
-	public void testTreeMap()	{
+
+  F<TreeNode, P1<String>> toP3 = new F<TreeNode, P1<String>> () {
+
+    @Override
+    public P1<String> f(TreeNode node) {
+      return P.p(node.toString());
+    }
+
+  };
+
+  
+  @Test
+  public void testTreeMap() {
 
-		List<Integer> list = List.nil();
-		list = list.cons(1).cons(2).cons(3);
-		System.out.println(list.toString());
-		list.length();
-		TreeMap<String,String> map = TreeMap.empty(Ord.stringOrd);
-		TreeMap<String, String> newMap = map.set("name","tatsuki");
-		Option<String> op = newMap.get("name");
-		if (op.isNone()) {
-			
-		}
-		String str = op.some();
-		
-		TreeMap<String, String> newMap2 = map.set("name","kanagawa");
-		String str2 = newMap2.get("name").some();
-		Assert.assertEquals(str,"tatsuki");
-		Assert.assertEquals(str2,"kanagawa");
-	}
-	
+     Ord<P1<String>> aaa = Ord.p1Ord(Ord.stringOrd);
+     Ord<TreeNode> test = aaa.comap(toP3);
+     TreeMap<TreeNode, TreeNode> treeMap = TreeMap.empty(test);
+     TreeNode node1 = new DefaultTreeNode();
+     TreeNode node2 = new DefaultTreeNode();
+     treeMap = treeMap.set(node1,node2);
+     treeMap = treeMap.delete(node2);
+     System.out.println(node1.toString());
+     System.out.println(node2.toString());
+     System.out.println(node1.toString());
+     System.out.println(node2.toString());
+     Option<TreeNode> nodee = treeMap.get(node1);
+     TreeNode node = nodee.some();
+     System.out.println(node.toString());
+    List<Integer> list = List.nil();
+    list = list.cons(1).cons(2).cons(3);
+    System.out.println(list.toString());
+    list.length();
+    TreeMap<String, String> map = TreeMap.empty(Ord.stringOrd);
+    TreeMap<String, String> newMap = map.set("name", "tatsuki");
+    Option<String> op = newMap.get("name");
+    if (op.isNone()) {
+
+    }
+    String str = op.some();
+
+    TreeMap<String, String> newMap2 = map.set("name", "kanagawa");
+    String str2 = newMap2.get("name").some();
+    Assert.assertEquals(str, "tatsuki");
+    Assert.assertEquals(str2, "kanagawa");
+  }
 
 }
diff -r 0854f9a9e81d -r a2c374a2686b src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/AddChildrenIndexTest.java
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/AddChildrenIndexTest.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/AddChildrenIndexTest.java	Fri Nov 21 12:49:28 2014 +0900
@@ -1,11 +1,15 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.index;
 
+
+
 import java.nio.ByteBuffer;
 import java.util.Iterator;
 
 import org.junit.Test;
+import org.junit.experimental.theories.suppliers.TestedOn;
 
 import fj.data.List;
+import fj.data.Option;
 import fj.data.TreeMap;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
@@ -14,6 +18,7 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
+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.transaction.DefaultTreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.IndexJungleTreeEditor;
@@ -26,104 +31,77 @@
 
 public class AddChildrenIndexTest {
 
-  @Test
-  public void AddChildrenTest() {
-    Jungle jungle = new DefaultJungle(null, "hogehoge", new DefaultTreeEditor(new DefaultTraverser()));
-    jungle.createNewTree("tree");
-    JungleTree tree = jungle.getTreeByName("tree");
-    createTree(tree);
-    tree.getRootNode();
-    InterfaceTraverser ifTraverser = tree.getTraverser();
-
-    Iterator<Pair<TreeNode, NodePath>> pairIterator = ifTraverser.find((TreeNode node) -> {
-      List<ByteBuffer> attributeList = node.getAttributes().get(key);
-      if (attributeList.isNotEmpty()) {
-        for (ByteBuffer attribute : attributeList) {
-          byte[] byteAttribute = attribute.array();
-          String str = new String(byteAttribute);
-          System.out.println("attribute = " + str);
-          if (str.equals("<-1,0,1>"))
-            return true;
-          continue;
-        }
-      }
-      return false;
-    }, key, "<-1,0,1>");
+	@Test
+	public void DeleteChildrenTest(){
+		Jungle jungle = new DefaultJungle(null, "hogehoge",new DefaultTraverser());
+		jungle.createNewTree("tree");
+		JungleTree tree = jungle.getTreeByName("tree");
+		createTree(tree);
+		tree.getRootNode();
+		InterfaceTraverser ifTraverser = tree.getTraverser();
 
-    for (; pairIterator.hasNext(); pairIterator.next()) {
-
-    }
-    ifTraverser.commitIndex();
-
-    IndexJungleTreeEditor editor = tree.getIndexTreeEditor();
-    Either<Error, JungleTreeEditor> either = editor.addNewChildAt(new DefaultNodePath().add(0), 0);
-    either.b().success();
+		Iterator<Pair<TreeNode, NodePath>> pairIterator = ifTraverser.find((TreeNode node) -> {
+			ByteBuffer attribute = node.getAttributes().get(key);
+			if (attribute != null) {
+				byte[] byteAttribute = attribute.array();
+				String str = new String(byteAttribute);
+				System.out.println("attribute = " + str);
+				return str.equals("<-1,0,1>");
+			}
+			return false;
+		}, key, "<-1,0,1>");
 
-    InterfaceTraverser newIfTraverser = tree.getTraverser();
-    TreeMap<String, TreeMap<String, List<NodePath>>> newIndex = newIfTraverser.getIndex();
-    NodePath targetPath = newIndex.get(key).some().get("<-1,0,2>").some().head();
-    TreeNode targetNode = getTarget(tree.getRootNode(), targetPath);
-    Iterator<String> attributeIterator = targetNode.getAttributes().getString(key);
-    Assert.assertTrue(attributeIterator.hasNext());
-    String attribute = attributeIterator.next();
-    Assert.assertEquals(attribute, "<-1,0,1>");
-
-  }
-
-  public static String key = "KEY";
-  public static DefaultTreeNode factory = new DefaultTreeNode();
-
-  public void createTree(JungleTree tree) {
-    NodePath root = new DefaultNodePath();
-    createChildren(tree, root, 0);
+		 for (;pairIterator.hasNext();pairIterator.next()) {
+			 
+		 }
+		ifTraverser.commitIndex(); 
+		
+		IndexJungleTreeEditor editor = tree.getIndexTreeEditor();
+		Either<Error, JungleTreeEditor> either = editor.addNewChildAt(new DefaultNodePath().add(0), 0);
+		either.b().success();
+		
+		InterfaceTraverser newIfTraverser = tree.getTraverser();
+		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = newIfTraverser.getIndex();
+		Assert.assertEquals(newIndex.get(key).some().get("<-1,0,1>").some().head().right().toString(),"<-1,0,2>");
+		
+		}
+	public static String key = "KEY";
+	public static DefaultTreeNode factory = new DefaultTreeNode();
 
-    for (int x = 0; x < 3; x++) {
-      createChildren(tree, root.add(0), x);
-      for (int y = 0; y < 3; y++) {
-        createChildren(tree, root.add(0).add(x), y);
-      }
-    }
+	public void createTree(JungleTree tree) {
+		NodePath root = new DefaultNodePath();
+		createChildren(tree, root, 0);
 
-  }
+		for (int x = 0; x < 3; x++) {
+			createChildren(tree, root.add(0), x);
+			for (int y = 0; y < 3; y++) {
+				createChildren(tree, root.add(0).add(x), y);
+			}
+		}
+
+	}
 
-  public void createChildren(JungleTree tree, NodePath root, int num) {
-    JungleTreeEditor editor = tree.getTreeEditor();// Treeのeditorを作成
-    Either<Error, JungleTreeEditor> either = editor.addNewChildAt(root, num); // 新しく入れるところへのパス
-    if (either.isA()) {
-      Assert.fail();
-    }
-    editor = either.b();
-    either = editor.success();
-    if (either.isA()) {
-      Assert.fail();
-    }
-    NodePath childPath = root.add(num);
-    editor = tree.getTreeEditor();
-    NodePath attribute = root.add(num);
-    System.out.println(attribute.toString());
-    either = editor.putAttribute(childPath, key, ByteBuffer.wrap(attribute.toString().getBytes()));
-    if (either.isA()) {
-      Assert.fail();
-    }
-    editor = either.b();
-    either = editor.success();
-  }
-
-  public TreeNode getTarget(TreeNode node, NodePath path) {
-    Pair<Integer, NodePath> removeHeadPath = path.pop();
-
-    if (removeHeadPath.left() == -1)
-      return getTarget(node, removeHeadPath.right());
-
-    Either<Error, TreeNode> either = node.getChildren().at(removeHeadPath.left());
-    if (either.isA())
-      return node;
-
-    TreeNode child = either.b();
-    if (removeHeadPath.right().size() == 0)
-      return child;
-
-    TreeNode target = getTarget(child, removeHeadPath.right());
-    return target;
-  }
+	public void createChildren(JungleTree tree, NodePath root, int num) {
+		JungleTreeEditor editor = tree.getTreeEditor();// Treeのeditorを作成
+		Either<Error, JungleTreeEditor> either = editor
+				.addNewChildAt(root, num); // 新しく入れるところへのパス
+		if (either.isA()) {
+			Assert.fail();
+		}
+		editor = either.b();
+		either = editor.success();
+		if (either.isA()) {
+			Assert.fail();
+		}
+		NodePath childPath = root.add(num);
+		editor = tree.getTreeEditor();
+		NodePath attribute = root.add(num);
+		System.out.println(attribute.toString());
+		either = editor.putAttribute(childPath, key,ByteBuffer.wrap(attribute.toString().getBytes()));
+		if (either.isA()) {
+			Assert.fail();
+		}
+		editor = either.b();
+		either = editor.success();
+	}
 }
diff -r 0854f9a9e81d -r a2c374a2686b src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/AttributeIndexTest.java
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/AttributeIndexTest.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/AttributeIndexTest.java	Fri Nov 21 12:49:28 2014 +0900
@@ -1,35 +1,34 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.index;
 
+
+
 import java.nio.ByteBuffer;
-import java.util.Iterator;
 
 import org.junit.Test;
 
-
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
 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.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.IndexJungleTreeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
 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.Pair;
 import junit.framework.Assert;
 import fj.data.List;
+import fj.data.Option;
 import fj.data.TreeMap;
 
 public class AttributeIndexTest {
 
 	@Test
 	public void PutAttributeIndexTest(){
-		DefaultJungle jungle = new DefaultJungle(null,"hoge",new DefaultTreeEditor(new DefaultTraverser()));
+		DefaultJungle jungle = new DefaultJungle(null,"hoge",new DefaultTraverser());
 		JungleTree tree = jungle.createNewTree("fuga");
 		IndexJungleTreeEditor editor = tree.getIndexTreeEditor();
-		TreeMap<String, TreeMap<String, List<NodePath>>> emptyIndex = editor.getIndex();
+		TreeMap<String, TreeMap<String, List<TreeNode>>> emptyIndex = editor.getIndex();
 		Assert.assertTrue(emptyIndex.isEmpty());
 		NodePath path = new DefaultNodePath();
 		Either<Error, JungleTreeEditor> either = editor.addNewChildAt(path, 0);
@@ -39,44 +38,28 @@
 		Either<Error, JungleTreeEditor> either2 = editor2.putAttribute(path.add(0),"key", ByteBuffer.wrap("test".toString().getBytes()));
 		Assert.assertFalse(either2.isA());
 		JungleTreeEditor editor3 = either2.b();
-		editor3.success();
-		
+		editor3 = editor3.success().b();
+	
+		editor3.putAttribute(path.add(0),"key", ByteBuffer.wrap("tatsuki".toString().getBytes())).b().success().b();	
+		TreeNode targetNode = tree.getRootNode().getChildren().at(0).b();
 		IndexJungleTreeEditor IndexEditor = tree.getIndexTreeEditor();
-		TreeMap<String, TreeMap<String, List< NodePath>>> index = IndexEditor.getIndex();
-		
-		NodePath targetPath = index.get("key").some().get("test").some().head();
-		TreeNode targetNode = getTarget(tree.getRootNode(), targetPath);
-		Iterator<String> AttributeIterator = targetNode.getAttributes().getString("key");
-		Assert.assertTrue(AttributeIterator.hasNext());
-		Assert.assertEquals(AttributeIterator.next(),"test");
+		TreeMap<String, TreeMap<String, List<TreeNode>>> index = IndexEditor.getIndex();
+		List<TreeNode> NodeList = index.get("key").some().get("tatsuki").some();
+		String attributeIndex = NodeList.head().getAttributes().getString("key");
+		Assert.assertEquals(attributeIndex,"tatsuki");
+		Assert.assertEquals(NodeList.head(),targetNode);
 		
 		JungleTreeEditor editor4 = tree.getIndexTreeEditor();
-		Either<Error, JungleTreeEditor> either3 = editor4.deleteAttribute(path.add(0), "key");
+		Either<Error, JungleTreeEditor> either3 = editor4.deleteAttribute(path.add(0), "key").b().success();
 		Assert.assertFalse(either3.isA());
 		JungleTreeEditor editor5 = either3.b();
 		editor5.success();
 		
 		IndexJungleTreeEditor IndexEditor2 = tree.getIndexTreeEditor();
-		TreeMap<String, TreeMap<String, List<NodePath>>> deleteIndex = IndexEditor2.getIndex();		
-		Assert.assertTrue(deleteIndex.isEmpty());
+		TreeMap<String, TreeMap<String, List<TreeNode>>> deleteIndexList = IndexEditor2.getIndex();		
+		Option<TreeMap<String, List<TreeNode>>> deleteIndexOp = deleteIndexList.get("key");
+		TreeMap<String, List<TreeNode>> deleteIndex = deleteIndexOp.some();
+		Assert.assertTrue(deleteIndex.get("test").some().isEmpty());
+		Assert.assertTrue(deleteIndex.get("tatsuki").some().isEmpty());
 	}
-	
-	
-  public TreeNode getTarget(TreeNode node, NodePath path) {
-    Pair<Integer, NodePath> removeHeadPath = path.pop();
-
-    if (removeHeadPath.left() == -1)
-      return getTarget(node, removeHeadPath.right());
-
-    Either<Error, TreeNode> either = node.getChildren().at(removeHeadPath.left());
-    if (either.isA())
-      return node;
-
-    TreeNode child = either.b();
-    if (removeHeadPath.right().size() == 0)
-      return child;
-
-    TreeNode target = getTarget(child, removeHeadPath.right());
-    return target;
-  }
 }
diff -r 0854f9a9e81d -r a2c374a2686b src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/DeleteChildrenIndexTest.java
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/DeleteChildrenIndexTest.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/DeleteChildrenIndexTest.java	Fri Nov 21 12:49:28 2014 +0900
@@ -4,8 +4,10 @@
 import java.util.Iterator;
 
 import org.junit.Test;
+import org.junit.experimental.theories.suppliers.TestedOn;
 
 import fj.data.List;
+import fj.data.Option;
 import fj.data.TreeMap;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
@@ -14,6 +16,7 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
+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.transaction.DefaultTreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.IndexJungleTreeEditor;
@@ -26,107 +29,81 @@
 
 public class DeleteChildrenIndexTest {
 
-  @Test
-  public void DeleteChildrenTest() {
-    Jungle jungle = new DefaultJungle(null, "hogehoge", new DefaultTreeEditor(new DefaultTraverser()));
-    jungle.createNewTree("tree");
-    JungleTree tree = jungle.getTreeByName("tree");
-    createTree(tree);
-    tree.getRootNode();
-    InterfaceTraverser ifTraverser = tree.getTraverser();
-
-    Iterator<Pair<TreeNode, NodePath>> pairIterator = ifTraverser.find((TreeNode node) -> {
-      List<ByteBuffer> attributeList = node.getAttributes().get(key);
-      if (attributeList.isNotEmpty()) {
-        for (ByteBuffer attribute : attributeList) {
-          byte[] byteAttribute = attribute.array();
-          String str = new String(byteAttribute);
-          System.out.println("attribute = " + str);
-          if (str.equals("<-1,0,1>"))
-            return true;          
-          continue;
-        }
-      }
-      return false;
-    }, key, "<-1,0,1>");
+	@Test
+	public void DeleteChildrenTest(){
+		Jungle jungle = new DefaultJungle(null, "hogehoge",new DefaultTraverser());
+		jungle.createNewTree("tree");
+		JungleTree tree = jungle.getTreeByName("tree");
+		createTree(tree);
+		tree.getRootNode();
+		InterfaceTraverser ifTraverser = tree.getTraverser();
 
-    for (; pairIterator.hasNext(); pairIterator.next()) {
-
-    }
-    // check index
-    ifTraverser.commitIndex();
-    TreeMap<String, TreeMap<String, List<NodePath>>> index = ifTraverser.getIndex();
-    Assert.assertTrue(index.get(key).some().get("<-1,0,0>").isSome());
-
-    IndexJungleTreeEditor editor = tree.getIndexTreeEditor();
-    Either<Error, JungleTreeEditor> either = editor.deleteChildAt(new DefaultNodePath().add(0), 0);
-    either.b().success();
-
-    InterfaceTraverser newIfTraverser = tree.getTraverser();
-    TreeMap<String, TreeMap<String, List<NodePath>>> newIndex = newIfTraverser.getIndex();
-    NodePath targetPath = newIndex.get(key).some().get("<-1,0,1>").some().head();
-    TreeNode targetNode = getTarget(tree.getRootNode(), targetPath);
-    Iterator<String> attributeIterator = targetNode.getAttributes().getString(key);
-    Assert.assertTrue(attributeIterator.hasNext());
-    String attribute = attributeIterator.next();
-    Assert.assertEquals(attribute, "<-1,0,2>");
-
-  }
-
-  public static String key = "KEY";
-  public static DefaultTreeNode factory = new DefaultTreeNode();
+		Iterator<Pair<TreeNode, NodePath>> pairIterator = ifTraverser.find((TreeNode node) -> {
+			ByteBuffer attribute = node.getAttributes().get(key);
+			if (attribute != null) {
+				byte[] byteAttribute = attribute.array();
+				String str = new String(byteAttribute);
+				System.out.println("attribute = " + str);
+				return str.equals("<-1,0,1>");
+			}
+			return false;
+		}, key, "<-1,0,1>");
 
-  public void createTree(JungleTree tree) {
-    NodePath root = new DefaultNodePath();
-    createChildren(tree, root, 0);
+		 for (;pairIterator.hasNext();pairIterator.next()) {
+			 
+		 }
+		//check index
+		ifTraverser.commitIndex();
+		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index = ifTraverser.getIndex();
+		Assert.assertTrue(index.get(key).some().get("<-1,0,0>").isSome());
+		
+		IndexJungleTreeEditor editor = tree.getIndexTreeEditor();
+		Either<Error, JungleTreeEditor> either = editor.deleteChildAt(new DefaultNodePath().add(0), 0);
+		either.b().success();
+		
+		InterfaceTraverser newIfTraverser = tree.getTraverser();
+		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = newIfTraverser.getIndex();
+		Assert.assertEquals(newIndex.get(key).some().get("<-1,0,1>").some().head().right().toString(),"<-1,0,0>");
+		
+		}
+	public static String key = "KEY";
+	public static DefaultTreeNode factory = new DefaultTreeNode();
 
-    for (int x = 0; x < 3; x++) {
-      createChildren(tree, root.add(0), x);
-      for (int y = 0; y < 3; y++) {
-        createChildren(tree, root.add(0).add(x), y);
-      }
-    }
-
-  }
+	public void createTree(JungleTree tree) {
+		NodePath root = new DefaultNodePath();
+		createChildren(tree, root, 0);
 
-  public void createChildren(JungleTree tree, NodePath root, int num) {
-    JungleTreeEditor editor = tree.getTreeEditor();// Treeのeditorを作成
-    Either<Error, JungleTreeEditor> either = editor.addNewChildAt(root, num); // 新しく入れるところへのパス
-    if (either.isA()) {
-      Assert.fail();
-    }
-    editor = either.b();
-    either = editor.success();
-    if (either.isA()) {
-      Assert.fail();
-    }
-    NodePath childPath = root.add(num);
-    editor = tree.getTreeEditor();
-    NodePath attribute = root.add(num);
-    System.out.println(attribute.toString());
-    either = editor.putAttribute(childPath, key, ByteBuffer.wrap(attribute.toString().getBytes()));
-    if (either.isA()) {
-      Assert.fail();
-    }
-    editor = either.b();
-    either = editor.success();
-  }
+		for (int x = 0; x < 3; x++) {
+			createChildren(tree, root.add(0), x);
+			for (int y = 0; y < 3; y++) {
+				createChildren(tree, root.add(0).add(x), y);
+			}
+		}
+
+	}
 
-  public TreeNode getTarget(TreeNode node, NodePath path) {
-    Pair<Integer, NodePath> removeHeadPath = path.pop();
-
-    if (removeHeadPath.left() == -1)
-      return getTarget(node, removeHeadPath.right());
-
-    Either<Error, TreeNode> either = node.getChildren().at(removeHeadPath.left());
-    if (either.isA())
-      return node;
-
-    TreeNode child = either.b();
-    if (removeHeadPath.right().size() == 0)
-      return child;
-
-    TreeNode target = getTarget(child, removeHeadPath.right());
-    return target;
-  }
+	public void createChildren(JungleTree tree, NodePath root, int num) {
+		JungleTreeEditor editor = tree.getTreeEditor();// Treeのeditorを作成
+		Either<Error, JungleTreeEditor> either = editor
+				.addNewChildAt(root, num); // 新しく入れるところへのパス
+		if (either.isA()) {
+			Assert.fail();
+		}
+		editor = either.b();
+		either = editor.success();
+		if (either.isA()) {
+			Assert.fail();
+		}
+		NodePath childPath = root.add(num);
+		editor = tree.getTreeEditor();
+		NodePath attribute = root.add(num);
+		System.out.println(attribute.toString());
+		either = editor.putAttribute(childPath, key,
+				ByteBuffer.wrap(attribute.toString().getBytes()));
+		if (either.isA()) {
+			Assert.fail();
+		}
+		editor = either.b();
+		either = editor.success();
+	}
 }
diff -r 0854f9a9e81d -r a2c374a2686b src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/IndexCommitTest.java
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/IndexCommitTest.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/IndexCommitTest.java	Fri Nov 21 12:49:28 2014 +0900
@@ -1,5 +1,7 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.index;
 
+import java.util.Iterator;
+
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
@@ -7,11 +9,13 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
+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.transaction.DefaultTreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
 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.Pair;
 import junit.framework.Assert;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
 
@@ -25,119 +29,111 @@
 
 public class IndexCommitTest {
 
-  @Test
-  public void IndexCommitTest() throws InterruptedException {
-
-    Jungle jungle = new DefaultJungle(null, "hogehoge", new DefaultTreeEditor(new DefaultTraverser()));
-    jungle.createNewTree("tree");
-    JungleTree tree = jungle.getTreeByName("tree");
-    createTree(tree);
-    tree.getRootNode();
-    InterfaceTraverser ifTraverser = tree.getTraverser();
+	@Test
+	public void IndexCommitTest() throws InterruptedException {
+		
+		Jungle jungle = new DefaultJungle(null, "hogehoge",new DefaultTraverser());
+		jungle.createNewTree("tree");
+		JungleTree tree = jungle.getTreeByName("tree");
+		createTree(tree);
+		tree.getRootNode();
+		InterfaceTraverser ifTraverser = tree.getTraverser();
 
-    ifTraverser.find((TreeNode node) -> {
-      List<ByteBuffer> attributeList = node.getAttributes().get(key);
-      if (attributeList.isNotEmpty()) {
-        for (ByteBuffer attribute : attributeList) {
-          byte[] byteAttribute = attribute.array();
-          String str = new String(byteAttribute);
-          System.out.println("attribute = " + str);
-          if (str.equals("<-1,0,1>"))
-            return true;
-          continue;
-        }
-      }
-      return false;
-    }, key, "<-1,0,1>");
+		 ifTraverser.find((TreeNode node) -> {
+			ByteBuffer attribute = node.getAttributes().get(key);
+			if (attribute != null) {
+				byte[] byteAttribute = attribute.array();
+				String str = new String(byteAttribute);
+				System.out.println("attribute = " + str);
+				return str.equals("<-1,0,1>");
+			}
+			return false;
+		}, key, "<-1,0,1>");
 
-    // check index
-    TreeMap<String, TreeMap<String, List<NodePath>>> index = ifTraverser.getIndex();
-    Option<TreeMap<String, List<NodePath>>> opIndex = index.get(key);
-
-    Assert.assertTrue(!opIndex.isNone());
-
-    TreeMap<String, List<NodePath>> innerIndex = opIndex.some();
-    Assert.assertTrue(!innerIndex.get("<-1,0,0>").isNone());
+		//check index
+		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index = ifTraverser.getIndex();
+		Option<TreeMap<String, List<Pair<TreeNode, NodePath>>>> opIndex = index.get(key);
+		Assert.assertTrue(!opIndex.isNone());
+		TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = opIndex.some();
+		Assert.assertTrue(!innerIndex.get("<-1,0,0>").isNone());
 
-    JungleTreeEditor editor = tree.getTreeEditor();
-    Either<Error, JungleTreeEditor> either = editor.addNewChildAt(new DefaultNodePath(), 0);
-    editor = either.b();
-    editor.success();
-
-    ifTraverser.commitIndex();
-    JungleTree newTree = jungle.getTreeByName("tree");
-    InterfaceTraverser newIfTraverser = newTree.getTraverser();
-    TreeMap<String, TreeMap<String, List<NodePath>>> newIndex = newIfTraverser.getIndex();
-    Assert.assertTrue(newIndex.isEmpty());
-
-    InterfaceTraverser ifTraverser1 = tree.getTraverser();
+		JungleTreeEditor editor = tree.getTreeEditor();
+		Either<Error, JungleTreeEditor> either = editor.addNewChildAt(new DefaultNodePath(), 0);
+		editor = either.b();
+		editor.success();
+		
+		ifTraverser.commitIndex();
+		JungleTree newTree = jungle.getTreeByName("tree");
+		InterfaceTraverser newIfTraverser = newTree.getTraverser();
+		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = newIfTraverser.getIndex();
+		Assert.assertTrue(newIndex.isEmpty());
+		
+		InterfaceTraverser ifTraverser1= tree.getTraverser();
 
-    ifTraverser1.find((TreeNode node) -> {
-      List<ByteBuffer> attributeList = node.getAttributes().get(key);
-      if (attributeList.isNotEmpty()) {
-        for (ByteBuffer attribute : attributeList) {
-          byte[] byteAttribute = attribute.array();
-          String str = new String(byteAttribute);
-          System.out.println("attribute = " + str);
-          if (str.equals("<-1,0,1>"))
-            return true;
-          continue;
-        }
-      }
-      return false;
-    }, key, "<-1,0,1>");
+		 ifTraverser1.find((TreeNode node) -> {
+			ByteBuffer attribute = node.getAttributes().get(key);
+			if (attribute != null) {
+				byte[] byteAttribute = attribute.array();
+				String str = new String(byteAttribute);
+				System.out.println("attribute = " + str);
+				return str.equals("<-1,0,1>");
+			}
+			return false;
+		}, key, "<-1,0,1>");
+		 
+		ifTraverser1.commitIndex();
+		JungleTree newTree2 = jungle.getTreeByName("tree");
+		InterfaceTraverser newIfTraverser2 = newTree2.getTraverser();
+		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex1 = newIfTraverser2.getIndex();
+		Assert.assertFalse(newIndex1.isEmpty());
 
-    ifTraverser1.commitIndex();
-    JungleTree newTree2 = jungle.getTreeByName("tree");
-    InterfaceTraverser newIfTraverser2 = newTree2.getTraverser();
-    TreeMap<String, TreeMap<String, List<NodePath>>> newIndex1 = newIfTraverser2.getIndex();
-    Assert.assertFalse(newIndex1.isEmpty());
-
-  }
+	}
 
-  public boolean compare(TreeNode compareNode, String compareAttribute) {
-    String labName = compareNode.getAttributes().getString(key).next();
-    if (labName.equals(compareAttribute))
-      return true;
-    return false;
-  }
+	public boolean compare(TreeNode compareNode, String compareAttribute) {
+		String labName = compareNode.getAttributes().getString(key);
+		if (labName.equals(compareAttribute))
+			return true;
+		return false;
+	}
 
-  public static String key = "KEY";
-  public static DefaultTreeNode factory = new DefaultTreeNode();
+	public static String key = "KEY";
+	public static DefaultTreeNode factory = new DefaultTreeNode();
+
+	public void createTree(JungleTree tree) {
+		NodePath root = new DefaultNodePath();
+		createChildren(tree, root, 0);
 
-  public void createTree(JungleTree tree) {
-    NodePath root = new DefaultNodePath();
-    createChildren(tree, root, 0);
+		for (int x = 0; x < 2; x++) {
+			createChildren(tree, root.add(0), x);
+			for (int y = 0; y < 2; y++) {
+				createChildren(tree, root.add(0).add(x), y);
+			}
+		}
 
-    for (int x = 0; x < 2; x++) {
-      createChildren(tree, root.add(0), x);
-      for (int y = 0; y < 2; y++) {
-        createChildren(tree, root.add(0).add(x), y);
-      }
-    }
-
-  }
+	}
 
-  public void createChildren(JungleTree tree, NodePath root, int num) {
-    JungleTreeEditor editor = tree.getTreeEditor();// Treeのeditorを作成
-    Either<Error, JungleTreeEditor> either = editor.addNewChildAt(root, num); // 新しく入れるところへのパス
-    if (either.isA()) {
-      Assert.fail();
-    }
-    editor = either.b();
-    either = editor.success();
-    if (either.isA()) {
-      Assert.fail();
-    }
-    NodePath childPath = root.add(num);
-    editor = tree.getTreeEditor();
-    NodePath attribute = root.add(num);
-    System.out.println(attribute.toString());
-    either = editor.putAttribute(childPath, key, ByteBuffer.wrap(attribute.toString().getBytes()));
-    if (either.isA()) {
-      Assert.fail();
-    }
-    editor = either.b();
-    either = editor.success();
-  }
+	public void createChildren(JungleTree tree, NodePath root, int num) {
+		JungleTreeEditor editor = tree.getTreeEditor();// Treeのeditorを作成
+		Either<Error, JungleTreeEditor> either = editor
+				.addNewChildAt(root, num); // 新しく入れるところへのパス
+		if (either.isA()) {
+			Assert.fail();
+		}
+		editor = either.b();
+		either = editor.success();
+		if (either.isA()) {
+			Assert.fail();
+		}
+		NodePath childPath = root.add(num);
+		editor = tree.getTreeEditor();
+		NodePath attribute = root.add(num);
+		System.out.println(attribute.toString());
+		either = editor.putAttribute(childPath, key,
+				ByteBuffer.wrap(attribute.toString().getBytes()));
+		if (either.isA()) {
+			Assert.fail();
+		}
+		editor = either.b();
+		either = editor.success();
+	}
 }
diff -r 0854f9a9e81d -r a2c374a2686b src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/ParentIndexTest.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/ParentIndexTest.java	Fri Nov 21 12:49:28 2014 +0900
@@ -0,0 +1,60 @@
+package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.index;
+
+import java.nio.ByteBuffer;
+import java.util.Iterator;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
+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 junit.framework.Assert;
+
+import org.junit.Test;
+
+import fj.data.List;
+import fj.data.Option;
+import fj.data.TreeMap;
+
+public class ParentIndexTest {
+
+  @Test
+  public void testParentIndex() {
+    Jungle jungle = new DefaultJungle(null, "hogehoge", new DefaultTraverser());
+    jungle.createNewTree("tree");
+    JungleTree tree = jungle.getTreeByName("tree");
+    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();
+    }
+    
+    TreeMap<TreeNode, TreeNode> parentIndex = tree.getParentIndex();
+    TreeNode node = tree.getRootNode();
+    for (int num = 0; node.getChildren().size() != 0; num++) {
+      Iterator<TreeNode> children = node.getChildren().iterator();
+      for (; children.hasNext();) {
+        TreeNode child = children.next();
+        TreeNode parent = parentIndex.get(child).some();
+        Assert.assertEquals(parent, node);
+      }
+      node = node.getChildren().at(num).b();
+    }
+
+    JungleTree oldTree = tree.getOldTree(tree.revision() - 1).b();
+    TreeNode oldRoot = oldTree.getRootNode();
+    TreeNode oldNode = oldRoot.getChildren().at(0).b();
+    Option<TreeNode> oldParentOp = parentIndex.get(oldNode);
+    Assert.assertTrue(oldParentOp.isNone());
+    TreeMap<TreeNode, TreeNode> oldTreeParentIndex = oldTree.getParentIndex();
+    oldParentOp = oldTreeParentIndex.get(oldNode);
+    Assert.assertTrue(oldParentOp.isSome());
+        
+  }
+}
diff -r 0854f9a9e81d -r a2c374a2686b src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/query/SearchQueryTest.java
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/query/SearchQueryTest.java	Sun Nov 16 06:40:48 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/query/SearchQueryTest.java	Fri Nov 21 12:49:28 2014 +0900
@@ -10,6 +10,7 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
+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.transaction.DefaultTreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
@@ -29,7 +30,7 @@
 
   @Test
 	public void SearchQueryTest() {
-		Jungle jungle = new DefaultJungle(null, "hogehoge",new DefaultTreeEditor(new DefaultTraverser()));
+		Jungle jungle = new DefaultJungle(null, "hogehoge",new DefaultTraverser());
 		jungle.createNewTree("tree");
 		JungleTree tree = jungle.getTreeByName("tree");
 		createTree(tree);