changeset 143:afbe19c98f53

change Index form TreeMap<String,TreeMap<String<List<Pair<TreeNode,NodePath>>>> → TreeMap<String,TreeMap<String<List<NodePath>>> bag
author one
date Sat, 15 Nov 2014 17:48:07 +0900
parents ef183969bf31
children 0854f9a9e81d
files src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTree.java src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/ChangeSet.java src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultChangeSet.java src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultJungleTreeEditor.java src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeChildren.java src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/IndexJungleTreeEditor.java src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/TransactionManager.java src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/AddNewChildrenIndexEditor.java src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DefaultIndexEditor.java src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DeleteChildIndexEditor.java src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DeleteIndexEditor.java src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexEditor.java src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexManager.java src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/PutIndexEditor.java src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/GetOldTreeTest.java src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/functionaljava/FjListTest.java src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/AddChildrenIndexTest.java src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/AttributeIndexTest.java src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/DeleteChildrenIndexTest.java src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/IndexCommitTest.java src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/query/SearchQueryTest.java
diffstat 25 files changed, 455 insertions(+), 289 deletions(-) [+]
line wrap: on
line diff
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java	Sat Nov 15 17:48:07 2014 +0900
@@ -14,7 +14,6 @@
 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.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;
@@ -22,7 +21,6 @@
 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;
 
 public class DefaultJungle implements Jungle
 {
@@ -82,7 +80,7 @@
 		};
 		
 		DefaultTreeNode root = new DefaultTreeNode();
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index = TreeMap.empty(Ord.stringOrd);
+		TreeMap<String, TreeMap<String, List<NodePath>>> index = TreeMap.empty(Ord.stringOrd);
 		ChangeSet set = new DefaultChangeSet(root,null,list,uuid,name,0,index);
 		DefaultTreeContext tc = new DefaultTreeContext(root,set);
 		JungleTree newTree = new DefaultJungleTree(tc,uuid,journal.getWriter(),editor);
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java	Sat Nov 15 17:48:07 2014 +0900
@@ -41,7 +41,7 @@
     TreeContext tc = repository.get();
     DefaultTransactionManager txManager = new DefaultTransactionManager(writer, tc, repository, uuid);
     TreeNode root = tc.getTreeNode();
-    TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index = getIndex();
+    TreeMap<String, TreeMap<String, List<NodePath>>> index = getIndex();
     return new DefaultJungleTreeEditor(root, txManager, editor, index);
   }
 
@@ -50,7 +50,7 @@
     TreeContext tc = repository.get();
     DefaultTransactionManager txManager = new DefaultTransactionManager(writer, tc, repository, uuid);
     TreeNode root = tc.getTreeNode();
-    TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = getIndex();
+    TreeMap<String, TreeMap<String, List<NodePath>>> newIndex = getIndex();
     return new IndexJungleTreeEditor(root, txManager, editor, newIndex);
   }
 
@@ -70,14 +70,14 @@
   public InterfaceTraverser getTraverser() {
     AtomicReservableReference<TreeContext>.Reservation reservation = repository.getReservation();
     IndexManager indexManager = new IndexManager(reservation);
-    TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index = getIndex();
+    TreeMap<String, TreeMap<String, List<NodePath>>> index = getIndex();
     if (index != null)
       return new InterfaceTraverser(getRootNode(), index, indexManager);
     return new InterfaceTraverser(getRootNode(), indexManager);
   }
 
   @Override
