# HG changeset patch
# User one
# Date 1413888445 -32400
# Node ID f46a6e0e459460987432b2753eae42aac2edf7da
# Parent  c4846688f635bade99b1aa47fd86e3729034788f
add deleteIndexEditor

diff -r c4846688f635 -r f46a6e0e4594 src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java	Sun Oct 19 18:34:58 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java	Tue Oct 21 19:47:25 2014 +0900
@@ -20,6 +20,7 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TreeContext;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
+import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexManager;
 
 
 public class DefaultJungleTree implements JungleTree
@@ -43,7 +44,8 @@
 		TreeContext tc = repository.get();
 		DefaultTransactionManager txManager = new DefaultTransactionManager(writer,tc,repository,uuid);
 		TreeNode root = tc.getTreeNode();
-		return new DefaultJungleTreeEditor(root,txManager,editor);
+		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index = getIndex();
+		return new DefaultJungleTreeEditor(root,txManager,editor,index);
 	}
 	
 	@Override
@@ -74,10 +76,11 @@
 	@Override
 	public InterfaceTraverser getTraverser() {
 		AtomicReservableReference<TreeContext>.Reservation reservation = repository.getReservation();
+		IndexManager indexManager = new IndexManager(reservation);
 		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index = getIndex();
 		if (index != null)
-			return new InterfaceTraverser(getRootNode(), index, reservation);
-		return new InterfaceTraverser(getRootNode(),reservation);
+			return new InterfaceTraverser(getRootNode(), index, indexManager);
+		return new InterfaceTraverser(getRootNode(),indexManager);
 	}
 	
 	@Override
diff -r c4846688f635 -r f46a6e0e4594 src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultJungleTreeEditor.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultJungleTreeEditor.java	Sun Oct 19 18:34:58 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultJungleTreeEditor.java	Tue Oct 21 19:47:25 2014 +0900
@@ -32,23 +32,26 @@
 	private final TreeNode root;
 	private final TreeEditor editor;
 	private final TreeOperationLog log;
-	
+	private final TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index;
 //	public DefaultJungleTreeEditor(TreeNode root)
 //	{
 //	    this(root,txManager,_editor,new DefaultTreeOperationLog());
 //	}
 
-	public DefaultJungleTreeEditor(TreeNode _root,TransactionManager _txManager,TreeEditor _editor)
+	public DefaultJungleTreeEditor(TreeNode _root,TransactionManager _txManager,TreeEditor _editor,	TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index)
 	{
-		this(_root,_txManager,_editor,new DefaultTreeOperationLog());
+		this(_root,_txManager,_editor,new DefaultTreeOperationLog(),index);
 	}
 	
-	public DefaultJungleTreeEditor(TreeNode newNode,TransactionManager _txManager,TreeEditor _editor,TreeOperationLog _log)
+	
+	
+	public DefaultJungleTreeEditor(TreeNode newNode,TransactionManager _txManager,TreeEditor _editor,TreeOperationLog _log,	TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index)
 	{
 		this.root = newNode;
 		this.txManager = _txManager;
 		this.editor = _editor;
 		this.log = _log;
+		this.index = index;
 	}
 	
 	private Either<Error,JungleTreeEditor> _edit(final NodePath _path,NodeEditor _e)
@@ -73,7 +76,7 @@
 		DefaultTreeOperationLog treeOperationLog = new DefaultTreeOperationLog(iterable,newLog.length());
 		TreeOperationLog newTreeOpLog = log.append(treeOperationLog);
 		
-		JungleTreeEditor newEditor = new DefaultJungleTreeEditor(newNode,txManager,editor,newTreeOpLog);
+		JungleTreeEditor newEditor = new DefaultJungleTreeEditor(newNode,txManager,editor,newTreeOpLog,index);
 		return DefaultEither.newB(newEditor);
 	}
 	
@@ -114,13 +117,13 @@
 	@Override
 	public Either<Error,JungleTreeEditor> success()
 	{
-		Either<Error,TransactionManager> either = txManager.commit(root,log,null);
+		Either<Error,TransactionManager> either = txManager.commit(root,log,index);
 		if(either.isA()){
 			return DefaultEither.newA(either.a());
 		}
 		
 		TransactionManager newTxManager = either.b();
-		JungleTreeEditor newTreeEditor = new DefaultJungleTreeEditor(root,newTxManager,editor);
+		JungleTreeEditor newTreeEditor = new DefaultJungleTreeEditor(root,newTxManager,editor,index);
 		
 		return DefaultEither.newB(newTreeEditor);
 	}
