changeset 174:a2598139df64

test
author one
date Mon, 16 Feb 2015 12:08:47 +0900
parents f26535302c96
children 550f51183d8a
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/DefaultTransactionManager.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/Index.java src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexCreater.java src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexManager.java
diffstat 10 files changed, 429 insertions(+), 365 deletions(-) [+]
line wrap: on
line diff
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java	Mon Feb 16 11:36:45 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java	Mon Feb 16 12:08:47 2015 +0900
@@ -3,6 +3,7 @@
 import java.util.Iterator;
 import java.util.concurrent.ConcurrentHashMap;
 
+import fj.Ord;
 import fj.data.List;
 import fj.data.TreeMap;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList;
@@ -20,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.tatsuki.jungle.store.index.Index;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
 public class DefaultJungle implements Jungle
@@ -80,7 +80,7 @@
 		};
 		
 		DefaultTreeNode root = new DefaultTreeNode();
-	  TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList = new Index().getIndex();
+	  TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList = TreeMap.empty(Ord.stringOrd);
 		 TreeMap<TreeNode, TreeNode> parentIndex = new ParentIndex().getParentIndex();
 		ChangeSet set = new DefaultChangeSet(root,null,list,uuid,name,0,indexList,parentIndex);
 		DefaultTreeContext tc = new DefaultTreeContext(root,set);
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java	Mon Feb 16 11:36:45 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java	Mon Feb 16 12:08:47 2015 +0900
@@ -1,5 +1,6 @@
 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle;
 
+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;
@@ -15,7 +16,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.GetOldTreeError;
-import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.Index;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexManager;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
@@ -57,7 +57,7 @@
   public InterfaceTraverser getTraverser(boolean useIndex) {
     AtomicReservableReference<TreeContext>.Reservation reservation = repository.getReservation();
     IndexManager indexManager = new IndexManager(reservation);
-    Index index = getIndex();
+    TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> index = getIndex();
     ParentIndex parentIndex = getParentIndex();
     return new InterfaceTraverser(getRootNode(), index, parentIndex, indexManager, useIndex);
   }
@@ -70,7 +70,7 @@
   }
 
   @Override
-  public Index getIndex() {
+  public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> 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	Mon Feb 16 11:36:45 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTree.java	Mon Feb 16 12:08:47 2015 +0900
@@ -2,12 +2,12 @@
 
 
 
+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.traverser.InterfaceTraverser;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.Index;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
 public interface JungleTree
@@ -17,7 +17,7 @@
 	public TreeNode getRootNode();
   public long revision();
   public Either<Error, JungleTree> getOldTree(long revision);
-  public Index getIndex();
+  public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex();
   public ParentIndex getParentIndex();
   public InterfaceTraverser getTraverser(boolean useIndex);
   public Either<Error, TreeNode> getNodeOfPath(NodePath path);
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/ChangeSet.java	Mon Feb 16 11:36:45 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/ChangeSet.java	Mon Feb 16 12:08:47 2015 +0900
@@ -2,10 +2,10 @@
 
 
 
+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.impl.TreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.Index;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
 public interface ChangeSet
@@ -17,8 +17,7 @@
 	public String uuid();
 	public String getTreeName();
 	public long revision();
-	
-	public Index getIndex();
+	public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex();
 	public Iterable<TreeOperation> getOperations();
   public ParentIndex getParentIndex();
 }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultChangeSet.java	Mon Feb 16 11:36:45 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultChangeSet.java	Mon Feb 16 12:08:47 2015 +0900
@@ -5,7 +5,6 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.Index;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
 public class DefaultChangeSet implements ChangeSet
@@ -76,8 +75,8 @@
 	}
 
 	@Override
-	public Index getIndex() {
-		return new Index(indexList);
+	public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex() {
+		return indexList;
 	}
 
 
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java	Mon Feb 16 11:36:45 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java	Mon Feb 16 12:08:47 2015 +0900
@@ -3,6 +3,7 @@
 
 import java.util.Iterator;
 
+import fj.data.TreeMap;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.Result;
@@ -16,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.tatsuki.jungle.store.index.Index;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexManager;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
@@ -58,14 +58,13 @@
       }
 
     };
-
+System.out.println("transaction");
     IndexManager indexManager = new IndexManager(repository.getReservation());
     InterfaceTraverser traverser = new InterfaceTraverser(_newRoot, indexManager, true);
     traverser.createIndex();