-  public TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> getIndex() {
+  public TreeMap<String, TreeMap<String, List<NodePath>>> getIndex() {
     TreeContext tc = repository.get();
     ChangeSet cs = tc.getChangeSet();
     return cs.getIndex();
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTree.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTree.java	Sat Nov 15 17:48:07 2014 +0900
@@ -10,7 +10,6 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
 
 public interface JungleTree
 {
@@ -18,7 +17,7 @@
 	public InterfaceTraverser getTraverser();
 	public JungleTreeEditor getLocalTreeEditor();
 	public TreeNode getRootNode();
-	public TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> getIndex();
+	public TreeMap<String, TreeMap<String, List<NodePath>>> getIndex();
 	public IndexJungleTreeEditor getIndexTreeEditor();
 	public Iterable<TreeOperation> getLog();
   public long revision();
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/ChangeSet.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/ChangeSet.java	Sat Nov 15 17:48:07 2014 +0900
@@ -21,6 +21,6 @@
 	public String getTreeName();
 	public long revision();
 	
-	public TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> getIndex();
+	public TreeMap<String, TreeMap<String, List<NodePath>>> getIndex();
 	public Iterable<TreeOperation> getOperations();
 }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultChangeSet.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultChangeSet.java	Sat Nov 15 17:48:07 2014 +0900
@@ -17,9 +17,9 @@
 	private final String uuid;
 	private final String treeName;
 	private final long revision; 
-	private final TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index;
+	private final 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<Pair<TreeNode, NodePath>>>> index)
+	public DefaultChangeSet(TreeNode _node,ChangeSet _prev,ChangeList _log,String _uuid, String _treeName, long _revision, TreeMap<String, TreeMap<String, List<NodePath>>> index)
 	{
 		this.root = _node;
 		this.previous = _prev;
@@ -74,7 +74,7 @@
 	}
 
 	@Override
-	public TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> getIndex() {
+	public TreeMap<String, TreeMap<String, List<NodePath>>> getIndex() {
 		return index;
 	}
 
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultJungleTreeEditor.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultJungleTreeEditor.java	Sat Nov 15 17:48:07 2014 +0900
@@ -32,20 +32,20 @@
 	private final TreeNode root;
 	private final TreeEditor editor;
 	private final TreeOperationLog log;
-	private final TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index;
+	private final TreeMap<String, TreeMap<String, List<NodePath>>> index;
 //	public DefaultJungleTreeEditor(TreeNode root)
 //	{
 //	    this(root,txManager,_editor,new DefaultTreeOperationLog());
 //	}
 
-	public DefaultJungleTreeEditor(TreeNode _root,TransactionManager _txManager,TreeEditor _editor,	TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index)
+	public DefaultJungleTreeEditor(TreeNode _root,TransactionManager _txManager,TreeEditor _editor,	TreeMap<String, TreeMap<String, List<NodePath>>> index)
 	{
 		this(_root,_txManager,_editor,new DefaultTreeOperationLog(),index);
 	}
 	
 	
 	
-	public DefaultJungleTreeEditor(TreeNode newNode,TransactionManager _txManager,TreeEditor _editor,TreeOperationLog _log,	TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index)
+	public DefaultJungleTreeEditor(TreeNode newNode,TransactionManager _txManager,TreeEditor _editor,TreeOperationLog _log,	TreeMap<String, TreeMap<String, List<NodePath>>> index)
 	{
 		this.root = newNode;
 		this.txManager = _txManager;
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java	Sat Nov 15 17:48:07 2014 +0900
@@ -17,7 +17,6 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultError;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
 
 public class DefaultTransactionManager implements TransactionManager
 {
@@ -36,7 +35,7 @@
 	}
 	
 	@Override
-	public Either<Error,TransactionManager> commit(TreeNode _newRoot,final TreeOperationLog _log, TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index)
+	public Either<Error,TransactionManager> commit(TreeNode _newRoot,final TreeOperationLog _log, TreeMap<String, TreeMap<String, List<NodePath>>> index)
 	{
 		ChangeSet cs = tip.getChangeSet();
 		long currentRevision = cs.revision();
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeChildren.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeChildren.java	Sat Nov 15 17:48:07 2014 +0900
@@ -52,6 +52,7 @@
 	public List<TreeNode> getChildrenAsRawList(){
 		return children;
 	}
+	
 	@Override
 	public Either<Error,TreeNode> addNewChildAt(int _pos)
 	{
@@ -111,8 +112,7 @@
 	@Override
 	public Either<Error,TreeNode> at(int _pos)
 	{
-	  System.out.println(children.length());
-    if(children.length() < _pos + 1){
+    if(!boundaryCheck(_pos)){
       return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
     }
 
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/IndexJungleTreeEditor.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/IndexJungleTreeEditor.java	Sat Nov 15 17:48:07 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;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.AddNewChildrenIndexEditor;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.DefaultIndexEditor;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.DeleteChildIndexEditor;
@@ -38,28 +37,28 @@
 	private final TreeNode root;
 	private final TreeEditor editor;
 	private final TreeOperationLog log;
-	private TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index;
+	private TreeMap<String, TreeMap<String, List<NodePath>>> index;
 	
 //	public DefaultJungleTreeEditor(TreeNode root)
 //	{
 //	    this(root,txManager,_editor,new DefaultTreeOperationLog());
 //	}
 
-	public TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> getIndex() {
+	public TreeMap<String, TreeMap<String, List<NodePath>>> getIndex() {
 		return index;
 	}
 
 	public void setIndex(
-			TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index) {
+			TreeMap<String, TreeMap<String, List<NodePath>>> index) {
 		this.index = index;
 	}
 
-	public IndexJungleTreeEditor(TreeNode _root,TransactionManager _txManager,TreeEditor _editor, TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index)
+	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<Pair<TreeNode, NodePath>>>> index)
+	public IndexJungleTreeEditor(TreeNode newNode,TransactionManager _txManager,TreeEditor _editor,TreeOperationLog _log, TreeMap<String, TreeMap<String, List<NodePath>>> index)
 	{
 		this.root = newNode;
 		this.txManager = _txManager;
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/TransactionManager.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/TransactionManager.java	Sat Nov 15 17:48:07 2014 +0900
@@ -7,11 +7,10 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
 
 public interface TransactionManager
 {
-	public Either<Error,TransactionManager> commit(TreeNode _newRoot,TreeOperationLog _log,	TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index);
+	public Either<Error,TransactionManager> commit(TreeNode _newRoot,TreeOperationLog _log,	TreeMap<String, TreeMap<String, List<NodePath>>> index);
 	public String getUUID();
 	public long getRevision();
 }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java	Sat Nov 15 17:48:07 2014 +0900
@@ -11,6 +11,8 @@
 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;
@@ -20,7 +22,7 @@
 
   // InterfaceTraverser traverser;
   TreeNode node;
-  TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index;
+  TreeMap<String, TreeMap<String, List<NodePath>>> index;
   IndexManager indexManager;
 
   public InterfaceTraverser(TreeNode _root, IndexManager indexManager) {
@@ -29,7 +31,7 @@
     this.indexManager = indexManager;
   }
 
-  public InterfaceTraverser(TreeNode _root, TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index,
+  public InterfaceTraverser(TreeNode _root, TreeMap<String, TreeMap<String, List<NodePath>>> index,
       IndexManager indexManager) {
     this.node = _root;
     this.index = index;
@@ -40,11 +42,11 @@
     indexManager.commit(index);
   }
 
-  public TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> getIndex() {
+  public TreeMap<String, TreeMap<String, List<NodePath>>> getIndex() {
     return index;
   }
 
-  public void setIndex(TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index) {
+  public void setIndex(TreeMap<String, TreeMap<String, List<NodePath>>> index) {
     this.index = index;
   }
 
@@ -66,26 +68,42 @@
 
     if (index.get(key).isSome()) {
 
-      TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = this.index.get(key).some();
+      TreeMap<String, List<NodePath>> innerIndex = this.index.get(key).some();
 
-      Option<List<Pair<TreeNode, NodePath>>> opList = innerIndex.get(searchValue);
+      Option<List<NodePath>> opList = innerIndex.get(searchValue);
 
       if (opList.isNone())
         return new NulIterator<Pair<TreeNode, NodePath>>();// 空のIteratorを返す
 
-      List<Pair<TreeNode, NodePath>> list = opList.some();
+      List<NodePath> list = opList.some();
       NodePath targetNodePath = subTree.right();
-      List<Pair<TreeNode, NodePath>> filteredList = List.nil();
+
+      return new Iterator<Pair<TreeNode, NodePath>>() {
 
-      for (Pair<TreeNode, NodePath> pair : list) {
-        NodePath compareNodePath = pair.right();
-        if (targetNodePath.compare(compareNodePath))
-          filteredList = filteredList.cons(pair);
-      }
+        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;
+        }
 
-      return filteredList.iterator();
+        @Override
+        public Pair<TreeNode, NodePath> next() {
+          TreeNode targetNode = getTarget(node, path);
+          Pair<TreeNode, NodePath> targetPair = new Pair<TreeNode, NodePath>(targetNode, path);
+          return targetPair;
+        }
+
+      };
 
     } else {
+
       final PathNodeIterator itNode = new PathNodeIterator(subTree);
       return new Iterator<Pair<TreeNode, NodePath>>() {
 
@@ -144,26 +162,50 @@
 
     if (index.get(key).isSome()) {
 
-      TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = this.index.get(key).some();
-      List<String> searchValues = innerIndex.keys();
-      List<Pair<TreeNode, NodePath>> filteredList = List.nil();
+      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();
+
+      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>>() {
 
-      for (String searchValue : searchValues) {
-        Option<List<Pair<TreeNode, NodePath>>> opList = innerIndex.get(searchValue);
+        List<NodePath> pathList = List.nil();
+        NodePath path;
 
-        if (opList.isNone())
-          continue;
+        @Override
+        public boolean hasNext() {
+          if (!pathList.isEmpty()) {
+            path = pathList.head();
+            pathList = pathList.tail();
+            if (targetNodePath.compare(path))
+              return true;
+            return this.hasNext();
+          }
 
-        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);
+          if (searchValueIterator.hasNext()) {
+            pathList = searchValueIterator.next()._2();
+            path = pathList.head();
+            pathList = pathList.tail();
+            
+            if (targetNodePath.compare(path))
+              return true;
+            return this.hasNext();
+          }
+          return false;
+        }
 
+        @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);
@@ -208,14 +250,36 @@
 
     if (index.get(key).isSome()) {
 
-      TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = this.index.get(key).some();
-      Option<List<Pair<TreeNode, NodePath>>> opList = innerIndex.get(searchValue);
+      TreeMap<String, List<NodePath>> innerIndex = this.index.get(key).some();
+      Option<List<NodePath>> opList = innerIndex.get(searchValue);
 
       if (opList.isNone())
         return new NulIterator<Pair<TreeNode, NodePath>>();// 空のIteratorを返す
 
-      final List<Pair<TreeNode, NodePath>> list = opList.some();
-      return list.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;
+        }
+      };
 
     } else {
       Pair<TreeNode, NodePath> pair = new Pair<TreeNode, NodePath>(node, new DefaultNodePath());
@@ -229,32 +293,32 @@
           for (; itNode.hasNext();) {
             Pair<TreeNode, NodePath> pathNode = itNode.next();
             String value = pathNode.left().getAttributes().getString(key);
-            Option<TreeMap<String, List<Pair<TreeNode, NodePath>>>> innerIndexOp = index.get(key);
+            Option<TreeMap<String, List<NodePath>>> innerIndexOp = index.get(key);
 
             if (value != null) {
               if (innerIndexOp.isNone()) {
 
-                TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = TreeMap.empty(Ord.stringOrd);
-                List<Pair<TreeNode, NodePath>> list = List.nil();
-                list = list.cons(pathNode);
+                TreeMap<String, List<NodePath>> innerIndex = TreeMap.empty(Ord.stringOrd);
+                List<NodePath> list = List.nil();
+                list = list.cons(pathNode.right());
                 innerIndex = innerIndex.set(value, list);
                 index = index.set(key, innerIndex);
 
               } else {
 
-                TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = innerIndexOp.some();
-                Option<List<Pair<TreeNode, NodePath>>> opList = innerIndex.get(value);
+                TreeMap<String, List<NodePath>> innerIndex = innerIndexOp.some();
+                Option<List<NodePath>> opList = innerIndex.get(value);
 
                 if (opList.isNone()) {
 
-                  List<Pair<TreeNode, NodePath>> list = List.nil();
-                  list = list.cons(pathNode);
+                  List<NodePath> list = List.nil();
+                  list = list.cons(pathNode.right());
                   innerIndex = innerIndex.set(value, list);
 
                 } else {
 
-                  List<Pair<TreeNode, NodePath>> list = opList.some();
-                  list = list.cons(pathNode);
+                  List<NodePath> list = opList.some();
+                  list = list.cons(pathNode.right());
                   innerIndex = innerIndex.set(value, list);
 
                 }
@@ -297,20 +361,38 @@
 
     if (index.get(key).isSome()) {
 
-      TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = this.index.get(key).some();
-      List<String> searchValues = innerIndex.keys();
-      List<Pair<TreeNode, NodePath>> valueList = List.nil();
+      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;
 
-      for (String searchValue : searchValues) {
-        Option<List<Pair<TreeNode, NodePath>>> opList = innerIndex.get(searchValue);
+        @Override
+        public boolean hasNext() {
+          if (!pathList.isEmpty()) {
+            targetPath = pathList.head();
+            pathList = pathList.tail();
+            return true;
+          }
 
-        if (opList.isNone())
-          continue;
+          if (searchValueIterator.hasNext()) {
+            pathList = searchValueIterator.next()._2();
+            targetPath = pathList.head();
+            pathList = pathList.tail();
+            return true;
+          }
+          return false;
+        }
 
-        List<Pair<TreeNode, NodePath>> list = opList.some();
-        valueList = valueList.append(list);
-      }
-      return valueList.iterator();
+        @Override
+        public Pair<TreeNode, NodePath> next() {
+          TreeNode targetNode = getTarget(node, targetPath);
+          Pair<TreeNode, NodePath> targetPair = new Pair<TreeNode, NodePath>(targetNode, targetPath);
+          return targetPair;
+        }
+      };
 
     } else {
       Pair<TreeNode, NodePath> pair = new Pair<TreeNode, NodePath>(node, new DefaultNodePath());
@@ -324,32 +406,32 @@
           for (; itNode.hasNext();) {
             Pair<TreeNode, NodePath> pathNode = itNode.next();
             String value = pathNode.left().getAttributes().getString(key);
-            Option<TreeMap<String, List<Pair<TreeNode, NodePath>>>> innerIndexOp = index.get(key);
+            Option<TreeMap<String, List<NodePath>>> innerIndexOp = index.get(key);
 
             if (value != null) {
               if (innerIndexOp.isNone()) {
 
-                TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = TreeMap.empty(Ord.stringOrd);
-                List<Pair<TreeNode, NodePath>> list = List.nil();
-                list = list.cons(pathNode);
+                TreeMap<String, List<NodePath>> innerIndex = TreeMap.empty(Ord.stringOrd);
+                List<NodePath> list = List.nil();
+                list = list.cons(pathNode.right());
                 innerIndex = innerIndex.set(value, list);
                 index = index.set(key, innerIndex);
 
               } else {
 
-                TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = innerIndexOp.some();
-                Option<List<Pair<TreeNode, NodePath>>> opList = innerIndex.get(value);
+                TreeMap<String, List<NodePath>> innerIndex = innerIndexOp.some();
+                Option<List<NodePath>> opList = innerIndex.get(value);
 
                 if (opList.isNone()) {
 
-                  List<Pair<TreeNode, NodePath>> list = List.nil();
-                  list = list.cons(pathNode);
+                  List<NodePath> list = List.nil();
+                  list = list.cons(pathNode.right());
                   innerIndex = innerIndex.set(value, list);
 
                 } else {
 
-                  List<Pair<TreeNode, NodePath>> list = opList.some();
-                  list = list.cons(pathNode);
+                  List<NodePath> list = opList.some();
+                  list = list.cons(pathNode.right());
                   innerIndex = innerIndex.set(value, list);
 
                 }
@@ -387,4 +469,22 @@
       };
     }
   }
+
+  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;
+  }
 }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/AddNewChildrenIndexEditor.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/AddNewChildrenIndexEditor.java	Sat Nov 15 17:48:07 2014 +0900
@@ -1,14 +1,9 @@
 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;
@@ -35,28 +30,28 @@
 			TransactionManager txManager,
 			TreeEditor editor,
 			TreeOperationLog log,
-			TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index) {
+			TreeMap<String, TreeMap<String, List<NodePath>>> index) {
 
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = editIndex(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<Pair<TreeNode, NodePath>>>> editIndex(
-			TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index) {
+	public TreeMap<String, TreeMap<String, List<NodePath>>> editIndex(
+			TreeMap<String, TreeMap<String, List<NodePath>>> index) {
 
 		if (!index.isEmpty()) {
 			List<String> keyList = index.keys();
-			TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = TreeMap.empty(Ord.stringOrd);
-			TreeMap<String, List<Pair<TreeNode, NodePath>>> newInnerIndex = TreeMap.empty(Ord.stringOrd);
+			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<Pair<TreeNode, NodePath>>> innerIndex = index.get(indexKey).some();
+				TreeMap<String, List<NodePath>> innerIndex = index.get(indexKey).some();
 				List<String> innerIndexKeyList = innerIndex.keys();
 
 				for (String innerIndexKey : innerIndexKeyList) {
-					List<Pair<TreeNode, NodePath>> pairList = innerIndex.get(innerIndexKey).some();
-					List<Pair<TreeNode, NodePath>> list = checkPath(pairList);
+					List<NodePath> pairList = innerIndex.get(innerIndexKey).some();
+					List<NodePath> list = checkPath(pairList);
 					if (!list.isEmpty()){
 						//System.out.println(new String(list.head().left().getAttributes().get("KEY").array()));
 						newInnerIndex = newInnerIndex.set(innerIndexKey, list);
@@ -70,18 +65,18 @@
 		}
 	}
 
-	public List<Pair<TreeNode, NodePath>> checkPath(List<Pair<TreeNode, NodePath>> pairList){
+	public List<NodePath> checkPath(List<NodePath> pairList){
 
-		List<Pair<TreeNode, NodePath>> list = List.nil();
-		for (Pair<TreeNode, NodePath> pair : pairList) {
+		List<NodePath> list = List.nil();
+		for (NodePath path : pairList) {
 
-			NodePath path = pair.right();
+	
 			//System.out.println("oldPath = " + path.toString());
 			NodePath newPath = new DefaultNodePath();
 			
 			
 			if (editNodePath.size() > path.size()) {
-				list = list.cons(pair);
+				list = list.cons(path);
 				continue;
 			}
 
@@ -113,8 +108,7 @@
 			}
 
 			//System.out.println("newPath = " + newPath.toString());
-			Pair<TreeNode, NodePath> newPair = new Pair<TreeNode, NodePath>(pair.left(), newPath);
-			list = list.cons(newPair);
+			list = list.cons(path);
 		}
 
 		return list;
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DefaultIndexEditor.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DefaultIndexEditor.java	Sat Nov 15 17:48:07 2014 +0900
@@ -2,7 +2,6 @@
 
 import fj.data.List;
 import fj.data.TreeMap;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
@@ -12,12 +11,11 @@
 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 DefaultIndexEditor implements IndexEditor {
 
 	@Override
-	public Either<Error, IndexJungleTreeEditor> edit(TreeNode root,TransactionManager txManager,TreeEditor editor,TreeOperationLog log,TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index) {
+	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;
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DeleteChildIndexEditor.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DeleteChildIndexEditor.java	Sat Nov 15 17:48:07 2014 +0900
@@ -35,30 +35,29 @@
 			TransactionManager txManager,
 			TreeEditor editor,
 			TreeOperationLog log,
-			TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index) {
+			TreeMap<String, TreeMap<String, List<NodePath>>> index) {
 
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = editIndex(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<Pair<TreeNode, NodePath>>>> editIndex(
-			TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index) {
+	public TreeMap<String, TreeMap<String, List<NodePath>>> editIndex(
+			TreeMap<String, TreeMap<String, List<NodePath>>> index) {
 
 		if (!index.isEmpty()) {
 			List<String> keyList = index.keys();
-			TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = TreeMap.empty(Ord.stringOrd);
-			TreeMap<String, List<Pair<TreeNode, NodePath>>> newInnerIndex = TreeMap.empty(Ord.stringOrd);
+			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<Pair<TreeNode, NodePath>>> innerIndex = index.get(indexKey).some();
+				TreeMap<String, List<NodePath>> innerIndex = index.get(indexKey).some();
 				List<String> innerIndexKeyList = innerIndex.keys();
 
 				for (String innerIndexKey : innerIndexKeyList) {
-					List<Pair<TreeNode, NodePath>> pairList = innerIndex.get(innerIndexKey).some();
-					List<Pair<TreeNode, NodePath>> list = checkPath(pairList);
+					List<NodePath> pairList = innerIndex.get(innerIndexKey).some();
+					List<NodePath> list = checkPath(pairList);
 					if (!list.isEmpty()){
-						System.out.println(new String(list.head().left().getAttributes().get("KEY").array()));
 						newInnerIndex = newInnerIndex.set(innerIndexKey, list);
 					}
 				}
@@ -70,12 +69,11 @@
 		}
 	}
 
-	public List<Pair<TreeNode, NodePath>> checkPath(List<Pair<TreeNode, NodePath>> pairList){
+	public List<NodePath> checkPath(List<NodePath> pairList){
 
-		List<Pair<TreeNode, NodePath>> list = List.nil();
-		for (Pair<TreeNode, NodePath> pair : pairList) {
+		List<NodePath> list = List.nil();
+		for (NodePath path : pairList) {
 
-			NodePath path = pair.right();
 			System.out.println("oldPath = " + path.toString());
 			NodePath newPath = new DefaultNodePath();
 			
@@ -84,7 +82,7 @@
 			}
 			
 			if (editNodePath.size() > path.size()) {
-				list = list.cons(pair);
+				list = list.cons(path);
 				continue;
 			}
 
@@ -115,9 +113,7 @@
 			}
 
 			System.out.println("newPath = " + newPath.toString());
-			Pair<TreeNode, NodePath> newPair = new Pair<TreeNode, NodePath>(
-					pair.left(), newPath);
-			list = list.cons(newPair);
+			list = list.cons(path);
 		}
 
 		return list;
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DeleteIndexEditor.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DeleteIndexEditor.java	Sat Nov 15 17:48:07 2014 +0900
@@ -32,48 +32,48 @@
 	}
 	
 	@Override
-	public Either<Error, IndexJungleTreeEditor> edit(TreeNode root,TransactionManager txManager,TreeEditor editor,TreeOperationLog log,TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index) {
+	public Either<Error, IndexJungleTreeEditor> edit(TreeNode root,TransactionManager txManager,TreeEditor editor,TreeOperationLog log,TreeMap<String, TreeMap<String, List<NodePath>>> index) {
 		NodePath newPath = path.pop().right();
 		TreeNode target = getTarget(node, newPath);
 		String attribute = target.getAttributes().getString(key);
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = editIndex(attribute, index);
+		TreeMap<String, TreeMap<String, List<NodePath>>> newIndex = editIndex(attribute, index);
 		IndexJungleTreeEditor newEditor = new IndexJungleTreeEditor(root,txManager,editor,log, newIndex);
 		Either<Error, IndexJungleTreeEditor> either = DefaultEither.newB(newEditor);
 		return either;
 	}
 	
-	public TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> editIndex(String attribute, TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index){
+	public TreeMap<String, TreeMap<String, List<NodePath>>> editIndex(String attribute, TreeMap<String, TreeMap<String, List<NodePath>>> index){
 	
-		Option<TreeMap<String, List<Pair<TreeNode, NodePath>>>> innerIndexOp = index.get(key);
+		Option<TreeMap<String, List<NodePath>>> innerIndexOp = index.get(key);
 		
 		if (innerIndexOp.isSome()) {
-			TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = innerIndexOp.some();
-			Option<List<Pair<TreeNode, NodePath>>> listOp = innerIndex.get(attribute);
+			TreeMap<String, List<NodePath>> innerIndex = innerIndexOp.some();
+			Option<List<NodePath>> listOp = innerIndex.get(attribute);
 			
 			if (listOp.isSome()) {
-				List<Pair<TreeNode, NodePath>> list = listOp.some();
-				List<Pair<TreeNode, NodePath>> newList = List.nil();
+				List<NodePath> list = listOp.some();
+				List<NodePath> newList = List.nil();
 				
-				for (Pair<TreeNode, NodePath> pathNode : list){
-					if (!pathNode.right().toString().equalsIgnoreCase(pathString)) {
-						newList = newList.cons(pathNode);
+				for (NodePath path : list){
+					if (!path.toString().equals(pathString)) {
+						newList = newList.cons(path);
 					}
 				}
 				
 				if (newList.isEmpty()) {
-					TreeMap<String, List<Pair<TreeNode, NodePath>>> newInnerIndex = innerIndex.delete(attribute);
+					TreeMap<String, List<NodePath>> newInnerIndex = innerIndex.delete(attribute);
 					
 					if (newInnerIndex.isEmpty()) {
-						TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = index.delete(key);
+						TreeMap<String, TreeMap<String, List<NodePath>>> newIndex = index.delete(key);
 						return newIndex;	
 					}
 					
-					TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = index.set(key, newInnerIndex);
+					TreeMap<String, TreeMap<String, List<NodePath>>> newIndex = index.set(key, newInnerIndex);
 					return newIndex;
 				}
 					
-				TreeMap<String, List<Pair<TreeNode, NodePath>>> newInnerIndex = innerIndex.set(attribute,newList);
-				TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = index.set(key, newInnerIndex);
+				TreeMap<String, List<NodePath>> newInnerIndex = innerIndex.set(attribute,newList);
+				TreeMap<String, TreeMap<String, List<NodePath>>> newIndex = index.set(key, newInnerIndex);
 				return newIndex;
 				
 			} else {
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexEditor.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexEditor.java	Sat Nov 15 17:48:07 2014 +0900
@@ -2,7 +2,6 @@
 
 import fj.data.List;
 import fj.data.TreeMap;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
@@ -11,8 +10,7 @@
 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;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
 
 public interface IndexEditor {
-	Either<Error, IndexJungleTreeEditor> edit(TreeNode root,TransactionManager txManager, TreeEditor editor,TreeOperationLog log,TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index);
+	Either<Error, IndexJungleTreeEditor> edit(TreeNode root,TransactionManager txManager, TreeEditor editor,TreeOperationLog log,TreeMap<String, TreeMap<String, List<NodePath>>> index);
 }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexManager.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexManager.java	Sat Nov 15 17:48:07 2014 +0900
@@ -11,7 +11,6 @@
 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.TreeContext;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
 
 public class IndexManager {
 
@@ -21,7 +20,7 @@
 		this.reservation = reservation;
 	}
 	
-	public void commit(TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index){
+	public void commit(TreeMap<String, TreeMap<String, List<NodePath>>> index){
 		TreeContext tc = reservation.get();
 		ChangeSet cs = tc.getChangeSet();
 		TreeNode root = cs.getRoot();
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/PutIndexEditor.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/PutIndexEditor.java	Sat Nov 15 17:48:07 2014 +0900
@@ -15,7 +15,6 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
 
 import java.nio.ByteBuffer;
 
@@ -36,67 +35,64 @@
 	}
 
 	@Override
-	public Either<Error, IndexJungleTreeEditor> edit(TreeNode root,TransactionManager txManager,TreeEditor editor,TreeOperationLog log,TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index) {
-		NodePath newPath = path.pop().right();
-		TreeNode target = getTarget(root, newPath);
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = editIndex(target, path, key, attribute,index);
+	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(path, key, attribute,index);
 		IndexJungleTreeEditor newEditor = new IndexJungleTreeEditor(root,txManager,editor,log, newIndex);
 		Either<Error, IndexJungleTreeEditor> either = DefaultEither.newB(newEditor);
 		return either;
 	}
 	
-	public TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> editIndex(TreeNode target, NodePath path, String key, String attribute,TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index){
+	public TreeMap<String, TreeMap<String, List<NodePath>>> editIndex(NodePath path, String key, String attribute,TreeMap<String, TreeMap<String, List<NodePath>>> index){
 
-		Option<TreeMap<String, List<Pair<TreeNode, NodePath>>>> innerIndexOp = index.get(key);
-		Pair<TreeNode, NodePath> pathNode = new Pair<TreeNode, NodePath>(target,path);
+		Option<TreeMap<String, List<NodePath>>> innerIndexOp = index.get(key); 
 		
 		if (attribute != null) {
 			if (innerIndexOp.isNone()) {
 
-				TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = TreeMap.empty(Ord.stringOrd);
-				List<Pair<TreeNode, NodePath>> list = List.nil();
-				list = list.cons(pathNode);
+				TreeMap<String, List<NodePath>> innerIndex = TreeMap.empty(Ord.stringOrd);
+				List<NodePath> list = List.nil();
+				list = list.cons(path);
 				innerIndex = innerIndex.set(attribute, list);
-				TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = index.set(key, innerIndex);
+				TreeMap<String, TreeMap<String, List<NodePath>>> newIndex = index.set(key, innerIndex);
 				return newIndex;
 			} else {
 
-				TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = innerIndexOp.some();
+				TreeMap<String, List<NodePath>> innerIndex = innerIndexOp.some();
 				
-				Option<List<Pair<TreeNode, NodePath>>> opList = innerIndex.get(attribute);
+				Option<List<NodePath>> opList = innerIndex.get(attribute);
 
 				if (opList.isNone()) {
 
-					List<Pair<TreeNode, NodePath>> list = List.nil();
-					list = list.cons(pathNode);
+					List<NodePath> list = List.nil();
+					list = list.cons(path);
 					innerIndex = innerIndex.set(attribute, list);
 
 				} else {
 
-					List<Pair<TreeNode, NodePath>> list = opList.some();
-					list = list.cons(pathNode);
+					List<NodePath> list = opList.some();
+					list = list.cons(path);
 					innerIndex = innerIndex.set(attribute, list);
 
 				}
-				TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = index.set(key, innerIndex);
+				TreeMap<String, TreeMap<String, List<NodePath>>> newIndex = index.set(key, innerIndex);
 				return newIndex;
 			}
 		}
 		return index;
 	}
 	
-	public TreeNode getTarget(TreeNode node , NodePath path){
-		Pair<Integer, NodePath> pathNode = path.pop();
-		Either<Error, TreeNode> either = node.getChildren().at(pathNode.left());
-		if (either.isA())
-			return node;
-		
-		TreeNode child = either.b();
-		if (pathNode.right().size() == 0)
-			return child;
-		
-		TreeNode target = getTarget(child,pathNode.right());
-		return target;
-	}
+//	public TreeNode getTarget(TreeNode node , NodePath path){
+//		Pair<Integer, NodePath> path = path.pop();
+//		Either<Error, TreeNode> either = node.getChildren().at(path.left());
+//		if (either.isA())
+//			return node;
+//		
+//		TreeNode child = either.b();
+//		if (path.right().size() == 0)
+//			return child;
+//		
+//		TreeNode target = getTarget(child,path.right());
+//		return target;
+//	}
 
 }
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/GetOldTreeTest.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/GetOldTreeTest.java	Sat Nov 15 17:48:07 2014 +0900
@@ -28,18 +28,37 @@
 
     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();
+      JungleTreeEditor putAttributeEditor = addChildEditor.putAttribute(path.add(num), "test",
+          ByteBuffer.wrap("tatsuki".getBytes())).b();
       Either<Error, JungleTreeEditor> successEither = putAttributeEditor.success();
       Assert.assertFalse(successEither.isA());
       editor = successEither.b();
     }
-    System.out.println(tree.revision());
-    TreeNode root = tree.getRootNode();
-    Assert.assertTrue(root.getChildren().at(9).isB());
+
+    JungleTreeEditor newEditor = tree.getTreeEditor();
+    JungleTreeEditor newPutEditor = newEditor.putAttribute(path.add(9), "test", ByteBuffer.wrap("kanagawa".getBytes())).b();
+    newPutEditor.success();
     
-    JungleTree oldTree = tree.getOldTree(9).b();
-    System.out.println(oldTree.revision());
-    TreeNode oldRoot = oldTree.getRootNode();
-    Assert.assertTrue(oldRoot.getChildren().at(9).isA());
+    TreeNode root = tree.getRootNode();
+    Either<Error, TreeNode> childNodeEither = root.getChildren().at(9);
+    Assert.assertTrue(childNodeEither.isB());
+    TreeNode child = childNodeEither.b();
+    Assert.assertEquals(child.getAttributes().getString("test"),"kanagawa");
+    long t1 = System.currentTimeMillis();
+    JungleTree oldTree1 = tree.getOldTree(10).b();
+    long t2 = System.currentTimeMillis();
+    System.out.println("time = " + (t2 - t1));
+    TreeNode oldRoot1 = oldTree1.getRootNode();
+    Either<Error, TreeNode> oldChildNodeEither = oldRoot1.getChildren().at(9);
+    Assert.assertTrue(oldChildNodeEither.isB());
+    TreeNode oldChildNode = oldChildNodeEither.b();
+    Assert.assertEquals(oldChildNode.getAttributes().getString("test"),"tatsuki");
+    
+    
+    JungleTree oldTree2 = tree.getOldTree(9).b();
+    TreeNode oldRoot2 = oldTree2.getRootNode();
+    Assert.assertTrue(oldRoot2.getChildren().at(9).isA());
+    
+    
   }
 }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/functionaljava/FjListTest.java	Sat Nov 15 17:48:07 2014 +0900
@@ -0,0 +1,17 @@
+package jp.ac.u_ryukyu.ie.cr.tatsuki.functionaljava;
+
+import fj.F;
+import fj.data.List;
+
+public class FjListTest {
+
+  static public void main(String args[]){
+    List<String> list = List.nil();
+    list = list.cons("wei");
+    String aaa = list.head();
+    boolean t1 = list.isEmpty();
+    list = list.tail();
+    boolean t2 = list.isEmpty();
+    System.out.println(aaa);
+  }
+}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/AddChildrenIndexTest.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/AddChildrenIndexTest.java	Sat Nov 15 17:48:07 2014 +0900
@@ -29,7 +29,7 @@
 public class AddChildrenIndexTest {
 
 	@Test
-	public void DeleteChildrenTest(){
+	public void AddChildrenTest(){
 		Jungle jungle = new DefaultJungle(null, "hogehoge",new DefaultTreeEditor(new DefaultTraverser()));
 		jungle.createNewTree("tree");
 		JungleTree tree = jungle.getTreeByName("tree");
@@ -58,8 +58,10 @@
 		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>");
+		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);
+		Assert.assertEquals(targetNode.getAttributes().getString(key) ,"<-1,0,1>");
 		
 		}
 	public static String key = "KEY";
@@ -101,4 +103,21 @@
 		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;
+  }
 }
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/AttributeIndexTest.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/AttributeIndexTest.java	Sat Nov 15 17:48:07 2014 +0900
@@ -27,7 +27,7 @@
 		DefaultJungle jungle = new DefaultJungle(null,"hoge",new DefaultTreeEditor(new DefaultTraverser()));
 		JungleTree tree = jungle.createNewTree("fuga");
 		IndexJungleTreeEditor editor = tree.getIndexTreeEditor();
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> emptyIndex = editor.getIndex();
+		TreeMap<String, TreeMap<String, List<NodePath>>> emptyIndex = editor.getIndex();
 		Assert.assertTrue(emptyIndex.isEmpty());
 		NodePath path = new DefaultNodePath();
 		Either<Error, JungleTreeEditor> either = editor.addNewChildAt(path, 0);
@@ -40,9 +40,11 @@
 		editor3.success();
 		
 		IndexJungleTreeEditor IndexEditor = tree.getIndexTreeEditor();
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index = IndexEditor.getIndex();
+		TreeMap<String, TreeMap<String, List< NodePath>>> index = IndexEditor.getIndex();
 		
-		Assert.assertEquals(index.get("key").some().get("test").some().head().left().getAttributes().getString("key"),"test");
+		NodePath targetPath = index.get("key").some().get("test").some().head();
+		TreeNode targetNode = getTarget(tree.getRootNode(), targetPath);
+		Assert.assertEquals(targetNode.getAttributes().getString("key"),"test");
 		
 		JungleTreeEditor editor4 = tree.getIndexTreeEditor();
 		Either<Error, JungleTreeEditor> either3 = editor4.deleteAttribute(path.add(0), "key");
@@ -51,7 +53,26 @@
 		editor5.success();
 		
 		IndexJungleTreeEditor IndexEditor2 = tree.getIndexTreeEditor();
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> deleteIndex = IndexEditor2.getIndex();		
+		TreeMap<String, TreeMap<String, List<NodePath>>> deleteIndex = IndexEditor2.getIndex();		
 		Assert.assertTrue(deleteIndex.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;
+  }
 }
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/DeleteChildrenIndexTest.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/DeleteChildrenIndexTest.java	Sat Nov 15 17:48:07 2014 +0900
@@ -4,10 +4,8 @@
 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;
@@ -28,81 +26,100 @@
 
 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();
+  @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) -> {
+      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>");
+
+    for (; pairIterator.hasNext(); pairIterator.next()) {
 
-		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>");
+    }
+    // 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);
+    Assert.assertEquals(targetNode.getAttributes().getString(key), "<-1,0,2>");
+
+  }
+
+  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()) {
-			 
-		 }
-		//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);
+  }
 
-		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 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;
+  }
 }
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/IndexCommitTest.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/IndexCommitTest.java	Sat Nov 15 17:48:07 2014 +0900
@@ -1,6 +1,6 @@
 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;
@@ -14,7 +14,6 @@
 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;
 
@@ -51,10 +50,12 @@
 		}, key, "<-1,0,1>");
 
 		//check index
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index = ifTraverser.getIndex();
-		Option<TreeMap<String, List<Pair<TreeNode, NodePath>>>> opIndex = index.get(key);
+		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<Pair<TreeNode, NodePath>>> innerIndex = opIndex.some();
+		
+		TreeMap<String, List< NodePath>> innerIndex = opIndex.some();
 		Assert.assertTrue(!innerIndex.get("<-1,0,0>").isNone());
 
 		JungleTreeEditor editor = tree.getTreeEditor();
@@ -65,7 +66,7 @@
 		ifTraverser.commitIndex();
 		JungleTree newTree = jungle.getTreeByName("tree");
 		InterfaceTraverser newIfTraverser = newTree.getTraverser();
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = newIfTraverser.getIndex();
+		TreeMap<String, TreeMap<String, List<NodePath>>> newIndex = newIfTraverser.getIndex();
 		Assert.assertTrue(newIndex.isEmpty());
 		
 		InterfaceTraverser ifTraverser1= tree.getTraverser();
@@ -84,7 +85,7 @@
 		ifTraverser1.commitIndex();
 		JungleTree newTree2 = jungle.getTreeByName("tree");
 		InterfaceTraverser newIfTraverser2 = newTree2.getTraverser();
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex1 = newIfTraverser2.getIndex();
+		TreeMap<String, TreeMap<String, List<NodePath>>> newIndex1 = newIfTraverser2.getIndex();
 		Assert.assertFalse(newIndex1.isEmpty());
 
 	}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/query/SearchQueryTest.java	Thu Nov 13 22:04:14 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/query/SearchQueryTest.java	Sat Nov 15 17:48:07 2014 +0900
@@ -1,11 +1,9 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.query;
 
 import java.nio.ByteBuffer;
-import java.security.KeyStore.Entry.Attribute;
 import java.util.Iterator;
 
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungleTree;
 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;
@@ -19,7 +17,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.Pair;
-import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.PathNodeIndexIterator;
 
 import org.junit.Assert;
 import org.junit.Test;
@@ -38,7 +35,7 @@
 		createTree(tree);
 		tree.getRootNode();
 		InterfaceTraverser ifTraverser = tree.getTraverser();
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> cheackIndex = ifTraverser.getIndex();
+		TreeMap<String, TreeMap<String, List< NodePath>>> cheackIndex = ifTraverser.getIndex();
 		Assert.assertTrue(cheackIndex.isEmpty());
 		
 		Iterator<Pair<TreeNode, NodePath>> searchNode = ifTraverser.find(
@@ -59,10 +56,10 @@
 			Assert.assertTrue(compare(searchNode.next().left(),"<-1,0,1>"));			
 		}
 				
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index = ifTraverser.getIndex();
-		Option<TreeMap<String, List<Pair<TreeNode, NodePath>>>> opIndex = index.get(key);
+		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<Pair<TreeNode, NodePath>>> innerIndex = opIndex.some();
+		TreeMap<String, List<NodePath>> innerIndex = opIndex.some();
 		Assert.assertTrue(!innerIndex.get("<-1,0,0>").isNone());
 	}