diff -r c4846688f635 -r f46a6e0e4594 src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/IndexJungleTreeEditor.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/IndexJungleTreeEditor.java	Sun Oct 19 18:34:58 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/IndexJungleTreeEditor.java	Tue Oct 21 19:47:25 2014 +0900
@@ -107,7 +107,7 @@
 	public Either<Error,JungleTreeEditor> deleteChildAt(NodePath _path, int _pos)
 	{
 		DeleteChildAt deleteChildAt = new DeleteChildAt(_pos);
-		DeleteChildIndexEditor indexEditor = new DeleteChildIndexEditor();
+		DeleteChildIndexEditor indexEditor = new DeleteChildIndexEditor(_pos, _path);
 		Either<Error,IndexJungleTreeEditor> either = _edit(_path,deleteChildAt, indexEditor);
 		JungleTreeEditor editor = either.b();
 		Either<Error,JungleTreeEditor> newEither = DefaultEither.newB(editor);
@@ -154,7 +154,7 @@
 		}
 		
 		TransactionManager newTxManager = either.b();
-		JungleTreeEditor newTreeEditor = new DefaultJungleTreeEditor(root,newTxManager,editor);
+		JungleTreeEditor newTreeEditor = new DefaultJungleTreeEditor(root,newTxManager,editor,index);
 		
 		return DefaultEither.newB(newTreeEditor);
 	}