-    Index index = traverser.getIndex();
+    TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> index = traverser.getIndex();
     ParentIndex parentIndex = traverser.getParentIndex();
-    DefaultChangeSet newCs = new DefaultChangeSet(_newRoot, cs, list, uuid, _treeName, nextRevision, index.getIndex(),
-        parentIndex.getParentIndex());
+    DefaultChangeSet newCs = new DefaultChangeSet(_newRoot, cs, list, uuid, _treeName, nextRevision, index, parentIndex.getParentIndex());
     DefaultTreeContext newContext = new DefaultTreeContext(_newRoot, newCs);
 
     @SuppressWarnings("rawtypes")
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java	Mon Feb 16 11:36:45 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java	Mon Feb 16 12:08:47 2015 +0900
@@ -2,11 +2,15 @@
 
 
 import java.util.Iterator;
-import fj.data.List;
+
+import fj.Ord;
+import fj.P2;
+import fj.data.Option;
+import fj.data.TreeMap;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NulIterator;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.PathNodeIterator;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.Query;
-import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.Index;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexCreater;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexManager;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
@@ -14,17 +18,17 @@
 public class InterfaceTraverser {
 
   TreeNode node;
-  Index index;
+  TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> index;
   ParentIndex parentIndex;
   boolean parentUpdateFlag;
   IndexManager indexManager;
   boolean useIndex;
 
   public InterfaceTraverser(TreeNode root, IndexManager indexManager, boolean indexFlag) {
-    this(root, new Index(), new ParentIndex(), indexManager, indexFlag);
+    this(root, TreeMap.empty(Ord.stringOrd), new ParentIndex(), indexManager, indexFlag);
   }
 
-  public InterfaceTraverser(TreeNode root, Index index, ParentIndex parentIndex, IndexManager indexManager,
+  public InterfaceTraverser(TreeNode root, TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> index, ParentIndex parentIndex, IndexManager indexManager,
       boolean useIndex) {
     this.node = root;
     this.index = index;
@@ -37,7 +41,7 @@
     this.useIndex = useIndex;
   }
 
-  public Index getIndex() {
+  public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex() {
     return index;
   }
 
@@ -50,7 +54,7 @@
     return parentIndex;
   }
 
-  public void setIndex(Index index) {
+  public void setIndex(TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> index) {
     this.index = index;
   }
 
@@ -59,7 +63,7 @@
     long t1 = System.currentTimeMillis();
     IndexCreater creater = new IndexCreater(node);
     long t2 = System.currentTimeMillis();
-    System.out.println("createIndex time = " + (t2 - t1));
+   // System.out.println("createIndex time = " + (t2 - t1));
     index = creater.getIndex();
     parentIndex = creater.getParentIndex();
   }
@@ -73,67 +77,67 @@
    * @param searchValue
    * @return
    */
-  public Iterator<TreeNode> findInSubTree(final Query query, TreeNode subTree, String key, String searchValue) {
-    /*
-     * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から1つずつ比較し、
-     * indexから取ってきたNodeのPathが一致した場合、そのNodeを返す
-     */
-    Iterator<TreeNode> nodeIterator = index.get(key, searchValue);
-    if (nodeIterator.hasNext() && useIndex) {
-
-      // ここでNode以下にあるか調べる
-      List<TreeNode> filteredList = List.nil();
-
-      for (;nodeIterator.hasNext();) {
-        TreeNode targetNode = nodeIterator.next();
-        TreeNode parent = targetNode;
-        while (parent != null) {
-          parent = parentIndex.get(parent);
-          if (parent.equals(subTree))
-            filteredList = filteredList.cons(targetNode);
-        }
-      }
-
-      return filteredList.iterator();
-
-    } else {
-      final PathNodeIterator itNode = new PathNodeIterator(subTree);
-      return new Iterator<TreeNode>() {
-
-        private TreeNode matchNode = nextmatch(itNode);
-
-        private TreeNode nextmatch(PathNodeIterator itNode) {
-
-          for (; itNode.hasNext();) {
-            TreeNode targetNode = itNode.next();
-            if (query.condition(targetNode))
-              return targetNode;
-          }
-          return null;
-        }
-
-        @Override
-        public boolean hasNext() {
-          if (matchNode == null) {
-            return false;
-          }
-          return true;
-        }
-
-        @Override
-        public TreeNode next() {
-          TreeNode currentNode = matchNode;
-          matchNode = nextmatch(itNode);
-          return currentNode;
-        }
-
-        @Override
-        public void remove() {
-        }
-
-      };
-    }
-  }
+//  public Iterator<TreeNode> findInSubTree(final Query query, TreeNode subTree, String key, String searchValue) {
+//    /*
+//     * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から1つずつ比較し、
+//     * indexから取ってきたNodeのPathが一致した場合、そのNodeを返す
+//     */
+//    Iterator<TreeNode> nodeIterator = index.get(key, searchValue);
+//    if (nodeIterator.hasNext() && useIndex) {
+//
+//      // ここでNode以下にあるか調べる
+//      List<TreeNode> filteredList = List.nil();
+//
+//      for (;nodeIterator.hasNext();) {
+//        TreeNode targetNode = nodeIterator.next();
+//        TreeNode parent = targetNode;
+//        while (parent != null) {
+//          parent = parentIndex.get(parent);
+//          if (parent.equals(subTree))
+//            filteredList = filteredList.cons(targetNode);
+//        }
+//      }
+//
+//      return filteredList.iterator();
+//
+//    } else {
+//      final PathNodeIterator itNode = new PathNodeIterator(subTree);
+//      return new Iterator<TreeNode>() {
+//
+//        private TreeNode matchNode = nextmatch(itNode);
+//
+//        private TreeNode nextmatch(PathNodeIterator itNode) {
+//
+//          for (; itNode.hasNext();) {
+//            TreeNode targetNode = itNode.next();
+//            if (query.condition(targetNode))
+//              return targetNode;
+//          }
+//          return null;
+//        }
+//
+//        @Override
+//        public boolean hasNext() {
+//          if (matchNode == null) {
+//            return false;
+//          }
+//          return true;
+//        }
+//
+//        @Override
+//        public TreeNode next() {
+//          TreeNode currentNode = matchNode;
+//          matchNode = nextmatch(itNode);
+//          return currentNode;
+//        }
+//
+//        @Override
+//        public void remove() {
+//        }
+//
+//      };
+//    }
+//  }
 
   /**
    * subTree以下のNodeに対してKeyに対応する値をindexを使って探索する
@@ -144,70 +148,100 @@
    * @param searchValue
    * @return
    */
-  public Iterator<TreeNode> findInSubTreeAllValue(final Query query, TreeNode subTree, String key) {
-    /*
-     * indexからinnerIndexを取得 取得したinnerIndexが保有するKeyを取得
-     * そのKeyを保有するNodeとNodeのPathを取得する
-     * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から1つずつ比較し、
-     * indexから取ってきたNodeのPathが一致した場合、そのNodeを返す
-     */
-    Iterator<TreeNode> NodeIterator = index.getAll(key);
-    if (NodeIterator != null && useIndex) {
-      List<TreeNode> filteredList = List.nil();
-      for (; NodeIterator.hasNext();) {
-        TreeNode targetNode = NodeIterator.next();
-        TreeNode parent = targetNode;
-        while (parent != null) {
-          parent = parentIndex.get(parent);
-          if (parent.equals(subTree))
-            filteredList = filteredList.cons(targetNode);
-        }
-      }
-      return filteredList.iterator();
-
-    } else {
-
-      final PathNodeIterator itNode = new PathNodeIterator(subTree);
-      return new Iterator<TreeNode>() {
-
-        private TreeNode matchPair = nextmatch(itNode);
-
-        private TreeNode nextmatch(PathNodeIterator itNode) {
+//  public Iterator<TreeNode> findInSubTreeAllValue(final Query query, TreeNode subTree, String key) {
+//    /*
+//     * indexからinnerIndexを取得 取得したinnerIndexが保有するKeyを取得
+//     * そのKeyを保有するNodeとNodeのPathを取得する
+//     * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から1つずつ比較し、
+//     * indexから取ってきたNodeのPathが一致した場合、そのNodeを返す
+//     */
+//    Iterator<TreeNode> NodeIterator = index.getAll(key);
+//    if (NodeIterator != null && useIndex) {
+//      List<TreeNode> filteredList = List.nil();
+//      for (; NodeIterator.hasNext();) {
+//        TreeNode targetNode = NodeIterator.next();
+//        TreeNode parent = targetNode;
+//        while (parent != null) {
+//          parent = parentIndex.get(parent);
+//          if (parent.equals(subTree))
+//            filteredList = filteredList.cons(targetNode);
+//        }
+//      }
+//      return filteredList.iterator();
+//
+//    } else {
+//
+//      final PathNodeIterator itNode = new PathNodeIterator(subTree);
+//      return new Iterator<TreeNode>() {
+//
+//        private TreeNode matchPair = nextmatch(itNode);
+//
+//        private TreeNode nextmatch(PathNodeIterator itNode) {
+//
+//          for (; itNode.hasNext();) {
+//            TreeNode targetNode = itNode.next();
+//            if (query.condition(targetNode))
+//              return targetNode;
+//          }
+//          return null;
+//        }
+//
+//        @Override
+//        public boolean hasNext() {
+//          if (matchPair == null) {
+//            return false;
+//          }
+//          return true;
+//        }
+//
+//        @Override
+//        public TreeNode next() {
+//          TreeNode currentNode = matchPair;
+//          matchPair = nextmatch(itNode);
+//          return currentNode;
+//        }
+//
+//        @Override
+//        public void remove() {
+//        }
+//
+//      };
+//    }
+//  }
 
-          for (; itNode.hasNext();) {
-            TreeNode targetNode = itNode.next();
-            if (query.condition(targetNode))
-              return targetNode;
-          }
-          return null;
-        }
+  
+public Iterator<TreeNode> get(String key, String value) {
 
-        @Override
-        public boolean hasNext() {
-          if (matchPair == null) {
-            return false;
-          }
-          return true;
-        }
+  Option<TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexOp = index.get(key);
+  if (indexOp.isNone())
+    return new NulIterator<TreeNode>();
+
+  TreeMap<String, TreeMap<TreeNode, TreeNode>> index = indexOp.some();
+  Option<TreeMap<TreeNode, TreeNode>> nodeMapOp = index.get(value);
+
+  if (nodeMapOp.isNone())
+    return new NulIterator<TreeNode>();
 
-        @Override
-        public TreeNode next() {
-          TreeNode currentNode = matchPair;
-          matchPair = nextmatch(itNode);
-          return currentNode;
-        }
+  Iterator<P2<TreeNode, TreeNode>> mapIterator = nodeMapOp.some().iterator();
+  return new Iterator<TreeNode>() {
+
+    @Override
+    public boolean hasNext() {
+      return mapIterator.hasNext();
+    }
 
-        @Override
-        public void remove() {
-        }
+    @Override
+    public TreeNode next() {
+      return mapIterator.next()._1();
+    }
 
-      };
-    }
-  }
-
+  };
+}
+  
+  
   public Iterator<TreeNode> find(final Query query, final String key, String searchValue) {
 
-     Iterator<TreeNode> nodeIterator = index.get(key, searchValue);
+     Iterator<TreeNode> nodeIterator = get(key, searchValue);
     if (nodeIterator.hasNext() && useIndex) {
       return nodeIterator;
     } else {
@@ -223,8 +257,8 @@
             TreeNode targetNode = itNode.next();
             String value = targetNode.getAttributes().getString(key);
             if (useIndex) {
-              if (value != null)
-                index = index.set(key, value, targetNode);
+              if (value != null);
+//                index = index.set(key, value, targetNode);
             }
             if (parentUpdateFlag);
       //        parentIndex = parentIndex.set(targetNode);
@@ -259,59 +293,59 @@
     }
   }
 
-  public Iterator<TreeNode> findAll(final Query query, final String key) {
-
-    Iterator<TreeNode> nodeList = index.getAll(key);
-    if (nodeList != null && useIndex) {
-
-      return nodeList;
-
-    } else {
-
-      final PathNodeIterator itNode = new PathNodeIterator(node);
-      return new Iterator<TreeNode>() {
-
-        private TreeNode matchNode = nextmatch(itNode);
-
-        private TreeNode nextmatch(PathNodeIterator itNode) {
-
-          for (; itNode.hasNext();) {
-            TreeNode targetNode = itNode.next();
-            String value = targetNode.getAttributes().getString(key);
-            if (useIndex) {
-              if (value != null)
-                index = index.set(key, value, targetNode);
-            }
-            if (parentUpdateFlag);
-     //         parentIndex = parentIndex.set(targetNode);
-            if (query.condition(targetNode))
-              return targetNode;
-          }
-          if (useIndex || parentUpdateFlag)
-            commit();
-          return null;
-        }
-
-        @Override
-        public boolean hasNext() {
-          if (matchNode == null) {
-            return false;
-          }
-          return true;
-        }
-
-        @Override
-        public TreeNode next() {
-          TreeNode currentPair = matchNode;
-          matchNode = nextmatch(itNode);
-          return currentPair;
-        }
-
-        @Override
-        public void remove() {
-        }
-
-      };
-    }
-  }
+//  public Iterator<TreeNode> findAll(final Query query, final String key) {
+//
+//    Iterator<TreeNode> nodeList = index.getAll(key);
+//    if (nodeList != null && useIndex) {
+//
+//      return nodeList;
+//
+//    } else {
+//
+//      final PathNodeIterator itNode = new PathNodeIterator(node);
+//      return new Iterator<TreeNode>() {
+//
+//        private TreeNode matchNode = nextmatch(itNode);
+//
+//        private TreeNode nextmatch(PathNodeIterator itNode) {
+//
+//          for (; itNode.hasNext();) {
+//            TreeNode targetNode = itNode.next();
+//            String value = targetNode.getAttributes().getString(key);
+//            if (useIndex) {
+//              if (value != null)
+//                index = index.set(key, value, targetNode);
+//            }
+//            if (parentUpdateFlag);
+//     //         parentIndex = parentIndex.set(targetNode);
+//            if (query.condition(targetNode))
+//              return targetNode;
+//          }
+//          if (useIndex || parentUpdateFlag)
+//            commit();
+//          return null;
+//        }
+//
+//        @Override
+//        public boolean hasNext() {
+//          if (matchNode == null) {
+//            return false;
+//          }
+//          return true;
+//        }
+//
+//        @Override
+//        public TreeNode next() {
+//          TreeNode currentPair = matchNode;
+//          matchNode = nextmatch(itNode);
+//          return currentPair;
+//        }
+//
+//        @Override
+//        public void remove() {
+//        }
+//
+//      };
+//    }
+//  }
 }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/Index.java	Mon Feb 16 11:36:45 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/Index.java	Mon Feb 16 12:08:47 2015 +0900
@@ -1,155 +1,155 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index;
-
-import java.util.Iterator;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NulIterator;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.TreeMapOrd;
-import fj.Ord;
-import fj.P2;
-import fj.data.Option;
-import fj.data.TreeMap;
-
-public class Index {
-
-  TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList;
-
-  public Index() {
-   indexList = TreeMap.empty(Ord.stringOrd);    
-  }
-
-  public Index(TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList) {
-    this.indexList = indexList;
-  }
-
-  public Index set(String key, String value, TreeNode node) {
-    
-    Option<TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexOp = indexList.get(key);
-    if (indexOp.isNone()) {
-      TreeMap<String, TreeMap<TreeNode, TreeNode>> index = TreeMap.empty(Ord.stringOrd);
-      TreeMap<TreeNode, TreeNode> nodeMap = TreeMap.empty(TreeMapOrd.treeNodeOrd);
-      nodeMap = nodeMap.set(node, node);
-      TreeMap<String, TreeMap<TreeNode, TreeNode>> newIndex = index.set(value, nodeMap);
-      indexList = indexList.set(key, newIndex);
-      return this;
-    }
-
-    TreeMap<String, TreeMap<TreeNode, TreeNode>> index = indexOp.some();
-    Option<TreeMap<TreeNode, TreeNode>> nodeMapOp = index.get(value);
-
-    TreeMap<TreeNode, TreeNode> newNodeMap;
-    if (nodeMapOp.isSome()) {
-      TreeMap<TreeNode, TreeNode> nodeMap = nodeMapOp.some();
-      newNodeMap = nodeMap.set(node, node);
-    } else {
-      TreeMap<TreeNode, TreeNode> nodeMap = TreeMap.empty(TreeMapOrd.treeNodeOrd);
-      newNodeMap = nodeMap.set(node, node);
-    }
-    TreeMap<String, TreeMap<TreeNode, TreeNode>> newIndex = index.set(value, newNodeMap);
-    indexList = indexList.set(key, newIndex);
-
-    return this;
-  }
-
-  // public Index delete(String key, String value, TreeNode node) {
-  // Option<TreeMap<String, List<TreeNode>>> indexOp = indexList.get(key);
-  // if (indexOp.isNone())
-  // return this;
-  //
-  // TreeMap<String, List<TreeNode>> index = indexOp.some();
-  // TreeMap<String, List<TreeNode>> newIndex = index;
-  // 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.equals(node))
-  // newNodeList = newNodeList.cons(indexingNode);
-  // }
-  //
-  // newIndex = index.set(value, newNodeList);
-  // } else {
-  // return this;
-  // }
-  // TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexList =
-  // indexList.set(key, newIndex);
-  // return new Index(newIndexList);
-  // }
-
-  public Iterator<TreeNode> get(String key, String value) {
-
-    Option<TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexOp = indexList.get(key);
-    if (indexOp.isNone())
-      return new NulIterator<TreeNode>();
-
-    TreeMap<String, TreeMap<TreeNode, TreeNode>> index = indexOp.some();
-    Option<TreeMap<TreeNode, TreeNode>> nodeMapOp = index.get(value);
-
-    if (nodeMapOp.isNone())
-      return new NulIterator<TreeNode>();
-
-    Iterator<P2<TreeNode, TreeNode>> mapIterator = nodeMapOp.some().iterator();
-    return new Iterator<TreeNode>() {
-
-      @Override
-      public boolean hasNext() {
-        return mapIterator.hasNext();
-      }
-
-      @Override
-      public TreeNode next() {
-        return mapIterator.next()._1();
-      }
-
-    };
-  }
-
-  public Iterator<TreeNode> getAll(String key) {
-
-    Option<TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexOp = indexList.get(key);
-    if (indexOp.isNone())
-      return null;
-
-    final TreeMap<String, TreeMap<TreeNode, TreeNode>> index = indexOp.some();
-    if (!index.isEmpty())
-      return new NulIterator<TreeNode>();
-
-    return new Iterator<TreeNode>() {
-
-      Iterator<P2<String, TreeMap<TreeNode, TreeNode>>> treeMapIterator = index.iterator();
-      Iterator<P2<TreeNode, TreeNode>> nodeIterator = new NulIterator<P2<TreeNode, TreeNode>>();
-      TreeNode node;
-
-      @Override
-      public boolean hasNext() {
-
-        if (nodeIterator.hasNext()) {
-          node = nodeIterator.next()._1();
-          return true;
-        }
-
-        for (; treeMapIterator.hasNext();) {
-          TreeMap<TreeNode, TreeNode> nodeMap = treeMapIterator.next()._2();
-          nodeIterator = nodeMap.iterator();
-          if (nodeIterator.hasNext()) {
-            node = nodeIterator.next()._1();
-            return true;
-          }
-        }
-        return false;
-      }
-
-      @Override
-      public TreeNode next() {
-        return node;
-      }
-
-    };
-
-  }
-
-  public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex() {
-    return indexList;
-  }
-
-}
+//package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index;
+//
+//import java.util.Iterator;
+//
+//import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NulIterator;
+//import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
+//import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.TreeMapOrd;
+//import fj.Ord;
+//import fj.P2;
+//import fj.data.Option;
+//import fj.data.TreeMap;
+//
+//public class Index {
+//
+//  TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList;
+//
+//  public Index() {
+//   indexList = TreeMap.empty(Ord.stringOrd);    
+//  }
+//
+//  public Index(TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList) {
+//    this.indexList = indexList;
+//  }
+//
+//  public Index set(String key, String value, TreeNode node) {
+//    
+//    Option<TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexOp = indexList.get(key);
+//    if (indexOp.isNone()) {
+//      TreeMap<String, TreeMap<TreeNode, TreeNode>> index = TreeMap.empty(Ord.stringOrd);
+//      TreeMap<TreeNode, TreeNode> nodeMap = TreeMap.empty(TreeMapOrd.treeNodeOrd);
+//      nodeMap = nodeMap.set(node, node);
+//      TreeMap<String, TreeMap<TreeNode, TreeNode>> newIndex = index.set(value, nodeMap);
+//      indexList = indexList.set(key, newIndex);
+//      return this;
+//    }
+//
+//    TreeMap<String, TreeMap<TreeNode, TreeNode>> index = indexOp.some();
+//    Option<TreeMap<TreeNode, TreeNode>> nodeMapOp = index.get(value);
+//
+//    TreeMap<TreeNode, TreeNode> newNodeMap;
+//    if (nodeMapOp.isSome()) {
+//      TreeMap<TreeNode, TreeNode> nodeMap = nodeMapOp.some();
+//      newNodeMap = nodeMap.set(node, node);
+//    } else {
+//      TreeMap<TreeNode, TreeNode> nodeMap = TreeMap.empty(TreeMapOrd.treeNodeOrd);
+//      newNodeMap = nodeMap.set(node, node);
+//    }
+//    TreeMap<String, TreeMap<TreeNode, TreeNode>> newIndex = index.set(value, newNodeMap);
+//    indexList = indexList.set(key, newIndex);
+//
+//    return this;
+//  }
+//
+//  // public Index delete(String key, String value, TreeNode node) {
+//  // Option<TreeMap<String, List<TreeNode>>> indexOp = indexList.get(key);
+//  // if (indexOp.isNone())
+//  // return this;
+//  //
+//  // TreeMap<String, List<TreeNode>> index = indexOp.some();
+//  // TreeMap<String, List<TreeNode>> newIndex = index;
+//  // 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.equals(node))
+//  // newNodeList = newNodeList.cons(indexingNode);
+//  // }
+//  //
+//  // newIndex = index.set(value, newNodeList);
+//  // } else {
+//  // return this;
+//  // }
+//  // TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexList =
+//  // indexList.set(key, newIndex);
+//  // return new Index(newIndexList);
+//  // }
+//
+//  public Iterator<TreeNode> get(String key, String value) {
+//
+//    Option<TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexOp = indexList.get(key);
+//    if (indexOp.isNone())
+//      return new NulIterator<TreeNode>();
+//
+//    TreeMap<String, TreeMap<TreeNode, TreeNode>> index = indexOp.some();
+//    Option<TreeMap<TreeNode, TreeNode>> nodeMapOp = index.get(value);
+//
+//    if (nodeMapOp.isNone())
+//      return new NulIterator<TreeNode>();
+//
+//    Iterator<P2<TreeNode, TreeNode>> mapIterator = nodeMapOp.some().iterator();
+//    return new Iterator<TreeNode>() {
+//
+//      @Override
+//      public boolean hasNext() {
+//        return mapIterator.hasNext();
+//      }
+//
+//      @Override
+//      public TreeNode next() {
+//        return mapIterator.next()._1();
+//      }
+//
+//    };
+//  }
+//
+//  public Iterator<TreeNode> getAll(String key) {
+//
+//    Option<TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexOp = indexList.get(key);
+//    if (indexOp.isNone())
+//      return null;
+//
+//    final TreeMap<String, TreeMap<TreeNode, TreeNode>> index = indexOp.some();
+//    if (!index.isEmpty())
+//      return new NulIterator<TreeNode>();
+//
+//    return new Iterator<TreeNode>() {
+//
+//      Iterator<P2<String, TreeMap<TreeNode, TreeNode>>> treeMapIterator = index.iterator();
+//      Iterator<P2<TreeNode, TreeNode>> nodeIterator = new NulIterator<P2<TreeNode, TreeNode>>();
+//      TreeNode node;
+//
+//      @Override
+//      public boolean hasNext() {
+//
+//        if (nodeIterator.hasNext()) {
+//          node = nodeIterator.next()._1();
+//          return true;
+//        }
+//
+//        for (; treeMapIterator.hasNext();) {
+//          TreeMap<TreeNode, TreeNode> nodeMap = treeMapIterator.next()._2();
+//          nodeIterator = nodeMap.iterator();
+//          if (nodeIterator.hasNext()) {
+//            node = nodeIterator.next()._1();
+//            return true;
+//          }
+//        }
+//        return false;
+//      }
+//
+//      @Override
+//      public TreeNode next() {
+//        return node;
+//      }
+//
+//    };
+//
+//  }
+//
+//  public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex() {
+//    return indexList;
+//  }
+//
+//}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexCreater.java	Mon Feb 16 11:36:45 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexCreater.java	Mon Feb 16 12:08:47 2015 +0900
@@ -2,9 +2,13 @@
 
 import java.util.Stack;
 
+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.impl.TreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNodeChildren;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.TreeMapOrd;
 
 public class IndexCreater {
 
@@ -15,7 +19,7 @@
   private Stack<TreeNode> nodeStack = new Stack<TreeNode>();
   private Stack<Integer> searchStack = new Stack<Integer>();
   ParentIndex parentIndex = new ParentIndex();
-  Index index = new Index();
+  TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList = TreeMap.empty(Ord.stringOrd);
 
   public IndexCreater(TreeNode rootNode) {
     this.root = rootNode;
@@ -26,7 +30,7 @@
       for (String key : keys) {
         String value = targetNode.getAttributes().getString(key);
         if (value != null)
-          index = index.set(key, value, targetNode);
+          indexList = set(key, value, targetNode);
       }
       if (node.getChildren().size() > 0) {
         nodeStack.push(node);
@@ -39,7 +43,7 @@
       } else if (node == root) {
         node = null; // no more node
         children = null;
-        return ;
+        return;
       } else if (children != null && children.size() > childNumber) {
         childNumber = searchStack.pop();
         TreeNode parent = nodeStack.pop();
@@ -55,7 +59,7 @@
           if (node == root) {
             node = null; // no more node
             children = null;
-            return ;
+            return;
           }
           node = nodeStack.pop();
           children = node.getChildren();
@@ -72,8 +76,37 @@
     }
   }
 
-  public Index getIndex() {
-    return index;
+  public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> set(String key, String value, TreeNode node) {
+
+    Option<TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexOp = indexList.get(key);
+    if (indexOp.isNone()) {
+      TreeMap<String, TreeMap<TreeNode, TreeNode>> index = TreeMap.empty(Ord.stringOrd);
+      TreeMap<TreeNode, TreeNode> nodeMap = TreeMap.empty(TreeMapOrd.treeNodeOrd);
+      nodeMap = nodeMap.set(node, node);
+      TreeMap<String, TreeMap<TreeNode, TreeNode>> newIndex = index.set(value, nodeMap);
+      indexList = indexList.set(key, newIndex);
+      return indexList;
+    }
+
+    TreeMap<String, TreeMap<TreeNode, TreeNode>> index = indexOp.some();
+    Option<TreeMap<TreeNode, TreeNode>> nodeMapOp = index.get(value);
+
+    TreeMap<TreeNode, TreeNode> newNodeMap;
+    if (nodeMapOp.isSome()) {
+      TreeMap<TreeNode, TreeNode> nodeMap = nodeMapOp.some();
+      newNodeMap = nodeMap.set(node, node);
+    } else {
+      TreeMap<TreeNode, TreeNode> nodeMap = TreeMap.empty(TreeMapOrd.treeNodeOrd);
+      newNodeMap = nodeMap.set(node, node);
+    }
+    TreeMap<String, TreeMap<TreeNode, TreeNode>> newIndex = index.set(value, newNodeMap);
+    indexList = indexList.set(key, newIndex);
+
+    return indexList;
+  }
+
+  public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex() {
+    return indexList;
   }
 
   public ParentIndex getParentIndex() {
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexManager.java	Mon Feb 16 11:36:45 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexManager.java	Mon Feb 16 12:08:47 2015 +0900
@@ -2,6 +2,7 @@
 
 
 
+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.impl.TreeNode;
@@ -18,7 +19,7 @@
 		this.reservation = reservation;
 	}
 	
-	public void commit(Index index, ParentIndex parentIndex){
+	public void commit(TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> index, ParentIndex parentIndex){
 		TreeContext tc = reservation.get();
 		ChangeSet cs = tc.getChangeSet();
 		TreeNode root = cs.getRoot();
@@ -27,8 +28,7 @@
 		String uuid = cs.uuid();
 		String treeName = cs.getTreeName();
 		long revision = cs.revision();
-		index.get("KER", "value");
-		DefaultChangeSet newCs = new DefaultChangeSet(root, prev, cl, uuid, treeName, revision, index.getIndex(), parentIndex.getParentIndex());
+		DefaultChangeSet newCs = new DefaultChangeSet(root, prev, cl, uuid, treeName, revision, index, parentIndex.getParentIndex());
 		DefaultTreeContext newTs = new DefaultTreeContext(root, newCs);
 		reservation.set(newTs);
 	}