# HG changeset patch
# User tatsuki
# Date 1427093068 -32400
# Node ID 066d9c5758dc051d39c39cdab8d8c3fade49a02b
# Parent  67d4c68578cf30ddf608727c9c5a16d1782e289e
change TreeContext

diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java	Fri Mar 20 15:35:53 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java	Mon Mar 23 15:44:28 2015 +0900
@@ -18,73 +18,71 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeContext;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
-public class DefaultJungle implements Jungle
-{
-	private Journal journal;
-	private ConcurrentHashMap<String,JungleTree> trees;
-	private String uuid;
-	private TreeEditor editor;
-	public static void main(String args[])
-	{
-		DefaultJungle j = new DefaultJungle(null,"hoge",new DefaultTreeEditor(new DefaultTraverser()));
-		JungleTree t = j.createNewTree("fuga");
-		
-		JungleTreeEditor e1 = t.getTreeEditor();
-		
-		DefaultNodePath root = new DefaultNodePath();
-		
-		Either<Error,JungleTreeEditor> either = e1.addNewChildAt(root,0);
-		e1 = either.b();
-		either = e1.addNewChildAt(root.add(0),0);
-		e1 = either.b();
-		e1.success();
-	}
-	
-  public DefaultJungle(Journal journal,String uuid,TreeEditor editor)
-	{
-		this.journal = new NullJournal();
-		this.trees = new ConcurrentHashMap<String,JungleTree>();
-		this.uuid = uuid;
-		this.editor = editor;
-	}
+public class DefaultJungle implements Jungle {
+    private Journal journal;
+    private ConcurrentHashMap<String, JungleTree> trees;
+    private String uuid;
+    private TreeEditor editor;
+
+    public static void main(String args[]) {
+        DefaultJungle j = new DefaultJungle(null, "hoge", new DefaultTreeEditor(new DefaultTraverser()));
+        JungleTree t = j.createNewTree("fuga");
+
+        JungleTreeEditor e1 = t.getTreeEditor();
+
+        DefaultNodePath root = new DefaultNodePath();
+
+        Either<Error, JungleTreeEditor> either = e1.addNewChildAt(root, 0);
+        e1 = either.b();
+        either = e1.addNewChildAt(root.add(0), 0);
+        e1 = either.b();
+        e1.success();
+    }
+
+    public DefaultJungle(Journal journal, String uuid, TreeEditor editor) {
+        this.journal = new NullJournal();
+        this.trees = new ConcurrentHashMap<String, JungleTree>();
+        this.uuid = uuid;
+        this.editor = editor;
+    }
 
-	@Override
-	public JungleTree getTreeByName(String name)
-	{
-		return trees.get(name);
-	}
+    @Override
+    public JungleTree getTreeByName(String name) {
+        return trees.get(name);
+    }
+
+    @Override
+    public JungleTree createNewTree(final String name) {
+        ChangeList list = new ChangeList() {
+            @Override
+            public Iterator<TreeOperation> iterator() {
+                List<TreeOperation> nil = List.nil();
+                return nil.iterator();
+            }
 
-	@Override
-	public JungleTree createNewTree(final String name)
-	{
-		ChangeList list = new ChangeList(){
-			@Override
-			public Iterator<TreeOperation> iterator() {
-				List<TreeOperation> nil = List.nil();
-				return nil.iterator();
-			}
-			@Override
-			public String uuid() {
-				return uuid;
-			}
-			@Override
-			public String getTreeName() {
-				return name;
-			}
-			
-		};
-		DefaultTreeNode root = new DefaultTreeNode();
-	  TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList = TreeMap.empty(Ord.stringOrd);
-		TreeMap<TreeNode, TreeNode> parentIndex = new ParentIndex().getParentIndex();
-		TreeContext tc = new DefaultTreeContext(root,null,list,uuid,name,0,indexList,parentIndex);
-		JungleTree newTree = new DefaultJungleTree(tc,uuid,journal.getWriter(),editor);
-		if(trees.putIfAbsent(name,newTree) != null){
-			return null;
-		}
-		return newTree;
-	}
+            @Override
+            public String uuid() {
+                return uuid;
+            }
+
+            @Override
+            public String getTreeName() {
+                return name;
+            }
+
+        };
+        DefaultTreeNode root = new DefaultTreeNode();
+        InterfaceTraverser traverser = new InterfaceTraverser(root, true);
+        TreeContext tc = new DefaultTreeContext(root, null, list, uuid, name, 0, traverser);
+        JungleTree newTree = new DefaultJungleTree(tc, uuid, journal.getWriter(), editor);
+        if (trees.putIfAbsent(name, newTree) != null) {
+            return null;
+        }
+        return newTree;
+    }
 }
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java	Fri Mar 20 15:35:53 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java	Mon Mar 23 15:44:28 2015 +0900
@@ -1,5 +1,6 @@
 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle;
 
+import fj.data.List;
 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.NodePath;
@@ -19,90 +20,89 @@
 
 public class DefaultJungleTree implements JungleTree {
 
-  private final AtomicReference<TreeContext> repository;
-  private final String uuid;
-  private final ChangeListWriter writer;
-  private final TreeEditor treeEditor;
-
-  public DefaultJungleTree(TreeContext tc, String uuid, ChangeListWriter writer, TreeEditor editor) {
-    this.repository = new AtomicReference<TreeContext>(tc);
-    this.uuid = uuid;
-    this.writer = writer;
-    this.treeEditor = editor;
-  }
+    private final AtomicReference<TreeContext> repository;
+    private final String uuid;
+    private final ChangeListWriter writer;
+    private final TreeEditor treeEditor;
 
-  @Override
-  public JungleTreeEditor getTreeEditor() {
-    TreeContext tc = repository.get();
-    DefaultTransactionManager txManager = new DefaultTransactionManager(writer, tc, repository, uuid);
-    TreeNode root = tc.getRoot();
-    return new DefaultJungleTreeEditor(root, txManager, treeEditor);
-  }
+    public DefaultJungleTree(TreeContext tc, String uuid, ChangeListWriter writer, TreeEditor editor) {
+        this.repository = new AtomicReference<TreeContext>(tc);
+        this.uuid = uuid;
+        this.writer = writer;
+        this.treeEditor = editor;
+    }
 
-  @Override
-  public JungleTreeEditor getLocalTreeEditor() {
-    return getTreeEditor();
-  }
-
-  @Override
-  public TreeNode getRootNode() {
-    TreeContext tc = repository.get();
-    return tc.getRoot();
-  }
+    @Override
+    public JungleTreeEditor getTreeEditor() {
+        TreeContext tc = repository.get();
+        DefaultTransactionManager txManager = new DefaultTransactionManager(writer, tc, repository, uuid);
+        TreeNode root = tc.getRoot();
+        return new DefaultJungleTreeEditor(root, txManager, treeEditor);
+    }
 
-  @Override
-  public InterfaceTraverser getTraverser(boolean useIndex) {
-    TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> index = getIndex();
-    ParentIndex parentIndex = getParentIndex();
-    return new InterfaceTraverser(repository.get().getRoot(), index, parentIndex, useIndex);
-  }
+    @Override
+    public JungleTreeEditor getLocalTreeEditor() {
+        return getTreeEditor();
+    }
 
-  @Override
-  public ParentIndex getParentIndex() {
-    TreeContext tc = repository.get();
-    return tc.getParentIndex();
-  }
+    @Override
+    public TreeNode getRootNode() {
+        TreeContext tc = repository.get();
+        return tc.getRoot();
+    }
 
-  @Override
-  public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex() {
-    TreeContext tc = repository.get();
-    return tc.getIndex();
-  }
+    @Override
+    public InterfaceTraverser getTraverser(boolean useIndex) {
+        TreeContext tc = repository.get();
+        return tc.getTraverser();
+    }
 
-  @Override
-  public long revision() {
-    TreeContext tc = repository.get();
-    return tc.revision();
-  }
-
-  @Override
-  public Either<Error, JungleTree> getOldTree(long revision) {
-    TreeContext tc = repository.get();
-
-    for (; tc.revision() != revision;) {
-      tc = tc.prev();
-      if (tc == null)
-        return DefaultEither.newA(GetOldTreeError.OLD_TREE_NOT_FOUND);
+    @Override
+    public ParentIndex getParentIndex() {
+        TreeContext tc = repository.get();
+        return tc.getParentIndex();
     }
 
+    @Override
+    public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
+        TreeContext tc = repository.get();
+        return tc.getIndex();
+    }
 
-    String oldTreeUuid = uuid + revision;
-    JungleTree oldTree = new DefaultJungleTree(tc, oldTreeUuid, writer, treeEditor);
-    return DefaultEither.newB(oldTree);
-  }
+    @Override
+    public long revision() {
+        TreeContext tc = repository.get();
+        return tc.revision();
+    }
+
+    @Override
+    public Either<Error, JungleTree> getOldTree(long revision) {
+        TreeContext tc = repository.get();
 
-  @Override
-  public Either<Error, TreeNode> getNodeOfPath(NodePath path) {
-    TreeNode node = repository.get().getRoot();
-    for (int num : path) {
-      if (num == -1)
-        continue;
-      Either<Error, TreeNode> either = node.getChildren().at(num);
-      if (either.isA())
-        return either;
-      node = either.b();
+        for (; tc.revision() != revision; ) {
+            tc = tc.prev();
+            if (tc == null)
+                return DefaultEither.newA(GetOldTreeError.OLD_TREE_NOT_FOUND);
+        }
+
+
+        String oldTreeUuid = uuid + revision;
+        JungleTree oldTree = new DefaultJungleTree(tc, oldTreeUuid, writer, treeEditor);
+        return DefaultEither.newB(oldTree);
     }
-    return DefaultEither.newB(node);
-  }
+
+    @Override
+    public Either<Error, TreeNode> getNodeOfPath(NodePath path) {
+        TreeNode node = repository.get().getRoot();
+        for (int num : path) {
+            if (num == -1)
+                continue;
+            Either<Error, TreeNode> either = node.getChildren().at(num);
+            if (either.isA())
+                return either;
+            node = either.b();
+        }
+        return DefaultEither.newB(node);
+    }
 
 }
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTree.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTree.java	Fri Mar 20 15:35:53 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTree.java	Mon Mar 23 15:44:28 2015 +0900
@@ -1,7 +1,7 @@
 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle;
 
 
-
+import fj.data.List;
 import fj.data.TreeMap;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
@@ -10,15 +10,22 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
-public interface JungleTree
-{
-	public JungleTreeEditor getTreeEditor();
-	public JungleTreeEditor getLocalTreeEditor();
+public interface JungleTree {
+    public JungleTreeEditor getTreeEditor();
+
+    public JungleTreeEditor getLocalTreeEditor();
+
     public TreeNode getRootNode();
-  public long revision();
-  public Either<Error, JungleTree> getOldTree(long revision);
-  public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex();
-  public ParentIndex getParentIndex();
-  public InterfaceTraverser getTraverser(boolean useIndex);
-  public Either<Error, TreeNode> getNodeOfPath(NodePath path);
+
+    public long revision();
+
+    public Either<Error, JungleTree> getOldTree(long revision);
+
+    public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex();
+
+    public ParentIndex getParentIndex();
+
+    public InterfaceTraverser getTraverser(boolean useIndex);
+
+    public Either<Error, TreeNode> getNodeOfPath(NodePath path);
 }
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/TreeContext.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/TreeContext.java	Fri Mar 20 15:35:53 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/TreeContext.java	Mon Mar 23 15:44:28 2015 +0900
@@ -1,25 +1,32 @@
 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store;
 
 
-
+import fj.data.List;
 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.shoshi.jungle.traverser.InterfaceTraverser;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
-public interface TreeContext
-{
-	public TreeNode getRoot();
-	public TreeContext prev();
-	public ChangeList getChangeList();
-	
-	public String uuid();
-	public String getTreeName();
-	public long revision();
-	public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex();
-	public Iterable<TreeOperation> getOperations();
+public interface TreeContext {
+    public TreeNode getRoot();
+
+    public TreeContext prev();
+
+    public ChangeList getChangeList();
+
+    public String uuid();
+
+    public String getTreeName();
+
+    public long revision();
+
+    public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex();
+
+    public Iterable<TreeOperation> getOperations();
+
     public ParentIndex getParentIndex();
-    public void setIndex(TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> index);
-    public void setParentIndex(ParentIndex parentIndex);
+
+    public InterfaceTraverser getTraverser();
 }
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java	Fri Mar 20 15:35:53 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java	Mon Mar 23 15:44:28 2015 +0900
@@ -4,6 +4,7 @@
 import java.util.Iterator;
 import java.util.concurrent.atomic.AtomicReference;
 
+import fj.data.List;
 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;
@@ -58,9 +59,7 @@
 
     InterfaceTraverser traverser = new InterfaceTraverser(newRoot, true);
     traverser.createIndex();
-    TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> index = traverser.getIndex();
-    ParentIndex parentIndex = traverser.getParentIndex();
-    TreeContext newTreeContext = new DefaultTreeContext(newRoot , tip, list, uuid, _treeName, nextRevision,index,parentIndex.getParentIndex());
+    TreeContext newTreeContext = new DefaultTreeContext(newRoot , tip, list, uuid, _treeName, nextRevision,traverser);
 
     if  (repository.compareAndSet(newTreeContext.prev(),newTreeContext)) {
         TransactionManager txManager = new DefaultTransactionManager(writer, newTreeContext, repository, uuid);
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeContext.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeContext.java	Fri Mar 20 15:35:53 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeContext.java	Mon Mar 23 15:44:28 2015 +0900
@@ -1,98 +1,81 @@
 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction;
 
+import fj.data.List;
 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.TreeContext;
 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.traverser.InterfaceTraverser;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
-public class DefaultTreeContext implements TreeContext
-{
-	private final TreeNode root;
-	private final TreeContext previous;
-	private final ChangeList changeList;
-	private final String uuid;
-	private final String treeName;
-	private final long revision;
-	private TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList;
-	private TreeMap<TreeNode, TreeNode> parentIndex;
+public class DefaultTreeContext implements TreeContext {
+    private final TreeNode root;
+    private final TreeContext previous;
+    private final ChangeList changeList;
+    private final String uuid;
+    private final String treeName;
+    private final long revision;
+    private final InterfaceTraverser traverser;
 
-  public DefaultTreeContext(TreeNode _node,TreeContext _prev,ChangeList _log,String _uuid, String _treeName, long _revision,  TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList,
-            TreeMap<TreeNode, TreeNode> parentIndex)
-	{
-		this.root = _node;
-		this.previous = _prev;
-		this.changeList = _log;
-		this.uuid = _uuid;
-		this.treeName = _treeName;
-		this.revision = _revision;
-		this.indexList = indexList;
-		this.parentIndex = parentIndex;
-	}
+    public DefaultTreeContext(TreeNode _node, TreeContext _prev, ChangeList _log, String _uuid, String _treeName, long _revision, InterfaceTraverser traverser) {
+        this.root = _node;
+        this.previous = _prev;
+        this.changeList = _log;
+        this.uuid = _uuid;
+        this.treeName = _treeName;
+        this.revision = _revision;
+        this.traverser = traverser;
+    }
 
 
     @Override
-	public TreeNode getRoot()
-	{
-		return root;
-	}
-
-	@Override
-	public TreeContext prev()
-	{
-		return previous;
-	}
-
-	@Override
-	public ChangeList getChangeList()
-	{
-		return changeList;
-	}
-
-	@Override
-	public String uuid()
-	{
-		return  uuid;
-	}
+    public TreeNode getRoot() {
+        return root;
+    }
 
-	@Override
-	public String getTreeName()
-	{
-		return treeName;
-	}
-
-	@Override
-	public long revision()
-	{
-		return revision;
-	}
-
-	@Override
-	public Iterable<TreeOperation> getOperations()
-	{
-		return changeList;
-	}
-
-	@Override
-	public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex() {
-		return indexList;
-	}
-
-
-  @Override
-  public ParentIndex getParentIndex() {
-    return new ParentIndex(parentIndex);
-  }
+    @Override
+    public TreeContext prev() {
+        return previous;
+    }
 
     @Override
-    public void setIndex(TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList) {
-        this.indexList = indexList;
+    public ChangeList getChangeList() {
+        return changeList;
+    }
+
+    @Override
+    public String uuid() {
+        return uuid;
+    }
+
+    @Override
+    public String getTreeName() {
+        return treeName;
     }
 
     @Override
-    public void setParentIndex(ParentIndex parentIndex) {
-        this.parentIndex = parentIndex.getParentIndex();
+    public long revision() {
+        return revision;
+    }
+
+    @Override
+    public Iterable<TreeOperation> getOperations() {
+        return changeList;
     }
 
+    @Override
+    public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
+        return traverser.getIndex();
+    }
+
+    @Override
+    public ParentIndex getParentIndex() {
+        return traverser.getParentIndex();
+    }
+
+    @Override
+    public InterfaceTraverser getTraverser() {
+        return traverser;
+    }
 }
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeAttribute.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeAttribute.java	Fri Mar 20 15:35:53 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeAttribute.java	Mon Mar 23 15:44:28 2015 +0900
@@ -64,8 +64,8 @@
 			return null;
 		}
 		
-		Option<ByteBuffer> result = attrs.get(_key);
-		return result.isSome() ? result.some() : null;
+		ByteBuffer result = attrs.getLoop(_key);
+		return result;
 	}
 
     @Override
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java	Fri Mar 20 15:35:53 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java	Mon Mar 23 15:44:28 2015 +0900
@@ -4,6 +4,7 @@
 
 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.store.NulIterator;
@@ -16,327 +17,306 @@
 
 public class InterfaceTraverser {
 
-  TreeNode root;
-  TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList;
-  ParentIndex parentIndex;
-  boolean parentUpdateFlag;
-  boolean useIndex;
-
-  public InterfaceTraverser(TreeNode root, boolean indexFlag) {
-    this(root, TreeMap.empty(Ord.stringOrd), new ParentIndex(), indexFlag);
-  }
+    TreeNode root;
+    TreeMap<String, TreeMap<String, List<TreeNode>>> indexList;
+    ParentIndex parentIndex;
+    boolean parentUpdateFlag;
+    boolean useIndex;
 
-  public InterfaceTraverser(TreeNode root, TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> index,
-      ParentIndex parentIndex, boolean useIndex) {
-    this.root = root;
-    this.indexList = index;
-    this.parentIndex = parentIndex;
-    if (parentIndex.isEmpty())
-      parentUpdateFlag = true;
-    else
-      parentUpdateFlag = false;
-    this.useIndex = useIndex;
-  }
+    public InterfaceTraverser(TreeNode root, boolean indexFlag) {
+        this(root, TreeMap.empty(Ord.stringOrd), new ParentIndex(), indexFlag);
+    }
 
-  public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex() {
-    return indexList;
-  }
+    public InterfaceTraverser(TreeNode root, TreeMap<String, TreeMap<String, List<TreeNode>>> index,
+                              ParentIndex parentIndex, boolean useIndex) {
+        this.root = root;
+        this.indexList = index;
+        this.parentIndex = parentIndex;
+        if (parentIndex.isEmpty())
+            parentUpdateFlag = true;
+        else
+            parentUpdateFlag = false;
+        this.useIndex = useIndex;
+    }
 
-  public void commit() {
-    parentUpdateFlag = false;
-  }
-
-  public ParentIndex getParentIndex() {
-    return parentIndex;
-  }
+    public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
+        return indexList;
+    }
 
-  public void setIndex(TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> index) {
-    this.indexList = index;
-  }
+    public void commit() {
+        parentUpdateFlag = false;
+    }
+
+    public ParentIndex getParentIndex() {
+        return parentIndex;
+    }
 
-  public void createIndex() {
-    // long t1 = System.currentTimeMillis();
-    IndexCreater creater = new IndexCreater(root);
-    // long t2 = System.currentTimeMillis();
-    // System.out.println("createIndex time = " + (t2 - t1));
-    indexList = creater.getIndex();
-    parentIndex = creater.getParentIndex();
-  }
+    public void createIndex() {
+        // long t1 = System.currentTimeMillis();
+        IndexCreater creater = new IndexCreater(root);
+        // long t2 = System.currentTimeMillis();
+        // System.out.println("createIndex time = " + (t2 - t1));
+        indexList = creater.getIndex();
+        parentIndex = creater.getParentIndex();
+    }
 
-  /**
-   * subTree以下のNodeに対してKey,Valueのペアでindexを使って探索を行う
-   * 
-   * @param query
-   * @param subTree
-   * @param key
-   * @param searchValue
-   * @return
-   */
-  // public Iterator<TreeNode> findInSubTree(final Query query, TreeNode
-  // subTree, String key, String searchValue) {
-  // /*
-  // * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から１つずつ比較し、
-  // * 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,Valueのペアでindexを使って探索を行う
+     *
+     * @param query
+     * @param subTree
+     * @param key
+     * @param searchValue
+     * @return
+     */
+    // public Iterator<TreeNode> findInSubTree(final Query query, TreeNode
+    // subTree, String key, String searchValue) {
+    // /*
+    // * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から１つずつ比較し、
+    // * 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を使って探索する
-   */
-  // public Iterator<TreeNode> findInSubTreeAllValue(final Query query, TreeNode
-  // subTree, String key) {
-  // /*
-  // * indexからinnerIndexを取得 取得したinnerIndexが保有するKeyを取得
-  // * そのKeyを保有するNodeとNodeのPathを取得する
-  // * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から１つずつ比較し、
-  // * 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() {
-  // }
-  //
-  // };
-  // }
-  // }
+    /**
+     * subTree以下のNodeに対してKeyに対応する値をindexを使って探索する
+     */
+    // public Iterator<TreeNode> findInSubTreeAllValue(final Query query, TreeNode
+    // subTree, String key) {
+    // /*
+    // * indexからinnerIndexを取得 取得したinnerIndexが保有するKeyを取得
+    // * そのKeyを保有するNodeとNodeのPathを取得する
+    // * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から１つずつ比較し、
+    // * 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() {
+    // }
+    //
+    // };
+    // }
+    // }
+    public Iterator<TreeNode> find(final Query query, final String key, String searchValue) {
 
-  public Iterator<TreeNode> find(final Query query, final String key, String searchValue) {
-
-    Iterator<TreeNode> nodeIterator = get(key, searchValue);
-    if (nodeIterator != null && useIndex) {
-      return nodeIterator;
-    } else {
-
-      final PathNodeIterator itNode = new PathNodeIterator(root);
-      return new Iterator<TreeNode>() {
-
-        private TreeNode matchNode = nextmatch(itNode);
-
-        private TreeNode nextmatch(PathNodeIterator itNode) {
+        Iterator<TreeNode> nodeIterator = get(key, searchValue);
+        if (nodeIterator != null && useIndex) {
+            return nodeIterator;
+        } else {
 
-          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;
-        }
+            final PathNodeIterator itNode = new PathNodeIterator(root);
+            return new Iterator<TreeNode>() {
+
+                private TreeNode matchNode = nextmatch(itNode);
+
+                private TreeNode nextmatch(PathNodeIterator itNode) {
 
-        @Override
-        public boolean hasNext() {
-          if (matchNode == null) {
-            return false;
-          }
-          return true;
-        }
+                    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 TreeNode next() {
-          TreeNode currentPair = matchNode;
-          matchNode = nextmatch(itNode);
-          return currentPair;
-        }
+                @Override
+                public boolean hasNext() {
+                    if (matchNode == null) {
+                        return false;
+                    }
+                    return true;
+                }
 
-        @Override
-        public void remove() {
-        }
+                @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() {
-  // }
-  //
-  // };
-  // }
-  // }
-  
-  public Iterator<TreeNode> get(String key, String value) {
+    // 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() {
+    // }
+    //
+    // };
+    // }
+    // }
 
-    Option<TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexOp = indexList.get(key);
-    if (indexOp.isNone())
-      return null;
+    public Iterator<TreeNode> get(String key, String value) {
 
-    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>() {
+        TreeMap<String, List<TreeNode>> index = indexList.getLoop(key);
+        if (index == null)
+            return null;
 
-      @Override
-      public boolean hasNext() {
-        return mapIterator.hasNext();
-      }
-
-      @Override
-      public TreeNode next() {
-        return mapIterator.next()._1();
-      }
-
-    };
-  }
+        List<TreeNode> nodeList = index.getLoop(value);
+        if (nodeList == null)
+            return new NulIterator<TreeNode>();
+        return nodeList.iterator();
+    }
 }
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexCreater.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexCreater.java	Fri Mar 20 15:35:53 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexCreater.java	Mon Mar 23 15:44:28 2015 +0900
@@ -12,104 +12,102 @@
 
 public class IndexCreater {
 
-  TreeNode root;
-  TreeNode node;
-  int childNumber;
-  private TreeNodeChildren children;
-  private Stack<TreeNode> nodeStack = new Stack<TreeNode>();
-  private Stack<Integer> searchStack = new Stack<Integer>();
-  ParentIndex parentIndex = new ParentIndex();
-  TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList = TreeMap.empty(Ord.stringOrd);
+    TreeNode root;
+    TreeNode node;
+    int childNumber;
+    private TreeNodeChildren children;
+    private Stack<TreeNode> nodeStack = new Stack<TreeNode>();
+    private Stack<Integer> searchStack = new Stack<Integer>();
+    ParentIndex parentIndex = new ParentIndex();
+    TreeMap<String, TreeMap<String, List<TreeNode>>> indexList = TreeMap.empty(Ord.stringOrd);
 
-  public IndexCreater(TreeNode rootNode) {
-    this.root = rootNode;
-    this.node = rootNode;
-    while (node != null) {
-      TreeNode targetNode = node;
-      List<String> keys = targetNode.getAttributes().getKeys();
-      for (String key : keys) {
-        String value = targetNode.getAttributes().getString(key);
-        if (value != null)
-          indexList = set(key, value, targetNode);
-      }
-      if (node.getChildren().size() > 0) {
-        nodeStack.push(node);
-        TreeNode parent = node;
-        children = node.getChildren();
-        node = children.at(0).b();
-        parentIndex.set(parent, node);
-        childNumber = 1;
-        searchStack.push(childNumber);
-      } else if (node == root) {
-        node = null; // no more node
-        children = null;
-        return;
-      } else if (children != null && children.size() > childNumber) {
-        childNumber = searchStack.pop();
-        TreeNode parent = nodeStack.pop();
-        nodeStack.push(parent);
-        node = children.at(childNumber).b();
-        parentIndex.set(parent, node);
-        searchStack.push(++childNumber);
-      } else {
-        node = nodeStack.pop();
-        children = node.getChildren();
-        childNumber = searchStack.pop();
-        for (; children.size() == childNumber;) {
-          if (node == root) {
-            node = null; // no more node
-            children = null;
-            return;
-          }
-          node = nodeStack.pop();
-          children = node.getChildren();
-          childNumber = searchStack.pop();
+    public IndexCreater(TreeNode rootNode) {
+        this.root = rootNode;
+        this.node = rootNode;
+        while (node != null) {
+            TreeNode targetNode = node;
+            List<String> keys = targetNode.getAttributes().getKeys();
+            for (String key : keys) {
+                String value = targetNode.getAttributes().getString(key);
+                if (value != null)
+                    indexList = set(key, value, targetNode);
+            }
+            if (node.getChildren().size() > 0) {
+                nodeStack.push(node);
+                TreeNode parent = node;
+                children = node.getChildren();
+                node = children.at(0).b();
+                parentIndex.set(parent, node);
+                childNumber = 1;
+                searchStack.push(childNumber);
+            } else if (node == root) {
+                node = null; // no more node
+                children = null;
+                return;
+            } else if (children != null && children.size() > childNumber) {
+                childNumber = searchStack.pop();
+                TreeNode parent = nodeStack.pop();
+                nodeStack.push(parent);
+                node = children.at(childNumber).b();
+                parentIndex.set(parent, node);
+                searchStack.push(++childNumber);
+            } else {
+                node = nodeStack.pop();
+                children = node.getChildren();
+                childNumber = searchStack.pop();
+                for (; children.size() == childNumber; ) {
+                    if (node == root) {
+                        node = null; // no more node
+                        children = null;
+                        return;
+                    }
+                    node = nodeStack.pop();
+                    children = node.getChildren();
+                    childNumber = searchStack.pop();
+                }
+                if (node != null && childNumber < children.size()) {
+                    nodeStack.push(node);
+                    TreeNode parent = node;
+                    node = children.at(childNumber).b();
+                    parentIndex.set(parent, node);
+                    searchStack.push(++childNumber);
+                }
+            }
         }
-        if (node != null && childNumber < children.size()) {
-          nodeStack.push(node);
-          TreeNode parent = node;
-          node = children.at(childNumber).b();
-          parentIndex.set(parent, node);
-          searchStack.push(++childNumber);
-        }
-      }
-    }
-  }
-
-  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);
+    public TreeMap<String, TreeMap<String, List<TreeNode>>> set(String key, String value, TreeNode node) {
+
+        TreeMap<String, List<TreeNode>> index = indexList.getLoop(key);
+        if (index == null) {
+            index = TreeMap.empty(Ord.stringOrd);
+            List<TreeNode> nodeList = List.nil();
+            nodeList = nodeList.cons(node);
+            TreeMap<String, List<TreeNode>> newIndex = index.set(value, nodeList);
+            indexList = indexList.set(key, newIndex);
+            return indexList;
+        }
 
-    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);
+        List<TreeNode> nodeList = index.getLoop(value);
+
+        List<TreeNode> newNodeList;
+        if (nodeList != null) {
+            newNodeList = nodeList.cons(node);
+        } else {
+            nodeList = List.nil();
+            newNodeList = nodeList.cons(node);
+        }
+        TreeMap<String, List<TreeNode>> newIndex = index.set(value, newNodeList);
+        indexList = indexList.set(key, newIndex);
+
+        return indexList;
     }
-    TreeMap<String, TreeMap<TreeNode, TreeNode>> newIndex = index.set(value, newNodeMap);
-    indexList = indexList.set(key, newIndex);
 
-    return indexList;
-  }
+    public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
+        return indexList;
+    }
 
-  public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex() {
-    return indexList;
-  }
-
-  public ParentIndex getParentIndex() {
-    return parentIndex;
-  }
+    public ParentIndex getParentIndex() {
+        return parentIndex;
+    }
 }
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/ParentIndex.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/ParentIndex.java	Fri Mar 20 15:35:53 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/ParentIndex.java	Mon Mar 23 15:44:28 2015 +0900
@@ -33,9 +33,9 @@
   }
 
   public TreeNode get(TreeNode child) {
-    Option<TreeNode> parentOp = parentIndex.get(child);
-    if (parentOp.isSome())
-      return parentOp.some();
+    TreeNode parent = parentIndex.getLoop(child);
+    if (parent != null)
+      return parent;
     return null;
   }
 
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/FJListAccessThread.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/FJListAccessThread.java	Mon Mar 23 15:44:28 2015 +0900
@@ -0,0 +1,42 @@
+package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test;
+
+
+import fj.data.List;
+import fj.data.Option;
+
+import java.util.Iterator;
+
+/**
+ * Created by e115731 on 15/03/21.
+ */
+public class FJListAccessThread extends AbstractTreeMapThread {
+    Option<List<String>> list;
+    private long findCount;
+    boolean loop = true;
+
+    public FJListAccessThread(Option<List<String>> list) {
+        this.list = list;
+    }
+
+    @Override
+    public long getFindCount() {
+        System.out.println("thread count = " + findCount);
+        return findCount;
+    }
+
+    @Override
+    public void set(boolean loop) {
+        this.loop = loop;
+    }
+
+    @Override
+    public void run() {
+        while (loop) {
+            Iterator<String> it = list.some().iterator();
+            for (; it.hasNext(); ) {
+                String str = it.next();
+            }
+            findCount++;
+        }
+    }
+}
\ No newline at end of file
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/FJTreeMapGetIteratorThread.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/FJTreeMapGetIteratorThread.java	Mon Mar 23 15:44:28 2015 +0900
@@ -0,0 +1,44 @@
+package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test;
+
+
+import fj.P2;
+import fj.data.Option;
+import fj.data.TreeMap;
+
+import java.util.Iterator;
+
+
+/**
+ * Created by e115731 on 15/03/17.
+ */
+public class FJTreeMapGetIteratorThread extends AbstractTreeMapThread {
+    TreeMap<String, String> map;
+    private long findCount;
+    boolean loop = true;
+
+    public FJTreeMapGetIteratorThread(TreeMap map) {
+        this.map = map;
+    }
+
+    @Override
+    public long getFindCount() {
+        System.out.println("thread count = " + findCount);
+        return findCount;
+    }
+
+    @Override
+    public void set(boolean loop) {
+        this.loop = loop;
+    }
+
+    @Override
+    public void run() {
+        while (loop) {
+            Iterator<P2<String, String>> it = map.iterator();
+            for (; it.hasNext(); ) {
+                if (it.next()._2().equals("50"))
+                    findCount++;
+            }
+        }
+    }
+}
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/FJTreeMapGetLoopThread.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/FJTreeMapGetLoopThread.java	Mon Mar 23 15:44:28 2015 +0900
@@ -0,0 +1,45 @@
+package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test;
+
+import fj.P2;
+import fj.data.Option;
+import fj.data.TreeMap;
+
+import java.util.Iterator;
+
+/**
+ * Created by e115731 on 15/03/17.
+ */
+public class FJTreeMapGetLoopThread extends AbstractTreeMapThread {
+
+    TreeMap<String, String> map;
+    private long findCount;
+    boolean loop = true;
+
+    public FJTreeMapGetLoopThread(TreeMap map) {
+        this.map = map;
+    }
+
+    @Override
+    public long getFindCount() {
+        System.out.println("thread count = " + findCount);
+        return findCount;
+    }
+
+    @Override
+    public void set(boolean loop) {
+        this.loop = loop;
+    }
+
+    @Override
+    public void run() {
+        while (loop) {
+            String op = map.getLoop("50");
+            if (op  != null)
+                findCount++;
+            else
+                System.out.println("faild");
+
+
+        }
+    }
+}
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/FunctionalTreeMapReadThread.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/FunctionalTreeMapReadThread.java	Fri Mar 20 15:35:53 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,40 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test;
-
-import fj.data.Option;
-import fj.data.TreeMap;
-
-/**
- * Created by e115731 on 15/03/17.
- */
-public class FunctionalTreeMapReadThread extends AbstractTreeMapThread{
-
-    TreeMap<String,String> map;
-    private long findCount;
-    boolean loop = true;
-
-    public FunctionalTreeMapReadThread(TreeMap map) {
-        this.map = map;
-    }
-
-    @Override
-    public long getFindCount() {
-        System.out.println("thread count = " + findCount);
-        return findCount;
-    }
-
-    @Override
-    public void set(boolean loop) {
-        this.loop = loop;
-    }
-
-    @Override
-    public void run() {
-        while (loop) {
-             Option<String> op = map.get("test");
-             if (op.isSome())
-                 findCount++;
-            else
-                System.out.println("faild");
-        }
-    }
-}
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/JungleBenchMark.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/JungleBenchMark.java	Fri Mar 20 15:35:53 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/JungleBenchMark.java	Mon Mar 23 15:44:28 2015 +0900
@@ -24,25 +24,42 @@
     public static void main(String[] args) throws InterruptedException, IOException, ParserConfigurationException, SAXException {
 
 
-        if (args.length == 0) {
-            System.out.println("args read or find");
+        if (args.length < 1) {
+            System.out.println("args[0] = read or find, args[1] = separate or nonSeparate");
             System.exit(0);
         }
 
-        Jungle jungle = new DefaultJungle(null, "hoge", new DefaultTreeEditor(new DefaultTraverser()));
-        JungleTree tree = jungle.createNewTree("Person");
-        JungleTreeEditor editor = tree.getTreeEditor();
-        JungleTreeEditor newEditor = createTree(0,new DefaultNodePath(),editor);
-        if (newEditor.success().isA()) {
-            System.out.println("success faild");
-            System.exit(1);
-        }
-
         Runtime rt = Runtime.getRuntime();
         int cpuNum = rt.availableProcessors();
 
+        Jungle jungle = new DefaultJungle(null, "hoge", new DefaultTreeEditor(new DefaultTraverser()));
+        JungleTree trees[] = new JungleTree[cpuNum];
 
-        File file = new File("./time/JungleTree" + args[0] + "Time");
+        if (args[1].equals("separate")){
+            for (int count = 0; count < cpuNum; count++) {
+                JungleTree tree = jungle.createNewTree("tree" + count);
+                JungleTreeEditor editor = tree.getTreeEditor();
+                editor = editor.putAttribute(new DefaultNodePath(), "key", ByteBuffer.wrap(String.valueOf(0).getBytes())).b();
+                JungleTreeEditor newEditor = createTree(0, new DefaultNodePath(), editor);
+                if (newEditor.success().isA()) {
+                    System.out.println("success faild");
+                    System.exit(1);
+                }
+                trees[count] = tree;
+            }
+        } else {
+            JungleTree tree = jungle.createNewTree("tree" );
+            JungleTreeEditor editor = tree.getTreeEditor();
+            editor = editor.putAttribute(new DefaultNodePath(), "key", ByteBuffer.wrap(String.valueOf(0).getBytes())).b();
+            JungleTreeEditor newEditor = createTree(0, new DefaultNodePath(), editor);
+            if (newEditor.success().isA()) {
+                System.out.println("success faild");
+                System.exit(1);
+            }
+            trees[0] = tree;
+        }
+
+        File file = new File("./time/" + args[1] + "JungleTree" + args[0] + "Time");
 
         PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(file)));
 
@@ -50,13 +67,21 @@
 
         for (int THREAD_COUNT = 1; THREAD_COUNT <= cpuNum; THREAD_COUNT++) {
             readThread = new JungleBenchMarkThread[THREAD_COUNT];
-
+            JungleTree tree = null;
             if (args[0].equals("read")) {
                 for (int count = 0; THREAD_COUNT > count; count++) {
+                    if (args[1].equals("separate"))
+                        tree = trees[count];
+                    else
+                        tree = trees[0];
                     readThread[count] = new readTreeAttributeThread(tree);
                 }
             } else if (args[0].equals("find")) {
                 for (int count = 0; THREAD_COUNT > count; count++) {
+                    if (args[1].equals("separate"))
+                        tree = trees[count];
+                    else
+                        tree = trees[0];
                     readThread[count] = new findTreeAttributeThread(tree);
                 }
             } else {
@@ -76,26 +101,29 @@
             for (int count = 0; THREAD_COUNT > count; count++) {
                 readCount = readCount + readThread[count].getFindCount();
                 readThread[count].set(false);
+                readThread[count] = null;
             }
 
             pw.println(THREAD_COUNT + " " + readCount);
             System.out.println(THREAD_COUNT + "readCount = " + readCount);
+            System.gc();
+            System.out.println("-------------GC--------------");
+            Thread.sleep(1000);
         }
 
         pw.close();
     }
 
-    static Integer nodeNum = 0;
+    static Integer nodeNum = 1;
+
     public static JungleTreeEditor createTree(int deep, NodePath path, JungleTreeEditor editor) {
 
         Random rnd = new Random();
         String value1 = String.valueOf(nodeNum);
-        nodeNum ++;
+        nodeNum++;
         String value2 = String.valueOf(nodeNum);
-        nodeNum ++;
+        nodeNum++;
 
-        if (value1.equals("500"))
-            System.out.println("aaa");
         editor = editor.addNewChildAt(path, 0).b();
         editor = editor.putAttribute(path.add(0), "key", ByteBuffer.wrap(value1.getBytes())).b();
         editor = editor.addNewChildAt(path, 1).b();
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/TreeMapBenchMark.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/TreeMapBenchMark.java	Fri Mar 20 15:35:53 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/TreeMapBenchMark.java	Mon Mar 23 15:44:28 2015 +0900
@@ -1,6 +1,8 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test;
 
 import fj.Ord;
+import fj.data.List;
+import fj.data.Option;
 import fj.data.TreeMap;
 import org.xml.sax.SAXException;
 
@@ -15,35 +17,46 @@
 
 
         if (args.length == 0) {
-            System.out.println("args fj or util");
+            System.out.println("args get or getLoop or list");
             System.exit(0);
         }
 
         Runtime rt = Runtime.getRuntime();
         int cpuNum = rt.availableProcessors();
 
-        File file = new File("./time//get" + args[0] + "TreeMapTime");
+        File file = new File("./time/" + args[0] + "Time");
 
         PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(file)));
 
         AbstractTreeMapThread readThread[] = null;
 
-            for (int THREAD_COUNT = 1; THREAD_COUNT <= cpuNum; THREAD_COUNT++) {
+        TreeMap<String, String> map = TreeMap.empty(Ord.stringOrd);
+        List<String> list = List.nil();
+        if (args[0].equals("list")) {
+            for (int count = 0 ;count < 100 ; count++) {
+                list = list.cons(String.valueOf(count));
+            }
+        }
+        for (int count = 0 ;count < 1000 ; count++) {
+            map = map.set(String.valueOf(count), String.valueOf(count));
+        }
+        for (int THREAD_COUNT = 1; THREAD_COUNT <= cpuNum; THREAD_COUNT++) {
+
                 readThread = new AbstractTreeMapThread[THREAD_COUNT];
 
-                if (args[0].equals("fj")) {
-                    TreeMap<String, String> map = TreeMap.empty(Ord.stringOrd);
-                    map = map.set("test","'test");
+                if (args[0].equals("getLoop")) {
                     for (int count = 0; THREAD_COUNT > count; count++) {
-                        readThread[count] = new FunctionalTreeMapReadThread(map);
+                        readThread[count] = new FJTreeMapGetLoopThread(map);
                     }
-                } else if (args[0].equals("util")) {
-                    java.util.TreeMap map = new java.util.TreeMap();
-                    map.put("test","test");
+                } else if (args[0].equals("get")) {
                     for (int count = 0; THREAD_COUNT > count; count++) {
-                        readThread[count] = new UtilTreeMapReadThread(map);
+                        readThread[count] = new FJTreeMapGetIteratorThread(map);
                     }
-                } else {
+                } else if (args[0].equals("list")) {
+                    for (int count = 0; THREAD_COUNT > count; count++) {
+                        readThread[count] = new FJListAccessThread(Option.<List<String>>some(list));
+                    }
+                } else{
                     System.out.println("not allow args");
                     System.exit(0);
                 }
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/UtilTreeMapReadThread.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/UtilTreeMapReadThread.java	Fri Mar 20 15:35:53 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,40 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test;
-
-
-import java.util.TreeMap;
-
-/**
- * Created by e115731 on 15/03/17.
- */
-public class UtilTreeMapReadThread extends AbstractTreeMapThread {
-
-    TreeMap map;
-    private long findCount;
-
-    boolean loop = true;
-
-    public UtilTreeMapReadThread(TreeMap map) {
-        this.map = map;
-    }
-
-    @Override
-    public long getFindCount() {
-        System.out.println("thread count = " + findCount);
-        return findCount;
-    }
-
-    @Override
-    public void set(boolean loop) {
-        this.loop = loop;
-    }
-
-    @Override
-    public void run() {
-        while (loop) {
-            if (map.get("test").equals("test"))
-                findCount++;
-            else
-                System.out.println("faild");
-        }
-    }
-}
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/findTreeAttributeThread.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/findTreeAttributeThread.java	Fri Mar 20 15:35:53 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/findTreeAttributeThread.java	Mon Mar 23 15:44:28 2015 +0900
@@ -12,14 +12,14 @@
 public class findTreeAttributeThread extends JungleBenchMarkThread {
 
     JungleTree tree;
-    InterfaceTraverser traverser;
+    //InterfaceTraverser traverser;
     private long findCount;
 
     boolean loop = true;
 
     public findTreeAttributeThread(JungleTree tree) {
         this.tree = tree;
-        this.traverser = tree.getTraverser(false);
+     //   this.traverser = tree.getTraverser(true);
         this.findCount = 0;
     }
 
@@ -36,20 +36,13 @@
     @Override
     public void run() {
         while (loop) {
+            InterfaceTraverser traverser = tree.getTraverser(false);
+   //         Iterator<TreeNode> it = traverser.find((TreeNode node) -> {return true;}, "key", "0");
 
-            Iterator<TreeNode> it = traverser.find((TreeNode node) -> {
-                String nodeNum = node.getAttributes().getString("key");
-                if (nodeNum == null)
-                    return false;
-                if (nodeNum.equals("8"))
-                        return true;
-                return false;
-                    }, "key","8");
-
-            if (it.hasNext())
-                findCount++;
-            else
-                System.out.println("faild");
+ //           if (it.hasNext()) {
+              findCount++;
+  //          } else
+  //              System.out.println("faild");
         }
     }
 }
diff -r 67d4c68578cf -r 066d9c5758dc src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/readTreeAttributeThread.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/readTreeAttributeThread.java	Fri Mar 20 15:35:53 2015 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/readTreeAttributeThread.java	Mon Mar 23 15:44:28 2015 +0900
@@ -3,6 +3,8 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
 
+import java.nio.ByteBuffer;
+
 /**
  * Created by e115731 on 15/03/17.
  */
@@ -20,7 +22,7 @@
 
     @Override
     public long getFindCount() {
-        System.out.println("thread count = " + findCount);
+        System.out.println("thread couny  = " + findCount);
         return findCount;
     }
 
@@ -32,13 +34,13 @@
     public void run() {
         while (loop) {
             TreeNode root = tree.getRootNode();
-            if (root != null)
-                findCount++;
-                   String attribute = root.getAttributes().getString("test");
-                 if (attribute.equals("test"))
-                   findCount++;
-                 else
-                   System.out.println("faild");
+            if (root != null) {
+                String attribute = root.getAttributes().getString("key");
+                if (attribute.equals("0"))
+                    findCount++;
+                else
+                    System.out.println("faild");
+            }
         }
     }
 }