Mercurial > hg > Members > shoshi > jungle > jungle-core

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/DefaultJungle.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,85 @@
+package jp.ac.u_ryukyu.ie.cr.jungle;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.persistent.Journal;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultTraverser;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.persistent.ChangeList;
+import jp.ac.u_ryukyu.ie.cr.jungle.persistent.NullJournal;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.TreeContext;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.TreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.TreeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeContext;
+import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.InterfaceTraverser;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+import java.util.Iterator;
+import java.util.concurrent.ConcurrentHashMap;
+
+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 createNewTree(final String name) {
+        ChangeList list = new ChangeList() {
+            @Override
+            public Iterator<TreeOperation> iterator() {
+                List<TreeOperation> nil = new List();
+                return nil.iterator();
+            }
+
+            @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;
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/DefaultJungleTree.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,108 @@
+package jp.ac.u_ryukyu.ie.cr.jungle;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.persistent.ChangeListWriter;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.TreeContext;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.TreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultJungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTransactionManager;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.InterfaceTraverser;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.GetOldTreeError;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.index.ParentIndex;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+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;
+    }
+
+    @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 JungleTreeEditor getLocalTreeEditor() {
+        return getTreeEditor();
+    }
+
+    @Override
+    public TreeNode getRootNode() {
+        TreeContext tc = repository.get();
+        return tc.getRoot();
+    }
+
+    @Override
+    public InterfaceTraverser getTraverser(boolean useIndex) {
+        TreeContext tc = repository.get();
+        return tc.getTraverser();
+    }
+
+    @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();
+    }
+
+    @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);
+        }
+
+
+        String oldTreeUuid = uuid + revision;
+        JungleTree oldTree = new DefaultJungleTree(tc, oldTreeUuid, writer, treeEditor);
+        return DefaultEither.newB(oldTree);
+    }
+
+    @Override
+    public Either<jp.ac.u_ryukyu.ie.cr.jungle.util.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);
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/Jungle.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,8 @@
+package jp.ac.u_ryukyu.ie.cr.jungle;
+
+
+public interface Jungle
+{
+	public JungleTree getTreeByName(String name);
+	public JungleTree createNewTree(String name);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/JungleTree.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,31 @@
+package jp.ac.u_ryukyu.ie.cr.jungle;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.InterfaceTraverser;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.index.ParentIndex;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
+
+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, List<TreeNode>>> getIndex();
+
+    public ParentIndex getParentIndex();
+
+    public InterfaceTraverser getTraverser(boolean useIndex);
+
+    public Either<Error, TreeNode> getNodeOfPath(NodePath path);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/JungleTreeEditor.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,20 @@
+package jp.ac.u_ryukyu.ie.cr.jungle;
+
+import java.nio.ByteBuffer;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.NodeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+public interface JungleTreeEditor
+{
+
+	public Either<Error,JungleTreeEditor> addNewChildAt(NodePath path,int pos);
+	public Either<Error,JungleTreeEditor> deleteChildAt(NodePath path,int pos);
+	public Either<Error,JungleTreeEditor> putAttribute(NodePath path,String key,ByteBuffer value);
+	public Either<Error,JungleTreeEditor> deleteAttribute(NodePath path,String key);
+	public Either<Error,JungleTreeEditor> edit(NodePath path,NodeEditor editor);
+	public Either<Error,JungleTreeEditor> success();
+  public Either<Error, JungleTreeEditor> replaceNewRootNode();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/benchMark/JungleBenchMark.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,54 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.benchMark;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.DefaultJungle;
+import jp.ac.u_ryukyu.ie.cr.jungle.Jungle;
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultTraverser;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.InterfaceTraverser;
+
+import java.nio.ByteBuffer;
+import java.util.Iterator;
+
+
+/**
+ * Created by e115731 on 15/05/07.
+ */
+public class JungleBenchMark {
+    public static void main(String args[]) {
+        Jungle jungle = new DefaultJungle(null, "hogehoge", new DefaultTreeEditor(new DefaultTraverser()));
+        jungle.createNewTree("tree");
+        JungleTree tree = jungle.getTreeByName("tree");
+        JungleTreeEditor editor = tree.getTreeEditor();
+        NodePath path = new DefaultNodePath().add(0);
+        for (int count = 1; count <= 10; count++) {
+            for (int personCount = 0; personCount < 1000 * count; personCount++) {
+                editor = editor.replaceNewRootNode().b();
+                editor = editor.putAttribute(path, "personId", ByteBuffer.wrap(("p:" + personCount).getBytes())).b();
+                editor = editor.putAttribute(path, "roleId", ByteBuffer.wrap(("r:" + personCount).getBytes())).b();
+            }
+            editor.success();
+            long t1 = System.currentTimeMillis();
+            for (int findCount = 0; findCount < 50000; ) {
+                InterfaceTraverser traverser = tree.getTraverser(true);
+                Iterator<TreeNode> it = traverser.find(null, "personId", "p:100");
+                if (it.hasNext()) {
+                    TreeNode targetNode = it.next();
+                    String targetRoleId = targetNode.getAttributes().getString("roleId");
+                    if (targetRoleId.equals("r:100"))
+                        findCount++;
+                } else {
+                    System.out.println("find miss");
+                    System.exit(1);
+                }
+            }
+            long t2 = System.currentTimeMillis();
+            System.out.println("time = " + (t2 - t1));
+        }
+
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/core/App.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,42 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.core;
+
+import java.nio.ByteBuffer;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.DefaultJungle;
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultTraverser;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+/**
+ * Hello world!
+ *
+ */
+public class App
+{
+    public static void main( String[] args )
+    {
+    	DefaultJungle jungle = new DefaultJungle(null,"sample", new DefaultTreeEditor(new DefaultTraverser()));
+    	jungle.createNewTree("hoge");
+    	JungleTree tree = jungle.getTreeByName("hoge");
+    	JungleTreeEditor editor = tree.getTreeEditor();
+    	DefaultNodePath path = new DefaultNodePath();
+
+    	String key = "key";
+    	ByteBuffer value = ByteBuffer.wrap(key.getBytes());
+
+    	Either<Error,JungleTreeEditor> either = editor.putAttribute(path,"key",value);
+    	JungleTreeEditor e = either.b();
+    	e.success();
+
+
+    	TreeNode root = tree.getRootNode();
+    	ByteBuffer v = root.getAttributes().get(key);
+    	String str = new String(v.array());
+    	System.out.println(str);
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/core/Attributes.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,9 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.core;
+
+import java.nio.ByteBuffer;
+
+public interface Attributes
+{
+	public ByteBuffer get(String key);
+	public String getString(String key);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/core/AttributesContainer.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,6 @@
+//package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core;
+//
+//public interface AttributesContainer
+//{
+//	public Attributes getAttributes();
+//}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/core/Children.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,11 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.core;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+public interface Children extends Iterable<TreeNode>
+{
+	public Either<Error,TreeNode> at(int pos);
+	public int size();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/data/list/DefaultNode.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,79 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.data.list;
+
+/**
+ * Created by e115731 on 15/05/16.
+ */
+public class DefaultNode<T> implements Node<T> {
+    private final T attribute;
+    private final Node next;
+
+    //最終的に消す
+    int num = 0;
+
+    public DefaultNode(T attribute, int num, Node next) {
+        this.attribute = attribute;
+        this.next = next;
+    }
+//ここまで
+
+    public DefaultNode(T attribute, Node next) {
+        this.attribute = attribute;
+        this.next = next;
+    }
+
+    public int getNum() {
+        return num;
+    }
+
+    public Node getNext() {
+        return next;
+    }
+
+    public T getAttribute() {
+        return attribute;
+    }
+
+    public Node<T> addLast(T attribute) {
+        Node<T> node = next.addLast(attribute);
+        return new DefaultNode<T>(this.attribute, node);
+    }
+
+    public Node<T> add(int currentNum, int num, T attribute) {
+        if (currentNum == num) {
+            Node<T> newNode = new DefaultNode(attribute, num, this.next);
+            return new DefaultNode<T>(this.attribute, this.num + 1, newNode);
+        }
+
+        Node<T> newNode = next.add(currentNum + 1, num, attribute);
+        if (newNode == null)
+            return null;
+
+        return new DefaultNode(this.attribute,  newNode);
+    }
+
+    @Override
+    public Node<T> delete(int deleteNum) {
+        if (this.num - 1 == deleteNum) {
+            return new DefaultNode(this.attribute, deleteNum, this.next.getNext());
+        }
+
+        Node<T> newNode = next.delete(deleteNum);
+        if (newNode == null)
+            return null;
+
+        return new DefaultNode(this.attribute, this.num - 1, newNode);
+    }
+
+    @Override
+    public Node<T> replaceNode(int num, T attribute) {
+        if (this.num == num) {
+            return new DefaultNode(attribute, num, this.getNext());
+        }
+
+        Node<T> newNode = next.replaceNode(num, attribute);
+        if (newNode == null)
+            return null;
+
+        return new DefaultNode(this.attribute, this.num, newNode);
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/data/list/List.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,163 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.data.list;
+
+import java.util.Iterator;
+import java.util.Stack;
+
+/**
+ * Created by e115731 on 15/05/16.
+ * 非破壊であるためこのListは逆順になっています
+ */
+public class List<T> implements Iterable<T> {
+    final private Node<T> head;
+    final private int listLength;
+
+    public List() {
+        this.head = new headNode();
+        this.listLength = 0;
+    }
+
+    public List(T... attributes) {
+        List<T> list = new List();
+        for (T attribute : attributes) {
+            list = list.addLast(attribute);
+        }
+        this.head = list.getHead();
+        this.listLength = head.getNext().getNum() + 1;
+    }
+
+    private List(Node<T> head) {
+        this.head = head;
+        this.listLength = head.getNext().getNum() + 1;
+    }
+
+    public Node<T> getHead() {
+        return head;
+    }
+
+    public List<T> add(int num, T attribute) {
+        Node<T> newHead = head.add(0,num, attribute);
+        if (newHead == null)
+            return this;
+        return new List<T>(newHead);
+    }
+
+    public List<T> addLast(T attribute) {
+        Node<T> newHead = head.addLast(attribute);
+        return new List<T>(newHead);
+    }
+
+
+    public T index(int num) {
+        int count = 0;
+        Node<T> currentNode = head.getNext();
+        while (currentNode != null) {
+            if (count == num)
+                return currentNode.getAttribute();
+            currentNode = currentNode.getNext();
+            count ++;
+        }
+        return null;
+    }
+
+    public Iterator<T> iterator() {
+        return new Iterator<T>() {
+            Node<T> currentNode = head.getNext();
+
+            @Override
+            public boolean hasNext() {
+                return currentNode.getNum() != -1;
+            }
+
+            @Override
+            public T next() {
+                T attribute = currentNode.getAttribute();
+                currentNode = currentNode.getNext();
+                return attribute;
+            }
+        };
+    }
+
+    public Iterator<T> reverseIterator() {
+        Node<T> currentNode = head.getNext();
+        Stack<T> stack = new Stack();
+        while (currentNode.getNum() != -1) {
+            stack.push(currentNode.getAttribute());
+            currentNode = currentNode.getNext();
+        }
+        return new Iterator<T>() {
+
+            @Override
+            public boolean hasNext() {
+                return !stack.isEmpty();
+            }
+
+            @Override
+            public T next() {
+                return stack.pop();
+            }
+        };
+    }
+
+
+    public List<T> delete(int num) {
+        Node<T> newNode = head.delete(num);
+        if (newNode == null)
+            return this;
+        Node<T> newHead = new headNode<>(newNode);
+        return new List<T>(newNode);
+    }
+
+    public List<T> replace(int num, T attribute) {
+        Node<T> newHead = head.replaceNode(num, attribute);
+        if (newHead == null)
+            return this;
+        return new List<T>(newHead);
+    }
+
+    public T last() {
+        return head.getNext().getAttribute();
+    }
+
+    public T head() {
+        return index(0);
+    }
+
+    public List<T> deleteLast() {
+        return delete(listLength - 1);
+    }
+
+    public List<T> deleteHead() {
+        return delete(0);
+    }
+
+    public int length() {
+        return listLength;
+    }
+
+    @Override
+    public String toString() {
+        String pathString = "<";
+        Iterator<T> iterator = reverseIterator();
+        while (true) {
+            pathString += iterator.next();
+            if (iterator.hasNext())
+                pathString += ",";
+            else
+                break;
+        }
+        pathString += ">";
+        return pathString;
+    }
+
+    public List<T> append(List<T> list) {
+        Iterator<T> iterator = list.reverseIterator();
+        List<T> newList = this;
+        while (iterator.hasNext()) {
+            T attribute = iterator.next();
+            newList = newList.addLast(attribute);
+        }
+        return newList;
+    }
+
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/data/list/Node.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,20 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.data.list;
+
+/**
+ * Created by e115731 on 15/05/18.
+ */
+public interface Node<T> {
+    public int getNum();
+
+    public Node<T> getNext();
+
+    public T getAttribute();
+
+    public Node<T> add(int currentNum, int num, T attribute);
+
+    public Node<T> addLast(T attribute);
+
+    public Node<T> delete(int num);
+
+    Node<T> replaceNode(int num, T attribute);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/data/list/TailNode.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,43 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.data.list;
+
+/**
+ * Created by e115731 on 15/05/19.
+ */
+public class TailNode<T> implements Node<T> {
+
+    @Override
+    public int getNum() {
+        return -1;
+    }
+
+    @Override
+    public Node<T> getNext() {
+        return null;
+    }
+
+    @Override
+    public T getAttribute() {
+        return null;
+    }
+
+    @Override
+    public Node<T> add(int currentNum, int num, T attribute) {
+        return null;
+    }
+
+    @Override
+    public Node<T> delete(int num) {
+        return null;
+    }
+
+    @Override
+    public Node<T> replaceNode(int num, T attribute) {
+        return null;
+    }
+
+    @Override
+    public Node<T> addLast(T attribute) {
+        return new DefaultNode<T>(attribute, this);
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/data/list/headNode.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,70 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.data.list;
+
+/**
+ * Created by e115731 on 15/05/18.
+ */
+public class headNode<T> implements Node<T> {
+    private final Node next;
+
+
+    public headNode() {
+        this.next = new TailNode<T>();
+    }
+
+    public headNode(Node next) {
+        this.next = next;
+    }
+
+    public int getNum() {
+        return -1;
+    }
+
+    public Node getNext() {
+        return next;
+    }
+
+    public T getAttribute() {
+        return null;
+    }
+
+    public Node<T> add(int currentNum, int num, T attribute) {
+        if (num == 0) {
+            Node<T> newNode = new DefaultNode<>(attribute, next);
+            return new headNode<T>(newNode);
+        }
+        Node<T> newNode = next.add(currentNum + 1, num, attribute);
+        if (newNode == null)
+            return this;
+        return new headNode(newNode);
+    }
+
+    public Node<T> addLast(T attribute) {
+        Node<T> node = next.addLast(attribute);
+        return new headNode<T>(node);
+    }
+
+    public Node<T> delete(int deleteNum) {
+        if (getNext().getNum() == deleteNum) {
+            return new headNode(this.next.getNext());
+        }
+
+        Node<T> newNode = next.delete(deleteNum);
+        if (newNode == null)
+            return this;
+        return new headNode(newNode);
+    }
+
+    @Override
+    public Node<T> replaceNode(int num, T attribute) {
+        Node<T> nextNode = getNext();
+        if (nextNode.getNum() == num) {
+            Node<T> newNode = new DefaultNode(attribute, num, nextNode.getNext());
+            return new headNode(newNode);
+        }
+
+        Node<T> newNode = nextNode.replaceNode(num, attribute);
+        if (newNode == null)
+            return this;
+        return new headNode(newNode);
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/data/treemap/BlackNode.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,135 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.data.treemap;
+
+import org.junit.Test;
+
+
+public class BlackNode<K, V> extends Node<K, V> {
+
+
+    public BlackNode(K key, V value, Node<K, V> left, Node<K, V> right) {
+        super(key, value, left, right);
+    }
+
+
+    @Override
+    public Node deleteNode() throws RotateParent {
+        EmptyNode<K, V> emptyNode = new EmptyNode<K, V>(key);
+        throw new RotateParent(emptyNode);
+    }
+
+    @Override
+    @Test
+    protected int checkDepth(int count, int minCount) { // test method
+        count++;
+        minCount = left().checkDepth(count, minCount);
+        minCount = right().checkDepth(count, minCount);
+        count--;
+        return minCount;
+    }
+
+
+    @Override
+    protected boolean isNotEmpty() {
+        return true;
+    }
+
+    @Override
+    public Node<K, V> createNode(K key, V value, Node<K, V> left, Node<K, V> right) {
+        return new BlackNode<K, V>(key, value, left, right);
+    }
+
+
+    @Override
+    Node insBalance() {
+        Rotate spin = left.checkRotate(Rotate.L);
+
+        if (spin == Rotate.R) {
+            Node<K, V> leftChild = new BlackNode<K, V>(left.left().getKey(), left.left().getValue(), left.left().left(), left.left().right());
+            Node<K, V> rightChild = new BlackNode<K, V>(getKey(), getValue(), left.right(), right);
+            return new RedNode<K, V>(left.getKey(), left.getValue(), leftChild, rightChild);
+
+        } else if (spin == Rotate.LR) {
+            Node<K, V> leftChild = new BlackNode<K, V>(left.getKey(), left.getValue(), left.left(), left.right().left());
+            Node<K, V> rightChild = new BlackNode<K, V>(getKey(), getValue(), left.right().right(), right);
+            return new RedNode<K, V>(left.right().getKey(), left.right().getValue(), leftChild, rightChild);
+
+        }
+
+        spin = right.checkRotate(Rotate.R);
+        if (spin == Rotate.L) {
+            Node<K, V> leftChild = new BlackNode<K, V>(getKey(), getValue(), left, right.left());
+            Node<K, V> rightChild = new BlackNode<K, V>(right.right().getKey(), (V) right.right().getValue(), right.right().left(), right.right().right());
+            return new RedNode<K, V>(right.getKey(), right.getValue(), leftChild, rightChild);
+
+        } else if (spin == Rotate.RL) {
+            Node leftChild = new BlackNode(getKey(), getValue(), left, right.left().left());
+            Node rightChild = new BlackNode(right.getKey(), right.getValue(), right.left().right(), right.right());
+            return new RedNode(right.left().getKey(), right.left().getValue(), leftChild, rightChild);
+
+        }
+
+        return this;
+    }
+
+
+    @Override
+    Rotate checkRotate(Rotate side) {
+        return Rotate.N;
+    }
+
+    @Override
+    boolean isRed() {
+        return false;
+    }
+
+
+    /**
+     * @param parent
+     * @return
+     */
+    @Override
+    public Node replaceNode(Node<K, V> parent) throws RotateParent {
+        Node<K, V> newNode = null;
+        if (!this.left().isNotEmpty() && !this.right().isNotEmpty()) { //自身を削除する
+            return deleteNode();//黒が1つ減るので木のバランスを取る
+        } else if (this.left().isNotEmpty() && !this.right().isNotEmpty()) { //左の部分木を昇格させる
+            newNode = createNode(left().getKey(), left().getValue(), left().left(), left().right());
+            if (!this.left().isRed()) //昇格させる木のrootが黒だったらバランスを取る
+                throw new RotateParent(newNode);
+            return newNode;
+        } else if (!this.left().isNotEmpty() && this.right().isNotEmpty()) { //右の部分木を昇格させる
+            newNode = createNode(right().getKey(), right().getValue(), right().left(), right().right());
+            if (!this.right().isRed()) //昇格させる木のrootが黒だったらバランスを取る
+                throw new RotateParent(newNode);
+            return newNode;
+        } else {//子ノードが左右にある場合 二回目はここには入らない
+            //左の部分木の最大の値を持つNodeと自身を置き換える
+            Node<K, V> cur = this.left();
+            while (cur.right().isNotEmpty()) { //左の部分期の最大値を持つNodeを取得する
+                cur = cur.right();
+            }
+            if (this.left().right().isNotEmpty()) { //左の部分木が右の子を持っているか
+                try {
+                    Node leftSubTreeNode = this.left().deleteSubTreeMaxNode(null, Rotate.L);//最大値を削除した左の部分木を返す。rootはthisと同じ。
+                    Node<K, V> newParent = createNode(cur.getKey(), cur.getValue(), leftSubTreeNode, this.right()); //rootをcurと入れ替えることでNodeの削除は完了する
+                    return newParent;
+                } catch (RotateParent e) {
+                    Node leftSubTreeNode = e.getParent();
+                    Node<K, V> newParent = createNode(cur.getKey(), cur.getValue(), leftSubTreeNode, this.right());
+                    return leftSubTreeNode.deleteBalance(newParent);
+                }
+            } else {
+                Node leftSubTreeNode = null;
+                try {
+                    leftSubTreeNode = this.left().replaceNode(this);//右の子がいなかった場合、左の子を昇格させるだけで良い。
+                    Node newParent = createNode(this.left().getKey(), this.left().getValue(), leftSubTreeNode, this.right());
+                    return newParent;
+                } catch (RotateParent e) {
+                    Node node = e.getParent();
+                    Node newParent = createNode(this.left().getKey(), this.left().getValue(), leftSubTreeNode, this.right());
+                    return node.deleteBalance(newParent);
+                }
+            }
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/data/treemap/EmptyNode.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,82 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.data.treemap;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Created by e115731 on 15/03/25.
+ */
+public class EmptyNode<K, V> extends Node<K, V> {
+
+    public EmptyNode() {
+        super(null, null);
+    }
+
+    public EmptyNode(K key) { //keyは削除時の回転処理に使用する
+        super(key, null);
+    }
+
+    @Override // 回転処理時にEmptyNodeの子を見ることがあるのでleft rightでEmptyNodeを返すようにする
+    public Node<K, V> left() {
+        return new EmptyNode<>();
+    }
+
+    @Override
+    public Node<K, V> right() {
+        return new EmptyNode<>();
+    }
+
+
+    @Override
+    protected boolean isNotEmpty() {
+        return false;
+    }
+
+
+    @Override
+    public Node<K, V> createNode(K key, V value, Node<K, V> left, Node<K, V> right) {
+        return new RedNode<K, V>(key, value, new EmptyNode<K, V>(), new EmptyNode<K, V>());
+    }
+
+
+    public Node<K, V> put(K k, V value) {
+        return new RedNode(k, value, new EmptyNode<K, V>(), new EmptyNode<K, V>());
+    }
+
+    @Override
+    public Node replaceNode(Node<K, V> parent) { // not use method
+        return this;
+    }
+
+    @Override
+    protected Node deleteNode() { //not use method
+        return this;
+    }
+
+    @Override
+    Node insBalance() {
+        return this;
+    }
+
+    @Override
+    Rotate checkRotate(Rotate side) {
+        return Rotate.N;
+    }
+
+    @Override
+    boolean isRed() {
+        return false;
+    }
+
+    @Override
+    @Test
+    protected int checkDepth(int count,int minCount) { // test method
+        if (count < minCount | minCount == 0)
+            minCount = count;
+        System.out.println("depth = " + count);
+
+        Assert.assertTrue(count <=  2 * minCount);
+        return minCount;
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/data/treemap/Node.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,295 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.data.treemap;
+
+import org.junit.Test;
+
+import java.util.Optional;
+
+
+/**
+ * Created by e115731 on 15/03/23.
+ */
+public abstract class Node<K, V>  {
+
+    protected K key;
+    protected V value;
+    protected Node<K, V> right;
+    protected Node<K, V> left;
+
+    public Node(K key, V value) {
+        this.key = key;
+        this.value = value;
+    }
+
+    public Node(K key, V value, Node<K, V> left, Node<K, V> right) {
+        this.key = key;
+        this.value = value;
+        this.right = right;
+        this.left = left;
+    }
+
+    public Node<K, V> left() {
+        return left;
+    }
+
+    public int compare(Comparable<? super K> compareKey) {
+        return compareKey.compareTo(getKey());
+
+    }
+
+    public Optional<V> get(K key) {
+        Node<K, V> cur = this;
+        Comparable<? super K> k = (Comparable<? super K>) key;
+        while (cur.isNotEmpty()) {
+            int result = cur.compare(k);
+            if (result > 0)
+                cur = cur.right();
+            else if (result < 0)
+                cur = cur.left();
+            else if (result == 0)
+                return Optional.ofNullable(cur.getValue());
+        }
+        return Optional.ofNullable(null);
+    }
+
+
+    public Node<K, V> right() {
+        return right;
+    }
+
+    public K getKey() {
+        return key;
+    }
+
+    public V getValue() {
+        return value;
+    }
+
+
+    public Node<K, V> put(Comparable<? super K> k, V value) {
+        if (!isNotEmpty()) {
+            return createNode((K)k, value, left, right);
+        }
+        int result = compare(k);
+        if (result > 0) {
+            Node<K, V> node = right.put(k, value);
+            node = createNode(key, this.value, left, node);
+            return node.insBalance();
+        } else if (result < 0) {
+            Node node = left.put(k, value);
+            return createNode(key, this.value, node, right).insBalance();
+        }
+        return createNode(key, value, left, right); // equals
+
+    }
+
+    public Node<K, V> delete(Comparable<? super K> key, Node<K, V> parent, Rotate side) throws RotateParent {
+        if (this.isNotEmpty()) {
+            int result = compare(key);
+
+            try {
+                Node<K, V> node = null;
+                if (result > 0) {
+                    node = right.delete(key, this, Rotate.R);
+                    if (node == null)
+                        return null;
+                    if (parent == null)
+                        return node;
+                } else if (result < 0) {
+                    node = left.delete(key, this, Rotate.L);
+                    if (node == null)
+                        return null;
+                    if (parent == null)
+                        return node;
+                } else if (result == 0) {
+                    node = replaceNode(parent);
+                    if (parent == null)// equals
+                        return node;
+                    if (side == Rotate.R)
+                        return parent.createNode(parent.getKey(), parent.getValue(), parent.left(), node);
+                    else
+                        return parent.createNode(parent.getKey(), parent.getValue(), node, parent.right());
+                }
+                if (side == Rotate.L)
+                    return parent.createNode(parent.getKey(), parent.getValue(), node, parent.right());
+                else
+                    return parent.createNode(parent.getKey(), parent.getValue(), parent.left(), node);
+            } catch (RotateParent e) {
+                Node node = e.getParent();
+                if (parent != null)
+                    return node.deleteBalance(parent);
+                return node;
+            }
+        }
+        return null; // no key
+    }
+
+
+    public Node<K, V> deleteSubTreeMaxNode(Node<K, V> parent, Rotate side) throws RotateParent {
+        Node<K, V> node;
+        try {
+            if (right().isNotEmpty()) {//最大値のノードが取得できるまで潜る
+                node = right().deleteSubTreeMaxNode(this, Rotate.R);
+            } else {
+                node = this.replaceNode(parent);
+            }
+        } catch (RotateParent e) {
+            node = e.getParent();
+            if (parent == null)
+                throw e;
+            return node.deleteBalance(parent);
+        }
+        if (parent == null)
+            return node;
+        if (side == Rotate.R)
+            return parent.createNode(parent.getKey(), parent.getValue(), parent.left(), node);
+        else
+            return parent.createNode(parent.getKey(), parent.getValue(), node, parent.right());
+
+    }
+
+    public Node deleteBalance(Node<K, V> parent) throws RotateParent {
+        if (!isRed()) {
+            if (0 > compare((Comparable<? super K>) parent.getKey())) { //自身がどちらの子かを調べる
+                boolean rightChild = parent.left().right().isRed();
+                boolean leftChild = parent.left().left().isRed();
+
+                if (!parent.isRed()) { //親が黒
+                    if (!parent.left().isRed()) { //左の子が黒
+                        if (!rightChild && !leftChild)
+                            throw new RotateParent(rebuildThree(parent, Rotate.R));
+                        if (rightChild)
+                            return rebuildfive(parent, Rotate.R);
+                        else if (leftChild)
+                            return rebuildsix(parent, Rotate.R);
+                    } else { //左の子が赤
+                        return rebuildTwo(parent, Rotate.R);
+                    }
+                } else { //親が赤
+                    if (!rightChild && !leftChild)
+                        return rebuildFour(parent, Rotate.R);
+                    if (rightChild)
+                        return rebuildfive(parent, Rotate.R);
+                    else if (leftChild)
+                        return rebuildsix(parent, Rotate.R);
+                }
+            } else {
+                boolean rightChild = parent.right().right().isRed();
+                boolean leftChild = parent.right().left().isRed();
+
+                if (!parent.isRed()) { //親が黒
+                    if (!parent.right().isRed()) { //左の子が黒
+                        if (!rightChild && !leftChild)
+                            throw new RotateParent(rebuildThree(parent, Rotate.L));
+                        if (rightChild)
+                            return rebuildsix(parent, Rotate.L);
+                        else if (leftChild)
+                            return rebuildfive(parent, Rotate.L);
+                    } else { //左の子が赤
+                        return rebuildTwo(parent, Rotate.L);
+                    }
+                } else { //親が赤
+                    if (!rightChild && !leftChild)
+                        return rebuildFour(parent, Rotate.L);
+                    if (rightChild)
+                        return rebuildsix(parent, Rotate.L);
+                    else if (leftChild)
+                        return rebuildfive(parent, Rotate.L);
+                }
+            }
+        }
+        if (0 > (compare((Comparable<? super K>) parent.getKey())))
+            return parent.createNode(parent.getKey(), parent.getValue(), parent.left(), this);
+        else
+            return parent.createNode(parent.getKey(), parent.getValue(), this, parent.right());
+    }
+
+    protected Node<K, V> rebuildTwo(Node<K, V> parent, Rotate side) throws RotateParent { // case2
+        if (side == Rotate.L) { // rotate Left
+            Node<K, V> node = parent.right();
+            Node<K, V> leftSubTreeRoot = node.createNode(parent.getKey(), parent.getValue(), this, node.left()); // check
+            Node<K, V> leftNode = this.deleteBalance(leftSubTreeRoot);
+            Node<K, V> rightNode = node.right();
+            return parent.createNode(node.getKey(), node.getValue(), leftNode, rightNode);
+        } else {  // rotate Right
+            Node<K, V> node = parent.left();
+            Node<K, V> rightSubTreeRoot = node.createNode(parent.getKey(), parent.getValue(), node.right(), this);
+            Node<K, V> rightNode = this.deleteBalance(rightSubTreeRoot);
+            Node<K, V> leftNode = node.left();
+            return parent.createNode(node.getKey(), node.getValue(), leftNode, rightNode);
+        }
+    }
+
+    protected Node rebuildThree(Node<K, V> parent, Rotate side) { // case3 再帰
+        if (side == Rotate.L) {
+            Node<K, V> rightNode;
+            if (parent.right().isNotEmpty())
+                rightNode = new RedNode<K, V>(parent.right().getKey(), parent.right().getValue(), parent.right().left(), parent.right().right()); // check
+            else
+                rightNode = new EmptyNode<>();
+            return parent.createNode(parent.getKey(), parent.getValue(), this, rightNode);
+        } else {
+            Node<K, V> leftNode;
+            if (parent.left().isNotEmpty())
+                leftNode = new RedNode<K, V>(parent.left().getKey(), parent.left().getValue(), parent.left().left(), parent.left().right()); // check
+            else
+                leftNode = new EmptyNode<>();
+            return parent.createNode(parent.getKey(), parent.getValue(), leftNode, this);
+        }
+    }
+
+    protected Node rebuildFour(Node<K, V> parent, Rotate side) { //case 4
+        if (side == Rotate.R) {
+            Node<K, V> leftNode = new RedNode<K, V>(parent.left().getKey(), parent.left().getValue(), parent.left().left(), parent.left().right());
+            return new BlackNode<K, V>(parent.getKey(), parent.getValue(), leftNode, this);
+        } else {
+            Node<K, V> rightNode = new RedNode<K, V>(parent.right().getKey(), parent.right().getValue(), parent.right().left(), parent.right().right());
+            return new BlackNode<K, V>(parent.getKey(), parent.getValue(), this, rightNode);
+        }
+    }
+
+    protected Node rebuildfive(Node<K, V> parent, Rotate side) { //case5
+        if (side == Rotate.R) { // rotate Left
+            Node<K, V> leftChild = new RedNode<K, V>(parent.left().getKey(), parent.left().getValue(), parent.left().left(), parent.left().right().left());
+            Node<K, V> rightChild = parent.left().right().right();
+            Node<K, V> leftSubTreeRoot = new BlackNode<K, V>(parent.left().right().getKey(), parent.left().right().getValue(), leftChild, rightChild);
+            Node<K, V> newParent = parent.createNode(parent.getKey(), parent.getValue(), leftSubTreeRoot, this);
+            return this.rebuildsix(newParent, Rotate.R);
+        } else {  // rotate Right 修正済み
+            Node<K, V> leftChild = parent.right().left().left();
+            Node<K, V> rightChild = new RedNode<K, V>(parent.right().getKey(), parent.right().getValue(), parent.right().left().right(), parent.right().right());
+            Node<K, V> rightSubTreeRoot = new BlackNode<K, V>(parent.right().left().getKey(), parent.right().left().getValue(), leftChild, rightChild);
+            Node<K, V> newParent = parent.createNode(parent.getKey(), parent.getValue(), this, rightSubTreeRoot);
+            return this.rebuildsix(newParent, Rotate.L);
+        }
+    }
+
+    protected Node rebuildsix(Node<K, V> parent, Rotate side) { //case6
+        if (side == Rotate.L) { // rotate Left
+            Node<K, V> leftChild = parent.right().createNode(parent.getKey(), parent.getValue(), this, parent.right().left()); //check
+            Node<K, V> rightChild = new BlackNode<K, V>(parent.right().right().getKey(), parent.right().right().getValue(), parent.right().right().left(), parent.right().right().right());
+            return parent.createNode(parent.right().getKey(), parent.right().getValue(), leftChild, rightChild);
+        } else {  // rotate Right
+            Node<K, V> leftChild = new BlackNode<K, V>(parent.left().left().getKey(), parent.left().left().getValue(), parent.left().left().left(), parent.left().left().right());
+            Node<K, V> rightChild = parent.left().createNode(parent.getKey(), parent.getValue(), parent.left().right(), this);
+            return parent.createNode(parent.left().getKey(), parent.left().getValue(), leftChild, rightChild);
+        }
+    }
+
+
+    protected abstract boolean isNotEmpty();
+
+    public abstract Node<K, V> createNode(K key, V value, Node<K, V> left, Node<K, V> right);
+
+    abstract Node<K, V> insBalance();
+
+    abstract Rotate checkRotate(Rotate side);
+
+    abstract boolean isRed();
+
+    public abstract Node replaceNode(Node<K, V> parent) throws RotateParent;
+
+    protected abstract Node deleteNode() throws RotateParent;
+
+    @Test
+    protected abstract int checkDepth (int count , int minCount); // test method
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/data/treemap/RedNode.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,113 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.data.treemap;
+
+import org.junit.Test;
+
+/**
+ * Created by e115731 on 15/03/25.
+ */
+public class RedNode<K, V> extends Node<K, V> {
+
+
+    public RedNode(K key, V value, Node<K, V> left, Node<K, V> right) {
+        super(key, value, left, right);
+    }
+
+
+    @Override
+    protected boolean isNotEmpty() {
+        return true;
+    }
+
+    @Override
+    public Node<K, V> createNode(K key, V value, Node<K, V> left, Node<K, V> right) {
+        return new RedNode<K, V>(key, value, left, right);
+    }
+
+    @Override
+    protected Node<K, V> insBalance() {
+        return this;
+    }
+
+    @Override
+    protected Node deleteNode() throws RotateParent {
+        EmptyNode emptyNode = new EmptyNode(this.getKey());
+        return emptyNode;
+    }
+
+    @Override
+    Rotate checkRotate(Rotate side) {
+        if (side == Rotate.L) {
+            if (left.isRed())
+                return Rotate.R;
+            else if (right.isRed())
+                return Rotate.LR;
+            return Rotate.N;
+        } else {
+            if (left.isRed())
+                return Rotate.RL;
+            else if (right.isRed())
+                return Rotate.L;
+            return Rotate.N;
+        }
+    }
+
+    @Override
+    boolean isRed() {
+        return true;
+    }
+
+    @Override
+    public Node replaceNode(Node<K, V> parent) throws RotateParent {
+        Node<K, V> newNode = null;
+        if (!this.left().isNotEmpty() && !this.right().isNotEmpty()) { //自身を削除する
+            return deleteNode();
+        } else if (this.left().isNotEmpty() && !this.right().isNotEmpty()) { //左の部分木を昇格させる
+            newNode = left().createNode(left().getKey(), left().getValue(), left().left(), left().right());
+            return newNode;
+        } else if (!this.left().isNotEmpty() && this.right().isNotEmpty()) { //右の部分木を昇格させる
+            newNode = right().createNode(right().getKey(), right().getValue(), right().left(), right().right());
+            return newNode;
+        } else {//子ノードが左右にある場合
+            //左の部分木の最大の値を持つNodeと自身を置き換える
+            Node<K, V> cur = this.left();
+
+            while (cur.right().isNotEmpty()) {
+                cur = cur.right();
+            }
+            Node leftSubTreeNode = null;
+            if (this.left().right().isNotEmpty()) {
+                try {
+                    leftSubTreeNode = this.left().deleteSubTreeMaxNode(null,Rotate.L);
+                    newNode = createNode(cur.getKey(), cur.getValue(), leftSubTreeNode, this.right());
+                    return newNode;
+                } catch (RotateParent e) {
+                    leftSubTreeNode = e.getParent();
+                    Node<K, V> newParent = createNode(cur.getKey(), cur.getValue(), leftSubTreeNode, this.right());
+                    return leftSubTreeNode.deleteBalance(newParent);
+                }
+            } else {
+                try {
+                    leftSubTreeNode = this.left().replaceNode(this);
+                    newNode = createNode(cur.getKey(), cur.getValue(), leftSubTreeNode, this.right());
+                    return newNode;
+                } catch (RotateParent e) {
+                    Node node = e.getParent();
+                    Node newParent = createNode(this.left().getKey(), this.left().getValue(), leftSubTreeNode, this.right());
+                    return node.deleteBalance(newParent);
+                }
+            }
+
+        }
+    }
+
+
+    @Override
+    @Test
+    protected int checkDepth(int count,int minCount) { // test method
+        count ++;
+        minCount = left().checkDepth(count, minCount);
+        minCount = right().checkDepth(count, minCount);
+        count --;
+        return minCount;
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/data/treemap/Rotate.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,8 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.data.treemap;
+
+/**
+ * Created by e115731 on 15/03/23.
+ */
+public enum Rotate {
+    R, L, RL, LR, N;
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/data/treemap/RotateParent.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,15 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.data.treemap;
+
+/**
+ * Created by e115731 on 15/04/17.
+ */
+public class RotateParent extends Exception {
+    Node parent ;
+    public RotateParent(Node node) {
+        this.parent = node;
+    }
+
+    public Node getParent(){
+        return parent;
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/data/treemap/TreeMap.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,114 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.data.treemap;
+
+
+import org.junit.Test;
+
+import java.util.Iterator;
+import java.util.Optional;
+import java.util.Stack;
+
+
+/**
+ * Created by e115731 on 15/03/23.
+ */
+public class TreeMap<K, V> {
+    final Node<K, V> root;
+    final int size;
+
+    public TreeMap() {
+        this.root = new EmptyNode();
+        this.size = 0;
+    }
+
+
+    public Node getRoot() {
+        return root;
+    }
+
+    public TreeMap(Node<K, V> root, int size) {
+        this.root = root;
+        this.size = size;
+    }
+
+    public Optional<V> get(final K key) {
+        return root.get(key);
+    }
+
+    public TreeMap put(K key, V value) {
+
+        if (key == null || value == null)  // null check
+            throw new NullPointerException();
+
+        if (isEmpty()) {
+            Node<K, V> newRoot = new BlackNode(key, value, new EmptyNode(), new EmptyNode());
+            return new TreeMap<K, V>(newRoot, size + 1);
+        }
+
+        Node<K, V> newEntry = root.put((Comparable<? super K>) key, value);
+        Node<K, V> newRoot = new BlackNode(newEntry.getKey(), newEntry.getValue(), newEntry.left(), newEntry.right());
+        return new TreeMap(newRoot, 0);
+    }
+
+
+    public boolean isEmpty() {
+        return !root.isNotEmpty();
+    }
+
+
+    public TreeMap<K, V> delete(K key) {
+        Node node = null;
+        try {
+            node = root.delete((Comparable<? super K>) key, null, Rotate.N);
+        } catch (RotateParent rotateParent) {
+        }
+        if (node == null)
+            return this; // not key
+        if (!node.isNotEmpty())
+            return new TreeMap(new EmptyNode<>(), 0);
+        Node newRoot = new BlackNode(node.getKey(), node.getValue(), node.left(), node.right());
+        return new TreeMap(newRoot, 0);
+    }
+
+    public Iterator<K> keys() {
+        return new Iterator<K>() {
+            Stack<Node> nodeStack = new Stack();
+            Node currentNode = root;
+
+            @Override
+            public boolean hasNext() {
+                return currentNode != null;
+            }
+
+            @Override
+            public K next() {
+                K key = (K) currentNode.getKey();
+
+                if (currentNode.left().isNotEmpty()) {
+                    nodeStack.push(currentNode);
+                    currentNode = currentNode.left();
+                    return key;
+                } else  if (currentNode.right().isNotEmpty()) {
+                    currentNode = currentNode.right();
+                    return key;
+                } else if (nodeStack.isEmpty()) {
+                    currentNode = null;
+                    return key;
+                }
+
+                do {
+                    currentNode = nodeStack.pop().right();
+                    if (currentNode.isNotEmpty())
+                        return key;
+
+                } while (!nodeStack.isEmpty());
+                return key;
+            }
+        };
+    }
+
+    @Test
+    public void checkDepth() {
+        root.checkDepth(0, 0);
+        System.out.println("-----------------------------------");
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/error/BasicErrors.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,10 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.error;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultError;
+
+public class BasicErrors
+{
+	public static final jp.ac.u_ryukyu.ie.cr.jungle.util.Error NULL_VALUE_NOT_ALLOWED = new DefaultError();
+	public static final Error INDEX_OUT_OF_BOUNDS = new DefaultError();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/persistent/ChangeList.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,9 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.persistent;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.TreeOperation;
+
+public interface ChangeList extends Iterable<TreeOperation>
+{
+	public String uuid();
+	public String getTreeName();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/persistent/ChangeListReader.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,8 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.persistent;
+
+public interface ChangeListReader extends Iterable<ChangeList>
+{
+	public ChangeListReader newReader();
+	public ChangeList read();
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/persistent/ChangeListWriter.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,6 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.persistent;
+
+public interface ChangeListWriter
+{
+    public Result write(ChangeList operations);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/persistent/DefaultChangeListReader.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,49 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.persistent;
+
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.util.Iterator;
+import java.util.LinkedList;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.TreeOperation;
+
+// not thread safe
+public class DefaultChangeListReader implements ChangeListReader
+{
+	private long pos;
+	private ByteBuffer buf;
+	private FileChannel ch;
+
+	DefaultChangeListReader(FileChannel ch,ByteBuffer buf,long pos)
+	{
+		this.pos = pos;
+		this.buf = buf;
+		this.ch = ch;
+	}
+
+	@Override
+	public ChangeListReader newReader()
+	{
+		return new DefaultChangeListReader(ch,buf.asReadOnlyBuffer(),pos);
+	}
+
+	@Override
+	public ChangeList read()
+	{
+		LinkedList<TreeOperation> list = new LinkedList<TreeOperation>();
+
+		int size = buf.getInt();
+		if(size == 0){
+
+		}
+
+		return null;
+	}
+
+	@Override
+	public Iterator<ChangeList> iterator() {
+		return null;
+	}
+
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/persistent/DefaultChangeListWriter.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,29 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.persistent;
+
+import java.nio.ByteBuffer;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.TreeOperation;
+
+public class DefaultChangeListWriter implements ChangeListWriter
+{
+	public DefaultChangeListWriter(ByteBuffer buf)
+	{
+
+	}
+
+	@Override
+	public synchronized Result write(ChangeList operations)
+	{
+		for(TreeOperation op : operations){
+			ByteBuffer treeOpBuf = serializeTreeOperation(op);
+		}
+		return null;
+	}
+
+	private ByteBuffer serializeTreeOperation(TreeOperation op)
+	{
+
+		return null;
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/persistent/DefaultJournal.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,114 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.persistent;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileChannel.MapMode;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+/*
+ * text based journal.
+ *
+ * non terminal symbols
+ *
+ * JOURNAL => CHANGELISTS
+ * CHANGE_LISTS => CHANGE_LIST | CHANGE_LISTS
+ * CHANGE_LISTS => *EMPTY*
+ *
+ * CHANGE_LIST => OPERATIONS
+ * OPERATIONS => OPERATION CR | OPERATIONS
+ * OPERATIONS => *EMPTY*
+
+ * OPERATION => APPEND_CHILD | DELETE_CHILD | PUT_ATTRIBUTE | DELETE_ATTRIBUTE | COMMIT
+ * APPEND_CHILD => APPEND_CHILD_ID NODE_PATH INSERT_POSITION
+ * DELETE_CHILD => DELETE_CHILD_ID NODE_PATH DELETE_POSITION
+ * PUT_ATTRIBUTE => PUT_ATTRIBUTE_ID NODE_PATH KEY VALUE
+ * DELETE_ATTRIBUTE => DELTE_ATTRIBUTE_ID NODE_PATH KEY
+ * COMMIT => COMMIT_ID
+ *
+ * NODE_PATH => POSITION "." NODE_PATH | POSITION
+ *
+ * terminal symbols
+ *
+ * APPEND_CHILD_ID = "APPEND_CHILD"
+ * DELETE_CHILD_ID = "DELETE_CHILD"
+ * PUT_ATTRIBUTE_ID = "PUT_ATTRIBUTE"
+ * SET_ATTRIBUTE_ID = "SET_ATTRIBUTE"
+ * COMMIT_ID => "COMMIT"
+ * CR => \n
+ * INSERT_POSITION => INTEGER
+ * DELETE_POSITION => INTEGER
+ * KEY => "*"
+ * VALUE => "*"
+ *
+ */
+
+public class DefaultJournal implements Journal
+{
+	private final ChangeListWriter writer;
+
+	public static void main(String args[]) throws Exception
+	{
+		RandomAccessFile f = new RandomAccessFile("./miscs/1.dat","rw");
+		MappedByteBuffer a = f.getChannel().map(MapMode.READ_WRITE,10,10);
+		MappedByteBuffer b = f.getChannel().map(MapMode.READ_WRITE,10,10);
+		MappedByteBuffer c = f.getChannel().map(MapMode.READ_WRITE,20,10);
+
+		a.putInt(5);
+		System.out.println(b.getInt());
+		c.putInt(2);
+		a.force();
+		b.force();
+		c.force();
+
+		System.out.println(b.capacity());
+		MappedByteBuffer d = f.getChannel().map(MapMode.READ_WRITE,50,10);
+		d.putInt(2);
+		d.force();
+		System.out.println(d.getInt());
+	}
+
+	public static final int READ_BUFFER_SIZE = 1000000;  // 1MB
+	public static final int WRITE_BUFFER_SIZE = 1000000; // 1MB
+
+	private DefaultJournal()
+	{
+		writer = null;
+	}
+
+	public static Either<Error,DefaultJournal> newInstance(String fileName)
+	{
+		RandomAccessFile journal = null;
+		try{
+			journal = new RandomAccessFile(fileName,"rw");
+			FileChannel ch = journal.getChannel();
+			long length = journal.length();
+			ByteBuffer readBuf = ch.map(MapMode.READ_ONLY,0,READ_BUFFER_SIZE);
+			ByteBuffer writeBuf = ch.map(MapMode.READ_WRITE,length,WRITE_BUFFER_SIZE);
+
+		}catch(FileNotFoundException _e){
+			_e.printStackTrace();
+			return null; // should return Error here.
+		}catch(IOException _e){
+			_e.printStackTrace();
+		}
+		return null;
+	}
+
+	@Override
+	public ChangeListReader getReader()
+	{
+		return null;
+	}
+
+	@Override
+	public ChangeListWriter getWriter()
+	{
+		return writer;
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/persistent/DefaultJournalWriter.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,31 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.persistent;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+
+public class DefaultJournalWriter
+{
+	public DefaultJournalWriter(String _fileName)
+	{
+
+	}
+
+	public static Either<Error,DefaultJournalWriter> newInstance(String fileName)
+	{
+		RandomAccessFile journal = null;
+		try{
+			journal = new RandomAccessFile(fileName,"rw");
+			//FileChannel ch = journal.getChannel();
+			long length = journal.length();
+		}catch(FileNotFoundException e){
+
+		}catch(IOException e){
+
+		}
+
+		return null;
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/persistent/Journal.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,7 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.persistent;
+
+public interface Journal
+{
+	public ChangeListReader getReader();
+	public ChangeListWriter getWriter();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/persistent/NullJournal.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,82 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.persistent;
+
+
+import java.util.Iterator;
+
+
+
+public class NullJournal implements Journal
+{
+	private static final NullChangeListWriter NULL_WRITER = new NullChangeListWriter();
+	private static final NullChangeListReader NULL_READER = new NullChangeListReader();
+
+	@Override
+	public ChangeListReader getReader()
+	{
+		return NULL_READER;
+	}
+
+	@Override
+	public ChangeListWriter getWriter()
+	{
+		return NULL_WRITER;
+	}
+
+	private static class NullChangeListWriter implements ChangeListWriter
+	{
+		@Override
+		public Result write(ChangeList operations)
+		{
+			/*
+			for(TreeOperation op : _operations){
+				NodePath p = op.getNodePath();
+				NodeOperation nodeOp = op.getNodeOperation();
+				Command c = nodeOp.getCommand();
+				String args = "";
+				switch(c){
+					case PUT_ATTRIBUTE:
+						String key = nodeOp.getKey();
+						ByteBuffer value = nodeOp.getValue();
+						if(value.limit() < 100){
+							args = String.format("key:%s,value:%s",key,new String(value.array()));
+						}else{
+							args = String.format("key:%s,value:%d",key,value.limit());
+						}
+						break;
+					case DELETE_ATTRIBUTE:
+						args = String.format("key:%s",nodeOp.getKey());
+						break;
+					case APPEND_CHILD:
+						args = String.format("pos:%d",nodeOp.getPosition());
+						break;
+					case DELETE_CHILD:
+						args = String.format("pos:%d",nodeOp.getPosition());
+						break;
+				}
+				System.out.println(String.format("[%s:%s:%s]",c,p,args));
+			}
+			*/
+			return Result.SUCCESS;
+		}
+	}
+
+	private static class NullChangeListReader implements ChangeListReader
+	{
+		@Override
+		public ChangeListReader newReader()
+		{
+			return this;
+		}
+
+		@Override
+		public ChangeList read()
+		{
+			return null;
+		}
+
+		@Override
+		public Iterator<ChangeList> iterator() {
+			return null;
+		}
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/persistent/Result.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,6 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.persistent;
+
+public class Result
+{
+	public static Result SUCCESS = new Result();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/query/PathNodeIterator.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,80 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.query;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNodeChildren;
+
+import java.util.Iterator;
+import java.util.Stack;
+
+public class PathNodeIterator implements Iterator<TreeNode> {
+
+	TreeNode root;
+	TreeNode node;
+	int childNumber;
+	private TreeNodeChildren children;
+	private Stack<TreeNode> nodeStack = new Stack<TreeNode>();
+	private Stack<Integer> searchStack = new Stack<Integer>();
+
+	/*
+	 * get queryIndexCondition from query
+	 * if already index exists, use index
+	 * otherwise traverse tree and create index
+	 *
+	 * */
+	public PathNodeIterator(TreeNode root) {
+		this.root = root;
+		this.node = root;
+	}
+
+	@Override
+	public boolean hasNext() {
+		return node != null;
+	}
+
+	@Override
+	public TreeNode next() {
+		TreeNode now = node;
+		if (node.getChildren().size() > 0) {
+			nodeStack.push(node);
+			children = node.getChildren();
+			node = children.at(0).b();
+			childNumber = 1;
+			searchStack.push(childNumber);
+		} else if (node == root) {
+			node = null; // no more node
+			children = null;
+			return now;
+		}else if (children != null && children.size() > childNumber) {
+			childNumber = searchStack.pop();
+			node = children.at(childNumber).b();
+			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 now;
+				}
+				node = nodeStack.pop();
+				children = node.getChildren();
+				childNumber = searchStack.pop();
+			}
+			if (node != null && childNumber < children.size()) {
+				nodeStack.push(node);
+				node = children.at(childNumber).b();
+				searchStack.push(++childNumber);
+			}
+		}
+		return now;
+	}
+
+	@Override
+	public void remove() {
+		// TODO Auto-generated method stub
+
+	}
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/query/Query.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,7 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.query;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+
+public interface Query {
+	boolean condition(TreeNode _node);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/Command.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,10 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store;
+
+public enum Command
+{
+	APPEND_CHILD,
+	DELETE_CHILD,
+	PUT_ATTRIBUTE,
+	DELETE_ATTRIBUTE,
+	REPLACE_ROOT;
+}
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/Constants.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,7 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store;
+
+public class Constants
+{
+	public static final String DEFAULT_OWNER = "default";
+	public static final long DEFAULT_REVISION_START_NUMBER = 0;
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/NodePath.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,12 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Pair;
+
+public interface NodePath extends Iterable<Integer>
+{
+	public NodePath add(int pos);
+	public Pair<Integer,NodePath> pop();
+	public NodePath tail();
+	public int size();
+	public Pair<Integer,NodePath> last();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/NulIterator.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,19 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store;
+
+import java.util.Iterator;
+
+public class NulIterator<T> implements Iterator<T> {
+
+  @Override
+  public boolean hasNext() {
+    // TODO Auto-generated method stub
+    return false;
+  }
+
+  @Override
+  public T next() {
+    // TODO Auto-generated method stub
+    return null;
+  }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/Transaction.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,9 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+public interface Transaction<T>
+{
+	public Either<Error,T> success();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/TreeContext.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,32 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.persistent.ChangeList;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.TreeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.InterfaceTraverser;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.index.ParentIndex;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
+
+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 InterfaceTraverser getTraverser();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/TreeEditor.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,12 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.LoggingNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.NodeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+public interface TreeEditor
+{
+	public Either<Error,LoggingNode> edit(TreeNode root,NodePath path,NodeEditor transformer);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/TreeEditorError.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,9 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultError;
+
+public class TreeEditorError
+{
+	public static final Error NODEPATH_NOTFOUND = new DefaultError();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/impl/DefaultNodePath.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,83 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.impl;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Pair;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+
+import java.util.Iterator;
+
+public class DefaultNodePath implements NodePath {
+    private final List<Integer> path;
+
+    public static void main(String args[]) {
+        DefaultNodePath p = new DefaultNodePath();
+        p = p.add(1).add(2).add(3).add(4);
+        System.out.println(p.toString());
+    }
+
+    public DefaultNodePath() {
+        path = new List<Integer>().addLast(-1);
+    }
+
+    private DefaultNodePath(List<Integer> path) {
+        this.path = path;
+    }
+
+    @Override
+    public Iterator<Integer> iterator() {
+        return path.iterator();
+    }
+
+    @Override
+    public DefaultNodePath add(int pos) {
+        List<Integer> newPath = path.addLast(pos);
+        return new DefaultNodePath(newPath);
+    }
+
+    @Override
+    public Pair<Integer, NodePath> pop() {
+        Integer head = path.head();
+        List<Integer> tail = path.deleteHead();
+
+        return new Pair<Integer, NodePath>(head, new DefaultNodePath(tail));
+    }
+
+    @Override
+    public Pair<Integer, NodePath> last() {
+        Integer last = path.head();
+        List<Integer> list = path.deleteHead();
+        return new Pair<Integer, NodePath>(last, new DefaultNodePath(list));
+    }
+
+    @Override
+    public String toString() {
+        return path.toString();
+    }
+
+    @Override
+    public int size() {
+        return path.length();
+    }
+
+
+    //PATHの一番後ろを取り除いたPATHを新しく作って返す
+// EXAMPLE <0,0,3> → <0,0>
+    @Override
+    public NodePath tail() {
+        List<Integer> tail = path.deleteLast();
+        return new DefaultNodePath(tail);
+    }
+
+    public List<DefaultNodePath> inits() {
+        List<DefaultNodePath> paths = new List();
+        List<Integer> coursePath = new List();
+        Iterator<Integer> iterator = path.reverseIterator();
+        while (iterator.hasNext()) {
+            List<Integer> tmp = coursePath.addLast(iterator.next());
+            paths = paths.add(1,new DefaultNodePath(tmp));
+            coursePath = tmp;
+        }
+        return paths;
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/impl/DefaultTreeEditor.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,84 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.impl;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.TreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.LoggingNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.NodeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultEvaluator;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.Direction;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.Traversal;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.Traverser;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+
+public class DefaultTreeEditor implements TreeEditor
+{
+	private final Traverser traverser;
+	public DefaultTreeEditor(Traverser traverser)
+	{
+		this.traverser = traverser;
+	}
+
+	@Override
+	public Either<Error,LoggingNode> edit(TreeNode root,NodePath path,NodeEditor editor)
+	{
+		DefaultEvaluator e = new DefaultEvaluator(path);
+		Either<jp.ac.u_ryukyu.ie.cr.jungle.util.Error, Traversal> either = traverser.traverse(root,e);
+
+		if(either.isA()){
+			return DefaultEither.newA(either.a());
+		}
+
+		Traversal t = either.b();
+		Either<Error,LoggingNode> ret = clone(t,editor);
+
+		return ret;
+	}
+
+	private Either<Error,LoggingNode> clone(Traversal t,NodeEditor editor)
+	{
+		// copying nodes from bottom to root
+
+		List<Direction<TreeNode>> path = new List();
+		for(Direction<TreeNode> direction : t){
+			path = path.addLast(direction);
+		}
+
+		// target
+		Direction<TreeNode> targetDirection = path.last();
+		TreeNode target = targetDirection.getTarget();
+		Either<Error,LoggingNode> either = editor.edit(target);
+		if(either.isA()){
+			return DefaultEither.newA(either.a());
+		}
+
+		LoggingNode newWrap = either.b();
+
+		// top
+		int pos = targetDirection.getPosition();
+		TreeNode child = newWrap.getWrap();
+
+
+		for(Direction<TreeNode> parentDirection : path.deleteLast()){
+
+			TreeNodeChildren chs =  parentDirection.getTarget().getChildren();
+
+			Either<Error,TreeNode> ret = chs.replaceNode(pos,child);
+			if(ret.isA()){
+				return DefaultEither.newA(ret.a());
+			}
+
+			TreeNode newParent = ret.b();
+			child = newParent;
+			pos = parentDirection.getPosition();
+		}
+
+		TreeNode newRoot = child;
+		LoggingNode logNode = editor.wrap(newRoot,newWrap.getOperationLog());
+		return DefaultEither.newB(logNode);
+	}
+
+}
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/impl/IndexTreeEditor.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,89 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.impl;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultEvaluator;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.Direction;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.Traversal;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.Traverser;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.LoggingNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.NodeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+
+public class IndexTreeEditor {
+
+  private final Traverser traverser;
+
+
+  public IndexTreeEditor(Traverser traverser)
+  {
+    this.traverser = traverser;
+  }
+
+
+  public Either<Error,LoggingNode> edit(TreeNode root,NodePath path,NodeEditor editor)
+  {
+    DefaultEvaluator e = new DefaultEvaluator(path);
+    Either<jp.ac.u_ryukyu.ie.cr.jungle.util.Error, Traversal> either = traverser.traverse(root,e);
+
+    if(either.isA()){
+      return DefaultEither.newA(either.a());
+    }
+
+    Traversal t = either.b();
+    Either<Error,LoggingNode> ret = clone(t,editor);
+
+    return ret;
+  }
+
+  private Either<Error,LoggingNode> clone(Traversal t,NodeEditor editor)
+  {
+    // copying nodes from bottom to root
+    List<Direction<TreeNode>> path = new List();
+    for (Direction<TreeNode> direction : t) {
+      path = path.addLast(direction);
+    }
+
+    // target
+    Direction<TreeNode> targetDirection = path.head();
+    TreeNode target = targetDirection.getTarget();
+
+    Either<Error, LoggingNode> either = editor.edit(target);
+    if (either.isA()) {
+      return DefaultEither.newA(either.a());
+    }
+
+    LoggingNode newWrap = either.b();
+
+    // top
+    int pos = targetDirection.getPosition();
+    TreeNode child = newWrap.getWrap();
+
+    for (Direction<TreeNode> parentDirection : path.deleteLast()) {
+      TreeNode updateTargetNode = parentDirection.getTarget();
+      TreeNodeChildren chs = updateTargetNode.getChildren();
+
+
+
+      Either<Error, TreeNode> ret = chs.replaceNode(pos, child);
+      if (ret.isA()) {
+        return DefaultEither.newA(ret.a());
+      }
+
+      TreeNode newParent = ret.b();
+
+      child = newParent;
+      pos = parentDirection.getPosition();
+    }
+
+    TreeNode newRoot = child;
+    LoggingNode logNode = editor.wrap(newRoot, newWrap.getOperationLog());
+
+
+    return DefaultEither.newB(logNode);
+  }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/impl/TreeNode.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,17 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.impl;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+
+public interface TreeNode extends Comparable<TreeNode> {
+    public TreeNodeChildren getChildren();
+
+    public TreeNodeAttributes getAttributes();
+
+    public TreeNode createNewNode();
+
+    public Either<Error, TreeNode> appendRootNode();
+
+    public String getNodeId();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/impl/TreeNodeAttributes.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,17 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.impl;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.core.Attributes;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
+
+import java.nio.ByteBuffer;
+import java.util.Iterator;
+
+public interface TreeNodeAttributes extends Attributes
+{
+	public Either<Error,TreeNode> delete(String key);
+	public Either<jp.ac.u_ryukyu.ie.cr.jungle.util.Error,TreeNode> put(String key,ByteBuffer value);
+	public TreeMap<String,ByteBuffer> getAttributesAsRawMap();
+	public Iterator<String> getKeys();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/impl/TreeNodeChildren.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,15 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.impl;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.core.Children;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+
+public interface TreeNodeChildren extends Children
+{
+	public Either<Error,TreeNode> addNewChildAt(int pos);
+	public Either<jp.ac.u_ryukyu.ie.cr.jungle.util.Error,TreeNode> deleteChildAt(int pos);
+	public Either<Error,TreeNode> addNewChildAt(int pos,TreeNode newChild);
+	public Either<Error,TreeNode> replaceNode(int pos,TreeNode replacement);
+	public List<TreeNode> getChildrenAsRawList();
+}
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/impl/logger/DefaultOperationLog.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,43 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.NodeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+
+import java.util.Iterator;
+
+public class DefaultOperationLog implements OperationLog
+{
+	private final List<NodeOperation> log;
+
+	private static final List<NodeOperation> EMPTY =new List<>();
+
+	public DefaultOperationLog()
+	{
+		this(EMPTY);
+	}
+
+	private DefaultOperationLog(List<NodeOperation> _log)
+	{
+		log = _log;
+	}
+
+	@Override
+	public Iterator<NodeOperation> iterator()
+	{
+		return log.iterator();
+	}
+
+
+	@Override
+	public DefaultOperationLog add(NodeOperation _op)
+	{
+		return new DefaultOperationLog(log.addLast(_op));
+	}
+
+	@Override
+	public int length()
+	{
+		return log.length();
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/impl/logger/DefaultTreeOperationLog.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,60 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger;
+
+import com.google.common.collect.Iterables;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.DefaultTreeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.NodeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.TreeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+
+import java.util.Iterator;
+
+public class DefaultTreeOperationLog implements TreeOperationLog
+{
+	private final Iterable<TreeOperation> list;
+	private final int size;
+
+	public DefaultTreeOperationLog()
+	{
+		list = new List<>();
+		size = 0;
+	}
+
+	public DefaultTreeOperationLog(Iterable<TreeOperation> _list,int _size)
+	{
+		list = _list;
+		size = _size;
+	}
+
+	@Override
+	public Iterator<TreeOperation> iterator()
+	{
+		return list.iterator();
+	}
+
+	@Override
+	public TreeOperationLog add(NodePath _p, NodeOperation _op)
+	{
+		TreeOperation op = new DefaultTreeOperation(_p,_op);
+		List<TreeOperation> newList =  new List(op);
+		Iterable<TreeOperation> concat = Iterables.concat(list,newList);
+
+		return new DefaultTreeOperationLog(concat,size + 1);
+	}
+
+	@Override
+	public TreeOperationLog append(TreeOperationLog _log)
+	{
+		int argumentLogSize = _log.length();
+		Iterable<TreeOperation> concat = Iterables.concat(list,_log);
+
+		return new DefaultTreeOperationLog(concat,argumentLogSize + size);
+	}
+
+	@Override
+	public int length()
+	{
+		return size;
+	}
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/impl/logger/LoggingAttributes.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,57 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger;
+
+import java.nio.ByteBuffer;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.DeleteAttributeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.NodeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.PutAttributeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNodeAttributes;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+
+public class LoggingAttributes //implements EditableAttributes
+{
+	private final TreeNode wrap;
+	private final OperationLog log;
+
+	public LoggingAttributes(TreeNode _wrap,OperationLog _log)
+	{
+		wrap = _wrap;
+		log = _log;
+	}
+
+	public ByteBuffer get(String _key)
+	{
+		TreeNodeAttributes attributes = wrap.getAttributes();
+		return attributes.get(_key);
+	}
+
+	private Either<Error,LoggingNode> edit(NodeOperation _op)
+	{
+		Either<jp.ac.u_ryukyu.ie.cr.jungle.util.Error,TreeNode> either = _op.invoke(wrap);
+		if(either.isA()){
+			return DefaultEither.newA(either.a());
+		}
+
+		TreeNode newNode = either.b();
+		OperationLog newLog = log.add(_op);
+		LoggingNode newLogNode = new LoggingNode(newNode,newLog);
+
+		return DefaultEither.newB(newLogNode);
+	}
+
+	public Either<Error,LoggingNode> delete(final String _key)
+	{
+
+		DeleteAttributeOperation deleteAttribute = new DeleteAttributeOperation(_key);
+		return edit(deleteAttribute);
+	}
+
+	public Either<Error,LoggingNode> put(final String _key,final ByteBuffer _value)
+	{
+		PutAttributeOperation putAttribute = new PutAttributeOperation(_key,_value);
+		return edit(putAttribute);
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/impl/logger/LoggingChildren.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,67 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.core.Children;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.AppendChildAtOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.DeleteChildAtOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.NodeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+
+public class LoggingChildren
+{
+	private final TreeNode wrap;
+	private final OperationLog log;
+
+	public LoggingChildren(TreeNode _wrap,OperationLog _log)
+	{
+		wrap = _wrap;
+		log = _log;
+	}
+
+	public int size()
+	{
+		Children children = wrap.getChildren();
+		return children.size();
+	}
+
+	public Either<Error,LoggingNode> edit(NodeOperation _op)
+	{
+		Either<jp.ac.u_ryukyu.ie.cr.jungle.util.Error,TreeNode> either = _op.invoke(wrap);
+		if(either.isA()){
+			return DefaultEither.newA(either.a());
+		}
+
+		TreeNode newWrap = either.b();
+		OperationLog newLog = log.add(_op);
+		LoggingNode newLoggingNode = new LoggingNode(newWrap,newLog);
+		return DefaultEither.newB(newLoggingNode);
+	}
+
+	public Either<Error,LoggingNode> addNewChildAt(final int _pos)
+	{
+		NodeOperation addNewChildAt = new AppendChildAtOperation(_pos);
+		return edit(addNewChildAt);
+	}
+
+	public Either<Error,LoggingNode> deleteChildAt(final int _pos)
+	{
+		NodeOperation deleteChildAt = new DeleteChildAtOperation(_pos);
+		return edit(deleteChildAt);
+	}
+
+	public Either<Error,LoggingNode> at(int _pos)
+	{
+		Children children = wrap.getChildren();
+		Either<Error,TreeNode> either = children.at(_pos);
+		if(either.isA()){
+			return DefaultEither.newA(either.a());
+		}
+
+		TreeNode node = either.b();
+		LoggingNode logNode = new LoggingNode(node);
+		return DefaultEither.newB(logNode);
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/impl/logger/LoggingNode.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,66 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.NodeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.ReplaceRootNodeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+
+
+public class LoggingNode
+{
+
+  private final TreeNode wrap;
+  private final OperationLog log;
+
+	public LoggingNode(TreeNode _wrap)
+	{
+		this(_wrap,new DefaultOperationLog());
+	}
+
+	public LoggingNode(TreeNode _wrap,OperationLog _log)
+	{
+		wrap = _wrap;
+		log = _log;
+	}
+
+	public LoggingAttributes getAttributes()
+	{
+		return new LoggingAttributes(wrap,log);
+	}
+
+	public LoggingChildren getChildren()
+	{
+		return new LoggingChildren(wrap,log);
+	}
+
+
+	public OperationLog getOperationLog()
+	{
+		return log;
+	}
+
+
+  public Either<Error, LoggingNode> replaceNewRootNode() {
+   NodeOperation replaceRootNode = new ReplaceRootNodeOperation();
+   return edit(replaceRootNode);
+  }
+
+  public Either<jp.ac.u_ryukyu.ie.cr.jungle.util.Error, LoggingNode> edit(NodeOperation op){
+    Either<Error,TreeNode> either = op.invoke(wrap);
+    if(either.isA()){
+      return DefaultEither.newA(either.a());
+    }
+
+    TreeNode newWrap = either.b();
+    OperationLog newLog = log.add(op);
+    LoggingNode newLoggingNode = new LoggingNode(newWrap,newLog);
+    return DefaultEither.newB(newLoggingNode);
+  }
+
+  public TreeNode getWrap()
+  {
+    return wrap;
+  }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/impl/logger/OperationLog.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,10 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.NodeOperation;
+
+
+public interface OperationLog extends Iterable<NodeOperation>
+{
+	public OperationLog add(NodeOperation _op);
+	public int length();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/impl/logger/TreeOperationLog.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,12 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.NodeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.TreeOperation;
+
+public interface TreeOperationLog extends Iterable<TreeOperation>
+{
+	public TreeOperationLog add(NodePath _p,NodeOperation _op);
+	public TreeOperationLog append(TreeOperationLog _log);
+	public int length();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/index/IndexCreater.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,119 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.index;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNodeChildren;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
+
+import java.util.Iterator;
+import java.util.Optional;
+import java.util.Stack;
+
+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, List<TreeNode>>> indexList = new TreeMap();
+
+    public IndexCreater(TreeNode rootNode) {
+        this.root = rootNode;
+        this.node = rootNode;
+        while (node != null) {
+            TreeNode targetNode = node;
+            Iterator<String> keys = targetNode.getAttributes().getKeys();
+            for (;keys.hasNext();) {
+                String key = keys.next();
+                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);
+                }
+            }
+        }
+    }
+
+    public TreeMap<String, TreeMap<String, List<TreeNode>>> set(String key, String value, TreeNode node) {
+        if (key == null )
+            System.out.println("");
+        Optional<TreeMap<String, List<TreeNode>>> indexOp = indexList.get(key);
+        if (!indexOp.isPresent()) {
+            TreeMap<String, List<TreeNode>> index = new TreeMap();
+            List<TreeNode> nodeList = new List();
+            nodeList = nodeList.addLast(node);
+            TreeMap<String, List<TreeNode>> newIndex = index.put(value, nodeList);
+            indexList = indexList.put(key, newIndex);
+            return indexList;
+        }
+
+        TreeMap<String, List<TreeNode>> index = indexOp.get();
+        Optional<List<TreeNode>> nodeListOp = index.get(value);
+
+        List<TreeNode> newNodeList;
+
+        if (nodeListOp.isPresent()) {
+            newNodeList = nodeListOp.get().addLast(node);
+
+        } else {
+            List<TreeNode> nodeList = new List();
+            newNodeList = nodeList.addLast(node);
+
+        }
+        TreeMap<String, List<TreeNode>> newIndex = index.put(value, newNodeList);
+        indexList = indexList.put(key, newIndex);
+
+        return indexList;
+    }
+
+    public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
+        return indexList;
+    }
+
+    public ParentIndex getParentIndex() {
+        return parentIndex;
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/index/ParentIndex.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,55 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.index;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNodeChildren;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
+
+import java.util.Iterator;
+
+public class ParentIndex {
+
+  private TreeMap<TreeNode, TreeNode> parentIndex;
+
+  public ParentIndex() {
+    parentIndex = new TreeMap();
+  }
+
+  public boolean isEmpty(){
+    return parentIndex.isEmpty();
+  }
+
+  public TreeNode get(TreeNode child) {
+    return parentIndex.get(child).get();
+  }
+
+  public ParentIndex set(TreeNode parent ,TreeNode child) {
+    parentIndex = parentIndex.put(child, parent);
+    return this;
+  }
+
+  public ParentIndex delete(TreeNode child) {
+    parentIndex = parentIndex.delete(child);
+    return this;
+  }
+
+  public ParentIndex deleteAllChildren(TreeNode parentNode) {
+    TreeNodeChildren children = parentNode.getChildren();
+    Iterator<TreeNode> childrenIterator = children.iterator();
+    for (; childrenIterator.hasNext();) {
+      TreeNode child = childrenIterator.next();
+      parentIndex = parentIndex.delete(child);
+    }
+    return this;
+  }
+
+  public ParentIndex addAllChildren(TreeNode parentNode) {
+    TreeNodeChildren children = parentNode.getChildren();
+    Iterator<TreeNode> childrenIterator = children.iterator();
+    for (; childrenIterator.hasNext();) {
+      TreeNode child = childrenIterator.next();
+      parentIndex = parentIndex.put(child, parentNode);
+    }
+    return this;
+  }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/operations/AppendChildAtOperation.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,48 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.operations;
+
+import java.nio.ByteBuffer;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.Command;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+
+public final class AppendChildAtOperation implements NodeOperation
+{
+	private final int pos;
+
+	public AppendChildAtOperation(int _pos)
+	{
+		pos = _pos;
+	}
+
+	public Command getCommand()
+	{
+		return Command.APPEND_CHILD;
+	}
+
+	@Override
+	public Either<Error,TreeNode> invoke(TreeNode _target)
+	{
+		return _target.getChildren().addNewChildAt(pos);
+	}
+
+	@Override
+	public int getPosition()
+	{
+		return pos;
+	}
+
+	@Override
+	public String getKey()
+	{
+		return null;
+	}
+
+	@Override
+	public ByteBuffer getValue()
+	{
+		return null;
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/operations/DefaultTreeOperation.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,27 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.operations;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.NodePath;
+
+public class DefaultTreeOperation implements TreeOperation
+{
+	private final NodePath path;
+	private final NodeOperation operation;
+
+	public DefaultTreeOperation(NodePath _path,NodeOperation _operation)
+	{
+		path = _path;
+		operation = _operation;
+	}
+
+	@Override
+	public NodePath getNodePath()
+	{
+		return path;
+	}
+
+	@Override
+	public NodeOperation getNodeOperation()
+	{
+		return operation;
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/operations/DeleteAttributeOperation.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,48 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.operations;
+
+import java.nio.ByteBuffer;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.Command;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+public final class DeleteAttributeOperation implements NodeOperation
+{
+	private final String key;
+
+	public DeleteAttributeOperation(String _key)
+	{
+		key = _key;
+	}
+
+	@Override
+	public Command getCommand()
+	{
+		return Command.DELETE_ATTRIBUTE;
+	}
+
+	@Override
+	public Either<Error, TreeNode> invoke(TreeNode _target)
+	{
+		return _target.getAttributes().delete(key);
+	}
+
+	@Override
+	public int getPosition()
+	{
+		return -1;
+	}
+
+	@Override
+	public String getKey()
+	{
+		return key;
+	}
+
+	@Override
+	public ByteBuffer getValue()
+	{
+		return null;
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/operations/DeleteChildAtOperation.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,48 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.operations;
+
+import java.nio.ByteBuffer;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.Command;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+public class DeleteChildAtOperation implements NodeOperation
+{
+	private final int pos;
+
+	public DeleteChildAtOperation(int _pos)
+	{
+		pos = _pos;
+	}
+
+	@Override
+	public Command getCommand()
+	{
+		return Command.DELETE_CHILD;
+	}
+
+	@Override
+	public Either<Error, TreeNode> invoke(TreeNode _target)
+	{
+		return _target.getChildren().deleteChildAt(pos);
+	}
+
+	@Override
+	public int getPosition()
+	{
+		return pos;
+	}
+
+	@Override
+	public String getKey()
+	{
+		return null;
+	}
+
+	@Override
+	public ByteBuffer getValue()
+	{
+		return null;
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/operations/NodeOperation.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,20 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.operations;
+
+import java.nio.ByteBuffer;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.Command;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+public interface NodeOperation
+{
+	public Command getCommand();
+	public Either<Error,TreeNode> invoke(TreeNode _target);
+
+	public int getPosition();
+	public String getKey();
+	public ByteBuffer getValue();
+}
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/operations/PutAttributeOperation.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,50 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.operations;
+
+import java.nio.ByteBuffer;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.Command;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+
+public class PutAttributeOperation implements NodeOperation
+{
+	private final String key;
+	private final ByteBuffer value;
+
+	public PutAttributeOperation(String _key,ByteBuffer _value)
+	{
+		key = _key;
+		value = _value;
+	}
+
+	@Override
+	public Command getCommand()
+	{
+		return Command.PUT_ATTRIBUTE;
+	}
+
+	@Override
+	public Either<Error,TreeNode> invoke(TreeNode _target)
+	{
+		return _target.getAttributes().put(key,value);
+	}
+	@Override
+	public int getPosition()
+	{
+		return -1;
+	}
+
+	@Override
+	public String getKey()
+	{
+		return key;
+	}
+
+	@Override
+	public ByteBuffer getValue()
+	{
+		return value;
+	}
+}
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/operations/ReplaceRootNodeOperation.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,37 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.operations;
+
+import java.nio.ByteBuffer;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.Command;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+public class ReplaceRootNodeOperation implements NodeOperation {
+
+  @Override
+  public Command getCommand() {
+    return Command.REPLACE_ROOT;
+  }
+
+  @Override
+  public Either<Error, TreeNode> invoke(TreeNode target) {
+    return  target.appendRootNode();
+  }
+
+  @Override
+  public int getPosition() {
+    return -1;
+  }
+
+  @Override
+  public String getKey() {
+    return null;
+  }
+
+  @Override
+  public ByteBuffer getValue() {
+    return null;
+  }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/operations/TreeOperation.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,9 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.operations;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.NodePath;
+
+public interface TreeOperation
+{
+	public NodePath getNodePath();
+	public NodeOperation getNodeOperation();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/trasnformer/AppendChildAt.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,44 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.LoggingNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.OperationLog;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+public class AppendChildAt implements NodeEditor
+{
+	private final int pos;
+
+	public AppendChildAt(int _pos)
+	{
+		pos = _pos;
+	}
+
+	public Either<Error, LoggingNode> _edit(LoggingNode _e)
+	{
+		Either<Error,LoggingNode> either = _e.getChildren().addNewChildAt(pos);
+		if(either.isA()){
+			// error
+			return either;
+		}
+		return DefaultEither.newB(either.b());
+	}
+
+	@Override
+	public Either<Error, LoggingNode> edit(TreeNode _e) {
+		LoggingNode logNode = wrap(_e);
+		return _edit(logNode);
+	}
+
+	public LoggingNode wrap(TreeNode node) {
+		return new LoggingNode(node);
+	}
+
+	@Override
+	public LoggingNode wrap(TreeNode node, OperationLog op) {
+		return new LoggingNode(node, op);
+	}
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/trasnformer/DeleteAttribute.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,43 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.LoggingNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.OperationLog;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+
+public class DeleteAttribute implements NodeEditor
+{
+	private final String key;
+	public DeleteAttribute(String _key)
+	{
+		key = _key;
+	}
+
+	public Either<Error,LoggingNode> _edit(LoggingNode logNode)
+	{
+		Either<jp.ac.u_ryukyu.ie.cr.jungle.util.Error,LoggingNode> either = logNode.getAttributes().delete(key);
+		if(either.isA()){
+			// error
+			return either;
+		}
+		return DefaultEither.newB(either.b());
+	}
+
+	@Override
+	public Either<Error, LoggingNode> edit(TreeNode _e) {
+		LoggingNode logNode = wrap(_e);
+		return _edit(logNode);
+	}
+
+	public LoggingNode wrap(TreeNode node) {
+		return new LoggingNode(node);
+	}
+
+	@Override
+	public LoggingNode wrap(TreeNode node, OperationLog op) {
+		return new LoggingNode(node, op);
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/trasnformer/DeleteChildAt.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,44 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.LoggingNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.OperationLog;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+
+public class DeleteChildAt implements NodeEditor
+{
+	private final int pos;
+	public DeleteChildAt(int _pos)
+	{
+		pos = _pos;
+	}
+
+	public Either<Error,LoggingNode> _edit(LoggingNode logNode)
+	{
+		Either<jp.ac.u_ryukyu.ie.cr.jungle.util.Error,LoggingNode> either = logNode.getChildren().deleteChildAt(pos);
+		if(either.isA()){
+			// error
+			return either;
+		}
+		return DefaultEither.newB(either.b());
+	}
+
+	@Override
+	public Either<Error, LoggingNode> edit(TreeNode _e) {
+		LoggingNode logNode = wrap(_e);
+		return _edit(logNode);
+	}
+
+	public LoggingNode wrap(TreeNode node) {
+		return new LoggingNode(node);
+	}
+
+	@Override
+	public LoggingNode wrap(TreeNode node, OperationLog op) {
+		return new LoggingNode(node, op);
+	}
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/trasnformer/NodeEditor.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,14 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.LoggingNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.OperationLog;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+public interface NodeEditor
+{
+	public Either<Error,LoggingNode> edit(TreeNode _e);
+	public LoggingNode wrap(TreeNode node, OperationLog op);
+}
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/trasnformer/NodeEditorError.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,11 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultError;
+
+public class NodeEditorError
+{
+	public static final Error INDEX_OUT_OF_BOUNDS = new DefaultError();
+	public static final Error DELETE_KEY_NOT_FOUND = new DefaultError();
+	public static final Error NULL_VALUE_NOT_ALLOWED = new DefaultError();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/trasnformer/PutAttribute.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,48 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer;
+
+import java.nio.ByteBuffer;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.LoggingNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.OperationLog;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+public class PutAttribute implements NodeEditor
+{
+	private final String key;
+	private final ByteBuffer value;
+
+	public PutAttribute(String _key,ByteBuffer _value)
+	{
+		key = _key;
+		value = _value;
+	}
+
+	public Either<Error,LoggingNode> _edit(LoggingNode _e)
+	{
+		Either<Error,LoggingNode> either = _e.getAttributes().put(key,value);
+		if(either.isA()){
+			// error
+			return either;
+		}
+		return DefaultEither.newB(either.b());
+	}
+
+	@Override
+	public Either<Error, LoggingNode> edit(TreeNode _e) {
+		LoggingNode logNode = wrap(_e);
+		return _edit(logNode);
+	}
+
+	public LoggingNode wrap(TreeNode node) {
+		return new LoggingNode(node);
+	}
+
+	@Override
+	public LoggingNode wrap(TreeNode node, OperationLog op) {
+		return new LoggingNode(node, op);
+	}
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/store/trasnformer/replaceRootNodeAt.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,40 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.LoggingNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.OperationLog;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+
+public class replaceRootNodeAt implements NodeEditor {
+
+
+  public Either<Error, LoggingNode> _edit(LoggingNode _e)
+  {
+    Either<jp.ac.u_ryukyu.ie.cr.jungle.util.Error,LoggingNode> either = _e.replaceNewRootNode();
+    if(either.isA()){
+      // error
+      return either;
+    }
+    return DefaultEither.newB(either.b());
+  }
+
+
+  @Override
+  public Either<Error, LoggingNode> edit(TreeNode _e) {
+    LoggingNode logNode = wrap(_e);
+    return _edit(logNode);
+  }
+
+  public LoggingNode wrap(TreeNode node) {
+    return new LoggingNode(node);
+  }
+
+
+  @Override
+  public LoggingNode wrap(TreeNode node, OperationLog op) {
+    return new LoggingNode(node, op);
+  }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/test/AbstractTreeMapThread.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,9 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.test;
+
+/**
+ * Created by e115731 on 15/03/17.
+ */
+public abstract class AbstractTreeMapThread extends Thread{
+    public abstract void set(boolean flag);
+    public abstract long getFindCount();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/test/DataBaseBenchMark.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,164 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.test;
+
+
+import com.mongodb.MongoClient;
+import com.mongodb.WriteConcern;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoDatabase;
+import jp.ac.u_ryukyu.ie.cr.jungle.DefaultJungle;
+import jp.ac.u_ryukyu.ie.cr.jungle.Jungle;
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultTraverser;
+import org.bson.Document;
+import org.xml.sax.SAXException;
+
+import javax.xml.parsers.ParserConfigurationException;
+import java.io.*;
+import java.nio.ByteBuffer;
+import java.util.Random;
+
+/**
+ * Created by e115731 on 15/03/20.
+ */
+public class DataBaseBenchMark {
+    public static void main(String[] args) throws InterruptedException, IOException, ParserConfigurationException, SAXException {
+
+        if (args.length < 2) {
+            System.out.println("args[0] = jungle or mongo, args[1] = read or write" );
+            System.exit(0);
+        }
+
+        Runtime rt = Runtime.getRuntime();
+        int cpuNum = rt.availableProcessors();
+
+        if (args[0].equals("jungle"))
+            jungleBench(args, cpuNum);
+        else if (args[0].equals("mongo"))
+            mongoBench(args, cpuNum);
+    }
+
+    private static void mongoBench(String[] args, int cpuNum) throws IOException, InterruptedException {
+        MongoClient client = new MongoClient("localhost", 27017);
+        client.setWriteConcern(WriteConcern.JOURNALED);
+        client.dropDatabase("mydb");
+        MongoDatabase database = client.getDatabase("mydb");
+        MongoCollection<Document> coll = database.getCollection("mycoll");
+            for (int i = 0; i < 10000; i++) {
+                if (i % 100 == 0)
+                    System.out.println(i / 100);
+                coll.insertOne(new Document("key",String.valueOf(i)));
+            }
+        coll.createIndex(new Document("key", 1));
+        //coll.dropIndex(new Document("key", 1));
+        for (final Document index : coll.listIndexes()) {
+            System.out.println(index.toJson());
+        }
+        File file = new File("./time/" + args[0] + args[1] + "Time");
+        PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(file)));
+        DataBaseBenchMarkThread readThread[] = null;
+        for (int THREAD_COUNT = 1; THREAD_COUNT <= cpuNum; THREAD_COUNT++) {
+            readThread = new DataBaseBenchMarkThread[THREAD_COUNT];
+            for (int count = 0; THREAD_COUNT > count; count++) {
+                readThread[count] = new findMongoAttributeThread(coll);
+            }
+            for (int count = 0; THREAD_COUNT > count; count++) {
+                readThread[count].start();
+            }
+            System.out.println("StartThread");
+            Thread.sleep(1000);
+            long readCount = 0;
+            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);
+        }
+        client.close();
+        pw.close();
+    }
+
+    private static void jungleBench(String[] args, int cpuNum) throws IOException, InterruptedException {
+        JungleTree tree = createJungleTree(cpuNum);
+        File file = new File("./time/" + args[0] + args[0] + "Time");
+        PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(file)));
+        DataBaseBenchMarkThread readThread[] = null;
+
+        for (int THREAD_COUNT = 1; THREAD_COUNT <= cpuNum; THREAD_COUNT++) {
+            readThread = new DataBaseBenchMarkThread[THREAD_COUNT];
+            for (int count = 0; THREAD_COUNT > count; count++) {
+                readThread[count] = new findTreeAttributeThread(tree);
+            }
+            JungleWriteThread writeThread = null;
+            if (args[1].equals("write")) {
+                writeThread = new JungleWriteThread(tree);
+                writeThread.start();
+            }
+            for (int count = 0; THREAD_COUNT > count; count++) {
+                readThread[count].start();
+            }
+            System.out.println("StartThread");
+            Thread.sleep(1000);
+            if (args[1].equals("write")) {
+                writeThread.set(false);
+                writeThread.get();
+            }
+            long readCount = 0;
+            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();
+    }
+
+    private static JungleTree createJungleTree(int cpuNum) {
+        Jungle jungle = new DefaultJungle(null, "hoge", new DefaultTreeEditor(new DefaultTraverser()));
+        JungleTree trees[] = new JungleTree[cpuNum];
+        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;
+        return tree;
+    }
+
+    static Integer nodeNum = 1;
+
+    public static JungleTreeEditor createTree(int deep, NodePath path, JungleTreeEditor editor) {
+
+        Random rnd = new Random();
+        String value1 = String.valueOf(nodeNum);
+        nodeNum++;
+        String value2 = String.valueOf(nodeNum);
+        nodeNum++;
+        editor = editor.addNewChildAt(path, 0).b();
+        editor = editor.putAttribute(path.add(0), "key", ByteBuffer.wrap(value1.getBytes())).b();
+        editor = editor.addNewChildAt(path, 1).b();
+        editor = editor.putAttribute(path.add(1), "key", ByteBuffer.wrap(value2.getBytes())).b();
+        deep++;
+        if (deep < 10) {
+            editor = createTree(deep, path.add(0), editor);
+            editor = createTree(deep, path.add(1), editor);
+        }
+        return editor;
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/test/DataBaseBenchMarkThread.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,9 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.test;
+
+/**
+ * Created by e115731 on 15/03/17.
+ */
+public abstract class DataBaseBenchMarkThread extends Thread{
+    public abstract long getFindCount();
+    public abstract void set(boolean flag);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/test/JungleWriteThread.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,48 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.test;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultNodePath;
+
+import java.nio.ByteBuffer;
+
+/**
+ * Created by e115731 on 15/04/18.
+ */
+public class JungleWriteThread extends Thread {
+
+    JungleTree tree;
+    boolean loop = true;
+    private int writeCount;
+
+    public JungleWriteThread(JungleTree tree) {
+        this.tree = tree;
+    }
+
+    public void set(boolean flag) {
+        loop = flag;
+    }
+
+    public void get() {
+        System.out.println("writeCount = " + writeCount);
+    }
+
+    ;
+
+    @Override
+    public void run() {
+        while (loop) {
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+            JungleTreeEditor editor = tree.getTreeEditor();
+            editor = editor.putAttribute(new DefaultNodePath(), "key", ByteBuffer.wrap(String.valueOf(0).getBytes())).b();
+            if (editor.success().isA())
+                System.out.println("faild");
+            else
+                writeCount++;
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/test/TatsukiTreeMapGetThread.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,42 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.test;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
+
+import java.util.Optional;
+
+
+/**
+ * Created by e115731 on 15/03/17.
+ */
+public class TatsukiTreeMapGetThread extends AbstractTreeMapThread {
+    TreeMap<Long, String> map;
+    private long findCount;
+    boolean loop = true;
+
+    public TatsukiTreeMapGetThread(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) {
+            for (long count = 0 ; count < 1000; count++) {
+                Optional<String> value = map.get(count);
+                if (!value.isPresent())
+                    System.out.println("error");
+            }
+            findCount++;
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/test/TreeMapBenchMark.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,77 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.test;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
+
+import java.io.*;
+
+/**
+ * Created by e115731 on 15/03/17.
+ */
+public class TreeMapBenchMark {
+    public static void main(String[] args) throws InterruptedException, IOException {
+
+        if (args.length == 0) {
+            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/" + 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++) {
+
+            readThread = new AbstractTreeMapThread[THREAD_COUNT];
+
+            if (args[0].equals("util")) {
+                java.util.TreeMap map = new java.util.TreeMap();
+                for (long count = 0; count < 1000; count++) {
+                    map.put(count, String.valueOf(count));
+                }
+
+                for (int count = 0; THREAD_COUNT > count; count++) {
+                    readThread[count] = new UtilTreeMapGetThread(map);
+                }
+            } else if (args[0].equals("tatsuki")) {
+                TreeMap map = new TreeMap();
+                for (long count = 0; count < 1000; count++) {
+                    map = map.put(count, String.valueOf(count));
+                }
+
+                for (int count = 0; THREAD_COUNT > count; count++) {
+                    readThread[count] = new TatsukiTreeMapGetThread(map);
+                }
+            }  else {
+                System.out.println("not allow args");
+                System.exit(0);
+            }
+
+            for (int count = 0; THREAD_COUNT > count; count++) {
+                readThread[count].start();
+            }
+
+            System.out.println("StartThread");
+
+            Thread.sleep(1000);
+            long readCount = 0;
+
+            for (int count = 0; THREAD_COUNT > count; count++) {
+                readThread[count].set(false);
+                readCount = readCount + readThread[count].getFindCount();
+                readThread[count].stop();
+            }
+
+            pw.println(THREAD_COUNT + " " + readCount);
+            System.out.println(THREAD_COUNT + "readCount = " + readCount);
+            Thread.sleep(1000);
+        }
+
+        pw.close();
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/test/UtilTreeMapGetThread.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,39 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.test;
+
+import java.util.TreeMap;
+
+/**
+ * Created by e115731 on 15/04/18.
+ */
+public class UtilTreeMapGetThread extends AbstractTreeMapThread {
+    TreeMap<Long, String> map;
+    private long findCount;
+    boolean loop = true;
+
+    public UtilTreeMapGetThread(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) {
+            for (long count = 0 ; count < 1000; count++) {
+                String value = map.get(count);
+                if (value == null)
+                    System.out.println("error");
+            }
+            findCount++;
+        }
+    }
+}
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/test/findMongoAttributeThread.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,41 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.test;
+
+import com.mongodb.client.FindIterable;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoCursor;
+import org.bson.Document;
+
+/**
+ * Created by e115731 on 15/04/30.
+ */
+public class findMongoAttributeThread extends DataBaseBenchMarkThread {
+    private long findCount;
+    boolean loop = true;
+    MongoCollection<Document> coll;
+
+    public findMongoAttributeThread( MongoCollection<Document> coll) {
+        this.coll = coll;
+        this.findCount = 0;
+    }
+
+    @Override
+    public long getFindCount() {
+        System.out.println("thread count = " + findCount);
+        return findCount;
+    }
+
+    public void set(boolean loop) {
+        this.loop = loop;
+    }
+
+    @Override
+    public void run() {
+        while (loop) {
+            FindIterable<Document> searchResultList = coll.find(new Document("key","1"));
+            MongoCursor<Document> iterator = searchResultList.iterator();
+            if (iterator.hasNext()) {
+                findCount++;
+            }
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/test/findTreeAttributeThread.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,43 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.test;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.InterfaceTraverser;
+import java.util.Iterator;
+
+/**
+ * Created by e115731 on 15/03/20.
+ */
+public class findTreeAttributeThread extends DataBaseBenchMarkThread {
+
+    JungleTree tree;
+    private long findCount;
+
+    boolean loop = true;
+
+    public findTreeAttributeThread(JungleTree tree) {
+        this.tree = tree;
+        this.findCount = 0;
+    }
+
+    @Override
+    public long getFindCount() {
+        System.out.println("thread count = " + findCount);
+        return findCount;
+    }
+
+    public void set(boolean loop) {
+        this.loop = loop;
+    }
+
+    @Override
+    public void run() {
+        while (loop) {
+            InterfaceTraverser traverser = tree.getTraverser(true);
+            Iterator<TreeNode> it = traverser.find(null, "key", "0");
+            if (it.hasNext()) {
+                findCount++;
+            }
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/test/readTreeAttributeThread.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,44 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.test;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+
+/**
+ * Created by e115731 on 15/03/17.
+ */
+public class readTreeAttributeThread extends DataBaseBenchMarkThread {
+
+    JungleTree tree;
+    private long findCount;
+
+    boolean loop = true;
+
+    public readTreeAttributeThread(JungleTree tree) {
+        this.tree = tree;
+        this.findCount = 0;
+    }
+
+    @Override
+    public long getFindCount() {
+        System.out.println("thread couny  = " + findCount);
+        return findCount;
+    }
+
+    public void set(boolean loop) {
+        this.loop = loop;
+    }
+
+    @Override
+    public void run() {
+        while (loop) {
+            TreeNode root = tree.getRootNode();
+            if (root != null) {
+                String attribute = root.getAttributes().getString("key");
+                if (attribute.equals("0"))
+                    findCount++;
+                else
+                    System.out.println("faild");
+            }
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/transaction/DefaultJungleTreeEditor.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,133 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.transaction;
+
+import java.nio.ByteBuffer;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.TreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.TreeOperationLog;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.DefaultTreeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.NodeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.AppendChildAt;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.PutAttribute;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.DefaultTreeOperationLog;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.LoggingNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.OperationLog;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.TreeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.replaceRootNodeAt;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.DeleteAttribute;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.DeleteChildAt;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.NodeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.IterableConverter;
+
+public class DefaultJungleTreeEditor implements JungleTreeEditor
+{
+	private final TransactionManager txManager;
+	private final TreeNode root;
+	private final TreeEditor editor;
+	private final TreeOperationLog log;
+
+
+	public DefaultJungleTreeEditor(TreeNode _root,TransactionManager _txManager,TreeEditor _editor)
+	{
+		this(_root,_txManager,_editor,new DefaultTreeOperationLog());
+	}
+
+
+
+	public DefaultJungleTreeEditor(TreeNode newNode,TransactionManager _txManager,TreeEditor _editor,TreeOperationLog _log)
+	{
+		this.root = newNode;
+		this.txManager = _txManager;
+		this.editor = _editor;
+		this.log = _log;
+	}
+
+	private Either<Error,JungleTreeEditor> _edit(final NodePath _path,NodeEditor _e)
+	{
+		Either<jp.ac.u_ryukyu.ie.cr.jungle.util.Error,LoggingNode> either = editor.edit(root,_path,_e);
+		if(either.isA()){
+			return DefaultEither.newA(either.a());
+		}
+
+		LoggingNode newLogging = either.b();
+		OperationLog newLog = newLogging.getOperationLog();
+		TreeNode newNode = newLogging.getWrap();
+
+		IterableConverter.Converter<TreeOperation,NodeOperation> converter = new IterableConverter.Converter<TreeOperation,NodeOperation>(){
+			@Override
+			public TreeOperation conv(NodeOperation _b){
+				return new DefaultTreeOperation(_path,_b);
+			}
+		};
+
+		Iterable<TreeOperation> iterable = new IterableConverter<TreeOperation,NodeOperation>(newLog,converter);
+		DefaultTreeOperationLog treeOperationLog = new DefaultTreeOperationLog(iterable,newLog.length());
+		TreeOperationLog newTreeOpLog = log.append(treeOperationLog);
+
+		JungleTreeEditor newEditor = new DefaultJungleTreeEditor(newNode,txManager,editor,newTreeOpLog);
+		return DefaultEither.newB(newEditor);
+	}
+
+	 @Override
+	  public Either<Error,JungleTreeEditor> replaceNewRootNode()
+	  {
+	   replaceRootNodeAt appendChildAt = new replaceRootNodeAt();
+	    return _edit(new DefaultNodePath(),appendChildAt);
+	  }
+
+	@Override
+	public Either<Error,JungleTreeEditor> addNewChildAt(NodePath _path, int _pos)
+	{
+		AppendChildAt appendChildAt = new AppendChildAt(_pos);
+		return _edit(_path,appendChildAt);
+	}
+
+	@Override
+	public Either<Error,JungleTreeEditor> deleteChildAt(NodePath _path, int _pos)
+	{
+		DeleteChildAt deleteChildAt = new DeleteChildAt(_pos);
+		return _edit(_path,deleteChildAt);
+	}
+
+	@Override
+	public Either<Error,JungleTreeEditor> putAttribute(NodePath _path,String _key,ByteBuffer _value)
+	{
+		PutAttribute putAttribute = new PutAttribute(_key,_value);
+		return _edit(_path,putAttribute);
+	}
+
+	@Override
+	public Either<Error,JungleTreeEditor> deleteAttribute(NodePath _path, String _key)
+	{
+		DeleteAttribute deleteAttribute = new DeleteAttribute(_key);
+		return _edit(_path,deleteAttribute);
+	}
+
+	@Override
+	public Either<Error,JungleTreeEditor> edit(NodePath _path,NodeEditor _editor)
+	{
+		return _edit(_path,_editor);
+	}
+
+	@Override
+	public Either<Error,JungleTreeEditor> success()
+	{
+		Either<Error,TransactionManager> either = txManager.commit(root,log);
+		if(either.isA()){
+			return DefaultEither.newA(either.a());
+		}
+
+		TransactionManager newTxManager = either.b();
+		JungleTreeEditor newTreeEditor = new DefaultJungleTreeEditor(root,newTxManager,editor);
+
+		return DefaultEither.newB(newTreeEditor);
+	}
+
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/transaction/DefaultTransactionManager.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,78 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.transaction;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.persistent.ChangeListWriter;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.TreeContext;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.TreeOperationLog;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.TreeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.persistent.ChangeList;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.InterfaceTraverser;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultError;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+import java.util.Iterator;
+import java.util.concurrent.atomic.AtomicReference;
+
+public class DefaultTransactionManager implements TransactionManager {
+  private final AtomicReference<TreeContext> repository;
+  private final TreeContext tip;
+  private final ChangeListWriter writer;
+  private final String uuid;
+
+  public DefaultTransactionManager(ChangeListWriter _writer, TreeContext _tip,
+      AtomicReference<TreeContext> _repository, String _uuid) {
+    repository = _repository;
+    tip = _tip;
+    writer = _writer;
+    uuid = _uuid;
+  }
+
+  @Override
+  public Either<Error, TransactionManager> commit(TreeNode newRoot, final TreeOperationLog _log) {
+    long currentRevision = tip.revision();
+    long nextRevision = currentRevision + 1;
+
+    final String _treeName = tip.getTreeName();
+    ChangeList list = new ChangeList() {
+      @Override
+      public Iterator<TreeOperation> iterator() {
+        return _log.iterator();
+      }
+
+      @Override
+      public String getTreeName() {
+        return _treeName;
+      }
+
+      @Override
+      public String uuid() {
+        return uuid;
+      }
+
+    };
+
+    InterfaceTraverser traverser = new InterfaceTraverser(newRoot, true);
+    traverser.createIndex();
+    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);
+        return DefaultEither.newB(txManager);
+    }
+
+    return DefaultEither.newA((jp.ac.u_ryukyu.ie.cr.jungle.util.Error) new DefaultError());
+  }
+
+  @Override
+  public String getUUID() {
+    return uuid;
+  }
+
+  @Override
+  public long getRevision() {
+    return tip.revision();
+  }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/transaction/DefaultTreeContext.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,82 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.transaction;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.persistent.ChangeList;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.TreeContext;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.TreeOperation;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.InterfaceTraverser;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.index.ParentIndex;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
+
+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, 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;
+    }
+
+    @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, List<TreeNode>>> getIndex() {
+        return traverser.getIndex();
+    }
+
+    @Override
+    public ParentIndex getParentIndex() {
+        return traverser.getParentIndex();
+    }
+
+    @Override
+    public InterfaceTraverser getTraverser() {
+        return traverser;
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/transaction/DefaultTreeNode.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,65 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.transaction;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNodeChildren;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
+
+import java.nio.ByteBuffer;
+import java.rmi.dgc.VMID;
+
+public class DefaultTreeNode implements TreeNode {
+    private List<TreeNode> children;
+    private TreeMap<String, ByteBuffer> attrs;
+    final String nodeId = new VMID().toString();
+
+    private static final List<TreeNode> NIL_LIST = new List();
+
+    public DefaultTreeNode() {
+        this(NIL_LIST, new TreeMap());
+    }
+
+    public DefaultTreeNode(List<TreeNode> _children, TreeMap<String, ByteBuffer> _attrs) {
+        attrs = _attrs;
+        children = _children;
+    }
+
+    @Override
+    public DefaultTreeNodeChildren getChildren() {
+        return new DefaultTreeNodeChildren(children, attrs);
+    }
+
+    @Override
+    public DefaultTreeNodeAttribute getAttributes() {
+        return new DefaultTreeNodeAttribute(children, attrs);
+    }
+
+    @Override
+    public DefaultTreeNode createNewNode() {
+        return new DefaultTreeNode();
+    }
+
+    public DefaultTreeNode clone() {
+        return new DefaultTreeNode(children, attrs);
+    }
+
+    @Override
+    public Either<Error, TreeNode> appendRootNode() {
+        TreeNodeChildren newRootChildren = new DefaultTreeNodeChildren(NIL_LIST, new TreeMap());
+        Either<jp.ac.u_ryukyu.ie.cr.jungle.util.Error, TreeNode> either = newRootChildren.addNewChildAt(0,this);
+        return either;
+    }
+
+    @Override
+    public String getNodeId() {
+        return nodeId;
+    }
+
+    @Override
+    public int compareTo(TreeNode o) {
+        return this.hashCode() - o.hashCode();
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/transaction/DefaultTreeNodeAttribute.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,80 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.transaction;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNodeAttributes;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.NodeEditorError;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
+
+import java.nio.ByteBuffer;
+import java.util.Iterator;
+import java.util.Optional;
+
+public class DefaultTreeNodeAttribute implements TreeNodeAttributes {
+    public List<TreeNode> children;
+    public TreeMap<String, ByteBuffer> attrs;
+
+
+    public DefaultTreeNodeAttribute(List<TreeNode> _children, TreeMap<String, ByteBuffer> _attrs) {
+        children = _children;
+        attrs = _attrs;
+    }
+
+    @Override
+    public TreeMap<String, ByteBuffer> getAttributesAsRawMap() {
+        return attrs;
+    }
+
+    @Override
+    public Either<Error, TreeNode> delete(String _key) {
+        if (_key == null) {
+            return DefaultEither.newA(NodeEditorError.NULL_VALUE_NOT_ALLOWED);
+        }
+
+        if (null == attrs.get(_key)) {
+            return DefaultEither.newA(NodeEditorError.DELETE_KEY_NOT_FOUND);
+        }
+
+        TreeMap<String, ByteBuffer> newMap = attrs.delete(_key);
+        TreeNode newNode = new DefaultTreeNode(children, newMap);
+        return DefaultEither.newB(newNode);
+    }
+
+    @Override
+    public Either<Error, TreeNode> put(String _key, ByteBuffer _value) {
+        if (_key == null || _value == null) {
+            return DefaultEither.newA(NodeEditorError.NULL_VALUE_NOT_ALLOWED);
+        }
+
+        TreeMap<String, ByteBuffer> newMap = attrs.put(_key, _value);
+        TreeNode newNode = new DefaultTreeNode(children, newMap);
+        return DefaultEither.newB(newNode);
+    }
+
+    @Override
+    public ByteBuffer get(String _key) {
+        if (_key == null) {
+            return null;
+        }
+        Optional<ByteBuffer> op = attrs.get(_key);
+        if (op.isPresent())
+            return op.get();
+        return null;
+    }
+
+    @Override
+    public String getString(String key) {
+        ByteBuffer attribute = get(key);
+        if (attribute != null)
+            return new String(attribute.array());
+        return null;
+    }
+
+    @Override
+    public Iterator<String> getKeys() {
+        return attrs.keys();
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/transaction/DefaultTreeNodeChildren.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,108 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.transaction;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.NodeEditorError;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNodeChildren;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
+
+import java.nio.ByteBuffer;
+import java.util.Iterator;
+
+public class DefaultTreeNodeChildren implements TreeNodeChildren {
+
+    public List<TreeNode> children;
+    public TreeMap<String, ByteBuffer> attrs;
+
+    public DefaultTreeNodeChildren(List<TreeNode> _children, TreeMap<String, ByteBuffer> _attrs) {
+        children = _children;
+        attrs = _attrs;
+    }
+
+    private boolean boundaryCheck(int _pos) {
+        int size = children.length();
+        if (size < _pos) {
+            return false;
+        }
+
+        return true;
+    }
+
+    @Override
+    public List<TreeNode> getChildrenAsRawList() {
+        return children;
+    }
+
+    @Override
+    public Either<Error, TreeNode> addNewChildAt(int _pos) {
+        if (!boundaryCheck(_pos) || _pos < 0) {
+            return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
+        }
+
+        List<TreeNode> newChildren = children.add(_pos, new DefaultTreeNode());
+        TreeNode newNode = new DefaultTreeNode(newChildren, attrs);
+        return DefaultEither.newB(newNode);
+    }
+
+    @Override
+    public Either<jp.ac.u_ryukyu.ie.cr.jungle.util.Error, TreeNode> deleteChildAt(int _pos) {
+        if (!boundaryCheck(_pos) || _pos < 0 || size() == 0) {
+            return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
+        }
+
+        List<TreeNode> newChildren = children.delete(_pos);
+        TreeNode newNode = new DefaultTreeNode(newChildren, attrs);
+
+        return DefaultEither.newB(newNode);
+    }
+
+    @Override
+    public int size() {
+        return children.length();
+    }
+
+    @Override
+    public Iterator<TreeNode> iterator() {
+        return children.iterator();
+    }
+
+    @Override
+    public Either<Error, TreeNode> replaceNode(int _pos, TreeNode _replacement) {
+        int size = children.length();
+        if (!(0 <= _pos && _pos < size)) {
+            return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
+        }
+        TreeNode replacement = _replacement;
+
+        List<TreeNode> newChildren = children.replace(_pos, replacement);
+        TreeNode node = new DefaultTreeNode(newChildren, attrs);
+        return DefaultEither.newB(node);
+    }
+
+    @Override
+    public Either<Error, TreeNode> at(int _pos) {
+        if (children.length() < _pos + 1) {
+            return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
+        }
+
+        TreeNode Node = children.index(_pos);
+
+        return DefaultEither.newB(Node);
+    }
+
+    @Override
+    public Either<Error, TreeNode> addNewChildAt(int _pos, TreeNode _newChild) {
+        if (!boundaryCheck(_pos) || _pos < 0) {
+            return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
+        }
+        List<TreeNode> newChildren = children.add(_pos, _newChild);
+        TreeNode newNode = new DefaultTreeNode(newChildren, attrs);
+
+        return DefaultEither.newB(newNode);
+    }
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/transaction/TransactionManager.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,14 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.transaction;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.TreeOperationLog;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+public interface TransactionManager
+{
+	public Either<Error,TransactionManager> commit(TreeNode _newRoot,TreeOperationLog _log);
+	public String getUUID();
+	public long getRevision();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/traverser/DefaultEvaluation.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,25 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.traverser;
+
+public class DefaultEvaluation implements Evaluation
+{
+	private final Result result;
+	private final Evaluator evaluator;
+
+	public DefaultEvaluation(Result _result,Evaluator _evaluator)
+	{
+		result = _result;
+		evaluator = _evaluator;
+	}
+
+	@Override
+	public Result result()
+	{
+		return result;
+	}
+
+	@Override
+	public Evaluator evaluator()
+	{
+		return evaluator;
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/traverser/DefaultEvaluator.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,40 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.traverser;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Pair;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+
+public class DefaultEvaluator implements Evaluator
+{
+	private final NodePath path;
+
+	public DefaultEvaluator(NodePath _path)
+	{
+		path = _path;
+	}
+
+	@Override
+	public Evaluation evaluate(TreeNode _current,int _pos)
+	{
+		Pair<Integer,NodePath> pop = path.pop();
+		int head = pop.left();
+
+		if(path.size() == 1){
+			if(head == _pos){
+				return new DefaultEvaluation(Result.GOAL,null);
+			}
+		}
+
+		DefaultEvaluator nextEvaluator;
+		Result result;
+		if(head == _pos){
+			result = Result.ACCEPT;
+			nextEvaluator = new DefaultEvaluator(pop.right());
+		}else{
+			result = Result.CONTINUE;
+			nextEvaluator = null;
+		}
+
+		return new DefaultEvaluation(result,nextEvaluator);
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/traverser/DefaultTraverser.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,144 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.traverser;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.core.Children;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.NodeEditorError;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+import java.util.Iterator;
+
+
+public class DefaultTraverser implements Traverser
+{
+	@Override
+	public Either<Error,Traversal> traverse(final TreeNode _root,Evaluator _evaluator)
+	{
+		Children wrapper = new Children(){
+			@Override
+			public Iterator<TreeNode> iterator(){
+				List<TreeNode> list = new List();
+				return list.addLast(_root).iterator();
+			}
+
+			@Override
+			public int size(){
+				return 1;
+			}
+
+			@Override
+			public Either<Error,TreeNode> at(int _pos){
+				if(_pos != 0){
+					return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
+				}
+				return DefaultEither.newB(_root);
+			}
+		};
+
+		//Children<T> chs = _root.getChildren();
+		Children chs = wrapper;
+
+		Either<Error,List<Direction<TreeNode>>> ret = _traverse(chs,_evaluator,-1);
+
+		if(ret.isA()){
+			return DefaultEither.newA(ret.a());
+		}
+
+		List<Direction<TreeNode>> list = ret.b();
+
+		final Iterable<Direction<TreeNode>> iterable = list;
+		final TreeNode destination = ret.b().last().getTarget();
+
+		Traversal traversal = new Traversal(){
+			@Override
+			public Iterator<Direction<TreeNode>> iterator(){
+				return iterable.iterator();
+			}
+
+			@Override
+			public TreeNode destination(){
+				return destination;
+			}
+		};
+
+		return DefaultEither.newB(traversal);
+	}
+
+	private Either<Error,List<Direction<TreeNode>>> _traverse(Children _chs,Evaluator _evaluator,int _pos)
+	{
+		int pos = _pos;
+		for(TreeNode ch : _chs){
+			Evaluation e = _evaluator.evaluate(ch,pos);
+			Result r = e.result();
+			if(r == Result.ACCEPT){
+				return _accept(ch,pos,e.evaluator());
+			}
+
+			if(r == Result.GOAL){
+				return DefaultEither.newB(_goal(ch,pos));
+			}
+
+			if(r == Result.BREAK){
+				break;
+			}
+
+			if(r == Result.CONTINUE){
+				pos --;
+				continue;
+			}
+
+			return DefaultEither.newA(TraverserError.UNDEFINED_OPERATOR);
+		}
+
+		return DefaultEither.newA(TraverserError.PATH_NOT_FOUND);
+	}
+
+	private List<Direction<TreeNode>> _goal(final TreeNode _current,final int _pos)
+	{
+		Direction<TreeNode> d = new Direction<TreeNode>(){
+			@Override
+			public int getPosition()
+			{
+				return _pos;
+			}
+			@Override
+			public TreeNode getTarget()
+			{
+				return _current;
+			}
+		};
+
+		List<Direction<TreeNode>> list = new List();
+		List<Direction<TreeNode>> newList = list.addLast(d);
+
+		return newList;
+	}
+
+	private <T extends TreeNode> Either<Error,List<Direction<TreeNode>>> _accept(final T _current,final int _pos,Evaluator _evaluator)
+	{
+		Children chs = _current.getChildren();
+		Either<Error,List<Direction<TreeNode>>> either = _traverse(chs,_evaluator,chs.size() - 1);
+		if(either.isA()){
+			return either;
+		}
+
+		List<Direction<TreeNode>> list = either.b();
+		Direction<TreeNode> d = new Direction<TreeNode>(){
+			@Override
+			public int getPosition()
+			{
+				return _pos;
+			}
+			@Override
+			public T getTarget()
+			{
+				return _current;
+			}
+		};
+
+		List<Direction<TreeNode>> newList = list.addLast(d);
+		return DefaultEither.newB(newList);
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/traverser/Direction.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,7 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.traverser;
+
+public interface Direction<T>
+{
+	public int getPosition();
+	public T getTarget();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/traverser/Evaluation.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,7 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.traverser;
+
+public interface Evaluation
+{
+	public Result result();
+	public Evaluator evaluator();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/traverser/Evaluator.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,8 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.traverser;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+
+public interface Evaluator
+{
+	public Evaluation evaluate(TreeNode _current,int _pos);
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/traverser/InterfaceTraverser.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,319 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.traverser;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.NulIterator;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.query.PathNodeIterator;
+import jp.ac.u_ryukyu.ie.cr.jungle.query.Query;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.index.IndexCreater;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.index.ParentIndex;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
+
+import java.util.Iterator;
+import java.util.Optional;
+
+public class InterfaceTraverser {
+
+    TreeNode root;
+    TreeMap<String, TreeMap<String, List<TreeNode>>> indexList;
+    ParentIndex parentIndex;
+    boolean parentUpdateFlag;
+    boolean useIndex;
+
+    public InterfaceTraverser(TreeNode root, boolean indexFlag) {
+        this(root, new TreeMap<>(), new ParentIndex(), indexFlag);
+    }
+
+    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 TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
+        return indexList;
+    }
+
+    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();
+    }
+
+    /**
+     * 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() {
+    // }
+    //
+    // };
+    // }
+    // }
+    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) {
+
+                    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() {
+    // }
+    //
+    // };
+    // }
+    // }
+
+    public Iterator<TreeNode> get(String key, String value) {
+        Optional<TreeMap<String, List<TreeNode>>> indexOp = indexList.get(key);
+        if (!indexOp.isPresent())
+            return null;
+
+        Optional<List<TreeNode>> nodeListOp = indexOp.get().get(value);
+        if (!nodeListOp.isPresent())
+            return new NulIterator<TreeNode>();
+
+        return nodeListOp.get().iterator();
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/traverser/Result.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,22 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.traverser;
+
+public class Result
+{
+
+	public static final Result ACCEPT = new Result("ACCEPT");
+	public static final Result CONTINUE = new Result("CONTINUE");
+	public static final Result BREAK = new Result("BREAK");
+	public static final Result GOAL = new Result("GOAL");
+
+	private final String name;
+
+	private Result(String _name)
+	{
+		name = _name;
+	}
+
+	public String toString()
+	{
+		return name;
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/traverser/Traversal.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,8 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.traverser;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+
+public interface Traversal extends Iterable<Direction<TreeNode>>
+{
+	public TreeNode destination();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/traverser/Traverser.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,12 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.traverser;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+public interface Traverser
+{
+	public Either<Error,Traversal> traverse(final TreeNode _root,Evaluator _evaluator);
+
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/traverser/TraverserError.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,10 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.traverser;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultError;
+
+public class TraverserError
+{
+	public static final jp.ac.u_ryukyu.ie.cr.jungle.util.Error UNDEFINED_OPERATOR = new DefaultError();
+	public static final Error PATH_NOT_FOUND = new DefaultError();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/util/DefaultEither.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,47 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.util;
+
+public class DefaultEither<A,B> implements Either<A,B>
+{
+	private final A theA;
+	private final B theB;
+
+	private DefaultEither(A _theA,B _theB)
+	{
+		theA = _theA;
+		theB = _theB;
+	}
+
+	public static final <A,B> DefaultEither<A,B> newA(A _theA)
+	{
+		return new DefaultEither<A,B>(_theA,null);
+	}
+
+	public static final <A,B> DefaultEither<A,B> newB(B _theB)
+	{
+		return new DefaultEither<A,B>(null,_theB);
+	}
+
+	@Override
+	public A a()
+	{
+		return theA;
+	}
+
+	@Override
+	public boolean isA()
+	{
+		return theA != null;
+	}
+
+	@Override
+	public B b()
+	{
+		return theB;
+	}
+
+	@Override
+	public boolean isB()
+	{
+		return theB != null;
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/util/DefaultError.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,5 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.util;
+
+public class DefaultError implements Error
+{
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/util/Either.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,9 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.util;
+
+public interface Either<A,B>
+{
+	public A a();
+	public boolean isA();
+	public B b();
+	public boolean isB();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/util/Error.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,5 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.util;
+
+public interface Error {
+
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/util/GetOldTreeError.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,5 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.util;
+
+public class GetOldTreeError implements Error {
+  public static final Error OLD_TREE_NOT_FOUND = new DefaultError();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/util/IterableConverter.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,56 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.util;
+
+import java.util.Iterator;
+
+public class IterableConverter<A,B> implements Iterable<A>
+{
+	private final Iterable<B> iterable;
+	private final Converter<A,B> converter;
+
+	public IterableConverter(Iterable<B> _iterable,Converter<A,B> _converter)
+	{
+		iterable = _iterable;
+		converter = _converter;
+	}
+
+	@Override
+	public Iterator<A> iterator()
+	{
+		return new IteratorConverter<A,B>(iterable.iterator(),converter);
+	}
+
+	private static final class IteratorConverter<A,B> implements Iterator<A>
+	{
+		private final Iterator<B> iterator;
+		private final Converter<A,B> converter;
+
+		public IteratorConverter(Iterator<B> _iterator,Converter<A,B> _converter)
+		{
+			iterator = _iterator;
+			converter = _converter;
+		}
+
+		@Override
+		public boolean hasNext()
+		{
+			return iterator.hasNext();
+		}
+
+		@Override
+		public A next()
+		{
+			return converter.conv(iterator.next());
+		}
+
+		@Override
+		public void remove()
+		{
+			iterator.remove();
+		}
+	}
+
+	public static interface Converter<A,B>
+	{
+		public A conv(B _b);
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/util/Pair.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,23 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.util;
+
+public class Pair<L,R>
+{
+	private L left;
+	private R right;
+
+	public Pair(L _left,R _right)
+	{
+		left = _left;
+		right = _right;
+	}
+
+	public L left()
+	{
+		return left;
+	}
+
+	public R right()
+	{
+		return right;
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/jungle/util/Triple.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,45 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.util;
+
+public class Triple<A,B,C>
+{
+	private A a;
+	private B b;
+	private C c;
+
+	public Triple(A _a,B _b,C _c)
+	{
+		a = _a;
+		b = _b;
+		c = _c;
+	}
+
+	public A getA()
+	{
+		return a;
+	}
+
+	public B getB()
+	{
+		return b;
+	}
+
+	public C getC()
+	{
+		return c;
+	}
+
+	public void setA(A _a)
+	{
+		a = _a;
+	}
+
+	public void setB(B _b)
+	{
+		b = _b;
+	}
+
+	public void setC(C _c)
+	{
+		c = _c;
+	}
+}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/list/DefaultNode.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,67 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.list;
-
-/**
- * Created by e115731 on 15/05/16.
- */
-public class DefaultNode<T> implements Node<T> {
-    private final T attribute;
-    private final int num;
-    private final Node next;
-
-    public DefaultNode(T attribute, int num, Node next) {
-        this.attribute = attribute;
-        this.num = num;
-        this.next = next;
-    }
-
-    public int getNum() {
-        return num;
-    }
-
-    public Node getNext() {
-        return next;
-    }
-
-    public T getAttribute() {
-        return attribute;
-    }
-
-    public Node<T> add(int num, T attribute) {
-        if (this.num == num) {
-            Node<T> newNode = new DefaultNode(attribute, num, this.next);
-            return new DefaultNode<T>(this.attribute, this.num + 1, newNode);
-        }
-
-        Node<T> newNode = next.add(num, attribute);
-        if (newNode == null)
-            return null;
-
-        return new DefaultNode(this.attribute, this.num + 1, newNode);
-    }
-
-    @Override
-    public Node<T> delete(int deleteNum) {
-        if (this.num - 1 == deleteNum) {
-            return new DefaultNode(this.attribute, deleteNum, this.next.getNext());
-        }
-
-        Node<T> newNode = next.delete(deleteNum);
-        if (newNode == null)
-            return null;
-
-        return new DefaultNode(this.attribute, this.num - 1, newNode);
-    }
-
-    @Override
-    public Node<T> replaceNode(int num, T attribute) {
-        if (this.num  == num) {
-            return new DefaultNode(attribute, num, this.getNext());
-        }
-
-        Node<T> newNode = next.replaceNode(num, attribute);
-        if (newNode == null)
-            return null;
-
-        return new DefaultNode(this.attribute, this.num, newNode);
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/list/List.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,161 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.list;
-
-import java.util.Iterator;
-import java.util.Stack;
-
-/**
- * Created by e115731 on 15/05/16.
- * 非破壊であるためこのListは逆順になっています
- */
-public class List<T> implements Iterable<T> {
-    final private Node<T> head;
-    final private int listLength;
-
-    public List() {
-        this.head = new headNode();
-        this.listLength = 0;
-    }
-
-    public List(T... attributes) {
-        List<T> list = new List();
-        for (T attribute : attributes) {
-            list = list.addLast(attribute);
-        }
-        this.head = list.getHead();
-        this.listLength = head.getNext().getNum() + 1;
-    }
-
-    private List(Node<T> head) {
-        this.head = head;
-        this.listLength = head.getNext().getNum() + 1;
-    }
-
-    public Node<T> getHead() {
-        return head;
-    }
-
-    public List<T> add(int num, T attribute) {
-        Node<T> newHead = head.add(num, attribute);
-        if (newHead == null)
-            return this;
-        return new List<T>(newHead);
-    }
-
-    public List<T> addLast(T attribute) {
-        Node newNode = new DefaultNode(attribute, listLength, head.getNext());
-        Node newHead = new headNode(newNode);
-        return new List(newHead);
-    }
-
-    public T index(int num) {
-        Node<T> currentNode = head.getNext();
-        while (currentNode.getNum() != -1) {
-            if (currentNode.getNum() == num)
-                return currentNode.getAttribute();
-            currentNode = currentNode.getNext();
-        }
-        return null;
-    }
-
-    public Iterator<T> iterator() {
-        return new Iterator<T>() {
-            Node<T> currentNode = head.getNext();
-
-            @Override
-            public boolean hasNext() {
-                return currentNode.getNum() != -1;
-            }
-
-            @Override
-            public T next() {
-                T attribute = currentNode.getAttribute();
-                currentNode = currentNode.getNext();
-                return attribute;
-            }
-        };
-    }
-
-    public Iterator<T> reverseIterator() {
-        Node<T> currentNode = head.getNext();
-        Stack<T> stack = new Stack();
-        while (currentNode.getNum() != -1) {
-            stack.push(currentNode.getAttribute());
-            currentNode = currentNode.getNext();
-        }
-        return new Iterator<T>() {
-
-            @Override
-            public boolean hasNext() {
-                return !stack.isEmpty();
-            }
-
-            @Override
-            public T next() {
-                return stack.pop();
-            }
-        };
-    }
-
-
-    public List<T> delete(int num) {
-        Node<T> newNode = head.delete(num);
-        if (newNode == null)
-            return this;
-        Node<T> newHead = new headNode<>(newNode);
-        return new List<T>(newNode);
-    }
-
-    public List<T> replace(int num, T attribute) {
-        Node<T> newHead = head.replaceNode(num, attribute);
-        if (newHead == null)
-            return this;
-        return new List<T>(newHead);
-    }
-
-    public T last() {
-        return head.getNext().getAttribute();
-    }
-
-    public T head() {
-        return index(0);
-    }
-
-    public List<T> deleteLast() {
-        return delete(listLength - 1);
-    }
-
-    public List<T> deleteHead() {
-        return delete(0);
-    }
-
-    public int length() {
-        return listLength;
-    }
-
-    @Override
-    public String toString() {
-        String pathString = "<";
-        Iterator<T> iterator = reverseIterator();
-        while (true) {
-            pathString += iterator.next();
-            if (iterator.hasNext())
-                pathString += ",";
-            else
-                break;
-        }
-        pathString += ">";
-        return pathString;
-    }
-
-    public List<T> append(List<T> list) {
-        Iterator<T> iterator = list.reverseIterator();
-        List<T> newList = this;
-        while (iterator.hasNext()) {
-            T attribute = iterator.next();
-            newList = newList.addLast(attribute);
-        }
-        return newList;
-    }
-
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/list/Node.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,18 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.list;
-
-/**
- * Created by e115731 on 15/05/18.
- */
-public interface Node<T> {
-    public int getNum();
-
-    public Node<T> getNext();
-
-    public T getAttribute();
-
-    public Node<T> add(int num, T attribute);
-
-    public Node<T> delete(int num);
-
-    Node<T> replaceNode(int num, T attribute);
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/list/TailNode.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,38 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.list;
-
-/**
- * Created by e115731 on 15/05/19.
- */
-public class TailNode<T> implements Node<T> {
-
-    @Override
-    public int getNum() {
-        return -1;
-    }
-
-    @Override
-    public Node<T> getNext() {
-        return null;
-    }
-
-    @Override
-    public T getAttribute() {
-        return null;
-    }
-
-    @Override
-    public Node<T> add(int num, T attribute) {
-        return null;
-    }
-
-    @Override
-    public Node<T> delete(int num) {
-        return null;
-    }
-
-    @Override
-    public Node<T> replaceNode(int num, T attribute) {
-        return null;
-    }
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/list/headNode.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,72 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.list;
-
-/**
- * Created by e115731 on 15/05/18.
- */
-public class headNode<T> implements Node<T> {
-    private final Node next;
-
-
-    public headNode() {
-        this.next = new TailNode<T>();
-    }
-
-    public headNode(Node next) {
-        this.next = next;
-    }
-
-    public int getNum() {
-        return -1;
-    }
-
-    public Node getNext() {
-        return next;
-    }
-
-    public T getAttribute() {
-        return null;
-    }
-
-    public Node<T> add(int num, T attribute) {
-        if (next.getNum() == num - 1) {
-            Node<T> newNode = new DefaultNode<>(attribute, num, next);
-            return new headNode<T>(newNode);
-        }
-
-        if (next.getNum() == num) {
-            Node<T> newNode = new DefaultNode(attribute, num, next.getNext());
-            Node<T> newNext = new DefaultNode(next.getAttribute(), num++, newNode);
-            return new headNode(newNext);
-        }
-
-        Node<T> newNode = next.add(num, attribute);
-        if (newNode == null)
-            return this;
-        return new headNode(newNode);
-    }
-
-    public Node<T> delete(int deleteNum) {
-        if (getNext().getNum() == deleteNum) {
-            return new headNode(this.next.getNext());
-        }
-
-        Node<T> newNode = next.delete(deleteNum);
-        if (newNode == null)
-            return this;
-        return new headNode(newNode);
-    }
-
-    @Override
-    public Node<T> replaceNode(int num, T attribute) {
-        Node<T> nextNode = getNext();
-        if (nextNode.getNum() == num) {
-            Node<T> newNode = new DefaultNode(attribute, num, nextNode.getNext());
-            return new headNode(newNode);
-        }
-
-        Node<T> newNode = nextNode.replaceNode(num, attribute);
-        if (newNode == null)
-            return this;
-        return new headNode(newNode);
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,85 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle;
-
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.Journal;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.NullJournal;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeContext;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-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 java.util.Iterator;
-import java.util.concurrent.ConcurrentHashMap;
-
-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 createNewTree(final String name) {
-        ChangeList list = new ChangeList() {
-            @Override
-            public Iterator<TreeOperation> iterator() {
-                List<TreeOperation> nil = new List();
-                return nil.iterator();
-            }
-
-            @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;
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,108 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle;
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeContext;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultJungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTransactionManager;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.GetOldTreeError;
-import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
-
-import java.util.concurrent.atomic.AtomicReference;
-
-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;
-    }
-
-    @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 JungleTreeEditor getLocalTreeEditor() {
-        return getTreeEditor();
-    }
-
-    @Override
-    public TreeNode getRootNode() {
-        TreeContext tc = repository.get();
-        return tc.getRoot();
-    }
-
-    @Override
-    public InterfaceTraverser getTraverser(boolean useIndex) {
-        TreeContext tc = repository.get();
-        return tc.getTraverser();
-    }
-
-    @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();
-    }
-
-    @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);
-        }
-
-
-        String oldTreeUuid = uuid + revision;
-        JungleTree oldTree = new DefaultJungleTree(tc, oldTreeUuid, writer, treeEditor);
-        return DefaultEither.newB(oldTree);
-    }
-
-    @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);
-    }
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/Jungle.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,8 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle;
-
-
-public interface Jungle
-{
-	public JungleTree getTreeByName(String name);
-	public JungleTree createNewTree(String name);
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTree.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,31 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle;
-
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-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.ParentIndex;
-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
-
-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, List<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/JungleTreeEditor.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,20 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle;
-
-import java.nio.ByteBuffer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public interface JungleTreeEditor
-{
-
-	public Either<Error,JungleTreeEditor> addNewChildAt(NodePath path,int pos);
-	public Either<Error,JungleTreeEditor> deleteChildAt(NodePath path,int pos);
-	public Either<Error,JungleTreeEditor> putAttribute(NodePath path,String key,ByteBuffer value);
-	public Either<Error,JungleTreeEditor> deleteAttribute(NodePath path,String key);
-	public Either<Error,JungleTreeEditor> edit(NodePath path,NodeEditor editor);
-	public Either<Error,JungleTreeEditor> success();
-  public Either<Error, JungleTreeEditor> replaceNewRootNode();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/App.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,42 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core;
-
-import java.nio.ByteBuffer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-/**
- * Hello world!
- *
- */
-public class App
-{
-    public static void main( String[] args )
-    {
-    	DefaultJungle jungle = new DefaultJungle(null,"sample", new DefaultTreeEditor(new DefaultTraverser()));
-    	jungle.createNewTree("hoge");
-    	JungleTree tree = jungle.getTreeByName("hoge");
-    	JungleTreeEditor editor = tree.getTreeEditor();
-    	DefaultNodePath path = new DefaultNodePath();
-
-    	String key = "key";
-    	ByteBuffer value = ByteBuffer.wrap(key.getBytes());
-
-    	Either<Error,JungleTreeEditor> either = editor.putAttribute(path,"key",value);
-    	JungleTreeEditor e = either.b();
-    	e.success();
-
-
-    	TreeNode root = tree.getRootNode();
-    	ByteBuffer v = root.getAttributes().get(key);
-    	String str = new String(v.array());
-    	System.out.println(str);
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/Attributes.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,9 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core;
-
-import java.nio.ByteBuffer;
-
-public interface Attributes
-{
-	public ByteBuffer get(String key);
-	public String getString(String key);
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/AttributesContainer.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,6 +0,0 @@
-//package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core;
-//
-//public interface AttributesContainer
-//{
-//	public Attributes getAttributes();
-//}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/Children.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,11 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public interface Children extends Iterable<TreeNode>
-{
-	public Either<Error,TreeNode> at(int pos);
-	public int size();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/error/BasicErrors.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,10 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.error;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultError;
-
-public class BasicErrors
-{
-	public static final Error NULL_VALUE_NOT_ALLOWED = new DefaultError();
-	public static final Error INDEX_OUT_OF_BOUNDS = new DefaultError();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/persistent/ChangeList.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,9 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-
-public interface ChangeList extends Iterable<TreeOperation>
-{
-	public String uuid();
-	public String getTreeName();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/persistent/ChangeListReader.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,8 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent;
-
-public interface ChangeListReader extends Iterable<ChangeList>
-{
-	public ChangeListReader newReader();
-	public ChangeList read();
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/persistent/ChangeListWriter.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,6 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent;
-
-public interface ChangeListWriter
-{
-    public Result write(ChangeList operations);
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/persistent/DefaultChangeListReader.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,49 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent;
-
-import java.nio.ByteBuffer;
-import java.nio.channels.FileChannel;
-import java.util.Iterator;
-import java.util.LinkedList;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-
-// not thread safe
-public class DefaultChangeListReader implements ChangeListReader
-{
-	private long pos;
-	private ByteBuffer buf;
-	private FileChannel ch;
-
-	DefaultChangeListReader(FileChannel ch,ByteBuffer buf,long pos)
-	{
-		this.pos = pos;
-		this.buf = buf;
-		this.ch = ch;
-	}
-
-	@Override
-	public ChangeListReader newReader()
-	{
-		return new DefaultChangeListReader(ch,buf.asReadOnlyBuffer(),pos);
-	}
-
-	@Override
-	public ChangeList read()
-	{
-		LinkedList<TreeOperation> list = new LinkedList<TreeOperation>();
-
-		int size = buf.getInt();
-		if(size == 0){
-
-		}
-
-		return null;
-	}
-
-	@Override
-	public Iterator<ChangeList> iterator() {
-		return null;
-	}
-
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/persistent/DefaultChangeListWriter.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,29 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent;
-
-import java.nio.ByteBuffer;
-
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-
-public class DefaultChangeListWriter implements ChangeListWriter
-{
-	public DefaultChangeListWriter(ByteBuffer buf)
-	{
-
-	}
-
-	@Override
-	public synchronized Result write(ChangeList operations)
-	{
-		for(TreeOperation op : operations){
-			ByteBuffer treeOpBuf = serializeTreeOperation(op);
-		}
-		return null;
-	}
-
-	private ByteBuffer serializeTreeOperation(TreeOperation op)
-	{
-
-		return null;
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/persistent/DefaultJournal.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,113 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent;
-
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.RandomAccessFile;
-import java.nio.ByteBuffer;
-import java.nio.MappedByteBuffer;
-import java.nio.channels.FileChannel;
-import java.nio.channels.FileChannel.MapMode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-/*
- * text based journal.
- *
- * non terminal symbols
- *
- * JOURNAL => CHANGELISTS
- * CHANGE_LISTS => CHANGE_LIST | CHANGE_LISTS
- * CHANGE_LISTS => *EMPTY*
- *
- * CHANGE_LIST => OPERATIONS
- * OPERATIONS => OPERATION CR | OPERATIONS
- * OPERATIONS => *EMPTY*
-
- * OPERATION => APPEND_CHILD | DELETE_CHILD | PUT_ATTRIBUTE | DELETE_ATTRIBUTE | COMMIT
- * APPEND_CHILD => APPEND_CHILD_ID NODE_PATH INSERT_POSITION
- * DELETE_CHILD => DELETE_CHILD_ID NODE_PATH DELETE_POSITION
- * PUT_ATTRIBUTE => PUT_ATTRIBUTE_ID NODE_PATH KEY VALUE
- * DELETE_ATTRIBUTE => DELTE_ATTRIBUTE_ID NODE_PATH KEY
- * COMMIT => COMMIT_ID
- *
- * NODE_PATH => POSITION "." NODE_PATH | POSITION
- *
- * terminal symbols
- *
- * APPEND_CHILD_ID = "APPEND_CHILD"
- * DELETE_CHILD_ID = "DELETE_CHILD"
- * PUT_ATTRIBUTE_ID = "PUT_ATTRIBUTE"
- * SET_ATTRIBUTE_ID = "SET_ATTRIBUTE"
- * COMMIT_ID => "COMMIT"
- * CR => \n
- * INSERT_POSITION => INTEGER
- * DELETE_POSITION => INTEGER
- * KEY => "*"
- * VALUE => "*"
- *
- */
-
-public class DefaultJournal implements Journal
-{
-	private final ChangeListWriter writer;
-
-	public static void main(String args[]) throws Exception
-	{
-		RandomAccessFile f = new RandomAccessFile("./miscs/1.dat","rw");
-		MappedByteBuffer a = f.getChannel().map(MapMode.READ_WRITE,10,10);
-		MappedByteBuffer b = f.getChannel().map(MapMode.READ_WRITE,10,10);
-		MappedByteBuffer c = f.getChannel().map(MapMode.READ_WRITE,20,10);
-
-		a.putInt(5);
-		System.out.println(b.getInt());
-		c.putInt(2);
-		a.force();
-		b.force();
-		c.force();
-
-		System.out.println(b.capacity());
-		MappedByteBuffer d = f.getChannel().map(MapMode.READ_WRITE,50,10);
-		d.putInt(2);
-		d.force();
-		System.out.println(d.getInt());
-	}
-
-	public static final int READ_BUFFER_SIZE = 1000000;  // 1MB
-	public static final int WRITE_BUFFER_SIZE = 1000000; // 1MB
-
-	private DefaultJournal()
-	{
-		writer = null;
-	}
-
-	public static Either<Error,DefaultJournal> newInstance(String fileName)
-	{
-		RandomAccessFile journal = null;
-		try{
-			journal = new RandomAccessFile(fileName,"rw");
-			FileChannel ch = journal.getChannel();
-			long length = journal.length();
-			ByteBuffer readBuf = ch.map(MapMode.READ_ONLY,0,READ_BUFFER_SIZE);
-			ByteBuffer writeBuf = ch.map(MapMode.READ_WRITE,length,WRITE_BUFFER_SIZE);
-
-		}catch(FileNotFoundException _e){
-			_e.printStackTrace();
-			return null; // should return Error here.
-		}catch(IOException _e){
-			_e.printStackTrace();
-		}
-		return null;
-	}
-
-	@Override
-	public ChangeListReader getReader()
-	{
-		return null;
-	}
-
-	@Override
-	public ChangeListWriter getWriter()
-	{
-		return writer;
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/persistent/DefaultJournalWriter.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,31 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent;
-
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.RandomAccessFile;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-
-public class DefaultJournalWriter
-{
-	public DefaultJournalWriter(String _fileName)
-	{
-
-	}
-
-	public static Either<Error,DefaultJournalWriter> newInstance(String fileName)
-	{
-		RandomAccessFile journal = null;
-		try{
-			journal = new RandomAccessFile(fileName,"rw");
-			//FileChannel ch = journal.getChannel();
-			long length = journal.length();
-		}catch(FileNotFoundException e){
-
-		}catch(IOException e){
-
-		}
-
-		return null;
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/persistent/Journal.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,7 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent;
-
-public interface Journal
-{
-	public ChangeListReader getReader();
-	public ChangeListWriter getWriter();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/persistent/NullJournal.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,82 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent;
-
-
-import java.util.Iterator;
-
-
-
-public class NullJournal implements Journal
-{
-	private static final NullChangeListWriter NULL_WRITER = new NullChangeListWriter();
-	private static final NullChangeListReader NULL_READER = new NullChangeListReader();
-
-	@Override
-	public ChangeListReader getReader()
-	{
-		return NULL_READER;
-	}
-
-	@Override
-	public ChangeListWriter getWriter()
-	{
-		return NULL_WRITER;
-	}
-
-	private static class NullChangeListWriter implements ChangeListWriter
-	{
-		@Override
-		public Result write(ChangeList operations)
-		{
-			/*
-			for(TreeOperation op : _operations){
-				NodePath p = op.getNodePath();
-				NodeOperation nodeOp = op.getNodeOperation();
-				Command c = nodeOp.getCommand();
-				String args = "";
-				switch(c){
-					case PUT_ATTRIBUTE:
-						String key = nodeOp.getKey();
-						ByteBuffer value = nodeOp.getValue();
-						if(value.limit() < 100){
-							args = String.format("key:%s,value:%s",key,new String(value.array()));
-						}else{
-							args = String.format("key:%s,value:%d",key,value.limit());
-						}
-						break;
-					case DELETE_ATTRIBUTE:
-						args = String.format("key:%s",nodeOp.getKey());
-						break;
-					case APPEND_CHILD:
-						args = String.format("pos:%d",nodeOp.getPosition());
-						break;
-					case DELETE_CHILD:
-						args = String.format("pos:%d",nodeOp.getPosition());
-						break;
-				}
-				System.out.println(String.format("[%s:%s:%s]",c,p,args));
-			}
-			*/
-			return Result.SUCCESS;
-		}
-	}
-
-	private static class NullChangeListReader implements ChangeListReader
-	{
-		@Override
-		public ChangeListReader newReader()
-		{
-			return this;
-		}
-
-		@Override
-		public ChangeList read()
-		{
-			return null;
-		}
-
-		@Override
-		public Iterator<ChangeList> iterator() {
-			return null;
-		}
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/persistent/Result.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,6 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent;
-
-public class Result
-{
-	public static Result SUCCESS = new Result();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/Command.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,10 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store;
-
-public enum Command
-{
-	APPEND_CHILD,
-	DELETE_CHILD,
-	PUT_ATTRIBUTE,
-	DELETE_ATTRIBUTE,
-	REPLACE_ROOT;
-}
\ No newline at end of file
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/Constants.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,7 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store;
-
-public class Constants
-{
-	public static final String DEFAULT_OWNER = "default";
-	public static final long DEFAULT_REVISION_START_NUMBER = 0;
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/NodePath.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,12 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
-
-public interface NodePath extends Iterable<Integer>
-{
-	public NodePath add(int pos);
-	public Pair<Integer,NodePath> pop();
-	public NodePath tail();
-	public int size();
-	public Pair<Integer,NodePath> last();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/NulIterator.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,19 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store;
-
-import java.util.Iterator;
-
-public class NulIterator<T> implements Iterator<T> {
-
-  @Override
-  public boolean hasNext() {
-    // TODO Auto-generated method stub
-    return false;
-  }
-
-  @Override
-  public T next() {
-    // TODO Auto-generated method stub
-    return null;
-  }
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/Transaction.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,9 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public interface Transaction<T>
-{
-	public Either<Error,T> success();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/TreeContext.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,32 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store;
-
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-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;
-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
-
-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 InterfaceTraverser getTraverser();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/TreeEditor.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,12 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public interface TreeEditor
-{
-	public Either<Error,LoggingNode> edit(TreeNode root,NodePath path,NodeEditor transformer);
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/TreeEditorError.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,9 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultError;
-
-public class TreeEditorError
-{
-	public static final Error NODEPATH_NOTFOUND = new DefaultError();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/DefaultNodePath.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,83 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl;
-
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
-
-import java.util.Iterator;
-
-public class DefaultNodePath implements NodePath {
-    private final List<Integer> path;
-
-    public static void main(String args[]) {
-        DefaultNodePath p = new DefaultNodePath();
-        p = p.add(1).add(2).add(3).add(4);
-        System.out.println(p.toString());
-    }
-
-    public DefaultNodePath() {
-        path = new List<Integer>().addLast(-1);
-    }
-
-    private DefaultNodePath(List<Integer> path) {
-        this.path = path;
-    }
-
-    @Override
-    public Iterator<Integer> iterator() {
-        return path.iterator();
-    }
-
-    @Override
-    public DefaultNodePath add(int pos) {
-        List<Integer> newPath = path.addLast(pos);
-        return new DefaultNodePath(newPath);
-    }
-
-    @Override
-    public Pair<Integer, NodePath> pop() {
-        Integer head = path.head();
-        List<Integer> tail = path.deleteHead();
-
-        return new Pair<Integer, NodePath>(head, new DefaultNodePath(tail));
-    }
-
-    @Override
-    public Pair<Integer, NodePath> last() {
-        Integer last = path.head();
-        List<Integer> list = path.deleteHead();
-        return new Pair<Integer, NodePath>(last, new DefaultNodePath(list));
-    }
-
-    @Override
-    public String toString() {
-        return path.toString();
-    }
-
-    @Override
-    public int size() {
-        return path.length();
-    }
-
-
-    //PATHの一番後ろを取り除いたPATHを新しく作って返す
-// EXAMPLE <0,0,3> → <0,0>
-    @Override
-    public NodePath tail() {
-        List<Integer> tail = path.deleteLast();
-        return new DefaultNodePath(tail);
-    }
-
-    public List<DefaultNodePath> inits() {
-        List<DefaultNodePath> paths = new List();
-        List<Integer> coursePath = new List();
-        Iterator<Integer> iterator = path.reverseIterator();
-        while (iterator.hasNext()) {
-            List<Integer> tmp = coursePath.addLast(iterator.next());
-            paths = paths.add(1,new DefaultNodePath(tmp));
-            coursePath = tmp;
-        }
-        return paths;
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/DefaultTreeEditor.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,84 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl;
-
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultEvaluator;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Direction;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Traversal;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Traverser;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public class DefaultTreeEditor implements TreeEditor
-{
-	private final Traverser traverser;
-	public DefaultTreeEditor(Traverser traverser)
-	{
-		this.traverser = traverser;
-	}
-
-	@Override
-	public Either<Error,LoggingNode> edit(TreeNode root,NodePath path,NodeEditor editor)
-	{
-		DefaultEvaluator e = new DefaultEvaluator(path);
-		Either<Error, Traversal> either = traverser.traverse(root,e);
-
-		if(either.isA()){
-			return DefaultEither.newA(either.a());
-		}
-
-		Traversal t = either.b();
-		Either<Error,LoggingNode> ret = clone(t,editor);
-
-		return ret;
-	}
-
-	private Either<Error,LoggingNode> clone(Traversal t,NodeEditor editor)
-	{
-		// copying nodes from bottom to root
-
-		List<Direction<TreeNode>> path = new List();
-		for(Direction<TreeNode> direction : t){
-			path = path.addLast(direction);
-		}
-
-		// target
-		Direction<TreeNode> targetDirection = path.last();
-		TreeNode target = targetDirection.getTarget();
-		Either<Error,LoggingNode> either = editor.edit(target);
-		if(either.isA()){
-			return DefaultEither.newA(either.a());
-		}
-
-		LoggingNode newWrap = either.b();
-
-		// top
-		int pos = targetDirection.getPosition();
-		TreeNode child = newWrap.getWrap();
-
-
-		for(Direction<TreeNode> parentDirection : path.deleteLast()){
-
-			TreeNodeChildren chs =  parentDirection.getTarget().getChildren();
-
-			Either<Error,TreeNode> ret = chs.replaceNode(pos,child);
-			if(ret.isA()){
-				return DefaultEither.newA(ret.a());
-			}
-
-			TreeNode newParent = ret.b();
-			child = newParent;
-			pos = parentDirection.getPosition();
-		}
-
-		TreeNode newRoot = child;
-		LoggingNode logNode = editor.wrap(newRoot,newWrap.getOperationLog());
-		return DefaultEither.newB(logNode);
-	}
-
-}
\ No newline at end of file
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/IndexTreeEditor.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,89 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl;
-
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultEvaluator;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Direction;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Traversal;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Traverser;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public class IndexTreeEditor {
-
-  private final Traverser traverser;
-
-
-  public IndexTreeEditor(Traverser traverser)
-  {
-    this.traverser = traverser;
-  }
-
-
-  public Either<Error,LoggingNode> edit(TreeNode root,NodePath path,NodeEditor editor)
-  {
-    DefaultEvaluator e = new DefaultEvaluator(path);
-    Either<Error, Traversal> either = traverser.traverse(root,e);
-
-    if(either.isA()){
-      return DefaultEither.newA(either.a());
-    }
-
-    Traversal t = either.b();
-    Either<Error,LoggingNode> ret = clone(t,editor);
-
-    return ret;
-  }
-
-  private Either<Error,LoggingNode> clone(Traversal t,NodeEditor editor)
-  {
-    // copying nodes from bottom to root
-    List<Direction<TreeNode>> path = new List();
-    for (Direction<TreeNode> direction : t) {
-      path = path.addLast(direction);
-    }
-
-    // target
-    Direction<TreeNode> targetDirection = path.head();
-    TreeNode target = targetDirection.getTarget();
-
-    Either<Error, LoggingNode> either = editor.edit(target);
-    if (either.isA()) {
-      return DefaultEither.newA(either.a());
-    }
-
-    LoggingNode newWrap = either.b();
-
-    // top
-    int pos = targetDirection.getPosition();
-    TreeNode child = newWrap.getWrap();
-
-    for (Direction<TreeNode> parentDirection : path.deleteLast()) {
-      TreeNode updateTargetNode = parentDirection.getTarget();
-      TreeNodeChildren chs = updateTargetNode.getChildren();
-
-
-
-      Either<Error, TreeNode> ret = chs.replaceNode(pos, child);
-      if (ret.isA()) {
-        return DefaultEither.newA(ret.a());
-      }
-
-      TreeNode newParent = ret.b();
-
-      child = newParent;
-      pos = parentDirection.getPosition();
-    }
-
-    TreeNode newRoot = child;
-    LoggingNode logNode = editor.wrap(newRoot, newWrap.getOperationLog());
-
-
-    return DefaultEither.newB(logNode);
-  }
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/TreeNode.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,17 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-
-public interface TreeNode extends Comparable<TreeNode> {
-    public TreeNodeChildren getChildren();
-
-    public TreeNodeAttributes getAttributes();
-
-    public TreeNode createNewNode();
-
-    public Either<Error, TreeNode> appendRootNode();
-
-    public String getNodeId();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/TreeNodeAttributes.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,17 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Attributes;
-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.treemap.TreeMap;
-
-import java.nio.ByteBuffer;
-import java.util.Iterator;
-
-public interface TreeNodeAttributes extends Attributes
-{
-	public Either<Error,TreeNode> delete(String key);
-	public Either<Error,TreeNode> put(String key,ByteBuffer value);
-	public TreeMap<String,ByteBuffer> getAttributesAsRawMap();
-	public Iterator<String> getKeys();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/TreeNodeChildren.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,15 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl;
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Children;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public interface TreeNodeChildren extends Children
-{
-	public Either<Error,TreeNode> addNewChildAt(int pos);
-	public Either<Error,TreeNode> deleteChildAt(int pos);
-	public Either<Error,TreeNode> addNewChildAt(int pos,TreeNode newChild);
-	public Either<Error,TreeNode> replaceNode(int pos,TreeNode replacement);
-	public List<TreeNode> getChildrenAsRawList();
-}
\ No newline at end of file
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/logger/DefaultOperationLog.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,43 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger;
-
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
-
-import java.util.Iterator;
-
-public class DefaultOperationLog implements OperationLog
-{
-	private final List<NodeOperation> log;
-
-	private static final List<NodeOperation> EMPTY =new List<>();
-
-	public DefaultOperationLog()
-	{
-		this(EMPTY);
-	}
-
-	private DefaultOperationLog(List<NodeOperation> _log)
-	{
-		log = _log;
-	}
-
-	@Override
-	public Iterator<NodeOperation> iterator()
-	{
-		return log.iterator();
-	}
-
-
-	@Override
-	public DefaultOperationLog add(NodeOperation _op)
-	{
-		return new DefaultOperationLog(log.addLast(_op));
-	}
-
-	@Override
-	public int length()
-	{
-		return log.length();
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/logger/DefaultTreeOperationLog.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,60 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger;
-
-import com.google.common.collect.Iterables;
-import jp.ac.u_ryukyu.ie.cr.list.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-
-import java.util.Iterator;
-
-public class DefaultTreeOperationLog implements TreeOperationLog
-{
-	private final Iterable<TreeOperation> list;
-	private final int size;
-
-	public DefaultTreeOperationLog()
-	{
-		list = new List<>();
-		size = 0;
-	}
-
-	public DefaultTreeOperationLog(Iterable<TreeOperation> _list,int _size)
-	{
-		list = _list;
-		size = _size;
-	}
-
-	@Override
-	public Iterator<TreeOperation> iterator()
-	{
-		return list.iterator();
-	}
-
-	@Override
-	public TreeOperationLog add(NodePath _p, NodeOperation _op)
-	{
-		TreeOperation op = new DefaultTreeOperation(_p,_op);
-		List<TreeOperation> newList =  new List(op);
-		Iterable<TreeOperation> concat = Iterables.concat(list,newList);
-
-		return new DefaultTreeOperationLog(concat,size + 1);
-	}
-
-	@Override
-	public TreeOperationLog append(TreeOperationLog _log)
-	{
-		int argumentLogSize = _log.length();
-		Iterable<TreeOperation> concat = Iterables.concat(list,_log);
-
-		return new DefaultTreeOperationLog(concat,argumentLogSize + size);
-	}
-
-	@Override
-	public int length()
-	{
-		return size;
-	}
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/logger/LoggingAttributes.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,57 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger;
-
-import java.nio.ByteBuffer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNodeAttributes;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteAttributeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public class LoggingAttributes //implements EditableAttributes
-{
-	private final TreeNode wrap;
-	private final OperationLog log;
-
-	public LoggingAttributes(TreeNode _wrap,OperationLog _log)
-	{
-		wrap = _wrap;
-		log = _log;
-	}
-
-	public ByteBuffer get(String _key)
-	{
-		TreeNodeAttributes attributes = wrap.getAttributes();
-		return attributes.get(_key);
-	}
-
-	private Either<Error,LoggingNode> edit(NodeOperation _op)
-	{
-		Either<Error,TreeNode> either = _op.invoke(wrap);
-		if(either.isA()){
-			return DefaultEither.newA(either.a());
-		}
-
-		TreeNode newNode = either.b();
-		OperationLog newLog = log.add(_op);
-		LoggingNode newLogNode = new LoggingNode(newNode,newLog);
-
-		return DefaultEither.newB(newLogNode);
-	}
-
-	public Either<Error,LoggingNode> delete(final String _key)
-	{
-
-		DeleteAttributeOperation deleteAttribute = new DeleteAttributeOperation(_key);
-		return edit(deleteAttribute);
-	}
-
-	public Either<Error,LoggingNode> put(final String _key,final ByteBuffer _value)
-	{
-		PutAttributeOperation putAttribute = new PutAttributeOperation(_key,_value);
-		return edit(putAttribute);
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/logger/LoggingChildren.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,67 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger;
-
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Children;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.AppendChildAtOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteChildAtOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public class LoggingChildren
-{
-	private final TreeNode wrap;
-	private final OperationLog log;
-
-	public LoggingChildren(TreeNode _wrap,OperationLog _log)
-	{
-		wrap = _wrap;
-		log = _log;
-	}
-
-	public int size()
-	{
-		Children children = wrap.getChildren();
-		return children.size();
-	}
-
-	public Either<Error,LoggingNode> edit(NodeOperation _op)
-	{
-		Either<Error,TreeNode> either = _op.invoke(wrap);
-		if(either.isA()){
-			return DefaultEither.newA(either.a());
-		}
-
-		TreeNode newWrap = either.b();
-		OperationLog newLog = log.add(_op);
-		LoggingNode newLoggingNode = new LoggingNode(newWrap,newLog);
-		return DefaultEither.newB(newLoggingNode);
-	}
-
-	public Either<Error,LoggingNode> addNewChildAt(final int _pos)
-	{
-		NodeOperation addNewChildAt = new AppendChildAtOperation(_pos);
-		return edit(addNewChildAt);
-	}
-
-	public Either<Error,LoggingNode> deleteChildAt(final int _pos)
-	{
-		NodeOperation deleteChildAt = new DeleteChildAtOperation(_pos);
-		return edit(deleteChildAt);
-	}
-
-	public Either<Error,LoggingNode> at(int _pos)
-	{
-		Children children = wrap.getChildren();
-		Either<Error,TreeNode> either = children.at(_pos);
-		if(either.isA()){
-			return DefaultEither.newA(either.a());
-		}
-
-		TreeNode node = either.b();
-		LoggingNode logNode = new LoggingNode(node);
-		return DefaultEither.newB(logNode);
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/logger/LoggingNode.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,66 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.ReplaceRootNodeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-
-public class LoggingNode
-{
-
-  private final TreeNode wrap;
-  private final OperationLog log;
-
-	public LoggingNode(TreeNode _wrap)
-	{
-		this(_wrap,new DefaultOperationLog());
-	}
-
-	public LoggingNode(TreeNode _wrap,OperationLog _log)
-	{
-		wrap = _wrap;
-		log = _log;
-	}
-
-	public LoggingAttributes getAttributes()
-	{
-		return new LoggingAttributes(wrap,log);
-	}
-
-	public LoggingChildren getChildren()
-	{
-		return new LoggingChildren(wrap,log);
-	}
-
-
-	public OperationLog getOperationLog()
-	{
-		return log;
-	}
-
-
-  public Either<Error, LoggingNode> replaceNewRootNode() {
-   NodeOperation replaceRootNode = new ReplaceRootNodeOperation();
-   return edit(replaceRootNode);
-  }
-
-  public Either<Error, LoggingNode> edit(NodeOperation op){
-    Either<Error,TreeNode> either = op.invoke(wrap);
-    if(either.isA()){
-      return DefaultEither.newA(either.a());
-    }
-
-    TreeNode newWrap = either.b();
-    OperationLog newLog = log.add(op);
-    LoggingNode newLoggingNode = new LoggingNode(newWrap,newLog);
-    return DefaultEither.newB(newLoggingNode);
-  }
-
-  public TreeNode getWrap()
-  {
-    return wrap;
-  }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/logger/OperationLog.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,10 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
-
-
-public interface OperationLog extends Iterable<NodeOperation>
-{
-	public OperationLog add(NodeOperation _op);
-	public int length();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/logger/TreeOperationLog.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,12 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-
-public interface TreeOperationLog extends Iterable<TreeOperation>
-{
-	public TreeOperationLog add(NodePath _p,NodeOperation _op);
-	public TreeOperationLog append(TreeOperationLog _log);
-	public int length();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/AppendChildAtOperation.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,48 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations;
-
-import java.nio.ByteBuffer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-
-public final class AppendChildAtOperation implements NodeOperation
-{
-	private final int pos;
-
-	public AppendChildAtOperation(int _pos)
-	{
-		pos = _pos;
-	}
-
-	public Command getCommand()
-	{
-		return Command.APPEND_CHILD;
-	}
-
-	@Override
-	public Either<Error,TreeNode> invoke(TreeNode _target)
-	{
-		return _target.getChildren().addNewChildAt(pos);
-	}
-
-	@Override
-	public int getPosition()
-	{
-		return pos;
-	}
-
-	@Override
-	public String getKey()
-	{
-		return null;
-	}
-
-	@Override
-	public ByteBuffer getValue()
-	{
-		return null;
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/DefaultTreeOperation.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,27 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-
-public class DefaultTreeOperation implements TreeOperation
-{
-	private final NodePath path;
-	private final NodeOperation operation;
-
-	public DefaultTreeOperation(NodePath _path,NodeOperation _operation)
-	{
-		path = _path;
-		operation = _operation;
-	}
-
-	@Override
-	public NodePath getNodePath()
-	{
-		return path;
-	}
-
-	@Override
-	public NodeOperation getNodeOperation()
-	{
-		return operation;
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/DeleteAttributeOperation.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,48 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations;
-
-import java.nio.ByteBuffer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public final class DeleteAttributeOperation implements NodeOperation
-{
-	private final String key;
-
-	public DeleteAttributeOperation(String _key)
-	{
-		key = _key;
-	}
-
-	@Override
-	public Command getCommand()
-	{
-		return Command.DELETE_ATTRIBUTE;
-	}
-
-	@Override
-	public Either<Error, TreeNode> invoke(TreeNode _target)
-	{
-		return _target.getAttributes().delete(key);
-	}
-
-	@Override
-	public int getPosition()
-	{
-		return -1;
-	}
-
-	@Override
-	public String getKey()
-	{
-		return key;
-	}
-
-	@Override
-	public ByteBuffer getValue()
-	{
-		return null;
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/DeleteChildAtOperation.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,48 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations;
-
-import java.nio.ByteBuffer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public class DeleteChildAtOperation implements NodeOperation
-{
-	private final int pos;
-
-	public DeleteChildAtOperation(int _pos)
-	{
-		pos = _pos;
-	}
-
-	@Override
-	public Command getCommand()
-	{
-		return Command.DELETE_CHILD;
-	}
-
-	@Override
-	public Either<Error, TreeNode> invoke(TreeNode _target)
-	{
-		return _target.getChildren().deleteChildAt(pos);
-	}
-
-	@Override
-	public int getPosition()
-	{
-		return pos;
-	}
-
-	@Override
-	public String getKey()
-	{
-		return null;
-	}
-
-	@Override
-	public ByteBuffer getValue()
-	{
-		return null;
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/NodeOperation.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,20 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations;
-
-import java.nio.ByteBuffer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public interface NodeOperation
-{
-	public Command getCommand();
-	public Either<Error,TreeNode> invoke(TreeNode _target);
-
-	public int getPosition();
-	public String getKey();
-	public ByteBuffer getValue();
-}
-
-
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/PutAttributeOperation.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,50 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations;
-
-import java.nio.ByteBuffer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-
-public class PutAttributeOperation implements NodeOperation
-{
-	private final String key;
-	private final ByteBuffer value;
-
-	public PutAttributeOperation(String _key,ByteBuffer _value)
-	{
-		key = _key;
-		value = _value;
-	}
-
-	@Override
-	public Command getCommand()
-	{
-		return Command.PUT_ATTRIBUTE;
-	}
-
-	@Override
-	public Either<Error,TreeNode> invoke(TreeNode _target)
-	{
-		return _target.getAttributes().put(key,value);
-	}
-	@Override
-	public int getPosition()
-	{
-		return -1;
-	}
-
-	@Override
-	public String getKey()
-	{
-		return key;
-	}
-
-	@Override
-	public ByteBuffer getValue()
-	{
-		return value;
-	}
-}
\ No newline at end of file
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/ReplaceRootNodeOperation.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,37 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations;
-
-import java.nio.ByteBuffer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public class ReplaceRootNodeOperation implements NodeOperation {
-
-  @Override
-  public Command getCommand() {
-    return Command.REPLACE_ROOT;
-  }
-
-  @Override
-  public Either<Error, TreeNode> invoke(TreeNode target) {
-    return  target.appendRootNode();
-  }
-
-  @Override
-  public int getPosition() {
-    return -1;
-  }
-
-  @Override
-  public String getKey() {
-    return null;
-  }
-
-  @Override
-  public ByteBuffer getValue() {
-    return null;
-  }
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/operations/TreeOperation.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,9 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-
-public interface TreeOperation
-{
-	public NodePath getNodePath();
-	public NodeOperation getNodeOperation();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/AppendChildAt.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,44 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public class AppendChildAt implements NodeEditor
-{
-	private final int pos;
-
-	public AppendChildAt(int _pos)
-	{
-		pos = _pos;
-	}
-
-	public Either<Error, LoggingNode> _edit(LoggingNode _e)
-	{
-		Either<Error,LoggingNode> either = _e.getChildren().addNewChildAt(pos);
-		if(either.isA()){
-			// error
-			return either;
-		}
-		return DefaultEither.newB(either.b());
-	}
-
-	@Override
-	public Either<Error, LoggingNode> edit(TreeNode _e) {
-		LoggingNode logNode = wrap(_e);
-		return _edit(logNode);
-	}
-
-	public LoggingNode wrap(TreeNode node) {
-		return new LoggingNode(node);
-	}
-
-	@Override
-	public LoggingNode wrap(TreeNode node, OperationLog op) {
-		return new LoggingNode(node, op);
-	}
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/DeleteAttribute.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,43 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer;
-
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public class DeleteAttribute implements NodeEditor
-{
-	private final String key;
-	public DeleteAttribute(String _key)
-	{
-		key = _key;
-	}
-
-	public Either<Error,LoggingNode> _edit(LoggingNode logNode)
-	{
-		Either<Error,LoggingNode> either = logNode.getAttributes().delete(key);
-		if(either.isA()){
-			// error
-			return either;
-		}
-		return DefaultEither.newB(either.b());
-	}
-
-	@Override
-	public Either<Error, LoggingNode> edit(TreeNode _e) {
-		LoggingNode logNode = wrap(_e);
-		return _edit(logNode);
-	}
-
-	public LoggingNode wrap(TreeNode node) {
-		return new LoggingNode(node);
-	}
-
-	@Override
-	public LoggingNode wrap(TreeNode node, OperationLog op) {
-		return new LoggingNode(node, op);
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/DeleteChildAt.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,44 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer;
-
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public class DeleteChildAt implements NodeEditor
-{
-	private final int pos;
-	public DeleteChildAt(int _pos)
-	{
-		pos = _pos;
-	}
-
-	public Either<Error,LoggingNode> _edit(LoggingNode logNode)
-	{
-		Either<Error,LoggingNode> either = logNode.getChildren().deleteChildAt(pos);
-		if(either.isA()){
-			// error
-			return either;
-		}
-		return DefaultEither.newB(either.b());
-	}
-
-	@Override
-	public Either<Error, LoggingNode> edit(TreeNode _e) {
-		LoggingNode logNode = wrap(_e);
-		return _edit(logNode);
-	}
-
-	public LoggingNode wrap(TreeNode node) {
-		return new LoggingNode(node);
-	}
-
-	@Override
-	public LoggingNode wrap(TreeNode node, OperationLog op) {
-		return new LoggingNode(node, op);
-	}
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/NodeEditor.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,14 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer;
-
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public interface NodeEditor
-{
-	public Either<Error,LoggingNode> edit(TreeNode _e);
-	public LoggingNode wrap(TreeNode node, OperationLog op);
-}
\ No newline at end of file
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/NodeEditorError.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,11 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultError;
-
-public class NodeEditorError
-{
-	public static final Error INDEX_OUT_OF_BOUNDS = new DefaultError();
-	public static final Error DELETE_KEY_NOT_FOUND = new DefaultError();
-	public static final Error NULL_VALUE_NOT_ALLOWED = new DefaultError();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/PutAttribute.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,48 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer;
-
-import java.nio.ByteBuffer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public class PutAttribute implements NodeEditor
-{
-	private final String key;
-	private final ByteBuffer value;
-
-	public PutAttribute(String _key,ByteBuffer _value)
-	{
-		key = _key;
-		value = _value;
-	}
-
-	public Either<Error,LoggingNode> _edit(LoggingNode _e)
-	{
-		Either<Error,LoggingNode> either = _e.getAttributes().put(key,value);
-		if(either.isA()){
-			// error
-			return either;
-		}
-		return DefaultEither.newB(either.b());
-	}
-
-	@Override
-	public Either<Error, LoggingNode> edit(TreeNode _e) {
-		LoggingNode logNode = wrap(_e);
-		return _edit(logNode);
-	}
-
-	public LoggingNode wrap(TreeNode node) {
-		return new LoggingNode(node);
-	}
-
-	@Override
-	public LoggingNode wrap(TreeNode node, OperationLog op) {
-		return new LoggingNode(node, op);
-	}
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/trasnformer/replaceRootNodeAt.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,40 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public class replaceRootNodeAt implements NodeEditor {
-
-
-  public Either<Error, LoggingNode> _edit(LoggingNode _e)
-  {
-    Either<Error,LoggingNode> either = _e.replaceNewRootNode();
-    if(either.isA()){
-      // error
-      return either;
-    }
-    return DefaultEither.newB(either.b());
-  }
-
-
-  @Override
-  public Either<Error, LoggingNode> edit(TreeNode _e) {
-    LoggingNode logNode = wrap(_e);
-    return _edit(logNode);
-  }
-
-  public LoggingNode wrap(TreeNode node) {
-    return new LoggingNode(node);
-  }
-
-
-  @Override
-  public LoggingNode wrap(TreeNode node, OperationLog op) {
-    return new LoggingNode(node, op);
-  }
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultJungleTreeEditor.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,133 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction;
-
-import java.nio.ByteBuffer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultTreeOperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.AppendChildAt;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.replaceRootNodeAt;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.DeleteAttribute;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.DeleteChildAt;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.PutAttribute;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.IterableConverter;
-
-public class DefaultJungleTreeEditor implements JungleTreeEditor
-{
-	private final TransactionManager txManager;
-	private final TreeNode root;
-	private final TreeEditor editor;
-	private final TreeOperationLog log;
-
-
-	public DefaultJungleTreeEditor(TreeNode _root,TransactionManager _txManager,TreeEditor _editor)
-	{
-		this(_root,_txManager,_editor,new DefaultTreeOperationLog());
-	}
-
-
-
-	public DefaultJungleTreeEditor(TreeNode newNode,TransactionManager _txManager,TreeEditor _editor,TreeOperationLog _log)
-	{
-		this.root = newNode;
-		this.txManager = _txManager;
-		this.editor = _editor;
-		this.log = _log;
-	}
-
-	private Either<Error,JungleTreeEditor> _edit(final NodePath _path,NodeEditor _e)
-	{
-		Either<Error,LoggingNode> either = editor.edit(root,_path,_e);
-		if(either.isA()){
-			return DefaultEither.newA(either.a());
-		}
-
-		LoggingNode newLogging = either.b();
-		OperationLog newLog = newLogging.getOperationLog();
-		TreeNode newNode = newLogging.getWrap();
-
-		IterableConverter.Converter<TreeOperation,NodeOperation> converter = new IterableConverter.Converter<TreeOperation,NodeOperation>(){
-			@Override
-			public TreeOperation conv(NodeOperation _b){
-				return new DefaultTreeOperation(_path,_b);
-			}
-		};
-
-		Iterable<TreeOperation> iterable = new IterableConverter<TreeOperation,NodeOperation>(newLog,converter);
-		DefaultTreeOperationLog treeOperationLog = new DefaultTreeOperationLog(iterable,newLog.length());
-		TreeOperationLog newTreeOpLog = log.append(treeOperationLog);
-
-		JungleTreeEditor newEditor = new DefaultJungleTreeEditor(newNode,txManager,editor,newTreeOpLog);
-		return DefaultEither.newB(newEditor);
-	}
-
-	 @Override
-	  public Either<Error,JungleTreeEditor> replaceNewRootNode()
-	  {
-	   replaceRootNodeAt appendChildAt = new replaceRootNodeAt();
-	    return _edit(new DefaultNodePath(),appendChildAt);
-	  }
-
-	@Override
-	public Either<Error,JungleTreeEditor> addNewChildAt(NodePath _path, int _pos)
-	{
-		AppendChildAt appendChildAt = new AppendChildAt(_pos);
-		return _edit(_path,appendChildAt);
-	}
-
-	@Override
-	public Either<Error,JungleTreeEditor> deleteChildAt(NodePath _path, int _pos)
-	{
-		DeleteChildAt deleteChildAt = new DeleteChildAt(_pos);
-		return _edit(_path,deleteChildAt);
-	}
-
-	@Override
-	public Either<Error,JungleTreeEditor> putAttribute(NodePath _path,String _key,ByteBuffer _value)
-	{
-		PutAttribute putAttribute = new PutAttribute(_key,_value);
-		return _edit(_path,putAttribute);
-	}
-
-	@Override
-	public Either<Error,JungleTreeEditor> deleteAttribute(NodePath _path, String _key)
-	{
-		DeleteAttribute deleteAttribute = new DeleteAttribute(_key);
-		return _edit(_path,deleteAttribute);
-	}
-
-	@Override
-	public Either<Error,JungleTreeEditor> edit(NodePath _path,NodeEditor _editor)
-	{
-		return _edit(_path,_editor);
-	}
-
-	@Override
-	public Either<Error,JungleTreeEditor> success()
-	{
-		Either<Error,TransactionManager> either = txManager.commit(root,log);
-		if(either.isA()){
-			return DefaultEither.newA(either.a());
-		}
-
-		TransactionManager newTxManager = either.b();
-		JungleTreeEditor newTreeEditor = new DefaultJungleTreeEditor(root,newTxManager,editor);
-
-		return DefaultEither.newB(newTreeEditor);
-	}
-
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,78 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction;
-
-
-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.store.TreeContext;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
-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 java.util.Iterator;
-import java.util.concurrent.atomic.AtomicReference;
-
-public class DefaultTransactionManager implements TransactionManager {
-  private final AtomicReference<TreeContext> repository;
-  private final TreeContext tip;
-  private final ChangeListWriter writer;
-  private final String uuid;
-
-  public DefaultTransactionManager(ChangeListWriter _writer, TreeContext _tip,
-      AtomicReference<TreeContext> _repository, String _uuid) {
-    repository = _repository;
-    tip = _tip;
-    writer = _writer;
-    uuid = _uuid;
-  }
-
-  @Override
-  public Either<Error, TransactionManager> commit(TreeNode newRoot, final TreeOperationLog _log) {
-    long currentRevision = tip.revision();
-    long nextRevision = currentRevision + 1;
-
-    final String _treeName = tip.getTreeName();
-    ChangeList list = new ChangeList() {
-      @Override
-      public Iterator<TreeOperation> iterator() {
-        return _log.iterator();
-      }
-
-      @Override
-      public String getTreeName() {
-        return _treeName;
-      }
-
-      @Override
-      public String uuid() {
-        return uuid;
-      }
-
-    };
-
-    InterfaceTraverser traverser = new InterfaceTraverser(newRoot, true);
-    traverser.createIndex();
-    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);
-        return DefaultEither.newB(txManager);
-    }
-
-    return DefaultEither.newA((Error) new DefaultError());
-  }
-
-  @Override
-  public String getUUID() {
-    return uuid;
-  }
-
-  @Override
-  public long getRevision() {
-    return tip.revision();
-  }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeContext.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,82 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction;
-
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-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;
-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
-
-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, 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;
-    }
-
-    @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, List<TreeNode>>> getIndex() {
-        return traverser.getIndex();
-    }
-
-    @Override
-    public ParentIndex getParentIndex() {
-        return traverser.getParentIndex();
-    }
-
-    @Override
-    public InterfaceTraverser getTraverser() {
-        return traverser;
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNode.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,65 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction;
-
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-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.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
-
-import java.nio.ByteBuffer;
-import java.rmi.dgc.VMID;
-
-public class DefaultTreeNode implements TreeNode {
-    private List<TreeNode> children;
-    private TreeMap<String, ByteBuffer> attrs;
-    final String nodeId = new VMID().toString();
-
-    private static final List<TreeNode> NIL_LIST = new List();
-
-    public DefaultTreeNode() {
-        this(NIL_LIST, new TreeMap());
-    }
-
-    public DefaultTreeNode(List<TreeNode> _children, TreeMap<String, ByteBuffer> _attrs) {
-        attrs = _attrs;
-        children = _children;
-    }
-
-    @Override
-    public DefaultTreeNodeChildren getChildren() {
-        return new DefaultTreeNodeChildren(children, attrs);
-    }
-
-    @Override
-    public DefaultTreeNodeAttribute getAttributes() {
-        return new DefaultTreeNodeAttribute(children, attrs);
-    }
-
-    @Override
-    public DefaultTreeNode createNewNode() {
-        return new DefaultTreeNode();
-    }
-
-    public DefaultTreeNode clone() {
-        return new DefaultTreeNode(children, attrs);
-    }
-
-    @Override
-    public Either<Error, TreeNode> appendRootNode() {
-        TreeNodeChildren newRootChildren = new DefaultTreeNodeChildren(NIL_LIST, new TreeMap());
-        Either<Error, TreeNode> either = newRootChildren.addNewChildAt(0,this);
-        return either;
-    }
-
-    @Override
-    public String getNodeId() {
-        return nodeId;
-    }
-
-    @Override
-    public int compareTo(TreeNode o) {
-        return this.hashCode() - o.hashCode();
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeAttribute.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,80 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction;
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNodeAttributes;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditorError;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
-
-import java.nio.ByteBuffer;
-import java.util.Iterator;
-import java.util.Optional;
-
-public class DefaultTreeNodeAttribute implements TreeNodeAttributes {
-    public List<TreeNode> children;
-    public TreeMap<String, ByteBuffer> attrs;
-
-
-    public DefaultTreeNodeAttribute(List<TreeNode> _children, TreeMap<String, ByteBuffer> _attrs) {
-        children = _children;
-        attrs = _attrs;
-    }
-
-    @Override
-    public TreeMap<String, ByteBuffer> getAttributesAsRawMap() {
-        return attrs;
-    }
-
-    @Override
-    public Either<Error, TreeNode> delete(String _key) {
-        if (_key == null) {
-            return DefaultEither.newA(NodeEditorError.NULL_VALUE_NOT_ALLOWED);
-        }
-
-        if (null == attrs.get(_key)) {
-            return DefaultEither.newA(NodeEditorError.DELETE_KEY_NOT_FOUND);
-        }
-
-        TreeMap<String, ByteBuffer> newMap = attrs.delete(_key);
-        TreeNode newNode = new DefaultTreeNode(children, newMap);
-        return DefaultEither.newB(newNode);
-    }
-
-    @Override
-    public Either<Error, TreeNode> put(String _key, ByteBuffer _value) {
-        if (_key == null || _value == null) {
-            return DefaultEither.newA(NodeEditorError.NULL_VALUE_NOT_ALLOWED);
-        }
-
-        TreeMap<String, ByteBuffer> newMap = attrs.put(_key, _value);
-        TreeNode newNode = new DefaultTreeNode(children, newMap);
-        return DefaultEither.newB(newNode);
-    }
-
-    @Override
-    public ByteBuffer get(String _key) {
-        if (_key == null) {
-            return null;
-        }
-        Optional<ByteBuffer> op = attrs.get(_key);
-        if (op.isPresent())
-            return op.get();
-        return null;
-    }
-
-    @Override
-    public String getString(String key) {
-        ByteBuffer attribute = get(key);
-        if (attribute != null)
-            return new String(attribute.array());
-        return null;
-    }
-
-    @Override
-    public Iterator<String> getKeys() {
-        return attrs.keys();
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeChildren.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,108 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction;
-
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNodeChildren;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditorError;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
-
-import java.nio.ByteBuffer;
-import java.util.Iterator;
-
-public class DefaultTreeNodeChildren implements TreeNodeChildren {
-
-    public List<TreeNode> children;
-    public TreeMap<String, ByteBuffer> attrs;
-
-    public DefaultTreeNodeChildren(List<TreeNode> _children, TreeMap<String, ByteBuffer> _attrs) {
-        children = _children;
-        attrs = _attrs;
-    }
-
-    private boolean boundaryCheck(int _pos) {
-        int size = children.length();
-        if (size < _pos) {
-            return false;
-        }
-
-        return true;
-    }
-
-    @Override
-    public List<TreeNode> getChildrenAsRawList() {
-        return children;
-    }
-
-    @Override
-    public Either<Error, TreeNode> addNewChildAt(int _pos) {
-        if (!boundaryCheck(_pos) || _pos < 0) {
-            return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
-        }
-
-        List<TreeNode> newChildren = children.add(_pos, new DefaultTreeNode());
-        TreeNode newNode = new DefaultTreeNode(newChildren, attrs);
-        return DefaultEither.newB(newNode);
-    }
-
-    @Override
-    public Either<Error, TreeNode> deleteChildAt(int _pos) {
-        if (!boundaryCheck(_pos) || _pos < 0 || size() == 0) {
-            return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
-        }
-
-        List<TreeNode> newChildren = children.delete(_pos);
-        TreeNode newNode = new DefaultTreeNode(newChildren, attrs);
-
-        return DefaultEither.newB(newNode);
-    }
-
-    @Override
-    public int size() {
-        return children.length();
-    }
-
-    @Override
-    public Iterator<TreeNode> iterator() {
-        return children.iterator();
-    }
-
-    @Override
-    public Either<Error, TreeNode> replaceNode(int _pos, TreeNode _replacement) {
-        int size = children.length();
-        if (!(0 <= _pos && _pos < size)) {
-            return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
-        }
-        TreeNode replacement = _replacement;
-
-        List<TreeNode> newChildren = children.replace(_pos, replacement);
-        TreeNode node = new DefaultTreeNode(newChildren, attrs);
-        return DefaultEither.newB(node);
-    }
-
-    @Override
-    public Either<Error, TreeNode> at(int _pos) {
-        if (children.length() < _pos + 1) {
-            return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
-        }
-
-        TreeNode Node = children.index(_pos);
-
-        return DefaultEither.newB(Node);
-    }
-
-    @Override
-    public Either<Error, TreeNode> addNewChildAt(int _pos, TreeNode _newChild) {
-        if (!boundaryCheck(_pos) || _pos < 0) {
-            return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
-        }
-        List<TreeNode> newChildren = children.add(_pos, _newChild);
-        TreeNode newNode = new DefaultTreeNode(newChildren, attrs);
-
-        return DefaultEither.newB(newNode);
-    }
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/TransactionManager.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,14 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction;
-
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public interface TransactionManager
-{
-	public Either<Error,TransactionManager> commit(TreeNode _newRoot,TreeOperationLog _log);
-	public String getUUID();
-	public long getRevision();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/DefaultEvaluation.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,25 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser;
-
-public class DefaultEvaluation implements Evaluation
-{
-	private final Result result;
-	private final Evaluator evaluator;
-
-	public DefaultEvaluation(Result _result,Evaluator _evaluator)
-	{
-		result = _result;
-		evaluator = _evaluator;
-	}
-
-	@Override
-	public Result result()
-	{
-		return result;
-	}
-
-	@Override
-	public Evaluator evaluator()
-	{
-		return evaluator;
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/DefaultEvaluator.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,40 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
-
-public class DefaultEvaluator implements Evaluator
-{
-	private final NodePath path;
-
-	public DefaultEvaluator(NodePath _path)
-	{
-		path = _path;
-	}
-
-	@Override
-	public Evaluation evaluate(TreeNode _current,int _pos)
-	{
-		Pair<Integer,NodePath> pop = path.pop();
-		int head = pop.left();
-
-		if(path.size() == 1){
-			if(head == _pos){
-				return new DefaultEvaluation(Result.GOAL,null);
-			}
-		}
-
-		DefaultEvaluator nextEvaluator;
-		Result result;
-		if(head == _pos){
-			result = Result.ACCEPT;
-			nextEvaluator = new DefaultEvaluator(pop.right());
-		}else{
-			result = Result.CONTINUE;
-			nextEvaluator = null;
-		}
-
-		return new DefaultEvaluation(result,nextEvaluator);
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/DefaultTraverser.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,144 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser;
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Children;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditorError;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-import java.util.Iterator;
-
-
-public class DefaultTraverser implements Traverser
-{
-	@Override
-	public Either<Error,Traversal> traverse(final TreeNode _root,Evaluator _evaluator)
-	{
-		Children wrapper = new Children(){
-			@Override
-			public Iterator<TreeNode> iterator(){
-				List<TreeNode> list = new List();
-				return list.addLast(_root).iterator();
-			}
-
-			@Override
-			public int size(){
-				return 1;
-			}
-
-			@Override
-			public Either<Error,TreeNode> at(int _pos){
-				if(_pos != 0){
-					return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
-				}
-				return DefaultEither.newB(_root);
-			}
-		};
-
-		//Children<T> chs = _root.getChildren();
-		Children chs = wrapper;
-
-		Either<Error,List<Direction<TreeNode>>> ret = _traverse(chs,_evaluator,-1);
-
-		if(ret.isA()){
-			return DefaultEither.newA(ret.a());
-		}
-
-		List<Direction<TreeNode>> list = ret.b();
-
-		final Iterable<Direction<TreeNode>> iterable = list;
-		final TreeNode destination = ret.b().last().getTarget();
-
-		Traversal traversal = new Traversal(){
-			@Override
-			public Iterator<Direction<TreeNode>> iterator(){
-				return iterable.iterator();
-			}
-
-			@Override
-			public TreeNode destination(){
-				return destination;
-			}
-		};
-
-		return DefaultEither.newB(traversal);
-	}
-
-	private Either<Error,List<Direction<TreeNode>>> _traverse(Children _chs,Evaluator _evaluator,int _pos)
-	{
-		int pos = _pos;
-		for(TreeNode ch : _chs){
-			Evaluation e = _evaluator.evaluate(ch,pos);
-			Result r = e.result();
-			if(r == Result.ACCEPT){
-				return _accept(ch,pos,e.evaluator());
-			}
-
-			if(r == Result.GOAL){
-				return DefaultEither.newB(_goal(ch,pos));
-			}
-
-			if(r == Result.BREAK){
-				break;
-			}
-
-			if(r == Result.CONTINUE){
-				pos --;
-				continue;
-			}
-
-			return DefaultEither.newA(TraverserError.UNDEFINED_OPERATOR);
-		}
-
-		return DefaultEither.newA(TraverserError.PATH_NOT_FOUND);
-	}
-
-	private List<Direction<TreeNode>> _goal(final TreeNode _current,final int _pos)
-	{
-		Direction<TreeNode> d = new Direction<TreeNode>(){
-			@Override
-			public int getPosition()
-			{
-				return _pos;
-			}
-			@Override
-			public TreeNode getTarget()
-			{
-				return _current;
-			}
-		};
-
-		List<Direction<TreeNode>> list = new List();
-		List<Direction<TreeNode>> newList = list.addLast(d);
-
-		return newList;
-	}
-
-	private <T extends TreeNode> Either<Error,List<Direction<TreeNode>>> _accept(final T _current,final int _pos,Evaluator _evaluator)
-	{
-		Children chs = _current.getChildren();
-		Either<Error,List<Direction<TreeNode>>> either = _traverse(chs,_evaluator,chs.size() - 1);
-		if(either.isA()){
-			return either;
-		}
-
-		List<Direction<TreeNode>> list = either.b();
-		Direction<TreeNode> d = new Direction<TreeNode>(){
-			@Override
-			public int getPosition()
-			{
-				return _pos;
-			}
-			@Override
-			public T getTarget()
-			{
-				return _current;
-			}
-		};
-
-		List<Direction<TreeNode>> newList = list.addLast(d);
-		return DefaultEither.newB(newList);
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/Direction.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,7 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser;
-
-public interface Direction<T>
-{
-	public int getPosition();
-	public T getTarget();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/Evaluation.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,7 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser;
-
-public interface Evaluation
-{
-	public Result result();
-	public Evaluator evaluator();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/Evaluator.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,8 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-
-public interface Evaluator
-{
-	public Evaluation evaluate(TreeNode _current,int _pos);
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,319 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser;
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-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.IndexCreater;
-import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
-
-import java.util.Iterator;
-import java.util.Optional;
-
-public class InterfaceTraverser {
-
-    TreeNode root;
-    TreeMap<String, TreeMap<String, List<TreeNode>>> indexList;
-    ParentIndex parentIndex;
-    boolean parentUpdateFlag;
-    boolean useIndex;
-
-    public InterfaceTraverser(TreeNode root, boolean indexFlag) {
-        this(root, new TreeMap<>(), new ParentIndex(), indexFlag);
-    }
-
-    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 TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
-        return indexList;
-    }
-
-    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();
-    }
-
-    /**
-     * 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() {
-    // }
-    //
-    // };
-    // }
-    // }
-    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) {
-
-                    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() {
-    // }
-    //
-    // };
-    // }
-    // }
-
-    public Iterator<TreeNode> get(String key, String value) {
-        Optional<TreeMap<String, List<TreeNode>>> indexOp = indexList.get(key);
-        if (!indexOp.isPresent())
-            return null;
-
-        Optional<List<TreeNode>> nodeListOp = indexOp.get().get(value);
-        if (!nodeListOp.isPresent())
-            return new NulIterator<TreeNode>();
-
-        return nodeListOp.get().iterator();
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/Result.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,22 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser;
-
-public class Result
-{
-
-	public static final Result ACCEPT = new Result("ACCEPT");
-	public static final Result CONTINUE = new Result("CONTINUE");
-	public static final Result BREAK = new Result("BREAK");
-	public static final Result GOAL = new Result("GOAL");
-
-	private final String name;
-
-	private Result(String _name)
-	{
-		name = _name;
-	}
-
-	public String toString()
-	{
-		return name;
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/Traversal.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,8 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-
-public interface Traversal extends Iterable<Direction<TreeNode>>
-{
-	public TreeNode destination();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/Traverser.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,12 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public interface Traverser
-{
-	public Either<Error,Traversal> traverse(final TreeNode _root,Evaluator _evaluator);
-
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/TraverserError.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,10 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultError;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-public class TraverserError
-{
-	public static final Error UNDEFINED_OPERATOR = new DefaultError();
-	public static final Error PATH_NOT_FOUND = new DefaultError();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/util/DefaultEither.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,47 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util;
-
-public class DefaultEither<A,B> implements Either<A,B>
-{
-	private final A theA;
-	private final B theB;
-
-	private DefaultEither(A _theA,B _theB)
-	{
-		theA = _theA;
-		theB = _theB;
-	}
-
-	public static final <A,B> DefaultEither<A,B> newA(A _theA)
-	{
-		return new DefaultEither<A,B>(_theA,null);
-	}
-
-	public static final <A,B> DefaultEither<A,B> newB(B _theB)
-	{
-		return new DefaultEither<A,B>(null,_theB);
-	}
-
-	@Override
-	public A a()
-	{
-		return theA;
-	}
-
-	@Override
-	public boolean isA()
-	{
-		return theA != null;
-	}
-
-	@Override
-	public B b()
-	{
-		return theB;
-	}
-
-	@Override
-	public boolean isB()
-	{
-		return theB != null;
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/util/DefaultError.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,5 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util;
-
-public class DefaultError implements Error
-{
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/util/Either.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,9 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util;
-
-public interface Either<A,B>
-{
-	public A a();
-	public boolean isA();
-	public B b();
-	public boolean isB();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/util/Error.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,5 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util;
-
-public interface Error {
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/util/GetOldTreeError.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,5 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util;
-
-public class GetOldTreeError implements Error {
-  public static final Error OLD_TREE_NOT_FOUND = new DefaultError();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/util/IterableConverter.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,56 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util;
-
-import java.util.Iterator;
-
-public class IterableConverter<A,B> implements Iterable<A>
-{
-	private final Iterable<B> iterable;
-	private final Converter<A,B> converter;
-
-	public IterableConverter(Iterable<B> _iterable,Converter<A,B> _converter)
-	{
-		iterable = _iterable;
-		converter = _converter;
-	}
-
-	@Override
-	public Iterator<A> iterator()
-	{
-		return new IteratorConverter<A,B>(iterable.iterator(),converter);
-	}
-
-	private static final class IteratorConverter<A,B> implements Iterator<A>
-	{
-		private final Iterator<B> iterator;
-		private final Converter<A,B> converter;
-
-		public IteratorConverter(Iterator<B> _iterator,Converter<A,B> _converter)
-		{
-			iterator = _iterator;
-			converter = _converter;
-		}
-
-		@Override
-		public boolean hasNext()
-		{
-			return iterator.hasNext();
-		}
-
-		@Override
-		public A next()
-		{
-			return converter.conv(iterator.next());
-		}
-
-		@Override
-		public void remove()
-		{
-			iterator.remove();
-		}
-	}
-
-	public static interface Converter<A,B>
-	{
-		public A conv(B _b);
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/util/Pair.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,23 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util;
-
-public class Pair<L,R>
-{
-	private L left;
-	private R right;
-
-	public Pair(L _left,R _right)
-	{
-		left = _left;
-		right = _right;
-	}
-
-	public L left()
-	{
-		return left;
-	}
-
-	public R right()
-	{
-		return right;
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/util/Triple.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,45 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util;
-
-public class Triple<A,B,C>
-{
-	private A a;
-	private B b;
-	private C c;
-
-	public Triple(A _a,B _b,C _c)
-	{
-		a = _a;
-		b = _b;
-		c = _c;
-	}
-
-	public A getA()
-	{
-		return a;
-	}
-
-	public B getB()
-	{
-		return b;
-	}
-
-	public C getC()
-	{
-		return c;
-	}
-
-	public void setA(A _a)
-	{
-		a = _a;
-	}
-
-	public void setB(B _b)
-	{
-		b = _b;
-	}
-
-	public void setC(C _c)
-	{
-		c = _c;
-	}
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/benchMark/JungleBenchMark.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,54 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.benchMark;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
-
-import java.nio.ByteBuffer;
-import java.util.Iterator;
-
-
-/**
- * Created by e115731 on 15/05/07.
- */
-public class JungleBenchMark {
-    public static void main(String args[]) {
-        Jungle jungle = new DefaultJungle(null, "hogehoge", new DefaultTreeEditor(new DefaultTraverser()));
-        jungle.createNewTree("tree");
-        JungleTree tree = jungle.getTreeByName("tree");
-        JungleTreeEditor editor = tree.getTreeEditor();
-        NodePath path = new DefaultNodePath().add(0);
-        for (int count = 1; count <= 10; count++) {
-            for (int personCount = 0; personCount < 1000 * count; personCount++) {
-                editor = editor.replaceNewRootNode().b();
-                editor = editor.putAttribute(path, "personId", ByteBuffer.wrap(("p:" + personCount).getBytes())).b();
-                editor = editor.putAttribute(path, "roleId", ByteBuffer.wrap(("r:" + personCount).getBytes())).b();
-            }
-            editor.success();
-            long t1 = System.currentTimeMillis();
-            for (int findCount = 0; findCount < 50000; ) {
-                InterfaceTraverser traverser = tree.getTraverser(true);
-                Iterator<TreeNode> it = traverser.find(null, "personId", "p:100");
-                if (it.hasNext()) {
-                    TreeNode targetNode = it.next();
-                    String targetRoleId = targetNode.getAttributes().getString("roleId");
-                    if (targetRoleId.equals("r:100"))
-                        findCount++;
-                } else {
-                    System.out.println("find miss");
-                    System.exit(1);
-                }
-            }
-            long t2 = System.currentTimeMillis();
-            System.out.println("time = " + (t2 - t1));
-        }
-
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/query/PathNodeIterator.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,80 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query;
-
-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 java.util.Iterator;
-import java.util.Stack;
-
-public class PathNodeIterator implements Iterator<TreeNode> {
-
-	TreeNode root;
-	TreeNode node;
-	int childNumber;
-	private TreeNodeChildren children;
-	private Stack<TreeNode> nodeStack = new Stack<TreeNode>();
-	private Stack<Integer> searchStack = new Stack<Integer>();
-
-	/*
-	 * get queryIndexCondition from query
-	 * if already index exists, use index
-	 * otherwise traverse tree and create index
-	 *
-	 * */
-	public PathNodeIterator(TreeNode root) {
-		this.root = root;
-		this.node = root;
-	}
-
-	@Override
-	public boolean hasNext() {
-		return node != null;
-	}
-
-	@Override
-	public TreeNode next() {
-		TreeNode now = node;
-		if (node.getChildren().size() > 0) {
-			nodeStack.push(node);
-			children = node.getChildren();
-			node = children.at(0).b();
-			childNumber = 1;
-			searchStack.push(childNumber);
-		} else if (node == root) {
-			node = null; // no more node
-			children = null;
-			return now;
-		}else if (children != null && children.size() > childNumber) {
-			childNumber = searchStack.pop();
-			node = children.at(childNumber).b();
-			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 now;
-				}
-				node = nodeStack.pop();
-				children = node.getChildren();
-				childNumber = searchStack.pop();
-			}
-			if (node != null && childNumber < children.size()) {
-				nodeStack.push(node);
-				node = children.at(childNumber).b();
-				searchStack.push(++childNumber);
-			}
-		}
-		return now;
-	}
-
-	@Override
-	public void remove() {
-		// TODO Auto-generated method stub
-
-	}
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/query/Query.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,7 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-
-public interface Query {
-	boolean condition(TreeNode _node);
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexCreater.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,119 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index;
-
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-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.treemap.TreeMap;
-
-import java.util.Iterator;
-import java.util.Optional;
-import java.util.Stack;
-
-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, List<TreeNode>>> indexList = new TreeMap();
-
-    public IndexCreater(TreeNode rootNode) {
-        this.root = rootNode;
-        this.node = rootNode;
-        while (node != null) {
-            TreeNode targetNode = node;
-            Iterator<String> keys = targetNode.getAttributes().getKeys();
-            for (;keys.hasNext();) {
-                String key = keys.next();
-                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);
-                }
-            }
-        }
-    }
-
-    public TreeMap<String, TreeMap<String, List<TreeNode>>> set(String key, String value, TreeNode node) {
-        if (key == null )
-            System.out.println("");
-        Optional<TreeMap<String, List<TreeNode>>> indexOp = indexList.get(key);
-        if (!indexOp.isPresent()) {
-            TreeMap<String, List<TreeNode>> index = new TreeMap();
-            List<TreeNode> nodeList = new List();
-            nodeList = nodeList.addLast(node);
-            TreeMap<String, List<TreeNode>> newIndex = index.put(value, nodeList);
-            indexList = indexList.put(key, newIndex);
-            return indexList;
-        }
-
-        TreeMap<String, List<TreeNode>> index = indexOp.get();
-        Optional<List<TreeNode>> nodeListOp = index.get(value);
-
-        List<TreeNode> newNodeList;
-
-        if (nodeListOp.isPresent()) {
-            newNodeList = nodeListOp.get().addLast(node);
-
-        } else {
-            List<TreeNode> nodeList = new List();
-            newNodeList = nodeList.addLast(node);
-
-        }
-        TreeMap<String, List<TreeNode>> newIndex = index.put(value, newNodeList);
-        indexList = indexList.put(key, newIndex);
-
-        return indexList;
-    }
-
-    public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
-        return indexList;
-    }
-
-    public ParentIndex getParentIndex() {
-        return parentIndex;
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/ParentIndex.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,55 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNodeChildren;
-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
-
-import java.util.Iterator;
-
-public class ParentIndex {
-
-  private TreeMap<TreeNode, TreeNode> parentIndex;
-
-  public ParentIndex() {
-    parentIndex = new TreeMap();
-  }
-
-  public boolean isEmpty(){
-    return parentIndex.isEmpty();
-  }
-
-  public TreeNode get(TreeNode child) {
-    return parentIndex.get(child).get();
-  }
-
-  public ParentIndex set(TreeNode parent ,TreeNode child) {
-    parentIndex = parentIndex.put(child, parent);
-    return this;
-  }
-
-  public ParentIndex delete(TreeNode child) {
-    parentIndex = parentIndex.delete(child);
-    return this;
-  }
-
-  public ParentIndex deleteAllChildren(TreeNode parentNode) {
-    TreeNodeChildren children = parentNode.getChildren();
-    Iterator<TreeNode> childrenIterator = children.iterator();
-    for (; childrenIterator.hasNext();) {
-      TreeNode child = childrenIterator.next();
-      parentIndex = parentIndex.delete(child);
-    }
-    return this;
-  }
-
-  public ParentIndex addAllChildren(TreeNode parentNode) {
-    TreeNodeChildren children = parentNode.getChildren();
-    Iterator<TreeNode> childrenIterator = children.iterator();
-    for (; childrenIterator.hasNext();) {
-      TreeNode child = childrenIterator.next();
-      parentIndex = parentIndex.put(child, parentNode);
-    }
-    return this;
-  }
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/AbstractTreeMapThread.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,9 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test;
-
-/**
- * Created by e115731 on 15/03/17.
- */
-public abstract class AbstractTreeMapThread extends Thread{
-    public abstract void set(boolean flag);
-    public abstract long getFindCount();
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/DataBaseBenchMark.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,164 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test;
-
-
-import com.mongodb.MongoClient;
-import com.mongodb.WriteConcern;
-import com.mongodb.client.MongoCollection;
-import com.mongodb.client.MongoDatabase;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
-import org.bson.Document;
-import org.xml.sax.SAXException;
-
-import javax.xml.parsers.ParserConfigurationException;
-import java.io.*;
-import java.nio.ByteBuffer;
-import java.util.Random;
-
-/**
- * Created by e115731 on 15/03/20.
- */
-public class DataBaseBenchMark {
-    public static void main(String[] args) throws InterruptedException, IOException, ParserConfigurationException, SAXException {
-
-        if (args.length < 2) {
-            System.out.println("args[0] = jungle or mongo, args[1] = read or write" );
-            System.exit(0);
-        }
-
-        Runtime rt = Runtime.getRuntime();
-        int cpuNum = rt.availableProcessors();
-
-        if (args[0].equals("jungle"))
-            jungleBench(args, cpuNum);
-        else if (args[0].equals("mongo"))
-            mongoBench(args, cpuNum);
-    }
-
-    private static void mongoBench(String[] args, int cpuNum) throws IOException, InterruptedException {
-        MongoClient client = new MongoClient("localhost", 27017);
-        client.setWriteConcern(WriteConcern.JOURNALED);
-        client.dropDatabase("mydb");
-        MongoDatabase database = client.getDatabase("mydb");
-        MongoCollection<Document> coll = database.getCollection("mycoll");
-            for (int i = 0; i < 10000; i++) {
-                if (i % 100 == 0)
-                    System.out.println(i / 100);
-                coll.insertOne(new Document("key",String.valueOf(i)));
-            }
-        coll.createIndex(new Document("key", 1));
-        //coll.dropIndex(new Document("key", 1));
-        for (final Document index : coll.listIndexes()) {
-            System.out.println(index.toJson());
-        }
-        File file = new File("./time/" + args[0] + args[1] + "Time");
-        PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(file)));
-        DataBaseBenchMarkThread readThread[] = null;
-        for (int THREAD_COUNT = 1; THREAD_COUNT <= cpuNum; THREAD_COUNT++) {
-            readThread = new DataBaseBenchMarkThread[THREAD_COUNT];
-            for (int count = 0; THREAD_COUNT > count; count++) {
-                readThread[count] = new findMongoAttributeThread(coll);
-            }
-            for (int count = 0; THREAD_COUNT > count; count++) {
-                readThread[count].start();
-            }
-            System.out.println("StartThread");
-            Thread.sleep(1000);
-            long readCount = 0;
-            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);
-        }
-        client.close();
-        pw.close();
-    }
-
-    private static void jungleBench(String[] args, int cpuNum) throws IOException, InterruptedException {
-        JungleTree tree = createJungleTree(cpuNum);
-        File file = new File("./time/" + args[0] + args[0] + "Time");
-        PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(file)));
-        DataBaseBenchMarkThread readThread[] = null;
-
-        for (int THREAD_COUNT = 1; THREAD_COUNT <= cpuNum; THREAD_COUNT++) {
-            readThread = new DataBaseBenchMarkThread[THREAD_COUNT];
-            for (int count = 0; THREAD_COUNT > count; count++) {
-                readThread[count] = new findTreeAttributeThread(tree);
-            }
-            JungleWriteThread writeThread = null;
-            if (args[1].equals("write")) {
-                writeThread = new JungleWriteThread(tree);
-                writeThread.start();
-            }
-            for (int count = 0; THREAD_COUNT > count; count++) {
-                readThread[count].start();
-            }
-            System.out.println("StartThread");
-            Thread.sleep(1000);
-            if (args[1].equals("write")) {
-                writeThread.set(false);
-                writeThread.get();
-            }
-            long readCount = 0;
-            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();
-    }
-
-    private static JungleTree createJungleTree(int cpuNum) {
-        Jungle jungle = new DefaultJungle(null, "hoge", new DefaultTreeEditor(new DefaultTraverser()));
-        JungleTree trees[] = new JungleTree[cpuNum];
-        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;
-        return tree;
-    }
-
-    static Integer nodeNum = 1;
-
-    public static JungleTreeEditor createTree(int deep, NodePath path, JungleTreeEditor editor) {
-
-        Random rnd = new Random();
-        String value1 = String.valueOf(nodeNum);
-        nodeNum++;
-        String value2 = String.valueOf(nodeNum);
-        nodeNum++;
-        editor = editor.addNewChildAt(path, 0).b();
-        editor = editor.putAttribute(path.add(0), "key", ByteBuffer.wrap(value1.getBytes())).b();
-        editor = editor.addNewChildAt(path, 1).b();
-        editor = editor.putAttribute(path.add(1), "key", ByteBuffer.wrap(value2.getBytes())).b();
-        deep++;
-        if (deep < 10) {
-            editor = createTree(deep, path.add(0), editor);
-            editor = createTree(deep, path.add(1), editor);
-        }
-        return editor;
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/DataBaseBenchMarkThread.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,9 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test;
-
-/**
- * Created by e115731 on 15/03/17.
- */
-public abstract class DataBaseBenchMarkThread extends Thread{
-    public abstract long getFindCount();
-    public abstract void set(boolean flag);
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/JungleWriteThread.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,48 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-
-import java.nio.ByteBuffer;
-
-/**
- * Created by e115731 on 15/04/18.
- */
-public class JungleWriteThread extends Thread {
-
-    JungleTree tree;
-    boolean loop = true;
-    private int writeCount;
-
-    public JungleWriteThread(JungleTree tree) {
-        this.tree = tree;
-    }
-
-    public void set(boolean flag) {
-        loop = flag;
-    }
-
-    public void get() {
-        System.out.println("writeCount = " + writeCount);
-    }
-
-    ;
-
-    @Override
-    public void run() {
-        while (loop) {
-            try {
-                Thread.sleep(100);
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-            JungleTreeEditor editor = tree.getTreeEditor();
-            editor = editor.putAttribute(new DefaultNodePath(), "key", ByteBuffer.wrap(String.valueOf(0).getBytes())).b();
-            if (editor.success().isA())
-                System.out.println("faild");
-            else
-                writeCount++;
-        }
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/TatsukiTreeMapGetThread.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,42 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test;
-
-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
-
-import java.util.Optional;
-
-
-/**
- * Created by e115731 on 15/03/17.
- */
-public class TatsukiTreeMapGetThread extends AbstractTreeMapThread {
-    TreeMap<Long, String> map;
-    private long findCount;
-    boolean loop = true;
-
-    public TatsukiTreeMapGetThread(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) {
-            for (long count = 0 ; count < 1000; count++) {
-                Optional<String> value = map.get(count);
-                if (!value.isPresent())
-                    System.out.println("error");
-            }
-            findCount++;
-        }
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/TreeMapBenchMark.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,77 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test;
-
-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
-
-import java.io.*;
-
-/**
- * Created by e115731 on 15/03/17.
- */
-public class TreeMapBenchMark {
-    public static void main(String[] args) throws InterruptedException, IOException {
-
-        if (args.length == 0) {
-            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/" + 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++) {
-
-            readThread = new AbstractTreeMapThread[THREAD_COUNT];
-
-            if (args[0].equals("util")) {
-                java.util.TreeMap map = new java.util.TreeMap();
-                for (long count = 0; count < 1000; count++) {
-                    map.put(count, String.valueOf(count));
-                }
-
-                for (int count = 0; THREAD_COUNT > count; count++) {
-                    readThread[count] = new UtilTreeMapGetThread(map);
-                }
-            } else if (args[0].equals("tatsuki")) {
-                TreeMap map = new TreeMap();
-                for (long count = 0; count < 1000; count++) {
-                    map = map.put(count, String.valueOf(count));
-                }
-
-                for (int count = 0; THREAD_COUNT > count; count++) {
-                    readThread[count] = new TatsukiTreeMapGetThread(map);
-                }
-            }  else {
-                System.out.println("not allow args");
-                System.exit(0);
-            }
-
-            for (int count = 0; THREAD_COUNT > count; count++) {
-                readThread[count].start();
-            }
-
-            System.out.println("StartThread");
-
-            Thread.sleep(1000);
-            long readCount = 0;
-
-            for (int count = 0; THREAD_COUNT > count; count++) {
-                readThread[count].set(false);
-                readCount = readCount + readThread[count].getFindCount();
-                readThread[count].stop();
-            }
-
-            pw.println(THREAD_COUNT + " " + readCount);
-            System.out.println(THREAD_COUNT + "readCount = " + readCount);
-            Thread.sleep(1000);
-        }
-
-        pw.close();
-    }
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/UtilTreeMapGetThread.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,39 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test;
-
-import java.util.TreeMap;
-
-/**
- * Created by e115731 on 15/04/18.
- */
-public class UtilTreeMapGetThread extends AbstractTreeMapThread {
-    TreeMap<Long, String> map;
-    private long findCount;
-    boolean loop = true;
-
-    public UtilTreeMapGetThread(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) {
-            for (long count = 0 ; count < 1000; count++) {
-                String value = map.get(count);
-                if (value == null)
-                    System.out.println("error");
-            }
-            findCount++;
-        }
-    }
-}
\ No newline at end of file
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/findMongoAttributeThread.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,41 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test;
-
-import com.mongodb.client.FindIterable;
-import com.mongodb.client.MongoCollection;
-import com.mongodb.client.MongoCursor;
-import org.bson.Document;
-
-/**
- * Created by e115731 on 15/04/30.
- */
-public class findMongoAttributeThread extends DataBaseBenchMarkThread {
-    private long findCount;
-    boolean loop = true;
-    MongoCollection<Document> coll;
-
-    public findMongoAttributeThread( MongoCollection<Document> coll) {
-        this.coll = coll;
-        this.findCount = 0;
-    }
-
-    @Override
-    public long getFindCount() {
-        System.out.println("thread count = " + findCount);
-        return findCount;
-    }
-
-    public void set(boolean loop) {
-        this.loop = loop;
-    }
-
-    @Override
-    public void run() {
-        while (loop) {
-            FindIterable<Document> searchResultList = coll.find(new Document("key","1"));
-            MongoCursor<Document> iterator = searchResultList.iterator();
-            if (iterator.hasNext()) {
-                findCount++;
-            }
-        }
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/findTreeAttributeThread.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,43 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
-import java.util.Iterator;
-
-/**
- * Created by e115731 on 15/03/20.
- */
-public class findTreeAttributeThread extends DataBaseBenchMarkThread {
-
-    JungleTree tree;
-    private long findCount;
-
-    boolean loop = true;
-
-    public findTreeAttributeThread(JungleTree tree) {
-        this.tree = tree;
-        this.findCount = 0;
-    }
-
-    @Override
-    public long getFindCount() {
-        System.out.println("thread count = " + findCount);
-        return findCount;
-    }
-
-    public void set(boolean loop) {
-        this.loop = loop;
-    }
-
-    @Override
-    public void run() {
-        while (loop) {
-            InterfaceTraverser traverser = tree.getTraverser(true);
-            Iterator<TreeNode> it = traverser.find(null, "key", "0");
-            if (it.hasNext()) {
-                findCount++;
-            }
-        }
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/readTreeAttributeThread.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,44 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-
-/**
- * Created by e115731 on 15/03/17.
- */
-public class readTreeAttributeThread extends DataBaseBenchMarkThread {
-
-    JungleTree tree;
-    private long findCount;
-
-    boolean loop = true;
-
-    public readTreeAttributeThread(JungleTree tree) {
-        this.tree = tree;
-        this.findCount = 0;
-    }
-
-    @Override
-    public long getFindCount() {
-        System.out.println("thread couny  = " + findCount);
-        return findCount;
-    }
-
-    public void set(boolean loop) {
-        this.loop = loop;
-    }
-
-    @Override
-    public void run() {
-        while (loop) {
-            TreeNode root = tree.getRootNode();
-            if (root != null) {
-                String attribute = root.getAttributes().getString("key");
-                if (attribute.equals("0"))
-                    findCount++;
-                else
-                    System.out.println("faild");
-            }
-        }
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/treemap/BlackNode.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,135 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.treemap;
-
-import org.junit.Test;
-
-
-public class BlackNode<K, V> extends Node<K, V> {
-
-
-    public BlackNode(K key, V value, Node<K, V> left, Node<K, V> right) {
-        super(key, value, left, right);
-    }
-
-
-    @Override
-    public Node deleteNode() throws RotateParent {
-        EmptyNode<K, V> emptyNode = new EmptyNode<K, V>(key);
-        throw new RotateParent(emptyNode);
-    }
-
-    @Override
-    @Test
-    protected int checkDepth(int count, int minCount) { // test method
-        count++;
-        minCount = left().checkDepth(count, minCount);
-        minCount = right().checkDepth(count, minCount);
-        count--;
-        return minCount;
-    }
-
-
-    @Override
-    protected boolean isNotEmpty() {
-        return true;
-    }
-
-    @Override
-    public Node<K, V> createNode(K key, V value, Node<K, V> left, Node<K, V> right) {
-        return new BlackNode<K, V>(key, value, left, right);
-    }
-
-
-    @Override
-    Node insBalance() {
-        Rotate spin = left.checkRotate(Rotate.L);
-
-        if (spin == Rotate.R) {
-            Node<K, V> leftChild = new BlackNode<K, V>(left.left().getKey(), left.left().getValue(), left.left().left(), left.left().right());
-            Node<K, V> rightChild = new BlackNode<K, V>(getKey(), getValue(), left.right(), right);
-            return new RedNode<K, V>(left.getKey(), left.getValue(), leftChild, rightChild);
-
-        } else if (spin == Rotate.LR) {
-            Node<K, V> leftChild = new BlackNode<K, V>(left.getKey(), left.getValue(), left.left(), left.right().left());
-            Node<K, V> rightChild = new BlackNode<K, V>(getKey(), getValue(), left.right().right(), right);
-            return new RedNode<K, V>(left.right().getKey(), left.right().getValue(), leftChild, rightChild);
-
-        }
-
-        spin = right.checkRotate(Rotate.R);
-        if (spin == Rotate.L) {
-            Node<K, V> leftChild = new BlackNode<K, V>(getKey(), getValue(), left, right.left());
-            Node<K, V> rightChild = new BlackNode<K, V>(right.right().getKey(), (V) right.right().getValue(), right.right().left(), right.right().right());
-            return new RedNode<K, V>(right.getKey(), right.getValue(), leftChild, rightChild);
-
-        } else if (spin == Rotate.RL) {
-            Node leftChild = new BlackNode(getKey(), getValue(), left, right.left().left());
-            Node rightChild = new BlackNode(right.getKey(), right.getValue(), right.left().right(), right.right());
-            return new RedNode(right.left().getKey(), right.left().getValue(), leftChild, rightChild);
-
-        }
-
-        return this;
-    }
-
-
-    @Override
-    Rotate checkRotate(Rotate side) {
-        return Rotate.N;
-    }
-
-    @Override
-    boolean isRed() {
-        return false;
-    }
-
-
-    /**
-     * @param parent
-     * @return
-     */
-    @Override
-    public Node replaceNode(Node<K, V> parent) throws RotateParent {
-        Node<K, V> newNode = null;
-        if (!this.left().isNotEmpty() && !this.right().isNotEmpty()) { //自身を削除する
-            return deleteNode();//黒が1つ減るので木のバランスを取る
-        } else if (this.left().isNotEmpty() && !this.right().isNotEmpty()) { //左の部分木を昇格させる
-            newNode = createNode(left().getKey(), left().getValue(), left().left(), left().right());
-            if (!this.left().isRed()) //昇格させる木のrootが黒だったらバランスを取る
-                throw new RotateParent(newNode);
-            return newNode;
-        } else if (!this.left().isNotEmpty() && this.right().isNotEmpty()) { //右の部分木を昇格させる
-            newNode = createNode(right().getKey(), right().getValue(), right().left(), right().right());
-            if (!this.right().isRed()) //昇格させる木のrootが黒だったらバランスを取る
-                throw new RotateParent(newNode);
-            return newNode;
-        } else {//子ノードが左右にある場合 二回目はここには入らない
-            //左の部分木の最大の値を持つNodeと自身を置き換える
-            Node<K, V> cur = this.left();
-            while (cur.right().isNotEmpty()) { //左の部分期の最大値を持つNodeを取得する
-                cur = cur.right();
-            }
-            if (this.left().right().isNotEmpty()) { //左の部分木が右の子を持っているか
-                try {
-                    Node leftSubTreeNode = this.left().deleteSubTreeMaxNode(null, Rotate.L);//最大値を削除した左の部分木を返す。rootはthisと同じ。
-                    Node<K, V> newParent = createNode(cur.getKey(), cur.getValue(), leftSubTreeNode, this.right()); //rootをcurと入れ替えることでNodeの削除は完了する
-                    return newParent;
-                } catch (RotateParent e) {
-                    Node leftSubTreeNode = e.getParent();
-                    Node<K, V> newParent = createNode(cur.getKey(), cur.getValue(), leftSubTreeNode, this.right());
-                    return leftSubTreeNode.deleteBalance(newParent);
-                }
-            } else {
-                Node leftSubTreeNode = null;
-                try {
-                    leftSubTreeNode = this.left().replaceNode(this);//右の子がいなかった場合、左の子を昇格させるだけで良い。
-                    Node newParent = createNode(this.left().getKey(), this.left().getValue(), leftSubTreeNode, this.right());
-                    return newParent;
-                } catch (RotateParent e) {
-                    Node node = e.getParent();
-                    Node newParent = createNode(this.left().getKey(), this.left().getValue(), leftSubTreeNode, this.right());
-                    return node.deleteBalance(newParent);
-                }
-            }
-        }
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/treemap/EmptyNode.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,82 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.treemap;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-/**
- * Created by e115731 on 15/03/25.
- */
-public class EmptyNode<K, V> extends Node<K, V> {
-
-    public EmptyNode() {
-        super(null, null);
-    }
-
-    public EmptyNode(K key) { //keyは削除時の回転処理に使用する
-        super(key, null);
-    }
-
-    @Override // 回転処理時にEmptyNodeの子を見ることがあるのでleft rightでEmptyNodeを返すようにする
-    public Node<K, V> left() {
-        return new EmptyNode<>();
-    }
-
-    @Override
-    public Node<K, V> right() {
-        return new EmptyNode<>();
-    }
-
-
-    @Override
-    protected boolean isNotEmpty() {
-        return false;
-    }
-
-
-    @Override
-    public Node<K, V> createNode(K key, V value, Node<K, V> left, Node<K, V> right) {
-        return new RedNode<K, V>(key, value, new EmptyNode<K, V>(), new EmptyNode<K, V>());
-    }
-
-
-    public Node<K, V> put(K k, V value) {
-        return new RedNode(k, value, new EmptyNode<K, V>(), new EmptyNode<K, V>());
-    }
-
-    @Override
-    public Node replaceNode(Node<K, V> parent) { // not use method
-        return this;
-    }
-
-    @Override
-    protected Node deleteNode() { //not use method
-        return this;
-    }
-
-    @Override
-    Node insBalance() {
-        return this;
-    }
-
-    @Override
-    Rotate checkRotate(Rotate side) {
-        return Rotate.N;
-    }
-
-    @Override
-    boolean isRed() {
-        return false;
-    }
-
-    @Override
-    @Test
-    protected int checkDepth(int count,int minCount) { // test method
-        if (count < minCount | minCount == 0)
-            minCount = count;
-        System.out.println("depth = " + count);
-
-        Assert.assertTrue(count <=  2 * minCount);
-        return minCount;
-    }
-
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/treemap/Node.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,295 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.treemap;
-
-import org.junit.Test;
-
-import java.util.Optional;
-
-
-/**
- * Created by e115731 on 15/03/23.
- */
-public abstract class Node<K, V>  {
-
-    protected K key;
-    protected V value;
-    protected Node<K, V> right;
-    protected Node<K, V> left;
-
-    public Node(K key, V value) {
-        this.key = key;
-        this.value = value;
-    }
-
-    public Node(K key, V value, Node<K, V> left, Node<K, V> right) {
-        this.key = key;
-        this.value = value;
-        this.right = right;
-        this.left = left;
-    }
-
-    public Node<K, V> left() {
-        return left;
-    }
-
-    public int compare(Comparable<? super K> compareKey) {
-        return compareKey.compareTo(getKey());
-
-    }
-
-    public Optional<V> get(K key) {
-        Node<K, V> cur = this;
-        Comparable<? super K> k = (Comparable<? super K>) key;
-        while (cur.isNotEmpty()) {
-            int result = cur.compare(k);
-            if (result > 0)
-                cur = cur.right();
-            else if (result < 0)
-                cur = cur.left();
-            else if (result == 0)
-                return Optional.ofNullable(cur.getValue());
-        }
-        return Optional.ofNullable(null);
-    }
-
-
-    public Node<K, V> right() {
-        return right;
-    }
-
-    public K getKey() {
-        return key;
-    }
-
-    public V getValue() {
-        return value;
-    }
-
-
-    public Node<K, V> put(Comparable<? super K> k, V value) {
-        if (!isNotEmpty()) {
-            return createNode((K)k, value, left, right);
-        }
-        int result = compare(k);
-        if (result > 0) {
-            Node<K, V> node = right.put(k, value);
-            node = createNode(key, this.value, left, node);
-            return node.insBalance();
-        } else if (result < 0) {
-            Node node = left.put(k, value);
-            return createNode(key, this.value, node, right).insBalance();
-        }
-        return createNode(key, value, left, right); // equals
-
-    }
-
-    public Node<K, V> delete(Comparable<? super K> key, Node<K, V> parent, Rotate side) throws RotateParent {
-        if (this.isNotEmpty()) {
-            int result = compare(key);
-
-            try {
-                Node<K, V> node = null;
-                if (result > 0) {
-                    node = right.delete(key, this, Rotate.R);
-                    if (node == null)
-                        return null;
-                    if (parent == null)
-                        return node;
-                } else if (result < 0) {
-                    node = left.delete(key, this, Rotate.L);
-                    if (node == null)
-                        return null;
-                    if (parent == null)
-                        return node;
-                } else if (result == 0) {
-                    node = replaceNode(parent);
-                    if (parent == null)// equals
-                        return node;
-                    if (side == Rotate.R)
-                        return parent.createNode(parent.getKey(), parent.getValue(), parent.left(), node);
-                    else
-                        return parent.createNode(parent.getKey(), parent.getValue(), node, parent.right());
-                }
-                if (side == Rotate.L)
-                    return parent.createNode(parent.getKey(), parent.getValue(), node, parent.right());
-                else
-                    return parent.createNode(parent.getKey(), parent.getValue(), parent.left(), node);
-            } catch (RotateParent e) {
-                Node node = e.getParent();
-                if (parent != null)
-                    return node.deleteBalance(parent);
-                return node;
-            }
-        }
-        return null; // no key
-    }
-
-
-    public Node<K, V> deleteSubTreeMaxNode(Node<K, V> parent, Rotate side) throws RotateParent {
-        Node<K, V> node;
-        try {
-            if (right().isNotEmpty()) {//最大値のノードが取得できるまで潜る
-                node = right().deleteSubTreeMaxNode(this, Rotate.R);
-            } else {
-                node = this.replaceNode(parent);
-            }
-        } catch (RotateParent e) {
-            node = e.getParent();
-            if (parent == null)
-                throw e;
-            return node.deleteBalance(parent);
-        }
-        if (parent == null)
-            return node;
-        if (side == Rotate.R)
-            return parent.createNode(parent.getKey(), parent.getValue(), parent.left(), node);
-        else
-            return parent.createNode(parent.getKey(), parent.getValue(), node, parent.right());
-
-    }
-
-    public Node deleteBalance(Node<K, V> parent) throws RotateParent {
-        if (!isRed()) {
-            if (0 > compare((Comparable<? super K>) parent.getKey())) { //自身がどちらの子かを調べる
-                boolean rightChild = parent.left().right().isRed();
-                boolean leftChild = parent.left().left().isRed();
-
-                if (!parent.isRed()) { //親が黒
-                    if (!parent.left().isRed()) { //左の子が黒
-                        if (!rightChild && !leftChild)
-                            throw new RotateParent(rebuildThree(parent, Rotate.R));
-                        if (rightChild)
-                            return rebuildfive(parent, Rotate.R);
-                        else if (leftChild)
-                            return rebuildsix(parent, Rotate.R);
-                    } else { //左の子が赤
-                        return rebuildTwo(parent, Rotate.R);
-                    }
-                } else { //親が赤
-                    if (!rightChild && !leftChild)
-                        return rebuildFour(parent, Rotate.R);
-                    if (rightChild)
-                        return rebuildfive(parent, Rotate.R);
-                    else if (leftChild)
-                        return rebuildsix(parent, Rotate.R);
-                }
-            } else {
-                boolean rightChild = parent.right().right().isRed();
-                boolean leftChild = parent.right().left().isRed();
-
-                if (!parent.isRed()) { //親が黒
-                    if (!parent.right().isRed()) { //左の子が黒
-                        if (!rightChild && !leftChild)
-                            throw new RotateParent(rebuildThree(parent, Rotate.L));
-                        if (rightChild)
-                            return rebuildsix(parent, Rotate.L);
-                        else if (leftChild)
-                            return rebuildfive(parent, Rotate.L);
-                    } else { //左の子が赤
-                        return rebuildTwo(parent, Rotate.L);
-                    }
-                } else { //親が赤
-                    if (!rightChild && !leftChild)
-                        return rebuildFour(parent, Rotate.L);
-                    if (rightChild)
-                        return rebuildsix(parent, Rotate.L);
-                    else if (leftChild)
-                        return rebuildfive(parent, Rotate.L);
-                }
-            }
-        }
-        if (0 > (compare((Comparable<? super K>) parent.getKey())))
-            return parent.createNode(parent.getKey(), parent.getValue(), parent.left(), this);
-        else
-            return parent.createNode(parent.getKey(), parent.getValue(), this, parent.right());
-    }
-
-    protected Node<K, V> rebuildTwo(Node<K, V> parent, Rotate side) throws RotateParent { // case2
-        if (side == Rotate.L) { // rotate Left
-            Node<K, V> node = parent.right();
-            Node<K, V> leftSubTreeRoot = node.createNode(parent.getKey(), parent.getValue(), this, node.left()); // check
-            Node<K, V> leftNode = this.deleteBalance(leftSubTreeRoot);
-            Node<K, V> rightNode = node.right();
-            return parent.createNode(node.getKey(), node.getValue(), leftNode, rightNode);
-        } else {  // rotate Right
-            Node<K, V> node = parent.left();
-            Node<K, V> rightSubTreeRoot = node.createNode(parent.getKey(), parent.getValue(), node.right(), this);
-            Node<K, V> rightNode = this.deleteBalance(rightSubTreeRoot);
-            Node<K, V> leftNode = node.left();
-            return parent.createNode(node.getKey(), node.getValue(), leftNode, rightNode);
-        }
-    }
-
-    protected Node rebuildThree(Node<K, V> parent, Rotate side) { // case3 再帰
-        if (side == Rotate.L) {
-            Node<K, V> rightNode;
-            if (parent.right().isNotEmpty())
-                rightNode = new RedNode<K, V>(parent.right().getKey(), parent.right().getValue(), parent.right().left(), parent.right().right()); // check
-            else
-                rightNode = new EmptyNode<>();
-            return parent.createNode(parent.getKey(), parent.getValue(), this, rightNode);
-        } else {
-            Node<K, V> leftNode;
-            if (parent.left().isNotEmpty())
-                leftNode = new RedNode<K, V>(parent.left().getKey(), parent.left().getValue(), parent.left().left(), parent.left().right()); // check
-            else
-                leftNode = new EmptyNode<>();
-            return parent.createNode(parent.getKey(), parent.getValue(), leftNode, this);
-        }
-    }
-
-    protected Node rebuildFour(Node<K, V> parent, Rotate side) { //case 4
-        if (side == Rotate.R) {
-            Node<K, V> leftNode = new RedNode<K, V>(parent.left().getKey(), parent.left().getValue(), parent.left().left(), parent.left().right());
-            return new BlackNode<K, V>(parent.getKey(), parent.getValue(), leftNode, this);
-        } else {
-            Node<K, V> rightNode = new RedNode<K, V>(parent.right().getKey(), parent.right().getValue(), parent.right().left(), parent.right().right());
-            return new BlackNode<K, V>(parent.getKey(), parent.getValue(), this, rightNode);
-        }
-    }
-
-    protected Node rebuildfive(Node<K, V> parent, Rotate side) { //case5
-        if (side == Rotate.R) { // rotate Left
-            Node<K, V> leftChild = new RedNode<K, V>(parent.left().getKey(), parent.left().getValue(), parent.left().left(), parent.left().right().left());
-            Node<K, V> rightChild = parent.left().right().right();
-            Node<K, V> leftSubTreeRoot = new BlackNode<K, V>(parent.left().right().getKey(), parent.left().right().getValue(), leftChild, rightChild);
-            Node<K, V> newParent = parent.createNode(parent.getKey(), parent.getValue(), leftSubTreeRoot, this);
-            return this.rebuildsix(newParent, Rotate.R);
-        } else {  // rotate Right 修正済み
-            Node<K, V> leftChild = parent.right().left().left();
-            Node<K, V> rightChild = new RedNode<K, V>(parent.right().getKey(), parent.right().getValue(), parent.right().left().right(), parent.right().right());
-            Node<K, V> rightSubTreeRoot = new BlackNode<K, V>(parent.right().left().getKey(), parent.right().left().getValue(), leftChild, rightChild);
-            Node<K, V> newParent = parent.createNode(parent.getKey(), parent.getValue(), this, rightSubTreeRoot);
-            return this.rebuildsix(newParent, Rotate.L);
-        }
-    }
-
-    protected Node rebuildsix(Node<K, V> parent, Rotate side) { //case6
-        if (side == Rotate.L) { // rotate Left
-            Node<K, V> leftChild = parent.right().createNode(parent.getKey(), parent.getValue(), this, parent.right().left()); //check
-            Node<K, V> rightChild = new BlackNode<K, V>(parent.right().right().getKey(), parent.right().right().getValue(), parent.right().right().left(), parent.right().right().right());
-            return parent.createNode(parent.right().getKey(), parent.right().getValue(), leftChild, rightChild);
-        } else {  // rotate Right
-            Node<K, V> leftChild = new BlackNode<K, V>(parent.left().left().getKey(), parent.left().left().getValue(), parent.left().left().left(), parent.left().left().right());
-            Node<K, V> rightChild = parent.left().createNode(parent.getKey(), parent.getValue(), parent.left().right(), this);
-            return parent.createNode(parent.left().getKey(), parent.left().getValue(), leftChild, rightChild);
-        }
-    }
-
-
-    protected abstract boolean isNotEmpty();
-
-    public abstract Node<K, V> createNode(K key, V value, Node<K, V> left, Node<K, V> right);
-
-    abstract Node<K, V> insBalance();
-
-    abstract Rotate checkRotate(Rotate side);
-
-    abstract boolean isRed();
-
-    public abstract Node replaceNode(Node<K, V> parent) throws RotateParent;
-
-    protected abstract Node deleteNode() throws RotateParent;
-
-    @Test
-    protected abstract int checkDepth (int count , int minCount); // test method
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/treemap/RedNode.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,113 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.treemap;
-
-import org.junit.Test;
-
-/**
- * Created by e115731 on 15/03/25.
- */
-public class RedNode<K, V> extends Node<K, V> {
-
-
-    public RedNode(K key, V value, Node<K, V> left, Node<K, V> right) {
-        super(key, value, left, right);
-    }
-
-
-    @Override
-    protected boolean isNotEmpty() {
-        return true;
-    }
-
-    @Override
-    public Node<K, V> createNode(K key, V value, Node<K, V> left, Node<K, V> right) {
-        return new RedNode<K, V>(key, value, left, right);
-    }
-
-    @Override
-    protected Node<K, V> insBalance() {
-        return this;
-    }
-
-    @Override
-    protected Node deleteNode() throws RotateParent {
-        EmptyNode emptyNode = new EmptyNode(this.getKey());
-        return emptyNode;
-    }
-
-    @Override
-    Rotate checkRotate(Rotate side) {
-        if (side == Rotate.L) {
-            if (left.isRed())
-                return Rotate.R;
-            else if (right.isRed())
-                return Rotate.LR;
-            return Rotate.N;
-        } else {
-            if (left.isRed())
-                return Rotate.RL;
-            else if (right.isRed())
-                return Rotate.L;
-            return Rotate.N;
-        }
-    }
-
-    @Override
-    boolean isRed() {
-        return true;
-    }
-
-    @Override
-    public Node replaceNode(Node<K, V> parent) throws RotateParent {
-        Node<K, V> newNode = null;
-        if (!this.left().isNotEmpty() && !this.right().isNotEmpty()) { //自身を削除する
-            return deleteNode();
-        } else if (this.left().isNotEmpty() && !this.right().isNotEmpty()) { //左の部分木を昇格させる
-            newNode = left().createNode(left().getKey(), left().getValue(), left().left(), left().right());
-            return newNode;
-        } else if (!this.left().isNotEmpty() && this.right().isNotEmpty()) { //右の部分木を昇格させる
-            newNode = right().createNode(right().getKey(), right().getValue(), right().left(), right().right());
-            return newNode;
-        } else {//子ノードが左右にある場合
-            //左の部分木の最大の値を持つNodeと自身を置き換える
-            Node<K, V> cur = this.left();
-
-            while (cur.right().isNotEmpty()) {
-                cur = cur.right();
-            }
-            Node leftSubTreeNode = null;
-            if (this.left().right().isNotEmpty()) {
-                try {
-                    leftSubTreeNode = this.left().deleteSubTreeMaxNode(null,Rotate.L);
-                    newNode = createNode(cur.getKey(), cur.getValue(), leftSubTreeNode, this.right());
-                    return newNode;
-                } catch (RotateParent e) {
-                    leftSubTreeNode = e.getParent();
-                    Node<K, V> newParent = createNode(cur.getKey(), cur.getValue(), leftSubTreeNode, this.right());
-                    return leftSubTreeNode.deleteBalance(newParent);
-                }
-            } else {
-                try {
-                    leftSubTreeNode = this.left().replaceNode(this);
-                    newNode = createNode(cur.getKey(), cur.getValue(), leftSubTreeNode, this.right());
-                    return newNode;
-                } catch (RotateParent e) {
-                    Node node = e.getParent();
-                    Node newParent = createNode(this.left().getKey(), this.left().getValue(), leftSubTreeNode, this.right());
-                    return node.deleteBalance(newParent);
-                }
-            }
-
-        }
-    }
-
-
-    @Override
-    @Test
-    protected int checkDepth(int count,int minCount) { // test method
-        count ++;
-        minCount = left().checkDepth(count, minCount);
-        minCount = right().checkDepth(count, minCount);
-        count --;
-        return minCount;
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/treemap/Rotate.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,8 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.treemap;
-
-/**
- * Created by e115731 on 15/03/23.
- */
-public enum Rotate {
-    R, L, RL, LR, N;
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/treemap/RotateParent.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,15 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.treemap;
-
-/**
- * Created by e115731 on 15/04/17.
- */
-public class RotateParent extends Exception {
-    Node parent ;
-    public RotateParent(Node node) {
-        this.parent = node;
-    }
-
-    public Node getParent(){
-        return parent;
-    }
-}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/treemap/TreeMap.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,114 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.treemap;
-
-
-import org.junit.Test;
-
-import java.util.Iterator;
-import java.util.Optional;
-import java.util.Stack;
-
-
-/**
- * Created by e115731 on 15/03/23.
- */
-public class TreeMap<K, V> {
-    final Node<K, V> root;
-    final int size;
-
-    public TreeMap() {
-        this.root = new EmptyNode();
-        this.size = 0;
-    }
-
-
-    public Node getRoot() {
-        return root;
-    }
-
-    public TreeMap(Node<K, V> root, int size) {
-        this.root = root;
-        this.size = size;
-    }
-
-    public Optional<V> get(final K key) {
-        return root.get(key);
-    }
-
-    public TreeMap put(K key, V value) {
-
-        if (key == null || value == null)  // null check
-            throw new NullPointerException();
-
-        if (isEmpty()) {
-            Node<K, V> newRoot = new BlackNode(key, value, new EmptyNode(), new EmptyNode());
-            return new TreeMap<K, V>(newRoot, size + 1);
-        }
-
-        Node<K, V> newEntry = root.put((Comparable<? super K>) key, value);
-        Node<K, V> newRoot = new BlackNode(newEntry.getKey(), newEntry.getValue(), newEntry.left(), newEntry.right());
-        return new TreeMap(newRoot, 0);
-    }
-
-
-    public boolean isEmpty() {
-        return !root.isNotEmpty();
-    }
-
-
-    public TreeMap<K, V> delete(K key) {
-        Node node = null;
-        try {
-            node = root.delete((Comparable<? super K>) key, null, Rotate.N);
-        } catch (RotateParent rotateParent) {
-        }
-        if (node == null)
-            return this; // not key
-        if (!node.isNotEmpty())
-            return new TreeMap(new EmptyNode<>(), 0);
-        Node newRoot = new BlackNode(node.getKey(), node.getValue(), node.left(), node.right());
-        return new TreeMap(newRoot, 0);
-    }
-
-    public Iterator<K> keys() {
-        return new Iterator<K>() {
-            Stack<Node> nodeStack = new Stack();
-            Node currentNode = root;
-
-            @Override
-            public boolean hasNext() {
-                return currentNode != null;
-            }
-
-            @Override
-            public K next() {
-                K key = (K) currentNode.getKey();
-
-                if (currentNode.left().isNotEmpty()) {
-                    nodeStack.push(currentNode);
-                    currentNode = currentNode.left();
-                    return key;
-                } else  if (currentNode.right().isNotEmpty()) {
-                    currentNode = currentNode.right();
-                    return key;
-                } else if (nodeStack.isEmpty()) {
-                    currentNode = null;
-                    return key;
-                }
-
-                do {
-                    currentNode = nodeStack.pop().right();
-                    if (currentNode.isNotEmpty())
-                        return key;
-
-                } while (!nodeStack.isEmpty());
-                return key;
-            }
-        };
-    }
-
-    @Test
-    public void checkDepth() {
-        root.checkDepth(0, 0);
-        System.out.println("-----------------------------------");
-    }
-}
--- a/src/test/java/DefaultJungleTreeTest.java	Tue May 19 15:15:34 2015 +0900
+++ b/src/test/java/DefaultJungleTreeTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -1,15 +1,15 @@
 import java.nio.ByteBuffer;

-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.DefaultJungle;
+import jp.ac.u_ryukyu.ie.cr.jungle.Jungle;
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultTraverser;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
 import junit.framework.Assert;
 import junit.framework.TestCase;
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/core/AttributesContainerTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,22 @@
+//package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core;
+//
+//import org.junit.Assert;
+//import org.junit.Ignore;
+//import org.junit.Test;
+//
+//import junit.framework.TestCase;
+//
+//@Ignore
+//public abstract class AttributesContainerTest extends TestCase
+//{
+//	public abstract AttributesContainer instance();
+//
+//	@Test
+//	public void testGetAttributes()
+//	{
+//		AttributesContainer instance = instance();
+//		Attributes attrs = instance.getAttributes();
+//
+//		Assert.assertNotNull(attrs);
+//	}
+//}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/core/AttributesTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,33 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.core;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Pair;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import junit.framework.Assert;
+import junit.framework.TestCase;
+import org.junit.Ignore;
+
+import java.nio.ByteBuffer;
+
+@Ignore
+public abstract class AttributesTest extends TestCase {
+    @SuppressWarnings("unchecked")
+    public static List<Pair<String, ByteBuffer>> ENTRIES = new List(
+            new Pair("KEY1", ByteBuffer.wrap("VALUE1".getBytes())),
+            new Pair("KEY2", ByteBuffer.wrap("VALUE2".getBytes())),
+            new Pair("KEY3", ByteBuffer.wrap("VALUE3".getBytes()))
+    );
+
+    public abstract Attributes instance();
+
+    public void testGet() {
+        Attributes attrs = instance();
+
+        for (Pair<String, ByteBuffer> entry : ENTRIES) {
+            String key = entry.left();
+            ByteBuffer expect = entry.right();
+            ByteBuffer actual = attrs.get(key);
+            Assert.assertNotNull(actual);
+            Assert.assertEquals(0, actual.compareTo(expect));
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/core/ChildrenTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,20 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.core;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNodeChildren;
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+public abstract class ChildrenTest<T> extends TestCase
+{
+	public abstract int expectSize();
+	public abstract DefaultTreeNodeChildren instance();
+
+	public void testSize()
+	{
+		int expect = expectSize();
+		Children children = instance();
+
+		Assert.assertEquals(expect,children.size());
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/core/GetNodeOfPathTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,48 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.core;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.DefaultJungle;
+import jp.ac.u_ryukyu.ie.cr.jungle.Jungle;
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultTraverser;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.InterfaceTraverser;
+import junit.framework.Assert;
+import org.junit.Test;
+
+import java.nio.ByteBuffer;
+import java.util.Iterator;
+
+public class GetNodeOfPathTest {
+
+    @Test
+    public void getNodeOfPathTest() {
+        Jungle jungle = new DefaultJungle(null, "hogehoge", new DefaultTreeEditor(new DefaultTraverser()));
+        jungle.createNewTree("tree");
+        JungleTree tree = jungle.getTreeByName("tree");
+        JungleTreeEditor editor = tree.getTreeEditor();
+        DefaultNodePath path = new DefaultNodePath();
+        editor = editor.addNewChildAt(path, 0).b();
+        path = path.add(0);
+        editor = editor.putAttribute(path, "KEY", ByteBuffer.wrap("tatsuki".getBytes())).b();
+        editor = editor.addNewChildAt(path, 0).b();
+        path = path.add(0);
+        editor = editor.putAttribute(path, "KEY", ByteBuffer.wrap("tatsuki".getBytes())).b();
+        editor.success();
+        InterfaceTraverser traverser = tree.getTraverser(true);
+        Iterator<TreeNode> nodeIterator = traverser.find((TreeNode node) -> {
+            String str = node.getAttributes().getString("KEY");
+            if (str == null)
+                return false;
+            if (str.equals("tatsuki"))
+                return true;
+            return false;
+        }, "KEY", "tatsuki");
+
+        TreeNode node = tree.getNodeOfPath(path).b();
+        Assert.assertTrue(nodeIterator.hasNext());
+        Assert.assertEquals(node, nodeIterator.next());
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/core/GetOldTreeTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,46 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.core;
+
+
+import java.nio.ByteBuffer;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.DefaultJungle;
+import jp.ac.u_ryukyu.ie.cr.jungle.Jungle;
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultTraverser;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import org.junit.Test;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import junit.framework.Assert;
+
+public class GetOldTreeTest {
+
+  @Test
+  public void getOldTreeTest() {
+    Jungle jungle = new DefaultJungle(null, "hogehoge", new DefaultTreeEditor(new DefaultTraverser()));
+    jungle.createNewTree("tree");
+    JungleTree tree = jungle.getTreeByName("tree");
+    JungleTreeEditor editor = tree.getTreeEditor();
+    DefaultNodePath path = new DefaultNodePath();
+
+    for (int num = 0; num < 10; num++) {
+      JungleTreeEditor addChildEditor = editor.addNewChildAt(path, num).b();
+      JungleTreeEditor putAttributeEditor = addChildEditor.putAttribute(path.add(num), "test", ByteBuffer.wrap("tatsuki".getBytes())).b();
+      Either<Error, JungleTreeEditor> successEither = putAttributeEditor.success();
+      Assert.assertFalse(successEither.isA());
+      editor = successEither.b();
+    }
+    System.out.println(tree.revision());
+    TreeNode root = tree.getRootNode();
+    Assert.assertTrue(root.getChildren().at(9).isB());
+
+    JungleTree oldTree = tree.getOldTree(9).b();
+    System.out.println(oldTree.revision());
+    TreeNode oldRoot = oldTree.getRootNode();
+    Assert.assertTrue(oldRoot.getChildren().at(9).isA());
+  }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/core/ParentTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,22 @@
+/*package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+@Ignore
+public abstract class ParentTest<T extends Parent<?>> extends TestCase
+{
+	public abstract T instance();
+
+	@Test
+	public void testGetChildren()
+	{
+		T instance = instance();
+		Children<?> children = instance.getChildren();
+		Assert.assertNotNull(children);
+	}
+}
+*/
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/core/impl/treeeditor/DefaultTreeEditorTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,94 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.core.impl.treeeditor;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.tests.util.TestUtil;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultTraverser;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.LoggingNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.AppendChildAt;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.PutAttribute;
+import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultEvaluator;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.Traversal;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+import java.nio.ByteBuffer;
+
+public class DefaultTreeEditorTest extends TestCase
+{
+	public DefaultTreeEditor instance()
+	{
+		DefaultTraverser traverser = new DefaultTraverser();
+		return new DefaultTreeEditor(traverser);
+	}
+
+	public void testEdittingDoesNotEffectToOtherTree()
+	{
+		TreeNode root = TestUtil.createMockTree(3);
+		DefaultTreeEditor editor = new DefaultTreeEditor(new DefaultTraverser());
+		DefaultNodePath path = new DefaultNodePath().add(0).add(2);
+
+		TreeNode oldRoot = root;
+
+		DefaultTreeEditor currentEditor = editor;
+		String key = "path";
+
+
+		TreeNode currentRoot = root;
+		for(DefaultNodePath part : path.inits()){
+        String str = part.toString();
+			ByteBuffer value = ByteBuffer.wrap(str.getBytes());
+			PutAttribute putAttribute = new PutAttribute(key,value);
+			Either<Error,LoggingNode> either = currentEditor.edit(currentRoot,part,putAttribute);
+			if(either.isA()){
+				Assert.fail();
+			}
+			currentRoot = either.b().getWrap();
+		}
+
+		TreeNode newRoot = currentRoot;
+		DefaultTraverser traverser = new DefaultTraverser();
+
+		for(DefaultNodePath part : path.inits()){
+			Either<Error,Traversal> either = traverser.traverse(newRoot,new DefaultEvaluator(part));
+			if(either.isA()){
+				Assert.fail();
+			}
+			TreeNode target = either.b().destination();
+			String expected = part.toString();
+			String actual = new String(target.getAttributes().get(key).array());
+
+			Assert.assertEquals(expected,actual);
+		}
+
+		for(DefaultNodePath part : path.inits()){
+			Either<Error,Traversal> either = traverser.traverse(oldRoot,new DefaultEvaluator(part));
+			if(either.isA()){
+				Assert.fail();
+			}
+			TreeNode target = either.b().destination();
+			ByteBuffer actual = target.getAttributes().get(key);
+
+			Assert.assertNull(actual);
+		}
+
+	}
+
+	public void testEdit()
+	{
+		DefaultTreeEditor instance = instance();
+		DefaultTreeNode node = new DefaultTreeNode();
+		DefaultNodePath path = new DefaultNodePath();
+
+		Either<Error,LoggingNode> either = instance.edit(node,path,new AppendChildAt(0));
+		if(either.isA()){
+			Assert.fail();
+		}
+		TreeNode newRoot = either.b().getWrap();
+		Assert.assertEquals(1,newRoot.getChildren().size());
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/core/nodeeditor/AppendChildAtTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,27 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.core.nodeeditor;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.AppendChildAt;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.LoggingNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+public class AppendChildAtTest extends TestCase
+{
+	public void testEdit()
+	{
+		TreeNode node = new DefaultTreeNode();
+		AppendChildAt op = new AppendChildAt(0);
+		Either<Error, LoggingNode> either = op.edit(node);
+		if(either.isA()){
+			Assert.fail();
+		}
+
+		LoggingNode newNode = either.b();
+		Assert.assertEquals(1,newNode.getChildren().size());
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/core/nodeeditor/DeleteAttributeAtTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,37 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.core.nodeeditor;
+
+import java.nio.ByteBuffer;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.LoggingNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.DeleteAttribute;
+import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+public class DeleteAttributeAtTest extends TestCase
+{
+	public void testEdit()
+	{
+		String key = "KEY";
+		ByteBuffer value = ByteBuffer.wrap(key.getBytes());
+
+		TreeNode node = new DefaultTreeNode();
+		Either<Error,TreeNode> either = node.getAttributes().put(key, value);
+		if(either.isA()){
+			Assert.fail();
+		}
+		node = either.b();
+
+		DeleteAttribute op = new DeleteAttribute(key);
+		Either<Error,LoggingNode> either2 = op.edit(node);
+		if(either2.isA()){
+			Assert.fail();
+		}
+		LoggingNode newNode = either2.b();
+		ByteBuffer ret = newNode.getAttributes().get(key);
+		Assert.assertNull(ret);
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/core/nodeeditor/DeleteChildAtTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,33 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.core.nodeeditor;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.LoggingNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.DeleteChildAt;
+import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+public class DeleteChildAtTest extends TestCase
+{
+	public void testEdit()
+	{
+		TreeNode node = new DefaultTreeNode();
+		Either<Error,TreeNode> either = node.getChildren().addNewChildAt(0);
+		if(either.isA()){
+			Assert.fail();
+		}
+		node = either.b();
+		Assert.assertEquals(1,node.getChildren().size());
+
+		DeleteChildAt op = new DeleteChildAt(0);
+		Either<Error,LoggingNode> either2 = op.edit(node);
+		if(either2.isA()){
+			Assert.fail();
+		}
+		LoggingNode logNode = either2.b();
+
+		Assert.assertEquals(0,logNode.getChildren().size());
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/core/nodeeditor/EditableAttributesTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,99 @@
+/*package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.nodeeditor;
+
+import java.nio.ByteBuffer;
+
+import org.junit.Assert;
+
+import fj.P;
+import fj.P2;
+import fj.data.List;
+import TreeNode;
+import TreeNodeAttributes;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableAttributes;
+import NodeEditorError;
+import Either;
+import Error;
+import junit.framework.TestCase;
+
+public abstract class EditableAttributesTest<T extends TreeNode<T>> extends TestCase
+{
+	public abstract TreeNodeAttributes<T> instance();
+
+	@SuppressWarnings("unchecked")
+	public static final List<P2<String,ByteBuffer>> ENTRIES = List.list(
+		P.p("KEY1",ByteBuffer.wrap("VALUE1".getBytes())),
+		P.p("KEY2",ByteBuffer.wrap("VALUE2".getBytes())),
+		P.p("KEY3",ByteBuffer.wrap("VALUE3".getBytes()))
+	);
+
+	public TreeNodeAttributes<T> createTestData()
+	{
+		TreeNodeAttributes<T> instance = instance();
+
+		T node;
+		TreeNodeAttributes<T> attr = instance;
+		for(P2<String,ByteBuffer> entry : ENTRIES){
+			Either<Error,T> either = attr.put(entry._1(),entry._2());
+			if(either.isA()){
+				Assert.fail("error during creating the data.");
+			}
+
+			node = either.b();
+			attr = node.getAttributes();
+		}
+
+		return attr;
+	}
+
+	public void testPutDoesNotAcceptNullValue()
+	{
+		TreeNodeAttributes<T> instance = instance();
+
+		Either<Error,T> either = instance.put("KEY",null);
+		if(!either.isA()){
+			Assert.fail("put must returns NULL_VALUE_NOT_ALLOWED when the value was null.");
+		}
+
+		Assert.assertEquals(NodeEditorError.NULL_VALUE_NOT_ALLOWED,either.a());
+
+		either = instance.put(null,ByteBuffer.wrap("VALUE".getBytes()));
+
+		if(!either.isA()){
+			Assert.fail("put must returns NULL_VALUE_NOT_ALLOWED when the key was null.");
+		}
+
+		Assert.assertEquals(NodeEditorError.NULL_VALUE_NOT_ALLOWED,either.a());
+	}
+
+	public void testPut()
+	{
+		createTestData();
+	}
+
+	public void testDeleteIfKeyExsist()
+	{
+		TreeNodeAttributes<T> attr = createTestData();
+
+		for(P2<String,ByteBuffer> entry : ENTRIES){
+			Either<Error,T> either = attr.delete(entry._1());
+			if(either.isA()){
+				Assert.fail("error during deleting exist key.");
+			}
+
+			attr = either.b().getAttributes();
+		}
+	}
+
+	public static final String DUMMY_KEY = "dummy";
+
+	public void testDeleteIfKeyNotExist()
+	{
+		TreeNodeAttributes<T> attr = createTestData();
+
+		Either<Error,T> either = attr.delete(DUMMY_KEY);
+		if(!either.isA()){
+			Assert.fail("delete must returns DELETE_KEY_NOT_FOUND when the deleting invalid key.");
+		}
+	}
+}
+*/
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/core/nodeeditor/EditableChildrenTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,135 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.core.nodeeditor;
+
+import java.nio.ByteBuffer;
+/*import org.junit.Assert;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableChildren;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableNode;
+import NodeEditorError;
+import Either;
+import Error;
+import junit.framework.TestCase;
+
+public abstract class EditableChildrenTest<T extends EditableNode<T>> extends TestCase
+{
+	public abstract EditableChildren<T> instance();
+
+	public static final String KEY = "KEY";
+	public static final ByteBuffer VALUE = ByteBuffer.wrap("VALUE".getBytes());
+
+	public void testAddNewChildAtMuinusValue()
+	{
+		EditableChildren<T> children = instance();
+		Either<Error,T> either = children.addNewChildAt(-1);
+		if(!either.isA()){
+			Assert.fail("addNewChildAt(-1) must returns INDEX_OUT_OF_BOUNDS Error");
+		}
+
+		Error e = either.a();
+		Assert.assertSame(e,NodeEditorError.INDEX_OUT_OF_BOUNDS);
+	}
+
+	public void testAddNewChildAtOutOfBounds()
+	{
+		EditableChildren<T> children = instance();
+		Either<Error,T> either = children.addNewChildAt(1);
+		if(!either.isA()){
+			Assert.fail("addNewChildAt(1) must returns INDEX_OUT_OF_BOUNDS Error");
+		}
+
+		Error e = either.a();
+		Assert.assertSame(e,NodeEditorError.INDEX_OUT_OF_BOUNDS);
+	}
+
+	public void testAddNewChildAtMiddle()
+	{
+		EditableChildren<T> children = instance();
+
+		for(int i = 0;i < 3;i ++){
+			Either<Error,T> either = children.addNewChildAt(0);
+			if(either.isA()){
+				Assert.fail("fail when adding new child to head");
+			}
+			children = either.b().getChildren();
+		}
+
+		Either<Error, T> either = children.addNewChildAt(1);
+		if(either.isA()){
+			Assert.fail("fail when adding new child to middle (1)");
+		}
+		// size must be 4
+		children = either.b().getChildren();
+		Assert.assertEquals(4,children.size());
+	}
+
+	public void testAddNewChildAtToHead()
+	{
+		EditableChildren<T> children = instance();
+
+		int size = children.size();
+
+		Either<Error,T> either = children.addNewChildAt(0);
+		if(either.isA()){
+			Assert.fail("error during add new child to head");
+		}
+		children = either.b().getChildren();
+		Assert.assertEquals(size + 1,children.size());
+	}
+
+	public void testDeleteChildAtMuinusValue()
+	{
+		EditableChildren<T> children = instance();
+		Either<Error,T> either = children.deleteChildAt(-1);
+		if(!either.isA()){
+			Assert.fail("deleteChildAt(-1) must returns INDEX_OUT_OF_BOUNDS Error");
+		}
+
+		Error e = either.a();
+		Assert.assertSame(e,NodeEditorError.INDEX_OUT_OF_BOUNDS);
+	}
+
+	public void testDeleteChildAtOutOfBounds()
+	{
+		EditableChildren<T> children = instance();
+		Either<Error,T> either = children.deleteChildAt(1);
+		if(!either.isA()){
+			Assert.fail("deleteChildAt(1) must returns INDEX_OUT_OF_BOUNDS Error");
+		}
+
+		Error e = either.a();
+		Assert.assertSame(e,NodeEditorError.INDEX_OUT_OF_BOUNDS);
+	}
+
+	public void testDeleteChildAtFailsWhenTheSizeIsZero()
+	{
+		EditableChildren<T> children = instance();
+		Either<Error,T> either = children.deleteChildAt(0);
+		if(!either.isA()){
+			Assert.fail("deleteChildAt(1) must returns INDEX_OUT_OF_BOUNDS Error");
+		}
+
+		Error e = either.a();
+		Assert.assertSame(e,NodeEditorError.INDEX_OUT_OF_BOUNDS);
+	}
+
+	public void testDeleteChildAt()
+	{
+		EditableChildren<T> children = instance();
+
+		int size = children.size();
+
+		Either<Error,T> either = children.addNewChildAt(0);
+		if(either.isA()){
+			Assert.fail("error during add new child to head");
+		}
+		children = either.b().getAttributes().put(KEY,VALUE).b().getChildren();
+		Assert.assertEquals(size + 1,children.size());
+
+		either = children.deleteChildAt(0);
+		if(either.isA()){
+			Assert.fail("error during deleting child");
+		}
+		children = either.b().getChildren();
+
+		Assert.assertEquals(size,children.size());
+	}
+}*/
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/core/nodeeditor/PutAttributeTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,33 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.core.nodeeditor;
+
+import java.nio.ByteBuffer;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.LoggingNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.PutAttribute;
+import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import org.junit.Assert;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import junit.framework.TestCase;
+
+public class PutAttributeTest extends TestCase
+{
+	public void testEdit()
+	{
+		String key = "KEY";
+		ByteBuffer value = ByteBuffer.wrap(key.getBytes());
+		TreeNode node = new DefaultTreeNode();
+		PutAttribute op = new PutAttribute(key,value);
+		//EditableNodeWrapper<DefaultTreeNode> wrapper = new EditableNodeWrapper<DefaultTreeNode>(node);
+		Either<Error, LoggingNode> either = op.edit(node);
+		if(either.isA()){
+			Assert.fail();
+		}
+
+		LoggingNode newNode = either.b();
+		ByteBuffer ret = newNode.getAttributes().get(key);
+		Assert.assertEquals(0,ret.compareTo(value));
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/core/nodeeditor/ReplaceRootNodeAt.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,38 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.core.nodeeditor;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.DefaultJungle;
+import jp.ac.u_ryukyu.ie.cr.jungle.Jungle;
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultTraverser;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import junit.framework.Assert;
+
+import org.junit.Test;
+
+public class ReplaceRootNodeAt {
+
+  @Test
+  public void ReplaceRootNodeAtTest() {
+    Jungle jungle = new DefaultJungle(null, "hogehoge", new DefaultTreeEditor(new DefaultTraverser()));
+    jungle.createNewTree("tree");
+    JungleTree tree = jungle.getTreeByName("tree");
+    JungleTreeEditor editor = tree.getTreeEditor();
+
+    TreeNode oldRoot = tree.getRootNode();
+    Either<Error, JungleTreeEditor> either = editor.replaceNewRootNode();
+    Assert.assertTrue(either.isB());
+    JungleTreeEditor newTreeEditor = either.b();
+    Assert.assertTrue(newTreeEditor.success().isB());
+    TreeNode newRoot = tree.getRootNode();
+    Assert.assertFalse(oldRoot.equals(newRoot));
+
+    Either<jp.ac.u_ryukyu.ie.cr.jungle.util.Error, TreeNode> childrenEither = newRoot.getChildren().at(0);
+    Assert.assertTrue(childrenEither.isB());
+    TreeNode newRootChildren = childrenEither.b();
+    Assert.assertEquals(oldRoot, newRootChildren);
+  }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/core/treeeditor/TreeNodeChildrenTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,131 @@
+/*package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.treeeditor;
+
+import java.nio.ByteBuffer;
+import org.junit.Assert;
+import fj.data.List;
+import TreeNode;
+import TreeNodeChildren;
+import Either;
+import Error;
+import junit.framework.TestCase;
+
+public abstract class TreeNodeChildrenTest<T extends TreeNode<T>> extends TestCase
+{
+	public abstract TreeNode<T> instance();
+
+	public void testAddNewChildAtWithNode()
+	{
+		int count = 5;
+		for(Integer pos : List.range(0,5)){
+			_testAddNewChildAtWithNode(count,pos);
+		}
+	}
+
+	public void _testAddNewChildAtWithNode(int _count,int _pos)
+	{
+		TreeNode<T> instance = instance();
+
+		Either<Error, T> either;
+		for(int i = 0;i < _count;i ++){
+			either = instance.getChildren().addNewChildAt(0);
+			if(either.isA()){
+				Assert.fail();
+			}
+			instance = either.b();
+		}
+
+		TreeNode<T> newNode = instance.createNewNode();
+		String key = "KEY";
+		ByteBuffer value = ByteBuffer.wrap("VALUE".getBytes());
+
+		either = newNode.getAttributes().put(key,value);
+		if(either.isA()){
+			Assert.fail();
+		}
+		newNode = either.b();
+
+		either = instance.getChildren().addNewChildAt(_pos,newNode);
+		if(either.isA()){
+			Assert.fail();
+		}
+		instance = either.b();
+
+		// check
+		either = instance.getChildren().at(_pos);
+		if(either.isA()){
+			Assert.fail();
+		}
+
+		T checkTarget = either.b();
+		ByteBuffer actual = checkTarget.getAttributes().get(key);
+		Assert.assertEquals(0,value.compareTo(actual));
+	}
+
+	public void testReplaceAt()
+	{
+		int count = 5;
+		for(Integer pos : List.range(0,count)){
+			_testReplaceAt(count,pos);
+		}
+	}
+
+	public void _testReplaceAt(int _count,int _pos)
+	{
+		TreeNode<T> instance = instance();
+		String key = "KEY";
+		ByteBuffer value = ByteBuffer.wrap("VALUE".getBytes());
+
+		// prepare
+
+		for(int i = 0;i < _count;i ++){
+			TreeNode<T> newNode = instance.createNewNode();
+			Either<Error,T> either = newNode.getAttributes().put(key,value);
+			if(either.isA()){
+				Assert.fail("failed to put attributes to child");
+			}
+
+			newNode = either.b();
+			either = instance.getChildren().addNewChildAt(0,newNode);
+			if(either.isA()){
+				Assert.fail("failed to add child to instance");
+			}
+
+			instance = either.b();
+		}
+
+		int size = instance.getChildren().size();
+		Assert.assertEquals(_count,size);
+
+		// create node for replacement.
+
+		ByteBuffer replaceNodeValue = ByteBuffer.wrap("EULAV".getBytes());
+		TreeNode<T> replacement = instance.createNewNode();
+		Either<Error,T> either = replacement.getAttributes().put(key,replaceNodeValue);
+		if(either.isA()){
+			Assert.fail("failed to create replacement node");
+		}
+		replacement = either.b();
+
+		// replace
+
+		either = instance.getChildren().replaceNode(_pos,replacement);
+		if(either.isA()){
+			Assert.fail("failed to replace node.");
+		}
+		instance = either.b();
+
+		TreeNodeChildren<T> children = instance.getChildren();
+		for(Integer pos : List.range(0,_count)){
+			either = children.at(pos.intValue());
+			if(either.isA()){
+				Assert.fail("failed to get node.");
+			}
+
+			T ch = either.b();
+			ByteBuffer expect = (_pos != pos) ? value : replaceNodeValue;
+			ByteBuffer actual = ch.getAttributes().get(key);
+
+			Assert.assertEquals(0,expect.compareTo(actual));
+		}
+	}
+}*/
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/impl/clonable/DefaultTreeNodeAttributesTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,60 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.impl.clonable;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.core.Attributes;
+import jp.ac.u_ryukyu.ie.cr.jungle.core.AttributesTest;
+import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Pair;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import java.nio.ByteBuffer;
+
+public class DefaultTreeNodeAttributesTest extends TestCase
+{
+	public static TestSuite suite()
+	{
+		TestSuite suite = new TestSuite();
+		suite.addTestSuite(AttributeTestImpl.class);
+		//suite.addTestSuite(EditableAttributesTestImpl.class);
+		return suite;
+	}
+
+	public static DefaultTreeNode instance()
+	{
+		List<TreeNode> rawList = new List();
+		TreeMap<String,ByteBuffer> rawMap = new TreeMap();
+
+		for(Pair<String,ByteBuffer> entry : AttributesTest.ENTRIES){
+			rawMap = rawMap.put(entry.left(),entry.right());
+		}
+
+		return new DefaultTreeNode(rawList,rawMap);
+	}
+
+	public static class AttributeTestImpl extends AttributesTest
+	{
+
+		@Override
+		public Attributes instance()
+		{
+			return DefaultTreeNodeAttributesTest.instance().getAttributes();
+		}
+
+	}
+
+	/*public static class EditableAttributesTestImpl extends EditableAttributesTest<DefaultTreeNode>
+	{
+
+		@Override
+		public DefaultTreeNodeAttribute instance()
+		{
+			DefaultTreeNode instance = DefaultTreeNodeAttributesTest.instance();
+			return instance.getAttributes();
+		}
+
+	}*/
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/impl/clonable/DefaultTreeNodeChildrenTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,45 @@
+/*package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.impl.clonable;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.nodeeditor.EditableChildrenTest;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.treeeditor.TreeNodeChildrenTest;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.EditableNodeWrapper;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableChildren;
+import DefaultTreeNode;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+public class DefaultTreeNodeChildrenTest extends TestCase
+{
+	public static TestSuite suite()
+	{
+		TestSuite suite = new TestSuite();
+		suite.addTestSuite(EditableChildrenTestImpl.class);
+		suite.addTestSuite(TreeNodeChildrenTestImpl.class);
+		return suite;
+	}
+
+	public static DefaultTreeNode instance()
+	{
+		return new DefaultTreeNode();
+	}
+
+	public static class TreeNodeChildrenTestImpl extends TreeNodeChildrenTest<DefaultTreeNode>
+	{
+		@Override
+		public DefaultTreeNode instance()
+		{
+			return DefaultTreeNodeChildrenTest.instance();
+		}
+	}
+
+	public static class EditableChildrenTestImpl extends EditableChildrenTest<EditableNodeWrapper<DefaultTreeNode>>
+	{
+		@Override
+		public EditableChildren<EditableNodeWrapper<DefaultTreeNode>> instance()
+		{
+			DefaultTreeNode wrap = DefaultTreeNodeChildrenTest.instance();
+			EditableNodeWrapper<DefaultTreeNode> wrapper = new EditableNodeWrapper<DefaultTreeNode>(wrap);
+			return wrapper.getChildren();
+		}
+	}
+}*/
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/impl/clonable/DefaultTreeNodeTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,55 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.impl.clonable;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNode;
+import junit.framework.Assert;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+public class DefaultTreeNodeTest extends TestCase
+{
+	public static TestSuite suite()
+	{
+		TestSuite suite = new TestSuite();
+		//suite.addTestSuite(AttributesContaierTestImpl.class);
+		//suite.addTestSuite(ParentTestImpl.class);
+		return suite;
+	}
+
+	public static DefaultTreeNode instance()
+	{
+		DefaultTreeNode node = new DefaultTreeNode();
+		return node;
+	}
+
+	public void testGetWrapped()
+	{
+		DefaultTreeNode instance = instance();
+	}
+
+	public void testCreateNewNode()
+	{
+		DefaultTreeNode instance = instance();
+		DefaultTreeNode node = instance.createNewNode();
+
+		Assert.assertNotNull(node);
+	}
+
+//	public static class AttributesContaierTestImpl extends AttributesContainerTest
+//	{
+//		@Override
+//		public AttributesContainer instance()
+//		{
+//			return DefaultTreeNodeTest.instance();
+//		}
+//	}
+
+	/*public static class ParentTestImpl extends ParentTest<DefaultTreeNode>
+	{
+
+		@Override
+		public DefaultTreeNode instance()
+		{
+			return DefaultTreeNodeTest.instance();
+		}
+	}*/
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/impl/node/DefaultAttributesTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,54 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.impl.node;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.core.AttributesTest;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNodeAttributes;
+import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Pair;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
+import org.junit.Assert;
+
+import java.nio.ByteBuffer;
+import java.util.Optional;
+
+public class DefaultAttributesTest extends AttributesTest
+{
+	public TreeNodeAttributes instance()
+	{
+		List<TreeNode> rawList = new List();
+		TreeMap<String,ByteBuffer> rawMap = new TreeMap();
+
+		// add attributes
+
+		for(Pair<String, ByteBuffer> entry : ENTRIES){
+			rawMap = rawMap.put(entry.left(),entry.right());
+		}
+
+		TreeNode node = new DefaultTreeNode(rawList,rawMap);
+		return node.getAttributes();
+	}
+
+	public void testGetAttributesAsRawMap()
+	{
+		TreeNodeAttributes attrs = instance();
+		TreeMap<String,ByteBuffer> rawMap = attrs.getAttributesAsRawMap();
+
+		// testing rawmap is not null.
+		Assert.assertNotNull(rawMap);
+
+		// testing rawmap has correct key values.
+		for(Pair<String,ByteBuffer> entry : ENTRIES){
+			String key = entry.left();
+			ByteBuffer value = entry.right();
+
+			Optional<ByteBuffer> option = rawMap.get(key);
+			if(!option.isPresent()){
+				Assert.fail();
+			}
+
+			ByteBuffer actual = option.get();
+			Assert.assertEquals(0,actual.compareTo(value));
+		}
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/impl/node/DefaultChildrenTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,44 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.impl.node;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.core.ChildrenTest;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNodeChildren;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
+import org.junit.Assert;
+
+import java.nio.ByteBuffer;
+
+public class DefaultChildrenTest extends ChildrenTest<TreeNode>
+{
+
+	@Override
+	public DefaultTreeNodeChildren instance()
+	{
+		List<TreeNode> rawList = new List();
+		for(int i = 0;i < expectSize();i ++){
+			rawList = rawList.addLast(new DefaultTreeNode());
+		}
+
+		TreeMap<String,ByteBuffer> rawMap =  new TreeMap();
+
+		return new DefaultTreeNode(rawList,rawMap).getChildren();
+	}
+
+	@Override
+	public int expectSize()
+	{
+		return 3;
+	}
+
+	public void testGetChildrenAsRawList()
+	{
+		DefaultTreeNodeChildren instance = instance();
+		List<TreeNode> rawList = instance.getChildrenAsRawList();
+
+		Assert.assertNotNull(rawList);
+		Assert.assertEquals(expectSize(),rawList.length());
+	}
+}
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/impl/node/DefaultNodeTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,55 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.impl.node;
+
+
+import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import java.nio.ByteBuffer;
+
+public class DefaultNodeTest extends TestCase
+{
+	public DefaultNodeTest(String _name)
+	{
+		super(_name);
+	}
+
+	public static TestSuite suite()
+	{
+		TestSuite suite = new TestSuite();
+		//suite.addTestSuite(DefaultNodeTest.AttributesContaierTestImpl.class);
+		//suite.addTestSuite(DefaultNodeTest.ParentTestImpl.class);
+		return suite;
+	}
+
+	public static DefaultTreeNode instance()
+	{
+		List<TreeNode> rawList = new List();
+		TreeMap<String,ByteBuffer> rawMap = new TreeMap();
+		DefaultTreeNode node = new DefaultTreeNode(rawList,rawMap);
+
+		return node;
+	}
+
+//	public static class AttributesContaierTestImpl extends AttributesContainerTest
+//	{
+//		@Override
+//		public AttributesContainer instance()
+//		{
+//			return DefaultNodeTest.instance();
+//		}
+////	}
+
+	/*public static class ParentTestImpl extends ParentTest<DefaultTreeNode>
+	{
+
+		@Override
+		public DefaultTreeNode instance()
+		{
+			return DefaultNodeTest.instance();
+		}
+	}*/
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/index/parentIndexTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,47 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.index;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.DefaultJungle;
+import jp.ac.u_ryukyu.ie.cr.jungle.Jungle;
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.jungle.JungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultTraverser;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.index.ParentIndex;
+import junit.framework.Assert;
+import org.junit.Test;
+
+import java.nio.ByteBuffer;
+
+/**
+ * Created by e115731 on 15/05/06.
+ */
+public class parentIndexTest {
+    @Test
+    public void parentIndex() {
+        Jungle jungle = new DefaultJungle(null, "hogehoge", new DefaultTreeEditor(new DefaultTraverser()));
+        jungle.createNewTree("tree");
+        JungleTree tree = jungle.getTreeByName("tree");
+        JungleTreeEditor editor = tree.getTreeEditor();
+
+        DefaultNodePath path = new DefaultNodePath();
+        for (int count = 0; count < 100; count++) {
+            editor = editor.addNewChildAt(path, 0).b();
+            path = path.add(0);
+            editor = editor.putAttribute(path, "KEY", ByteBuffer.wrap(("tatsuki" + count).getBytes())).b();
+        }
+
+        Either<Error, JungleTreeEditor> either = editor.success();
+        Assert.assertTrue(either.isB());
+        TreeNode node = tree.getNodeOfPath(path).b();
+        ParentIndex parentIndex = tree.getParentIndex();
+        for (int count = 99; count >= 0; count--) {
+            String attribute = node.getAttributes().getString("KEY");
+            Assert.assertEquals(attribute, "tatsuki" + count);
+            node = parentIndex.get(node);
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/tests/util/TestUtil.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,44 @@
+package jp.ac.u_ryukyu.ie.cr.jungle.tests.util;
+
+import java.nio.ByteBuffer;
+
+import org.junit.Ignore;
+
+import jp.ac.u_ryukyu.ie.cr.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNode;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
+
+@Ignore
+public class TestUtil
+{
+	public static TreeNode createMockTree(int _maxDepth)
+	{
+		return _createMockTree(1,_maxDepth,new DefaultNodePath());
+	}
+
+	public static TreeNode _createMockTree(int _currentDepth,int _maxDepth,NodePath _path)
+	{
+		TreeNode parent = new DefaultTreeNode();
+		Either<Error, TreeNode> either = parent.getAttributes().put("KEY",ByteBuffer.wrap(_path.toString().getBytes()));
+		if(either.isA()){
+			return null;
+		}
+		parent = either.b();
+
+		if(_currentDepth != _maxDepth){
+			for(int i = 0;i <= _currentDepth;i ++){
+				TreeNode ch = _createMockTree(_currentDepth + 1,_maxDepth,_path.add(i));
+				either = parent.getChildren().addNewChildAt(i,ch);
+				if(either.isA()){
+					return null;
+				}
+				parent = either.b();
+			}
+		}
+
+		return parent;
+	}
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/traverse/BruteForceTraverserTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,87 @@
+/*package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverse;
+
+import java.nio.ByteBuffer;
+import java.util.Iterator;
+
+import JungleTreeEditor;
+import NodePath;
+import DefaultNodePath;
+import TreeNode;
+import DefaultTreeNode;
+import InterfaceTraverser;
+import Either;
+import Error;
+import Pair;
+import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.SearchQuery;
+import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.UpdateQuery;
+import junit.framework.TestCase;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public abstract class BruteForceTraverserTest extends TestCase{
+	public abstract InterfaceTraverser instance(TreeNode node);
+
+	@Test
+	public void testSearch()	{
+		int maxHeight = 3;
+		Pair<TreeNode, NodePath> test = null;
+		TreeNode root = createTree(0,0,maxHeight,new DefaultNodePath());
+		InterfaceTraverser traverser = instance(root);
+		Iterator<Pair<TreeNode, NodePath>> itNode = traverser.find(new SearchQuery("KEY","<-1,0,0>"));
+		for(;itNode.hasNext(); ){
+			test = itNode.next();
+		}
+		String str = new String(test.left().getAttributes().get("KEY").array());
+		Assert.assertEquals(str,"<-1,0,0>");
+	}
+
+	@Test
+	public void testUpdate()	{
+		int maxHeight = 3;
+		Pair<TreeNode, NodePath> test = null;
+		TreeNode root = createTree(0,0,maxHeight,new DefaultNodePath());
+		InterfaceTraverser traverser = instance(root);
+		JungleTreeEditor editor = traverser.update(new UpdateQuery("KEY", "<-1,0,0>", "tatsuki"));
+		traverser.set(editor.getRoot());
+		Iterator<Pair<TreeNode, NodePath>> checkNode = traverser.find(new SearchQuery("KEY","tatsuki"));
+		for(;checkNode.hasNext(); ){
+			test = checkNode.next();
+		}
+		String str = new String(test.left().getAttributes().get("KEY").array());
+		Assert.assertEquals(str,"tatsuki");
+	}
+
+	public static String key = "KEY";
+	public static ByteBuffer value = ByteBuffer.wrap(key.getBytes());
+	public static DefaultTreeNode factory = new DefaultTreeNode();
+
+	public static TreeNode createTree(int _curX,int _curY,int _maxHeight,NodePath _address)
+	{
+		System.out.println(_address.toString());
+		TreeNode parent = factory.createNewNode();
+		Either<Error,TreeNode> either = parent.getAttributes().put(key,ByteBuffer.wrap(_address.toString().getBytes()));
+		if(either.isA()){
+			Assert.fail();
+		}
+		parent = either.b();
+
+		if(_curY == _maxHeight){
+			return parent;
+		}
+
+		for(int i = 0;i < _curY + 1;i ++){
+			TreeNode ch = createTree(i,_curY + 1,_maxHeight,_address.add(i));
+			either = parent.getChildren().addNewChildAt(i,ch);
+			if(either.isA()){
+				Assert.fail();
+			}
+
+			parent = either.b();
+		}
+
+		return parent;
+	}
+
+}
+*/
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/jungle/traverse/TraverserTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -0,0 +1,108 @@
+/*
+package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverse;
+
+import List;
+import NodePath;
+import DefaultNodePath;
+import TreeNode;
+import DefaultTreeNode;
+import DefaultEvaluator;
+import Direction;
+import Traversal;
+import Traverser;
+import Either;
+import Error;
+import junit.framework.TestCase;
+import org.junit.Assert;
+
+import java.nio.ByteBuffer;
+
+public abstract class TraverserTest extends TestCase
+{
+	public abstract Traverser instance();
+
+	public void testTraverse()
+	{
+		int maxHeight = 3;
+		TreeNode root = createTree(0,0,maxHeight,new DefaultNodePath());
+
+		//TraversableNodeWrapper<DefaultTreeNode> traversable = new TraversableNodeWrapper<DefaultTreeNode>(root);
+		Traverser traverser = instance();
+
+		// generate all pattern.
+		List<DefaultNodePath> paths = generatePathPattern(new DefaultNodePath(),0,maxHeight);
+		paths = paths.addLast(new DefaultNodePath());
+
+		for(DefaultNodePath path : paths){
+			DefaultEvaluator evaluator = new DefaultEvaluator(path);
+			Either<Error,Traversal> ret = traverser.traverse(root,evaluator);
+			if(ret.isA()){
+				Assert.fail();
+			}
+
+			Traversal traversal = ret.b();
+			TreeNode target = traversal.destination();
+			String expect = path.toString();
+			ByteBuffer value = target.getAttributes().get(key);
+			String actual = new String(value.array());
+			Assert.assertEquals(expect,actual);
+
+			List<DefaultNodePath> parts = path.inits();
+
+			for(Direction<TreeNode> d : traversal){
+				DefaultNodePath part = parts.head();
+				parts = parts.last();
+				value = d.getTarget().getAttributes().get(key);
+				String actualCurrentPathStr = new String(value.array());
+				String expectCurrentPathStr = part.toString();
+				Assert.assertEquals(expectCurrentPathStr,actualCurrentPathStr);
+			}
+		}
+	}
+
+	public List<DefaultNodePath> generatePathPattern(DefaultNodePath _cur,int _curHeight,int _maxHeight)
+	{
+		List<DefaultNodePath> paths = List.nil();
+		for(int p = 0;p <= _curHeight;p ++){
+			DefaultNodePath path = _cur.add(p);
+			if(_curHeight != _maxHeight - 1){
+				List<DefaultNodePath> newpaths = generatePathPattern(path,_curHeight+1,_maxHeight);
+				paths = paths.append(newpaths);
+			}
+			paths = paths.cons(path);
+		}
+
+		return paths;
+	}
+
+	public static String key = "KEY";
+	public static ByteBuffer value = ByteBuffer.wrap(key.getBytes());
+	public static DefaultTreeNode factory = new DefaultTreeNode();
+
+	public TreeNode createTree(int _curX,int _curY,int _maxHeight,NodePath _address)
+	{
+		TreeNode parent = factory.createNewNode();
+		Either<Error,TreeNode> either = parent.getAttributes().put(key,ByteBuffer.wrap(_address.toString().getBytes()));
+		if(either.isA()){
+			Assert.fail();
+		}
+		parent = either.b();
+
+		if(_curY == _maxHeight){
+			return parent;
+		}
+
+		for(int i = 0;i < _curY + 1;i ++){
+			TreeNode ch = createTree(i,_curY + 1,_maxHeight,_address.add(i));
+			either = parent.getChildren().addNewChildAt(i,ch);
+			if(either.isA()){
+				Assert.fail();
+			}
+
+			parent = either.b();
+		}
+
+		return parent;
+	}
+}
+*/
\ No newline at end of file
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/AttributesContainerTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,22 +0,0 @@
-//package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core;
-//
-//import org.junit.Assert;
-//import org.junit.Ignore;
-//import org.junit.Test;
-//
-//import junit.framework.TestCase;
-//
-//@Ignore
-//public abstract class AttributesContainerTest extends TestCase
-//{
-//	public abstract AttributesContainer instance();
-//
-//	@Test
-//	public void testGetAttributes()
-//	{
-//		AttributesContainer instance = instance();
-//		Attributes attrs = instance.getAttributes();
-//
-//		Assert.assertNotNull(attrs);
-//	}
-//}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/AttributesTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,33 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core;
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
-import junit.framework.Assert;
-import junit.framework.TestCase;
-import org.junit.Ignore;
-
-import java.nio.ByteBuffer;
-
-@Ignore
-public abstract class AttributesTest extends TestCase {
-    @SuppressWarnings("unchecked")
-    public static List<Pair<String, ByteBuffer>> ENTRIES = new List(
-            new Pair("KEY1", ByteBuffer.wrap("VALUE1".getBytes())),
-            new Pair("KEY2", ByteBuffer.wrap("VALUE2".getBytes())),
-            new Pair("KEY3", ByteBuffer.wrap("VALUE3".getBytes()))
-    );
-
-    public abstract Attributes instance();
-
-    public void testGet() {
-        Attributes attrs = instance();
-
-        for (Pair<String, ByteBuffer> entry : ENTRIES) {
-            String key = entry.left();
-            ByteBuffer expect = entry.right();
-            ByteBuffer actual = attrs.get(key);
-            Assert.assertNotNull(actual);
-            Assert.assertEquals(0, actual.compareTo(expect));
-        }
-    }
-}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/ChildrenTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,20 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core;
-
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNodeChildren;
-import junit.framework.Assert;
-import junit.framework.TestCase;
-
-public abstract class ChildrenTest<T> extends TestCase
-{
-	public abstract int expectSize();
-	public abstract DefaultTreeNodeChildren instance();
-
-	public void testSize()
-	{
-		int expect = expectSize();
-		Children children = instance();
-
-		Assert.assertEquals(expect,children.size());
-	}
-}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/GetNodeOfPathTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,48 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
-import junit.framework.Assert;
-import org.junit.Test;
-
-import java.nio.ByteBuffer;
-import java.util.Iterator;
-
-public class GetNodeOfPathTest {
-
-    @Test
-    public void getNodeOfPathTest() {
-        Jungle jungle = new DefaultJungle(null, "hogehoge", new DefaultTreeEditor(new DefaultTraverser()));
-        jungle.createNewTree("tree");
-        JungleTree tree = jungle.getTreeByName("tree");
-        JungleTreeEditor editor = tree.getTreeEditor();
-        DefaultNodePath path = new DefaultNodePath();
-        editor = editor.addNewChildAt(path, 0).b();
-        path = path.add(0);
-        editor = editor.putAttribute(path, "KEY", ByteBuffer.wrap("tatsuki".getBytes())).b();
-        editor = editor.addNewChildAt(path, 0).b();
-        path = path.add(0);
-        editor = editor.putAttribute(path, "KEY", ByteBuffer.wrap("tatsuki".getBytes())).b();
-        editor.success();
-        InterfaceTraverser traverser = tree.getTraverser(true);
-        Iterator<TreeNode> nodeIterator = traverser.find((TreeNode node) -> {
-            String str = node.getAttributes().getString("KEY");
-            if (str == null)
-                return false;
-            if (str.equals("tatsuki"))
-                return true;
-            return false;
-        }, "KEY", "tatsuki");
-
-        TreeNode node = tree.getNodeOfPath(path).b();
-        Assert.assertTrue(nodeIterator.hasNext());
-        Assert.assertEquals(node, nodeIterator.next());
-    }
-}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/GetOldTreeTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,46 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core;
-
-
-import java.nio.ByteBuffer;
-
-import org.junit.Test;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import junit.framework.Assert;
-
-public class GetOldTreeTest {
-
-  @Test
-  public void getOldTreeTest() {
-    Jungle jungle = new DefaultJungle(null, "hogehoge", new DefaultTreeEditor(new DefaultTraverser()));
-    jungle.createNewTree("tree");
-    JungleTree tree = jungle.getTreeByName("tree");
-    JungleTreeEditor editor = tree.getTreeEditor();
-    DefaultNodePath path = new DefaultNodePath();
-
-    for (int num = 0; num < 10; num++) {
-      JungleTreeEditor addChildEditor = editor.addNewChildAt(path, num).b();
-      JungleTreeEditor putAttributeEditor = addChildEditor.putAttribute(path.add(num), "test", ByteBuffer.wrap("tatsuki".getBytes())).b();
-      Either<Error, JungleTreeEditor> successEither = putAttributeEditor.success();
-      Assert.assertFalse(successEither.isA());
-      editor = successEither.b();
-    }
-    System.out.println(tree.revision());
-    TreeNode root = tree.getRootNode();
-    Assert.assertTrue(root.getChildren().at(9).isB());
-
-    JungleTree oldTree = tree.getOldTree(9).b();
-    System.out.println(oldTree.revision());
-    TreeNode oldRoot = oldTree.getRootNode();
-    Assert.assertTrue(oldRoot.getChildren().at(9).isA());
-  }
-}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/ParentTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,22 +0,0 @@
-/*package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core;
-
-import org.junit.Ignore;
-import org.junit.Test;
-
-import junit.framework.Assert;
-import junit.framework.TestCase;
-
-@Ignore
-public abstract class ParentTest<T extends Parent<?>> extends TestCase
-{
-	public abstract T instance();
-
-	@Test
-	public void testGetChildren()
-	{
-		T instance = instance();
-		Children<?> children = instance.getChildren();
-		Assert.assertNotNull(children);
-	}
-}
-*/
\ No newline at end of file
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/impl/treeeditor/DefaultTreeEditorTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,94 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.impl.treeeditor;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.AppendChildAt;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.PutAttribute;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.tests.util.TestUtil;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultEvaluator;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Traversal;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import junit.framework.Assert;
-import junit.framework.TestCase;
-
-import java.nio.ByteBuffer;
-
-public class DefaultTreeEditorTest extends TestCase
-{
-	public DefaultTreeEditor instance()
-	{
-		DefaultTraverser traverser = new DefaultTraverser();
-		return new DefaultTreeEditor(traverser);
-	}
-
-	public void testEdittingDoesNotEffectToOtherTree()
-	{
-		TreeNode root = TestUtil.createMockTree(3);
-		DefaultTreeEditor editor = new DefaultTreeEditor(new DefaultTraverser());
-		DefaultNodePath path = new DefaultNodePath().add(0).add(2);
-
-		TreeNode oldRoot = root;
-
-		DefaultTreeEditor currentEditor = editor;
-		String key = "path";
-
-
-		TreeNode currentRoot = root;
-		for(DefaultNodePath part : path.inits()){
-        String str = part.toString();
-			ByteBuffer value = ByteBuffer.wrap(str.getBytes());
-			PutAttribute putAttribute = new PutAttribute(key,value);
-			Either<Error,LoggingNode> either = currentEditor.edit(currentRoot,part,putAttribute);
-			if(either.isA()){
-				Assert.fail();
-			}
-			currentRoot = either.b().getWrap();
-		}
-
-		TreeNode newRoot = currentRoot;
-		DefaultTraverser traverser = new DefaultTraverser();
-
-		for(DefaultNodePath part : path.inits()){
-			Either<Error,Traversal> either = traverser.traverse(newRoot,new DefaultEvaluator(part));
-			if(either.isA()){
-				Assert.fail();
-			}
-			TreeNode target = either.b().destination();
-			String expected = part.toString();
-			String actual = new String(target.getAttributes().get(key).array());
-
-			Assert.assertEquals(expected,actual);
-		}
-
-		for(DefaultNodePath part : path.inits()){
-			Either<Error,Traversal> either = traverser.traverse(oldRoot,new DefaultEvaluator(part));
-			if(either.isA()){
-				Assert.fail();
-			}
-			TreeNode target = either.b().destination();
-			ByteBuffer actual = target.getAttributes().get(key);
-
-			Assert.assertNull(actual);
-		}
-
-	}
-
-	public void testEdit()
-	{
-		DefaultTreeEditor instance = instance();
-		DefaultTreeNode node = new DefaultTreeNode();
-		DefaultNodePath path = new DefaultNodePath();
-
-		Either<Error,LoggingNode> either = instance.edit(node,path,new AppendChildAt(0));
-		if(either.isA()){
-			Assert.fail();
-		}
-		TreeNode newRoot = either.b().getWrap();
-		Assert.assertEquals(1,newRoot.getChildren().size());
-	}
-}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/nodeeditor/AppendChildAtTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,27 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.nodeeditor;
-
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.AppendChildAt;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import junit.framework.Assert;
-import junit.framework.TestCase;
-
-public class AppendChildAtTest extends TestCase
-{
-	public void testEdit()
-	{
-		TreeNode node = new DefaultTreeNode();
-		AppendChildAt op = new AppendChildAt(0);
-		Either<Error, LoggingNode> either = op.edit(node);
-		if(either.isA()){
-			Assert.fail();
-		}
-
-		LoggingNode newNode = either.b();
-		Assert.assertEquals(1,newNode.getChildren().size());
-	}
-}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/nodeeditor/DeleteAttributeAtTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,37 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.nodeeditor;
-
-import java.nio.ByteBuffer;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.DeleteAttribute;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import junit.framework.Assert;
-import junit.framework.TestCase;
-
-public class DeleteAttributeAtTest extends TestCase
-{
-	public void testEdit()
-	{
-		String key = "KEY";
-		ByteBuffer value = ByteBuffer.wrap(key.getBytes());
-
-		TreeNode node = new DefaultTreeNode();
-		Either<Error,TreeNode> either = node.getAttributes().put(key, value);
-		if(either.isA()){
-			Assert.fail();
-		}
-		node = either.b();
-
-		DeleteAttribute op = new DeleteAttribute(key);
-		Either<Error,LoggingNode> either2 = op.edit(node);
-		if(either2.isA()){
-			Assert.fail();
-		}
-		LoggingNode newNode = either2.b();
-		ByteBuffer ret = newNode.getAttributes().get(key);
-		Assert.assertNull(ret);
-	}
-}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/nodeeditor/DeleteChildAtTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,33 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.nodeeditor;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.DeleteChildAt;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import junit.framework.Assert;
-import junit.framework.TestCase;
-
-public class DeleteChildAtTest extends TestCase
-{
-	public void testEdit()
-	{
-		TreeNode node = new DefaultTreeNode();
-		Either<Error,TreeNode> either = node.getChildren().addNewChildAt(0);
-		if(either.isA()){
-			Assert.fail();
-		}
-		node = either.b();
-		Assert.assertEquals(1,node.getChildren().size());
-
-		DeleteChildAt op = new DeleteChildAt(0);
-		Either<Error,LoggingNode> either2 = op.edit(node);
-		if(either2.isA()){
-			Assert.fail();
-		}
-		LoggingNode logNode = either2.b();
-
-		Assert.assertEquals(0,logNode.getChildren().size());
-	}
-}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/nodeeditor/EditableAttributesTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,99 +0,0 @@
-/*package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.nodeeditor;
-
-import java.nio.ByteBuffer;
-
-import org.junit.Assert;
-
-import fj.P;
-import fj.P2;
-import fj.data.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNodeAttributes;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableAttributes;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditorError;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import junit.framework.TestCase;
-
-public abstract class EditableAttributesTest<T extends TreeNode<T>> extends TestCase
-{
-	public abstract TreeNodeAttributes<T> instance();
-
-	@SuppressWarnings("unchecked")
-	public static final List<P2<String,ByteBuffer>> ENTRIES = List.list(
-		P.p("KEY1",ByteBuffer.wrap("VALUE1".getBytes())),
-		P.p("KEY2",ByteBuffer.wrap("VALUE2".getBytes())),
-		P.p("KEY3",ByteBuffer.wrap("VALUE3".getBytes()))
-	);
-
-	public TreeNodeAttributes<T> createTestData()
-	{
-		TreeNodeAttributes<T> instance = instance();
-
-		T node;
-		TreeNodeAttributes<T> attr = instance;
-		for(P2<String,ByteBuffer> entry : ENTRIES){
-			Either<Error,T> either = attr.put(entry._1(),entry._2());
-			if(either.isA()){
-				Assert.fail("error during creating the data.");
-			}
-
-			node = either.b();
-			attr = node.getAttributes();
-		}
-
-		return attr;
-	}
-
-	public void testPutDoesNotAcceptNullValue()
-	{
-		TreeNodeAttributes<T> instance = instance();
-
-		Either<Error,T> either = instance.put("KEY",null);
-		if(!either.isA()){
-			Assert.fail("put must returns NULL_VALUE_NOT_ALLOWED when the value was null.");
-		}
-
-		Assert.assertEquals(NodeEditorError.NULL_VALUE_NOT_ALLOWED,either.a());
-
-		either = instance.put(null,ByteBuffer.wrap("VALUE".getBytes()));
-
-		if(!either.isA()){
-			Assert.fail("put must returns NULL_VALUE_NOT_ALLOWED when the key was null.");
-		}
-
-		Assert.assertEquals(NodeEditorError.NULL_VALUE_NOT_ALLOWED,either.a());
-	}
-
-	public void testPut()
-	{
-		createTestData();
-	}
-
-	public void testDeleteIfKeyExsist()
-	{
-		TreeNodeAttributes<T> attr = createTestData();
-
-		for(P2<String,ByteBuffer> entry : ENTRIES){
-			Either<Error,T> either = attr.delete(entry._1());
-			if(either.isA()){
-				Assert.fail("error during deleting exist key.");
-			}
-
-			attr = either.b().getAttributes();
-		}
-	}
-
-	public static final String DUMMY_KEY = "dummy";
-
-	public void testDeleteIfKeyNotExist()
-	{
-		TreeNodeAttributes<T> attr = createTestData();
-
-		Either<Error,T> either = attr.delete(DUMMY_KEY);
-		if(!either.isA()){
-			Assert.fail("delete must returns DELETE_KEY_NOT_FOUND when the deleting invalid key.");
-		}
-	}
-}
-*/
\ No newline at end of file
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/nodeeditor/EditableChildrenTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,135 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.nodeeditor;
-
-import java.nio.ByteBuffer;
-/*import org.junit.Assert;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableChildren;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditorError;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import junit.framework.TestCase;
-
-public abstract class EditableChildrenTest<T extends EditableNode<T>> extends TestCase
-{
-	public abstract EditableChildren<T> instance();
-
-	public static final String KEY = "KEY";
-	public static final ByteBuffer VALUE = ByteBuffer.wrap("VALUE".getBytes());
-
-	public void testAddNewChildAtMuinusValue()
-	{
-		EditableChildren<T> children = instance();
-		Either<Error,T> either = children.addNewChildAt(-1);
-		if(!either.isA()){
-			Assert.fail("addNewChildAt(-1) must returns INDEX_OUT_OF_BOUNDS Error");
-		}
-
-		Error e = either.a();
-		Assert.assertSame(e,NodeEditorError.INDEX_OUT_OF_BOUNDS);
-	}
-
-	public void testAddNewChildAtOutOfBounds()
-	{
-		EditableChildren<T> children = instance();
-		Either<Error,T> either = children.addNewChildAt(1);
-		if(!either.isA()){
-			Assert.fail("addNewChildAt(1) must returns INDEX_OUT_OF_BOUNDS Error");
-		}
-
-		Error e = either.a();
-		Assert.assertSame(e,NodeEditorError.INDEX_OUT_OF_BOUNDS);
-	}
-
-	public void testAddNewChildAtMiddle()
-	{
-		EditableChildren<T> children = instance();
-
-		for(int i = 0;i < 3;i ++){
-			Either<Error,T> either = children.addNewChildAt(0);
-			if(either.isA()){
-				Assert.fail("fail when adding new child to head");
-			}
-			children = either.b().getChildren();
-		}
-
-		Either<Error, T> either = children.addNewChildAt(1);
-		if(either.isA()){
-			Assert.fail("fail when adding new child to middle (1)");
-		}
-		// size must be 4
-		children = either.b().getChildren();
-		Assert.assertEquals(4,children.size());
-	}
-
-	public void testAddNewChildAtToHead()
-	{
-		EditableChildren<T> children = instance();
-
-		int size = children.size();
-
-		Either<Error,T> either = children.addNewChildAt(0);
-		if(either.isA()){
-			Assert.fail("error during add new child to head");
-		}
-		children = either.b().getChildren();
-		Assert.assertEquals(size + 1,children.size());
-	}
-
-	public void testDeleteChildAtMuinusValue()
-	{
-		EditableChildren<T> children = instance();
-		Either<Error,T> either = children.deleteChildAt(-1);
-		if(!either.isA()){
-			Assert.fail("deleteChildAt(-1) must returns INDEX_OUT_OF_BOUNDS Error");
-		}
-
-		Error e = either.a();
-		Assert.assertSame(e,NodeEditorError.INDEX_OUT_OF_BOUNDS);
-	}
-
-	public void testDeleteChildAtOutOfBounds()
-	{
-		EditableChildren<T> children = instance();
-		Either<Error,T> either = children.deleteChildAt(1);
-		if(!either.isA()){
-			Assert.fail("deleteChildAt(1) must returns INDEX_OUT_OF_BOUNDS Error");
-		}
-
-		Error e = either.a();
-		Assert.assertSame(e,NodeEditorError.INDEX_OUT_OF_BOUNDS);
-	}
-
-	public void testDeleteChildAtFailsWhenTheSizeIsZero()
-	{
-		EditableChildren<T> children = instance();
-		Either<Error,T> either = children.deleteChildAt(0);
-		if(!either.isA()){
-			Assert.fail("deleteChildAt(1) must returns INDEX_OUT_OF_BOUNDS Error");
-		}
-
-		Error e = either.a();
-		Assert.assertSame(e,NodeEditorError.INDEX_OUT_OF_BOUNDS);
-	}
-
-	public void testDeleteChildAt()
-	{
-		EditableChildren<T> children = instance();
-
-		int size = children.size();
-
-		Either<Error,T> either = children.addNewChildAt(0);
-		if(either.isA()){
-			Assert.fail("error during add new child to head");
-		}
-		children = either.b().getAttributes().put(KEY,VALUE).b().getChildren();
-		Assert.assertEquals(size + 1,children.size());
-
-		either = children.deleteChildAt(0);
-		if(either.isA()){
-			Assert.fail("error during deleting child");
-		}
-		children = either.b().getChildren();
-
-		Assert.assertEquals(size,children.size());
-	}
-}*/
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/nodeeditor/PutAttributeTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,33 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.nodeeditor;
-
-import java.nio.ByteBuffer;
-
-import org.junit.Assert;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.PutAttribute;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import junit.framework.TestCase;
-
-public class PutAttributeTest extends TestCase
-{
-	public void testEdit()
-	{
-		String key = "KEY";
-		ByteBuffer value = ByteBuffer.wrap(key.getBytes());
-		TreeNode node = new DefaultTreeNode();
-		PutAttribute op = new PutAttribute(key,value);
-		//EditableNodeWrapper<DefaultTreeNode> wrapper = new EditableNodeWrapper<DefaultTreeNode>(node);
-		Either<Error, LoggingNode> either = op.edit(node);
-		if(either.isA()){
-			Assert.fail();
-		}
-
-		LoggingNode newNode = either.b();
-		ByteBuffer ret = newNode.getAttributes().get(key);
-		Assert.assertEquals(0,ret.compareTo(value));
-	}
-}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/nodeeditor/ReplaceRootNodeAt.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,38 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.nodeeditor;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import junit.framework.Assert;
-
-import org.junit.Test;
-
-public class ReplaceRootNodeAt {
-
-  @Test
-  public void ReplaceRootNodeAtTest() {
-    Jungle jungle = new DefaultJungle(null, "hogehoge", new DefaultTreeEditor(new DefaultTraverser()));
-    jungle.createNewTree("tree");
-    JungleTree tree = jungle.getTreeByName("tree");
-    JungleTreeEditor editor = tree.getTreeEditor();
-
-    TreeNode oldRoot = tree.getRootNode();
-    Either<Error, JungleTreeEditor> either = editor.replaceNewRootNode();
-    Assert.assertTrue(either.isB());
-    JungleTreeEditor newTreeEditor = either.b();
-    Assert.assertTrue(newTreeEditor.success().isB());
-    TreeNode newRoot = tree.getRootNode();
-    Assert.assertFalse(oldRoot.equals(newRoot));
-
-    Either<Error, TreeNode> childrenEither = newRoot.getChildren().at(0);
-    Assert.assertTrue(childrenEither.isB());
-    TreeNode newRootChildren = childrenEither.b();
-    Assert.assertEquals(oldRoot, newRootChildren);
-  }
-}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/treeeditor/TreeNodeChildrenTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,131 +0,0 @@
-/*package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.treeeditor;
-
-import java.nio.ByteBuffer;
-import org.junit.Assert;
-import fj.data.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNodeChildren;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import junit.framework.TestCase;
-
-public abstract class TreeNodeChildrenTest<T extends TreeNode<T>> extends TestCase
-{
-	public abstract TreeNode<T> instance();
-
-	public void testAddNewChildAtWithNode()
-	{
-		int count = 5;
-		for(Integer pos : List.range(0,5)){
-			_testAddNewChildAtWithNode(count,pos);
-		}
-	}
-
-	public void _testAddNewChildAtWithNode(int _count,int _pos)
-	{
-		TreeNode<T> instance = instance();
-
-		Either<Error, T> either;
-		for(int i = 0;i < _count;i ++){
-			either = instance.getChildren().addNewChildAt(0);
-			if(either.isA()){
-				Assert.fail();
-			}
-			instance = either.b();
-		}
-
-		TreeNode<T> newNode = instance.createNewNode();
-		String key = "KEY";
-		ByteBuffer value = ByteBuffer.wrap("VALUE".getBytes());
-
-		either = newNode.getAttributes().put(key,value);
-		if(either.isA()){
-			Assert.fail();
-		}
-		newNode = either.b();
-
-		either = instance.getChildren().addNewChildAt(_pos,newNode);
-		if(either.isA()){
-			Assert.fail();
-		}
-		instance = either.b();
-
-		// check
-		either = instance.getChildren().at(_pos);
-		if(either.isA()){
-			Assert.fail();
-		}
-
-		T checkTarget = either.b();
-		ByteBuffer actual = checkTarget.getAttributes().get(key);
-		Assert.assertEquals(0,value.compareTo(actual));
-	}
-
-	public void testReplaceAt()
-	{
-		int count = 5;
-		for(Integer pos : List.range(0,count)){
-			_testReplaceAt(count,pos);
-		}
-	}
-
-	public void _testReplaceAt(int _count,int _pos)
-	{
-		TreeNode<T> instance = instance();
-		String key = "KEY";
-		ByteBuffer value = ByteBuffer.wrap("VALUE".getBytes());
-
-		// prepare
-
-		for(int i = 0;i < _count;i ++){
-			TreeNode<T> newNode = instance.createNewNode();
-			Either<Error,T> either = newNode.getAttributes().put(key,value);
-			if(either.isA()){
-				Assert.fail("failed to put attributes to child");
-			}
-
-			newNode = either.b();
-			either = instance.getChildren().addNewChildAt(0,newNode);
-			if(either.isA()){
-				Assert.fail("failed to add child to instance");
-			}
-
-			instance = either.b();
-		}
-
-		int size = instance.getChildren().size();
-		Assert.assertEquals(_count,size);
-
-		// create node for replacement.
-
-		ByteBuffer replaceNodeValue = ByteBuffer.wrap("EULAV".getBytes());
-		TreeNode<T> replacement = instance.createNewNode();
-		Either<Error,T> either = replacement.getAttributes().put(key,replaceNodeValue);
-		if(either.isA()){
-			Assert.fail("failed to create replacement node");
-		}
-		replacement = either.b();
-
-		// replace
-
-		either = instance.getChildren().replaceNode(_pos,replacement);
-		if(either.isA()){
-			Assert.fail("failed to replace node.");
-		}
-		instance = either.b();
-
-		TreeNodeChildren<T> children = instance.getChildren();
-		for(Integer pos : List.range(0,_count)){
-			either = children.at(pos.intValue());
-			if(either.isA()){
-				Assert.fail("failed to get node.");
-			}
-
-			T ch = either.b();
-			ByteBuffer expect = (_pos != pos) ? value : replaceNodeValue;
-			ByteBuffer actual = ch.getAttributes().get(key);
-
-			Assert.assertEquals(0,expect.compareTo(actual));
-		}
-	}
-}*/
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/impl/clonable/DefaultTreeNodeAttributesTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,60 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.impl.clonable;
-
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Attributes;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.AttributesTest;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
-import junit.framework.TestCase;
-import junit.framework.TestSuite;
-
-import java.nio.ByteBuffer;
-
-public class DefaultTreeNodeAttributesTest extends TestCase
-{
-	public static TestSuite suite()
-	{
-		TestSuite suite = new TestSuite();
-		suite.addTestSuite(AttributeTestImpl.class);
-		//suite.addTestSuite(EditableAttributesTestImpl.class);
-		return suite;
-	}
-
-	public static DefaultTreeNode instance()
-	{
-		List<TreeNode> rawList = new List();
-		TreeMap<String,ByteBuffer> rawMap = new TreeMap();
-
-		for(Pair<String,ByteBuffer> entry : AttributesTest.ENTRIES){
-			rawMap = rawMap.put(entry.left(),entry.right());
-		}
-
-		return new DefaultTreeNode(rawList,rawMap);
-	}
-
-	public static class AttributeTestImpl extends AttributesTest
-	{
-
-		@Override
-		public Attributes instance()
-		{
-			return DefaultTreeNodeAttributesTest.instance().getAttributes();
-		}
-
-	}
-
-	/*public static class EditableAttributesTestImpl extends EditableAttributesTest<DefaultTreeNode>
-	{
-
-		@Override
-		public DefaultTreeNodeAttribute instance()
-		{
-			DefaultTreeNode instance = DefaultTreeNodeAttributesTest.instance();
-			return instance.getAttributes();
-		}
-
-	}*/
-}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/impl/clonable/DefaultTreeNodeChildrenTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,45 +0,0 @@
-/*package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.impl.clonable;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.nodeeditor.EditableChildrenTest;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.treeeditor.TreeNodeChildrenTest;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.EditableNodeWrapper;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableChildren;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
-import junit.framework.TestCase;
-import junit.framework.TestSuite;
-
-public class DefaultTreeNodeChildrenTest extends TestCase
-{
-	public static TestSuite suite()
-	{
-		TestSuite suite = new TestSuite();
-		suite.addTestSuite(EditableChildrenTestImpl.class);
-		suite.addTestSuite(TreeNodeChildrenTestImpl.class);
-		return suite;
-	}
-
-	public static DefaultTreeNode instance()
-	{
-		return new DefaultTreeNode();
-	}
-
-	public static class TreeNodeChildrenTestImpl extends TreeNodeChildrenTest<DefaultTreeNode>
-	{
-		@Override
-		public DefaultTreeNode instance()
-		{
-			return DefaultTreeNodeChildrenTest.instance();
-		}
-	}
-
-	public static class EditableChildrenTestImpl extends EditableChildrenTest<EditableNodeWrapper<DefaultTreeNode>>
-	{
-		@Override
-		public EditableChildren<EditableNodeWrapper<DefaultTreeNode>> instance()
-		{
-			DefaultTreeNode wrap = DefaultTreeNodeChildrenTest.instance();
-			EditableNodeWrapper<DefaultTreeNode> wrapper = new EditableNodeWrapper<DefaultTreeNode>(wrap);
-			return wrapper.getChildren();
-		}
-	}
-}*/
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/impl/clonable/DefaultTreeNodeTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,55 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.impl.clonable;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
-import junit.framework.Assert;
-import junit.framework.TestCase;
-import junit.framework.TestSuite;
-
-public class DefaultTreeNodeTest extends TestCase
-{
-	public static TestSuite suite()
-	{
-		TestSuite suite = new TestSuite();
-		//suite.addTestSuite(AttributesContaierTestImpl.class);
-		//suite.addTestSuite(ParentTestImpl.class);
-		return suite;
-	}
-
-	public static DefaultTreeNode instance()
-	{
-		DefaultTreeNode node = new DefaultTreeNode();
-		return node;
-	}
-
-	public void testGetWrapped()
-	{
-		DefaultTreeNode instance = instance();
-	}
-
-	public void testCreateNewNode()
-	{
-		DefaultTreeNode instance = instance();
-		DefaultTreeNode node = instance.createNewNode();
-
-		Assert.assertNotNull(node);
-	}
-
-//	public static class AttributesContaierTestImpl extends AttributesContainerTest
-//	{
-//		@Override
-//		public AttributesContainer instance()
-//		{
-//			return DefaultTreeNodeTest.instance();
-//		}
-//	}
-
-	/*public static class ParentTestImpl extends ParentTest<DefaultTreeNode>
-	{
-
-		@Override
-		public DefaultTreeNode instance()
-		{
-			return DefaultTreeNodeTest.instance();
-		}
-	}*/
-}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/impl/node/DefaultAttributesTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,54 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.impl.node;
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.AttributesTest;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNodeAttributes;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
-import org.junit.Assert;
-
-import java.nio.ByteBuffer;
-import java.util.Optional;
-
-public class DefaultAttributesTest extends AttributesTest
-{
-	public TreeNodeAttributes instance()
-	{
-		List<TreeNode> rawList = new List();
-		TreeMap<String,ByteBuffer> rawMap = new TreeMap();
-
-		// add attributes
-
-		for(Pair<String, ByteBuffer> entry : ENTRIES){
-			rawMap = rawMap.put(entry.left(),entry.right());
-		}
-
-		TreeNode node = new DefaultTreeNode(rawList,rawMap);
-		return node.getAttributes();
-	}
-
-	public void testGetAttributesAsRawMap()
-	{
-		TreeNodeAttributes attrs = instance();
-		TreeMap<String,ByteBuffer> rawMap = attrs.getAttributesAsRawMap();
-
-		// testing rawmap is not null.
-		Assert.assertNotNull(rawMap);
-
-		// testing rawmap has correct key values.
-		for(Pair<String,ByteBuffer> entry : ENTRIES){
-			String key = entry.left();
-			ByteBuffer value = entry.right();
-
-			Optional<ByteBuffer> option = rawMap.get(key);
-			if(!option.isPresent()){
-				Assert.fail();
-			}
-
-			ByteBuffer actual = option.get();
-			Assert.assertEquals(0,actual.compareTo(value));
-		}
-	}
-}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/impl/node/DefaultChildrenTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,44 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.impl.node;
-
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.ChildrenTest;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNodeChildren;
-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
-import org.junit.Assert;
-
-import java.nio.ByteBuffer;
-
-public class DefaultChildrenTest extends ChildrenTest<TreeNode>
-{
-
-	@Override
-	public DefaultTreeNodeChildren instance()
-	{
-		List<TreeNode> rawList = new List();
-		for(int i = 0;i < expectSize();i ++){
-			rawList = rawList.addLast(new DefaultTreeNode());
-		}
-
-		TreeMap<String,ByteBuffer> rawMap =  new TreeMap();
-
-		return new DefaultTreeNode(rawList,rawMap).getChildren();
-	}
-
-	@Override
-	public int expectSize()
-	{
-		return 3;
-	}
-
-	public void testGetChildrenAsRawList()
-	{
-		DefaultTreeNodeChildren instance = instance();
-		List<TreeNode> rawList = instance.getChildrenAsRawList();
-
-		Assert.assertNotNull(rawList);
-		Assert.assertEquals(expectSize(),rawList.length());
-	}
-}
\ No newline at end of file
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/impl/node/DefaultNodeTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,55 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.impl.node;
-
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
-import junit.framework.TestCase;
-import junit.framework.TestSuite;
-
-import java.nio.ByteBuffer;
-
-public class DefaultNodeTest extends TestCase
-{
-	public DefaultNodeTest(String _name)
-	{
-		super(_name);
-	}
-
-	public static TestSuite suite()
-	{
-		TestSuite suite = new TestSuite();
-		//suite.addTestSuite(DefaultNodeTest.AttributesContaierTestImpl.class);
-		//suite.addTestSuite(DefaultNodeTest.ParentTestImpl.class);
-		return suite;
-	}
-
-	public static DefaultTreeNode instance()
-	{
-		List<TreeNode> rawList = new List();
-		TreeMap<String,ByteBuffer> rawMap = new TreeMap();
-		DefaultTreeNode node = new DefaultTreeNode(rawList,rawMap);
-
-		return node;
-	}
-
-//	public static class AttributesContaierTestImpl extends AttributesContainerTest
-//	{
-//		@Override
-//		public AttributesContainer instance()
-//		{
-//			return DefaultNodeTest.instance();
-//		}
-////	}
-
-	/*public static class ParentTestImpl extends ParentTest<DefaultTreeNode>
-	{
-
-		@Override
-		public DefaultTreeNode instance()
-		{
-			return DefaultNodeTest.instance();
-		}
-	}*/
-}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/tests/util/TestUtil.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,44 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.tests.util;
-
-import java.nio.ByteBuffer;
-
-import org.junit.Ignore;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-@Ignore
-public class TestUtil
-{
-	public static TreeNode createMockTree(int _maxDepth)
-	{
-		return _createMockTree(1,_maxDepth,new DefaultNodePath());
-	}
-
-	public static TreeNode _createMockTree(int _currentDepth,int _maxDepth,NodePath _path)
-	{
-		TreeNode parent = new DefaultTreeNode();
-		Either<Error, TreeNode> either = parent.getAttributes().put("KEY",ByteBuffer.wrap(_path.toString().getBytes()));
-		if(either.isA()){
-			return null;
-		}
-		parent = either.b();
-
-		if(_currentDepth != _maxDepth){
-			for(int i = 0;i <= _currentDepth;i ++){
-				TreeNode ch = _createMockTree(_currentDepth + 1,_maxDepth,_path.add(i));
-				either = parent.getChildren().addNewChildAt(i,ch);
-				if(either.isA()){
-					return null;
-				}
-				parent = either.b();
-			}
-		}
-
-		return parent;
-	}
-}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverse/BruteForceTraverserTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,87 +0,0 @@
-/*package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverse;
-
-import java.nio.ByteBuffer;
-import java.util.Iterator;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
-import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.SearchQuery;
-import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.UpdateQuery;
-import junit.framework.TestCase;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-public abstract class BruteForceTraverserTest extends TestCase{
-	public abstract InterfaceTraverser instance(TreeNode node);
-
-	@Test
-	public void testSearch()	{
-		int maxHeight = 3;
-		Pair<TreeNode, NodePath> test = null;
-		TreeNode root = createTree(0,0,maxHeight,new DefaultNodePath());
-		InterfaceTraverser traverser = instance(root);
-		Iterator<Pair<TreeNode, NodePath>> itNode = traverser.find(new SearchQuery("KEY","<-1,0,0>"));
-		for(;itNode.hasNext(); ){
-			test = itNode.next();
-		}
-		String str = new String(test.left().getAttributes().get("KEY").array());
-		Assert.assertEquals(str,"<-1,0,0>");
-	}
-
-	@Test
-	public void testUpdate()	{
-		int maxHeight = 3;
-		Pair<TreeNode, NodePath> test = null;
-		TreeNode root = createTree(0,0,maxHeight,new DefaultNodePath());
-		InterfaceTraverser traverser = instance(root);
-		JungleTreeEditor editor = traverser.update(new UpdateQuery("KEY", "<-1,0,0>", "tatsuki"));
-		traverser.set(editor.getRoot());
-		Iterator<Pair<TreeNode, NodePath>> checkNode = traverser.find(new SearchQuery("KEY","tatsuki"));
-		for(;checkNode.hasNext(); ){
-			test = checkNode.next();
-		}
-		String str = new String(test.left().getAttributes().get("KEY").array());
-		Assert.assertEquals(str,"tatsuki");
-	}
-
-	public static String key = "KEY";
-	public static ByteBuffer value = ByteBuffer.wrap(key.getBytes());
-	public static DefaultTreeNode factory = new DefaultTreeNode();
-
-	public static TreeNode createTree(int _curX,int _curY,int _maxHeight,NodePath _address)
-	{
-		System.out.println(_address.toString());
-		TreeNode parent = factory.createNewNode();
-		Either<Error,TreeNode> either = parent.getAttributes().put(key,ByteBuffer.wrap(_address.toString().getBytes()));
-		if(either.isA()){
-			Assert.fail();
-		}
-		parent = either.b();
-
-		if(_curY == _maxHeight){
-			return parent;
-		}
-
-		for(int i = 0;i < _curY + 1;i ++){
-			TreeNode ch = createTree(i,_curY + 1,_maxHeight,_address.add(i));
-			either = parent.getChildren().addNewChildAt(i,ch);
-			if(either.isA()){
-				Assert.fail();
-			}
-
-			parent = either.b();
-		}
-
-		return parent;
-	}
-
-}
-*/
\ No newline at end of file
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverse/TraverserTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,108 +0,0 @@
-/*
-package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverse;
-
-import jp.ac.u_ryukyu.ie.cr.list.List;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultEvaluator;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Direction;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Traversal;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Traverser;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import junit.framework.TestCase;
-import org.junit.Assert;
-
-import java.nio.ByteBuffer;
-
-public abstract class TraverserTest extends TestCase
-{
-	public abstract Traverser instance();
-
-	public void testTraverse()
-	{
-		int maxHeight = 3;
-		TreeNode root = createTree(0,0,maxHeight,new DefaultNodePath());
-
-		//TraversableNodeWrapper<DefaultTreeNode> traversable = new TraversableNodeWrapper<DefaultTreeNode>(root);
-		Traverser traverser = instance();
-
-		// generate all pattern.
-		List<DefaultNodePath> paths = generatePathPattern(new DefaultNodePath(),0,maxHeight);
-		paths = paths.addLast(new DefaultNodePath());
-
-		for(DefaultNodePath path : paths){
-			DefaultEvaluator evaluator = new DefaultEvaluator(path);
-			Either<Error,Traversal> ret = traverser.traverse(root,evaluator);
-			if(ret.isA()){
-				Assert.fail();
-			}
-
-			Traversal traversal = ret.b();
-			TreeNode target = traversal.destination();
-			String expect = path.toString();
-			ByteBuffer value = target.getAttributes().get(key);
-			String actual = new String(value.array());
-			Assert.assertEquals(expect,actual);
-
-			List<DefaultNodePath> parts = path.inits();
-
-			for(Direction<TreeNode> d : traversal){
-				DefaultNodePath part = parts.head();
-				parts = parts.last();
-				value = d.getTarget().getAttributes().get(key);
-				String actualCurrentPathStr = new String(value.array());
-				String expectCurrentPathStr = part.toString();
-				Assert.assertEquals(expectCurrentPathStr,actualCurrentPathStr);
-			}
-		}
-	}
-
-	public List<DefaultNodePath> generatePathPattern(DefaultNodePath _cur,int _curHeight,int _maxHeight)
-	{
-		List<DefaultNodePath> paths = List.nil();
-		for(int p = 0;p <= _curHeight;p ++){
-			DefaultNodePath path = _cur.add(p);
-			if(_curHeight != _maxHeight - 1){
-				List<DefaultNodePath> newpaths = generatePathPattern(path,_curHeight+1,_maxHeight);
-				paths = paths.append(newpaths);
-			}
-			paths = paths.cons(path);
-		}
-
-		return paths;
-	}
-
-	public static String key = "KEY";
-	public static ByteBuffer value = ByteBuffer.wrap(key.getBytes());
-	public static DefaultTreeNode factory = new DefaultTreeNode();
-
-	public TreeNode createTree(int _curX,int _curY,int _maxHeight,NodePath _address)
-	{
-		TreeNode parent = factory.createNewNode();
-		Either<Error,TreeNode> either = parent.getAttributes().put(key,ByteBuffer.wrap(_address.toString().getBytes()));
-		if(either.isA()){
-			Assert.fail();
-		}
-		parent = either.b();
-
-		if(_curY == _maxHeight){
-			return parent;
-		}
-
-		for(int i = 0;i < _curY + 1;i ++){
-			TreeNode ch = createTree(i,_curY + 1,_maxHeight,_address.add(i));
-			either = parent.getChildren().addNewChildAt(i,ch);
-			if(either.isA()){
-				Assert.fail();
-			}
-
-			parent = either.b();
-		}
-
-		return parent;
-	}
-}
-*/
\ No newline at end of file
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/parentIndexTest.java	Tue May 19 15:15:34 2015 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,47 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.index;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
-import junit.framework.Assert;
-import org.junit.Test;
-
-import java.nio.ByteBuffer;
-
-/**
- * Created by e115731 on 15/05/06.
- */
-public class parentIndexTest {
-    @Test
-    public void parentIndex() {
-        Jungle jungle = new DefaultJungle(null, "hogehoge", new DefaultTreeEditor(new DefaultTraverser()));
-        jungle.createNewTree("tree");
-        JungleTree tree = jungle.getTreeByName("tree");
-        JungleTreeEditor editor = tree.getTreeEditor();
-
-        DefaultNodePath path = new DefaultNodePath();
-        for (int count = 0; count < 100; count++) {
-            editor = editor.addNewChildAt(path, 0).b();
-            path = path.add(0);
-            editor = editor.putAttribute(path, "KEY", ByteBuffer.wrap(("tatsuki" + count).getBytes())).b();
-        }
-
-        Either<Error, JungleTreeEditor> either = editor.success();
-        Assert.assertTrue(either.isB());
-        TreeNode node = tree.getNodeOfPath(path).b();
-        ParentIndex parentIndex = tree.getParentIndex();
-        for (int count = 99; count >= 0; count--) {
-            String attribute = node.getAttributes().getString("KEY");
-            Assert.assertEquals(attribute, "tatsuki" + count);
-            node = parentIndex.get(node);
-        }
-    }
-}
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/list/appendTest.java	Tue May 19 15:15:34 2015 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/list/appendTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -1,6 +1,6 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.list;

-import jp.ac.u_ryukyu.ie.cr.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
 import junit.framework.Assert;
 import org.junit.Test;
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/list/deleteTest.java	Tue May 19 15:15:34 2015 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/list/deleteTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -1,6 +1,6 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.list;

-import jp.ac.u_ryukyu.ie.cr.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
 import junit.framework.Assert;
 import org.junit.Test;
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/list/listAdd.java	Tue May 19 15:15:34 2015 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/list/listAdd.java	Tue Jul 28 08:32:58 2015 +0900
@@ -1,6 +1,6 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.list;

-import jp.ac.u_ryukyu.ie.cr.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
 import junit.framework.Assert;
 import org.junit.Test;

@@ -26,20 +26,12 @@
             Assert.assertEquals(num,count);
             Assert.assertEquals(num2,count);
         }
-        Assert.assertEquals(list.length(), 10);
+
+        List<Integer> newList = list.add(5, 50);
         int num = list.index(5);
-        Assert.assertEquals(num, 5);
-        List<Integer> newList = list.add(5, 1000);
-        num = newList.index(5);
-        Assert.assertEquals(num, 1000);
-        num = list.index(5);
-        Assert.assertEquals(num, 5);
-        list = list.add(1000, 1001);
-        num = list.index(5);
-        Assert.assertEquals(num, 5);
-        list = list.add(0,0);
-        num = list.index(0);
-        Assert.assertEquals(num, 0);
+        int num2 = newList.index(5);
+        Assert.assertEquals(num,5);
+        Assert.assertEquals(num2,50);

     }
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/list/listIterator.java	Tue May 19 15:15:34 2015 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/list/listIterator.java	Tue Jul 28 08:32:58 2015 +0900
@@ -1,6 +1,6 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.list;

-import jp.ac.u_ryukyu.ie.cr.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
 import junit.framework.Assert;
 import org.junit.Test;
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/list/replaceTest.java	Tue May 19 15:15:34 2015 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/list/replaceTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -1,6 +1,6 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.list;

-import jp.ac.u_ryukyu.ie.cr.list.List;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
 import junit.framework.Assert;
 import org.junit.Test;
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/treemap/TreeMapDelete.java	Tue May 19 15:15:34 2015 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/treemap/TreeMapDelete.java	Tue Jul 28 08:32:58 2015 +0900
@@ -1,7 +1,7 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.treemap;

-import jp.ac.u_ryukyu.ie.cr.treemap.RotateParent;
-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.RotateParent;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
 import org.junit.Test;

 import java.util.ArrayList;
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/treemap/TreeMapTest.java	Tue May 19 15:15:34 2015 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/treemap/TreeMapTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -1,6 +1,6 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.treemap;

-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;

 import java.util.Optional;
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/treemap/TreeNodeIteratorTest.java	Tue May 19 15:15:34 2015 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/treemap/TreeNodeIteratorTest.java	Tue Jul 28 08:32:58 2015 +0900
@@ -1,6 +1,6 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.treemap;

-import jp.ac.u_ryukyu.ie.cr.treemap.TreeMap;
+import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
 import junit.framework.Assert;
 import org.junit.Test;