diff -r c4846688f635 -r f46a6e0e4594 src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java	Sun Oct 19 18:34:58 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java	Tue Oct 21 19:47:25 2014 +0900
@@ -21,41 +21,32 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.PathNodeIterator;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.Query;
+import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexManager;
 
 public class InterfaceTraverser {
 
 	//InterfaceTraverser traverser;
 	TreeNode node;
 	TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index;
-	AtomicReservableReference<TreeContext>.Reservation reservation;
+	IndexManager indexManager;
 
-	public InterfaceTraverser(TreeNode _root, AtomicReservableReference<TreeContext>.Reservation reservation) {
+	public InterfaceTraverser(TreeNode _root, IndexManager indexManager) {
 		this.node = _root;
 		this.index = TreeMap.empty(Ord.stringOrd);
-		this.reservation = reservation;
+		this.indexManager = indexManager;
 	}
 
 	public InterfaceTraverser(
 			TreeNode _root,
 			TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index,
-			AtomicReservableReference<TreeContext>.Reservation reservation) {
+			IndexManager indexManager) {
 		this.node = _root;
 		this.index = index;
-		this.reservation = reservation;
+		this.indexManager = indexManager;
 	}
 
 	public void commitIndex(){
-		TreeContext tc = reservation.get();
-		ChangeSet cs = tc.getChangeSet();
-		TreeNode root = cs.getRoot();
-		ChangeSet prev = cs.prev();
-		ChangeList cl = cs.getChangeList();
-		String uuid = cs.uuid();
-		String treeName = cs.getTreeName();
-		long revision = cs.revision();
-		ChangeSet newCs = new DefaultChangeSet(root, prev,cl, uuid, treeName, revision, index);
-		TreeContext newTc = new DefaultTreeContext(root, newCs);
-		reservation.set(newTc);
+		indexManager.commit(index);
 	}
 	
 	public TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> getIndex() {
@@ -80,7 +71,7 @@
 
 
 
-	public Iterator<Pair<TreeNode, NodePath>> find(final Query query, String key, String searchValue) {
+	public Iterator<Pair<TreeNode, NodePath>> find(Query query, String key, String searchValue) {
 		
 		if (index.get(key).isSome()) {
 
@@ -107,7 +98,6 @@
 						Pair<TreeNode, NodePath> pathNode = itNode.next();
 						String value = pathNode.left().getAttributes().getString(key);
 						Option<TreeMap<String, List<Pair<TreeNode, NodePath>>>> innerIndexOp = index.get(key);
-						System.out.println("value = "+ value);
 
 						if (value != null) {
 							if (innerIndexOp.isNone()) {
diff -r c4846688f635 -r f46a6e0e4594 src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/query/PathNodeIterator.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/query/PathNodeIterator.java	Sun Oct 19 18:34:58 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/query/PathNodeIterator.java	Tue Oct 21 19:47:25 2014 +0900
@@ -40,6 +40,7 @@
 	public Pair<TreeNode, NodePath> next() {
 		TreeNode now = node;
 		NodePath currentPath = path;
+		System.out.println("path = " + currentPath.toString());
 		if (node.getChildren().size() > 0) { // 
 			nodeStack.push(node);
 			path = path.add(0);
@@ -79,7 +80,6 @@
 				searchStack.push(++childNumber);
 			}
 		}
-		System.out.println("path = " + path.toString());
 		return new Pair<TreeNode, NodePath>(now, currentPath);
 	}
 
diff -r c4846688f635 -r f46a6e0e4594 src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DeleteChildIndexEditor.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DeleteChildIndexEditor.java	Sun Oct 19 18:34:58 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DeleteChildIndexEditor.java	Tue Oct 21 19:47:25 2014 +0900
@@ -1,20 +1,34 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index;
 
+import java.util.Iterator;
+
+import fj.F;
+import fj.Ord;
+import fj.P2;
 import fj.data.List;
+import fj.data.Option;
 import fj.data.TreeMap;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.IndexJungleTreeEditor;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TransactionManager;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
 
 public class DeleteChildIndexEditor implements IndexEditor {
 
+	NodePath editNodePath;
+
+	public DeleteChildIndexEditor(int pos, NodePath path) {
+		this.editNodePath = path.add(pos);
+	}
+
 	@Override
 	public Either<Error, IndexJungleTreeEditor> edit(
 			TreeNode root,
@@ -22,10 +36,91 @@
 			TreeEditor editor,
 			TreeOperationLog log,
 			TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index) {
-		// TODO Auto-generated method stub
-		return null;
+
+		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = editIndex(index);
+		IndexJungleTreeEditor newEditor = new IndexJungleTreeEditor(root, txManager, editor, newIndex);
+		return DefaultEither.newB(newEditor);
+	}
+
+	public TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> editIndex(
+			TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index) {
+
+		if (!index.isEmpty()) {
+			List<String> keyList = index.keys();
+			TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = TreeMap.empty(Ord.stringOrd);
+			TreeMap<String, List<Pair<TreeNode, NodePath>>> newInnerIndex = TreeMap.empty(Ord.stringOrd);
+
+			for (String indexKey : keyList) {
+				TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = index.get(indexKey).some();
+				List<String> innerIndexKeyList = innerIndex.keys();
+
+				for (String innerIndexKey : innerIndexKeyList) {
+					List<Pair<TreeNode, NodePath>> pairList = innerIndex.get(innerIndexKey).some();
+					List<Pair<TreeNode, NodePath>> list = checkPath(pairList);
+					if (!list.isEmpty()){
+						System.out.println(new String(list.head().left().getAttributes().get("KEY").array()));
+						newInnerIndex = newInnerIndex.set(innerIndexKey, list);
+					}
+				}
+				newIndex = newIndex.set(indexKey, newInnerIndex);
+			}
+			return newIndex;
+		} else {
+			return index;
+		}
 	}
 
+	public List<Pair<TreeNode, NodePath>> checkPath(List<Pair<TreeNode, NodePath>> pairList){
 
+		List<Pair<TreeNode, NodePath>> list = List.nil();
+		for (Pair<TreeNode, NodePath> pair : pairList) {
+
+			NodePath path = pair.right();
+			System.out.println("oldPath = " + path.toString());
+			NodePath newPath = new DefaultNodePath();
+			
+			if (path.toString().equals(editNodePath.toString())) {
+				continue;
+			}
+			
+			if (editNodePath.size() > path.size()) {
+				list = list.cons(pair);
+				continue;
+			}
+
+			Pair<Integer, NodePath> editNodePathCopy = editNodePath.pop();
+			int loopCount = 0;
+
+			for (Integer pathInt : path) {
+				loopCount++;
+
+				if (pathInt == -1)
+					continue;
+				if (editNodePathCopy.right().size() > 0) {
+					editNodePathCopy = editNodePathCopy.right().pop();
+					if (loopCount >= editNodePath.size()
+							&& editNodePathCopy.left() < pathInt) {
+						newPath = newPath.add(pathInt - 1);
+						continue;
+					}
+
+					if (!(editNodePathCopy.left() == pathInt)) {
+						newPath = path;
+						break;
+					}
+				}
+
+				newPath = newPath.add(pathInt);
+
+			}
+
+			System.out.println("newPath = " + newPath.toString());
+			Pair<TreeNode, NodePath> newPair = new Pair<TreeNode, NodePath>(
+					pair.left(), newPath);
+			list = list.cons(newPair);
+		}
+
+		return list;
+	}
 
 }
diff -r c4846688f635 -r f46a6e0e4594 src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexManager.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexManager.java	Tue Oct 21 19:47:25 2014 +0900
@@ -0,0 +1,38 @@
+package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index;
+
+
+import fj.data.List;
+import fj.data.TreeMap;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultChangeSet;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeContext;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TreeContext;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
+
+public class IndexManager {
+
+	AtomicReservableReference<TreeContext>.Reservation reservation;
+	
+	public IndexManager(AtomicReservableReference<TreeContext>.Reservation reservation){
+		this.reservation = reservation;
+	}
+	
+	public void commit(TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index){
+		TreeContext tc = reservation.get();
+		ChangeSet cs = tc.getChangeSet();
+		TreeNode root = cs.getRoot();
+		ChangeSet prev = cs.prev();
+		ChangeList cl = cs.getChangeList();
+		String uuid = cs.uuid();
+		String treeName = cs.getTreeName();
+		long revision = cs.revision();
+		DefaultChangeSet newCs = new DefaultChangeSet(root, prev, cl, uuid, treeName, revision, index);
+		DefaultTreeContext newTs = new DefaultTreeContext(root, newCs);
+		reservation.set(newTs);
+	}
+	
+}
diff -r c4846688f635 -r f46a6e0e4594 src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexPushThread.java
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexPushThread.java	Sun Oct 19 18:34:58 2014 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,80 +0,0 @@
-package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index;
-
-import java.nio.ByteBuffer;
-
-import javax.swing.tree.DefaultTreeCellEditor.EditorContainer;
-
-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.ChangeSet;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.Command;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.IndexJungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
-import fj.data.List;
-import fj.data.TreeMap;
-
-public class IndexPushThread extends Thread {
-
-	TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index;
-	JungleTree tree;
-	int logSize;
-
-	public IndexPushThread(TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index, int logSize) {
-		this.index = index;
-		this.tree = tree;
-		this.logSize = logSize;
-	}
-
-	public void run() {
-		//editor.setIndex(index);
-		//editor.success().isB();
-//		while (true) {
-//			
-//			if (logSize == tree.getLogSize()) {
-//				editor.setIndex(index);
-//				if (editor.success().isB())
-//					break;
-//			} else {
-//				editor =  tree.getIndexTreeEditor();
-//				 Iterable<TreeOperation> Changeset = tree.getLog();
-//				 int loopCount = 0;
-//				 
-//				 for(TreeOperation treeOp : Changeset) {
-//					loopCount++;
-//					if (loopCount >= logSize) {
-//						NodePath path = treeOp.getNodePath();
-//						NodeOperation NodeOperation = treeOp.getNodeOperation();
-//						Command c = NodeOperation.getCommand();
-//
-//						switch (c) {
-//						case PUT_ATTRIBUTE://ここ以下でIndexEditorを使ってindexの更新を行う
-//							String key = NodeOperation.getKey();
-//							ByteBuffer value = NodeOperation.getValue();
-//							
-//							//return editor.putAttribute(path, key, value);
-//						case DELETE_ATTRIBUTE:
-//							key = NodeOperation.getKey();
-//							//return editor.deleteAttribute(path, key);
-//						case APPEND_CHILD:
-//							//return editor.addNewChildAt(path, pos);
-//						case DELETE_CHILD:
-//							//return editor.deleteChildAt(path, 0);
-//						}
-//					}
-//				 }
-//				 
-//				 logSize = loopCount;
-//				 editor.setIndex(index);
-//				 if (editor.success().isB())
-//						break;
-//				 
-//			}
-//			editor = tree.getIndexTreeEditor();
-//		}
-	}
-	
-}
diff -r c4846688f635 -r f46a6e0e4594 src/test/java/ip/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/IndexCommitTest.java
--- a/src/test/java/ip/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/IndexCommitTest.java	Sun Oct 19 18:34:58 2014 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,127 +0,0 @@
-package ip.ac.u_ryukyu.ie.cr.tatsuki.jungle.index;
-
-import java.util.Iterator;
-
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.IndexJungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
-import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexPushThread;
-import junit.framework.Assert;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-
-import java.nio.ByteBuffer;
-
-import javax.swing.tree.DefaultTreeCellEditor.EditorContainer;
-
-import org.junit.Test;
-import org.junit.experimental.theories.suppliers.TestedOn;
-
-import fj.data.List;
-import fj.data.Option;
-import fj.data.TreeMap;
-
-public class IndexCommitTest {
-
-	@Test
-	public void IndexCommitTest() throws InterruptedException {
-		
-		Jungle jungle = new DefaultJungle(null, "hogehoge",
-				new DefaultTreeEditor(new DefaultTraverser()));
-		jungle.createNewTree("tree");
-		JungleTree tree = jungle.getTreeByName("tree");
-		createTree(tree);
-		tree.getRootNode();
-		InterfaceTraverser ifTraverser = tree.getTraverser();
-
-		 ifTraverser.find((TreeNode node) -> {
-			ByteBuffer attribute = node.getAttributes().get(key);
-			if (attribute != null) {
-				byte[] byteAttribute = attribute.array();
-				String str = new String(byteAttribute);
-				System.out.println("attribute = " + str);
-				return str.equals("<-1,0,1>");
-			}
-			return false;
-		}, key, "<-1,0,1>");
-
-		//check index
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index = ifTraverser.getIndex();
-		Option<TreeMap<String, List<Pair<TreeNode, NodePath>>>> opIndex = index.get(key);
-		Assert.assertTrue(!opIndex.isNone());
-		TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = opIndex.some();
-		Assert.assertTrue(!innerIndex.get("<-1,0,0>").isNone());
-
-		JungleTreeEditor editor = tree.getTreeEditor();
-		Either<Error, JungleTreeEditor> either = editor.addNewChildAt(new DefaultNodePath(), 0);
-		editor = either.b();
-		editor.success();
-		
-		ifTraverser.commitIndex();
-		JungleTree newTree = jungle.getTreeByName("tree");
-		InterfaceTraverser newIfTraverser = newTree.getTraverser();
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = newIfTraverser.getIndex();
-		Assert.assertTrue(newIndex.isEmpty());
-		
-		
-
-	}
-
-	public boolean compare(TreeNode compareNode, String compareAttribute) {
-		String labName = compareNode.getAttributes().getString(key);
-		if (labName.equals(compareAttribute))
-			return true;
-		return false;
-	}
-
-	public static String key = "KEY";
-	public static DefaultTreeNode factory = new DefaultTreeNode();
-
-	public void createTree(JungleTree tree) {
-		NodePath root = new DefaultNodePath();
-		createChildren(tree, root, 0);
-
-		for (int x = 0; x < 2; x++) {
-			createChildren(tree, root.add(0), x);
-			for (int y = 0; y < 2; y++) {
-				createChildren(tree, root.add(0).add(x), y);
-			}
-		}
-
-	}
-
-	public void createChildren(JungleTree tree, NodePath root, int num) {
-		JungleTreeEditor editor = tree.getTreeEditor();// Treeのeditorを作成
-		Either<Error, JungleTreeEditor> either = editor
-				.addNewChildAt(root, num); // 新しく入れるところへのパス
-		if (either.isA()) {
-			Assert.fail();
-		}
-		editor = either.b();
-		either = editor.success();
-		if (either.isA()) {
-			Assert.fail();
-		}
-		NodePath childPath = root.add(num);
-		editor = tree.getTreeEditor();
-		NodePath attribute = root.add(num);
-		System.out.println(attribute.toString());
-		either = editor.putAttribute(childPath, key,
-				ByteBuffer.wrap(attribute.toString().getBytes()));
-		if (either.isA()) {
-			Assert.fail();
-		}
-		editor = either.b();
-		either = editor.success();
-	}
-}
diff -r c4846688f635 -r f46a6e0e4594 src/test/java/ip/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/IndexFormTest.java
--- a/src/test/java/ip/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/IndexFormTest.java	Sun Oct 19 18:34:58 2014 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,105 +0,0 @@
-package ip.ac.u_ryukyu.ie.cr.tatsuki.jungle.index;
-
-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.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.TreeNodeAttributes;
-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 jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-import fj.Ord;
-import fj.data.List;
-import fj.data.Option;
-import fj.data.TreeMap;
-
-public class IndexFormTest {
-
-	TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index = TreeMap
-			.empty(Ord.stringOrd);
-
-	@Test
-	public void IndexFormTest() {
-
-		NodePath path = new DefaultNodePath();
-		TreeNode node = createTree(3, 0, 3, path);
-		TreeMap<String, List<Pair<TreeNode, NodePath>>> map = index.get(key).some();
-		Option<List<Pair<TreeNode, NodePath>>> opList = map.get("<-1,0,0,2>");
-		List<Pair<TreeNode, NodePath>> list = opList.some();
-		Pair<TreeNode, NodePath> Pair = list.head();
-		NodePath newPath = Pair.right();
-		String pathStr = newPath.toString();
-		Assert.assertEquals(pathStr,"<-1,0,0,2>");
-		System.out.println("aaa");
-	}
-
-	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();
-		}
-		editIndex(parent, _address, _address.toString(), key);
-		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;
-	}
-
-
-	public void editIndex(TreeNode node, NodePath path, String attribute,String key) {
-
-		Pair<TreeNode, NodePath> pair = new Pair<TreeNode, NodePath>(node, path);
-		Option<TreeMap<String, List<Pair<TreeNode, NodePath>>>> opAttributeList = index.get(key);
-
-		if (opAttributeList.isNone()) {
-			TreeMap<String, List<Pair<TreeNode, NodePath>>> nodeIndex = TreeMap.empty(Ord.stringOrd);
-			List<Pair<TreeNode, NodePath>> list = List.nil();
-			list = list.cons(pair);
-			nodeIndex = nodeIndex.set(attribute, list);
-			index = index.set(key, nodeIndex);
-		} else {
-			TreeMap<String, List<Pair<TreeNode, NodePath>>> indexMap = opAttributeList.some();
-			Option<List<Pair<TreeNode, NodePath>>> opNodeIndex = indexMap.get(attribute);
-
-			if (opNodeIndex.isNone()) {
-				List<Pair<TreeNode, NodePath>> pairList = List.nil();
-				pairList = pairList.cons(pair);
-				indexMap = indexMap.set(attribute, pairList);
-
-			} else {
-				List<Pair<TreeNode, NodePath>> pairList = opNodeIndex.some();
-				pairList = pairList.cons(pair);
-				indexMap = indexMap.set(attribute, pairList);
-			}
-		index = index.set(key, indexMap);
-		}
-	System.out.println(attribute);
-
-	}
-
-}
diff -r c4846688f635 -r f46a6e0e4594 src/test/java/ip/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/IndexTest.java
--- a/src/test/java/ip/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/IndexTest.java	Sun Oct 19 18:34:58 2014 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,61 +0,0 @@
-package ip.ac.u_ryukyu.ie.cr.tatsuki.jungle.index;
-
-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.NodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.IndexJungleTreeEditor;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
-import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexEditor;
-import junit.framework.Assert;
-
-import org.junit.Test;
-
-import fj.data.List;
-import fj.data.Option;
-import fj.data.TreeMap;
-
-public class IndexTest {
-
-	@Test
-	public void IndexTest(){
-		
-		DefaultJungle jungle = new DefaultJungle(null,"hoge",new DefaultTreeEditor(new DefaultTraverser()));
-		JungleTree tree = jungle.createNewTree("fuga");
-		IndexJungleTreeEditor editor = tree.getIndexTreeEditor();
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> emptyIndex = editor.getIndex();
-		Assert.assertTrue(emptyIndex.isEmpty());
-		NodePath path = new DefaultNodePath();
-		Either<Error, JungleTreeEditor> either = editor.addNewChildAt(path, 0);
-		Assert.assertFalse(either.isA());
-		
-		JungleTreeEditor editor2 = either.b();
-		Either<Error, JungleTreeEditor> either2 = editor2.putAttribute(path.add(0),"key", ByteBuffer.wrap("test".toString().getBytes()));
-		Assert.assertFalse(either2.isA());
-		JungleTreeEditor editor3 = either2.b();
-		editor3.success();
-		
-		IndexJungleTreeEditor IndexEditor = tree.getIndexTreeEditor();
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index = IndexEditor.getIndex();
-		Assert.assertFalse(index.isEmpty());
-		
-		JungleTreeEditor editor4 = tree.getIndexTreeEditor();
-		Either<Error, JungleTreeEditor> either3 = editor4.deleteAttribute(path.add(0), "key");
-		Assert.assertFalse(either3.isA());
-		JungleTreeEditor editor5 = either3.b();
-		editor5.success();
-		
-		IndexJungleTreeEditor IndexEditor2 = tree.getIndexTreeEditor();
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> deleteIndex = IndexEditor2.getIndex();		
-		Assert.assertTrue(deleteIndex.isEmpty());
-
-	}
-}
diff -r c4846688f635 -r f46a6e0e4594 src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/AttributeIndexTest.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/AttributeIndexTest.java	Tue Oct 21 19:47:25 2014 +0900
@@ -0,0 +1,57 @@
+package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.index;
+
+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.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.IndexJungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
+import junit.framework.Assert;
+import fj.data.List;
+import fj.data.TreeMap;
+
+public class AttributeIndexTest {
+
+	@Test
+	public void PutAttributeIndexTest(){
+		DefaultJungle jungle = new DefaultJungle(null,"hoge",new DefaultTreeEditor(new DefaultTraverser()));
+		JungleTree tree = jungle.createNewTree("fuga");
+		IndexJungleTreeEditor editor = tree.getIndexTreeEditor();
+		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> emptyIndex = editor.getIndex();
+		Assert.assertTrue(emptyIndex.isEmpty());
+		NodePath path = new DefaultNodePath();
+		Either<Error, JungleTreeEditor> either = editor.addNewChildAt(path, 0);
+		Assert.assertFalse(either.isA());
+		
+		JungleTreeEditor editor2 = either.b();
+		Either<Error, JungleTreeEditor> either2 = editor2.putAttribute(path.add(0),"key", ByteBuffer.wrap("test".toString().getBytes()));
+		Assert.assertFalse(either2.isA());
+		JungleTreeEditor editor3 = either2.b();
+		editor3.success();
+		
+		IndexJungleTreeEditor IndexEditor = tree.getIndexTreeEditor();
+		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index = IndexEditor.getIndex();
+		
+		Assert.assertEquals(index.get("key").some().get("test").some().head().left().getAttributes().getString("key"),"test");
+		
+		JungleTreeEditor editor4 = tree.getIndexTreeEditor();
+		Either<Error, JungleTreeEditor> either3 = editor4.deleteAttribute(path.add(0), "key");
+		Assert.assertFalse(either3.isA());
+		JungleTreeEditor editor5 = either3.b();
+		editor5.success();
+		
+		IndexJungleTreeEditor IndexEditor2 = tree.getIndexTreeEditor();
+		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> deleteIndex = IndexEditor2.getIndex();		
+		Assert.assertTrue(deleteIndex.isEmpty());
+	}
+}
diff -r c4846688f635 -r f46a6e0e4594 src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/DeleteChildrenTest.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/DeleteChildrenTest.java	Tue Oct 21 19:47:25 2014 +0900
@@ -0,0 +1,109 @@
+package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.index;
+
+import java.nio.ByteBuffer;
+import java.util.Iterator;
+
+import org.junit.Test;
+import org.junit.experimental.theories.suppliers.TestedOn;
+
+import fj.data.List;
+import fj.data.Option;
+import fj.data.TreeMap;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.IndexJungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.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 junit.framework.Assert;
+
+public class DeleteChildrenTest {
+
+	@Test
+	public void DeleteChildrenTest(){
+		Jungle jungle = new DefaultJungle(null, "hogehoge",new DefaultTreeEditor(new DefaultTraverser()));
+		jungle.createNewTree("tree");
+		JungleTree tree = jungle.getTreeByName("tree");
+		createTree(tree);
+		tree.getRootNode();
+		InterfaceTraverser ifTraverser = tree.getTraverser();
+
+		Iterator<Pair<TreeNode, NodePath>> pairIterator = ifTraverser.find((TreeNode node) -> {
+			ByteBuffer attribute = node.getAttributes().get(key);
+			if (attribute != null) {
+				byte[] byteAttribute = attribute.array();
+				String str = new String(byteAttribute);
+				System.out.println("attribute = " + str);
+				return str.equals("<-1,0,1>");
+			}
+			return false;
+		}, key, "<-1,0,1>");
+
+		 for (;pairIterator.hasNext();pairIterator.next()) {
+			 
+		 }
+		//check index
+		ifTraverser.commitIndex();
+		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index = ifTraverser.getIndex();
+		Assert.assertTrue(index.get(key).some().get("<-1,0,0>").isSome());
+		
+		IndexJungleTreeEditor editor = tree.getIndexTreeEditor();
+		Either<Error, JungleTreeEditor> either = editor.deleteChildAt(new DefaultNodePath().add(0), 0);
+		either.b().success();
+		
+		InterfaceTraverser newIfTraverser = tree.getTraverser();
+		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = newIfTraverser.getIndex();
+		Assert.assertTrue(newIndex.get(key).some().get("<-1,0,0>").isNone());
+		Assert.assertEquals(newIndex.get(key).some().get("<-1,0,1>").some().head().right().toString(),"<-1,0,0>");
+		
+		}
+	public static String key = "KEY";
+	public static DefaultTreeNode factory = new DefaultTreeNode();
+
+	public void createTree(JungleTree tree) {
+		NodePath root = new DefaultNodePath();
+		createChildren(tree, root, 0);
+
+		for (int x = 0; x < 2; x++) {
+			createChildren(tree, root.add(0), x);
+			for (int y = 0; y < 2; y++) {
+				createChildren(tree, root.add(0).add(x), y);
+			}
+		}
+
+	}
+
+	public void createChildren(JungleTree tree, NodePath root, int num) {
+		JungleTreeEditor editor = tree.getTreeEditor();// Treeのeditorを作成
+		Either<Error, JungleTreeEditor> either = editor
+				.addNewChildAt(root, num); // 新しく入れるところへのパス
+		if (either.isA()) {
+			Assert.fail();
+		}
+		editor = either.b();
+		either = editor.success();
+		if (either.isA()) {
+			Assert.fail();
+		}
+		NodePath childPath = root.add(num);
+		editor = tree.getTreeEditor();
+		NodePath attribute = root.add(num);
+		System.out.println(attribute.toString());
+		either = editor.putAttribute(childPath, key,
+				ByteBuffer.wrap(attribute.toString().getBytes()));
+		if (either.isA()) {
+			Assert.fail();
+		}
+		editor = either.b();
+		either = editor.success();
+	}
+}
diff -r c4846688f635 -r f46a6e0e4594 src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/IndexCommitTest.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/IndexCommitTest.java	Tue Oct 21 19:47:25 2014 +0900
@@ -0,0 +1,139 @@
+package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.index;
+
+import java.util.Iterator;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
+import junit.framework.Assert;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
+
+import java.nio.ByteBuffer;
+
+
+import org.junit.Test;
+
+import fj.data.List;
+import fj.data.Option;
+import fj.data.TreeMap;
+
+public class IndexCommitTest {
+
+	@Test
+	public void IndexCommitTest() throws InterruptedException {
+		
+		Jungle jungle = new DefaultJungle(null, "hogehoge",new DefaultTreeEditor(new DefaultTraverser()));
+		jungle.createNewTree("tree");
+		JungleTree tree = jungle.getTreeByName("tree");
+		createTree(tree);
+		tree.getRootNode();
+		InterfaceTraverser ifTraverser = tree.getTraverser();
+
+		 ifTraverser.find((TreeNode node) -> {
+			ByteBuffer attribute = node.getAttributes().get(key);
+			if (attribute != null) {
+				byte[] byteAttribute = attribute.array();
+				String str = new String(byteAttribute);
+				System.out.println("attribute = " + str);
+				return str.equals("<-1,0,1>");
+			}
+			return false;
+		}, key, "<-1,0,1>");
+
+		//check index
+		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index = ifTraverser.getIndex();
+		Option<TreeMap<String, List<Pair<TreeNode, NodePath>>>> opIndex = index.get(key);
+		Assert.assertTrue(!opIndex.isNone());
+		TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = opIndex.some();
+		Assert.assertTrue(!innerIndex.get("<-1,0,0>").isNone());
+
+		JungleTreeEditor editor = tree.getTreeEditor();
+		Either<Error, JungleTreeEditor> either = editor.addNewChildAt(new DefaultNodePath(), 0);
+		editor = either.b();
+		editor.success();
+		
+		ifTraverser.commitIndex();
+		JungleTree newTree = jungle.getTreeByName("tree");
+		InterfaceTraverser newIfTraverser = newTree.getTraverser();
+		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = newIfTraverser.getIndex();
+		Assert.assertTrue(newIndex.isEmpty());
+		
+		InterfaceTraverser ifTraverser1= tree.getTraverser();
+
+		 ifTraverser1.find((TreeNode node) -> {
+			ByteBuffer attribute = node.getAttributes().get(key);
+			if (attribute != null) {
+				byte[] byteAttribute = attribute.array();
+				String str = new String(byteAttribute);
+				System.out.println("attribute = " + str);
+				return str.equals("<-1,0,1>");
+			}
+			return false;
+		}, key, "<-1,0,1>");
+		 
+		ifTraverser1.commitIndex();
+		JungleTree newTree2 = jungle.getTreeByName("tree");
+		InterfaceTraverser newIfTraverser2 = newTree2.getTraverser();
+		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex1 = newIfTraverser2.getIndex();
+		Assert.assertFalse(newIndex1.isEmpty());
+
+	}
+
+	public boolean compare(TreeNode compareNode, String compareAttribute) {
+		String labName = compareNode.getAttributes().getString(key);
+		if (labName.equals(compareAttribute))
+			return true;
+		return false;
+	}
+
+	public static String key = "KEY";
+	public static DefaultTreeNode factory = new DefaultTreeNode();
+
+	public void createTree(JungleTree tree) {
+		NodePath root = new DefaultNodePath();
+		createChildren(tree, root, 0);
+
+		for (int x = 0; x < 2; x++) {
+			createChildren(tree, root.add(0), x);
+			for (int y = 0; y < 2; y++) {
+				createChildren(tree, root.add(0).add(x), y);
+			}
+		}
+
+	}
+
+	public void createChildren(JungleTree tree, NodePath root, int num) {
+		JungleTreeEditor editor = tree.getTreeEditor();// Treeのeditorを作成
+		Either<Error, JungleTreeEditor> either = editor
+				.addNewChildAt(root, num); // 新しく入れるところへのパス
+		if (either.isA()) {
+			Assert.fail();
+		}
+		editor = either.b();
+		either = editor.success();
+		if (either.isA()) {
+			Assert.fail();
+		}
+		NodePath childPath = root.add(num);
+		editor = tree.getTreeEditor();
+		NodePath attribute = root.add(num);
+		System.out.println(attribute.toString());
+		either = editor.putAttribute(childPath, key,
+				ByteBuffer.wrap(attribute.toString().getBytes()));
+		if (either.isA()) {
+			Assert.fail();
+		}
+		editor = either.b();
+		either = editor.success();
+	}
+}
diff -r c4846688f635 -r f46a6e0e4594 src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/IndexFormTest.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/IndexFormTest.java	Tue Oct 21 19:47:25 2014 +0900
@@ -0,0 +1,105 @@
+package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.index;
+
+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.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.TreeNodeAttributes;
+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 jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import fj.Ord;
+import fj.data.List;
+import fj.data.Option;
+import fj.data.TreeMap;
+
+public class IndexFormTest {
+
+	TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index = TreeMap
+			.empty(Ord.stringOrd);
+
+	@Test
+	public void IndexFormTest() {
+
+		NodePath path = new DefaultNodePath();
+		TreeNode node = createTree(3, 0, 3, path);
+		TreeMap<String, List<Pair<TreeNode, NodePath>>> map = index.get(key).some();
+		Option<List<Pair<TreeNode, NodePath>>> opList = map.get("<-1,0,0,2>");
+		List<Pair<TreeNode, NodePath>> list = opList.some();
+		Pair<TreeNode, NodePath> Pair = list.head();
+		NodePath newPath = Pair.right();
+		String pathStr = newPath.toString();
+		Assert.assertEquals(pathStr,"<-1,0,0,2>");
+		System.out.println("aaa");
+	}
+
+	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();
+		}
+		editIndex(parent, _address, _address.toString(), key);
+		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;
+	}
+
+
+	public void editIndex(TreeNode node, NodePath path, String attribute,String key) {
+
+		Pair<TreeNode, NodePath> pair = new Pair<TreeNode, NodePath>(node, path);
+		Option<TreeMap<String, List<Pair<TreeNode, NodePath>>>> opAttributeList = index.get(key);
+
+		if (opAttributeList.isNone()) {
+			TreeMap<String, List<Pair<TreeNode, NodePath>>> nodeIndex = TreeMap.empty(Ord.stringOrd);
+			List<Pair<TreeNode, NodePath>> list = List.nil();
+			list = list.cons(pair);
+			nodeIndex = nodeIndex.set(attribute, list);
+			index = index.set(key, nodeIndex);
+		} else {
+			TreeMap<String, List<Pair<TreeNode, NodePath>>> indexMap = opAttributeList.some();
+			Option<List<Pair<TreeNode, NodePath>>> opNodeIndex = indexMap.get(attribute);
+
+			if (opNodeIndex.isNone()) {
+				List<Pair<TreeNode, NodePath>> pairList = List.nil();
+				pairList = pairList.cons(pair);
+				indexMap = indexMap.set(attribute, pairList);
+
+			} else {
+				List<Pair<TreeNode, NodePath>> pairList = opNodeIndex.some();
+				pairList = pairList.cons(pair);
+				indexMap = indexMap.set(attribute, pairList);
+			}
+		index = index.set(key, indexMap);
+		}
+	System.out.println(attribute);
+
+	}
+
+}
diff -r c4846688f635 -r f46a6e0e4594 src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/query/SearchQueryTest.java
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/query/SearchQueryTest.java	Sun Oct 19 18:34:58 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/query/SearchQueryTest.java	Tue Oct 21 19:47:25 2014 +0900
@@ -20,7 +20,6 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.PathNodeIndexIterator;
-import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexPushThread;
 
 import org.junit.Assert;
 import org.junit.Test;