--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DeleteChildIndexEditor.java	Fri Nov 21 08:11:24 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DeleteChildIndexEditor.java	Fri Nov 21 12:46:06 2014 +0900
@@ -1,116 +1,127 @@
 package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index;
 
-
 import fj.Ord;
 import fj.data.List;
+import fj.data.Option;
 import fj.data.TreeMap;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.IndexTreeEditor;
 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.store.impl.TreeNodeAttributes;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
+import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.PathNodeIterator;
 
 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,TransactionManager txManager, IndexTreeEditor editor,TreeOperationLog log,TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index, TreeMap<TreeNode,TreeNode> parentIndex) {
+  TreeMap<String, TreeMap<String, List<TreeNode>>> indexTreeMap;
+  int pos;
 
-		TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> newIndex = editIndex(index);
-		IndexJungleTreeEditor newEditor = new IndexJungleTreeEditor(root, txManager, editor, newIndex, parentIndex);
-		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);
+  public DeleteChildIndexEditor(int pos, TreeMap<String, TreeMap<String, List<TreeNode>>> indexTreeMap) {
+    this.indexTreeMap = indexTreeMap;
+    this.pos = pos;
+  }
 
-			for (String indexKey : keyList) {
-				TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = index.get(indexKey).some();
-				List<String> innerIndexKeyList = innerIndex.keys();
+  @Override
+  public IndexEditor delete(TreeNode node) {
+    TreeNodeAttributes attribute = node.getAttributes();
+    List<String> keys = attribute.getKeys();
+    TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexTreeMap = indexTreeMap;
+    for (String key : keys) {
+      Option<TreeMap<String, List<TreeNode>>> indexOp = indexTreeMap.get(key);
+      if (indexOp.isSome()) {
+        TreeMap<String, List<TreeNode>> index = indexOp.some();
+        String value = attribute.getString(key);
+        Option<List<TreeNode>> nodeListOp = index.get(value);
+        if (nodeListOp.isSome()) {
+          List<TreeNode> nodeList = nodeListOp.some();
+          List<TreeNode> newNodeList = List.nil();
+          for (TreeNode indexingNode : nodeList) {
+            if (indexingNode != node)
+              newNodeList = newNodeList.cons(indexingNode);
+          }
+          TreeMap<String, List<TreeNode>> newIndex;
+          newIndex = index.set(value, newNodeList);
+          newIndexTreeMap = newIndexTreeMap.set(key, newIndex);
+        }
 
-				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) {
+    return new DefaultIndexEditor(newIndexTreeMap);
+  }
 
-			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;
-			}
+  @Override
+  public IndexEditor add(TreeNode node) {
+    TreeNodeAttributes attribute = node.getAttributes();
+    List<String> keys = attribute.getKeys();
+    TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexTreeMap = indexTreeMap;
+    for (String key : keys) {
+      Option<TreeMap<String, List<TreeNode>>> indexOp = indexTreeMap.get(key);
+      if (indexOp.isSome()) {
+        TreeMap<String, List<TreeNode>> index = indexOp.some();
+        String value = attribute.getString(key);
+        Option<List<TreeNode>> nodeListOp = index.get(value);
+        if (nodeListOp.isSome()) {
+          List<TreeNode> nodeList = nodeListOp.some();
+          List<TreeNode> newNodeList = nodeList.cons(node);
+          TreeMap<String, List<TreeNode>> newIndex = index.set(value, newNodeList);
+          newIndexTreeMap = newIndexTreeMap.set(key, newIndex);
+        } else { // test
+          List<TreeNode> nodeList = List.nil();
+          value = attribute.getString(key);
+          List<TreeNode> newNodeList = nodeList.cons(node);
+          TreeMap<String, List<TreeNode>> newIndex = index.set(value, newNodeList);
+          newIndexTreeMap = newIndexTreeMap.set(key, newIndex);
+        }
 
-			Pair<Integer, NodePath> editNodePathCopy = editNodePath.pop();
-			int loopCount = 0;
+      } else { // test
+        TreeMap<String, List<TreeNode>> index = TreeMap.empty(Ord.stringOrd);
+        List<TreeNode> nodeList = List.nil();
+        String value = attribute.getString(key);
+        List<TreeNode> newNodeList = nodeList.cons(node);
+        TreeMap<String, List<TreeNode>> newIndex = index.set(value, newNodeList);
+        newIndexTreeMap = newIndexTreeMap.set(key, newIndex);
+      }
+    }
 
-			for (Integer pathInt : path) {
-				loopCount++;
+    return new DefaultIndexEditor(newIndexTreeMap);
+  }
 
-				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;
-					}
+  @Override
+  public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
+    return indexTreeMap;
+  }
+
+  @Override
+  public IndexEditor edit(TreeNode node) {
+    PathNodeIterator nodeSearcher = new PathNodeIterator(new Pair<TreeNode, NodePath>(node, new DefaultNodePath()));
+    TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexTreeMap = indexTreeMap;
 
-					if (!(editNodePathCopy.left() == pathInt)) {
-						newPath = path;
-						break;
-					}
-				}
-
-				newPath = newPath.add(pathInt);
+    for (; nodeSearcher.hasNext();) {
+      TreeNode deleteNode = nodeSearcher.next().left();
+      TreeNodeAttributes attribute = deleteNode.getAttributes();
+      List<String> keys = attribute.getKeys();
+      for (String key : keys) {
+        Option<TreeMap<String, List<TreeNode>>> indexOp = newIndexTreeMap.get(key);
+        if (indexOp.isSome()) {
+          TreeMap<String, List<TreeNode>> index = indexOp.some();
+          String value = attribute.getString(key);
+          Option<List<TreeNode>> nodeListOp = index.get(value);
+          if (nodeListOp.isSome()) {
+            List<TreeNode> nodeList = nodeListOp.some();
+            List<TreeNode> newNodeList = List.nil();
+            for (TreeNode indexingNode : nodeList) {
+              if (indexingNode != deleteNode)
+                newNodeList = newNodeList.cons(indexingNode);
+            }
+            TreeMap<String, List<TreeNode>> newIndex = index.set(value, newNodeList);
+            newIndexTreeMap = newIndexTreeMap.set(key, newIndex);
+          }
 
-			}
-
-			System.out.println("newPath = " + newPath.toString());
-			Pair<TreeNode, NodePath> newPair = new Pair<TreeNode, NodePath>(
-					pair.left(), newPath);
-			list = list.cons(newPair);
-		}
-
-		return list;
-	}
+        }
+      }
+    }
+    return null;
+  }
 
 }