Mercurial > hg > Members > tatsuki > bench > jungle-core
changeset 152:8a0aa8fc137c
Merge with a2c374a2686b82b0ad30f520412e191b84288fa9
line wrap: on
line diff
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java Sat Nov 22 15:25:09 2014 +0900 @@ -3,9 +3,7 @@ import java.util.Iterator; import java.util.concurrent.ConcurrentHashMap; -import fj.Ord; import fj.data.List; -import fj.data.TreeMap; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.Journal; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.NullJournal; @@ -14,7 +12,6 @@ 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.IndexTreeEditor; -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.transaction.DefaultChangeSet; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeContext; @@ -23,7 +20,8 @@ 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 jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.TreeMapOrd; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.Index; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; public class DefaultJungle implements Jungle { @@ -84,8 +82,8 @@ }; DefaultTreeNode root = new DefaultTreeNode(); - TreeMap<String, TreeMap<String, List<TreeNode>>> index = TreeMap.empty(Ord.stringOrd); - TreeMap<TreeNode,TreeNode> parentIndex = TreeMap.empty(TreeMapOrd.treeNodeOrd); + Index index = new Index(); + ParentIndex parentIndex = new ParentIndex(); ChangeSet set = new DefaultChangeSet(root,null,list,uuid,name,0,index,parentIndex); DefaultTreeContext tc = new DefaultTreeContext(root,set); JungleTree newTree = new DefaultJungleTree(tc,uuid,journal.getWriter(),editor,new IndexTreeEditor(traverser));
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java Sat Nov 22 15:25:09 2014 +0900 @@ -1,7 +1,5 @@ package jp.ac.u_ryukyu.ie.cr.shoshi.jungle; -import fj.data.List; -import fj.data.TreeMap; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor; @@ -19,7 +17,9 @@ import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.GetOldTreeError; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.Index; import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexManager; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; public class DefaultJungleTree implements JungleTree { private final AtomicReservableReference<TreeContext> repository; @@ -27,8 +27,9 @@ private final ChangeListWriter writer; private final TreeEditor treeEditor; private final IndexTreeEditor indexTreeEditor; - - public DefaultJungleTree(TreeContext tc, String uuid, ChangeListWriter writer, TreeEditor editor, IndexTreeEditor indexTreeEditor) { + + public DefaultJungleTree(TreeContext tc, String uuid, ChangeListWriter writer, TreeEditor editor, + IndexTreeEditor indexTreeEditor) { this.repository = new AtomicReservableReference<TreeContext>(tc); this.uuid = uuid; this.writer = writer; @@ -41,9 +42,9 @@ TreeContext tc = repository.get(); DefaultTransactionManager txManager = new DefaultTransactionManager(writer, tc, repository, uuid); TreeNode root = tc.getTreeNode(); - TreeMap<String, TreeMap<String, List<TreeNode>>>index = getIndex(); - TreeMap<TreeNode, TreeNode> parentIndex = getParentIndex(); - return new DefaultJungleTreeEditor(root, txManager, treeEditor, index,parentIndex); + Index index = getIndex(); + ParentIndex parentIndex = getParentIndex(); + return new DefaultJungleTreeEditor(root, txManager, treeEditor, index, parentIndex); } @Override @@ -51,13 +52,13 @@ TreeContext tc = repository.get(); DefaultTransactionManager txManager = new DefaultTransactionManager(writer, tc, repository, uuid); TreeNode root = tc.getTreeNode(); - TreeMap<String, TreeMap<String, List<TreeNode>>> index = getIndex(); - TreeMap<TreeNode, TreeNode> parentIndex = getParentIndex(); - return new IndexJungleTreeEditor(root, txManager, indexTreeEditor, index, parentIndex); + Index index = getIndex(); + ParentIndex parentIndex = getParentIndex(); + return new IndexJungleTreeEditor(root, root, txManager, indexTreeEditor, index, parentIndex); } @Override - public TreeMap<TreeNode, TreeNode> getParentIndex() { + public ParentIndex getParentIndex() { TreeContext tc = repository.get(); ChangeSet cs = tc.getChangeSet(); return cs.getParentIndex(); @@ -79,14 +80,14 @@ public InterfaceTraverser getTraverser() { AtomicReservableReference<TreeContext>.Reservation reservation = repository.getReservation(); IndexManager indexManager = new IndexManager(reservation); - TreeMap<String, TreeMap<String, List<TreeNode>>> index = getIndex(); + Index index = getIndex(); if (index != null) return new InterfaceTraverser(getRootNode(), index, indexManager); return new InterfaceTraverser(getRootNode(), indexManager); } @Override - public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() { + public Index getIndex() { TreeContext tc = repository.get(); ChangeSet cs = tc.getChangeSet(); return cs.getIndex(); @@ -110,20 +111,19 @@ public Either<Error, JungleTree> getOldTree(long revision) { TreeContext tc = repository.get(); ChangeSet cs = tc.getChangeSet(); - - for (;cs.revision() != revision;) { + + for (; cs.revision() != revision;) { cs = cs.prev(); if (cs == null) return DefaultEither.newA(GetOldTreeError.OLD_TREE_NOT_FOUND); } - + TreeNode root = cs.getRoot(); - + TreeContext oldTc = new DefaultTreeContext(root, cs); String oldTreeUuid = uuid + revision; - JungleTree oldTree = new DefaultJungleTree(oldTc,oldTreeUuid,writer,treeEditor,indexTreeEditor); + JungleTree oldTree = new DefaultJungleTree(oldTc, oldTreeUuid, writer, treeEditor, indexTreeEditor); return DefaultEither.newB(oldTree); } - }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTree.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTree.java Sat Nov 22 15:25:09 2014 +0900 @@ -1,14 +1,15 @@ package jp.ac.u_ryukyu.ie.cr.shoshi.jungle; -import fj.data.List; -import fj.data.TreeMap; + import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; 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.traverser.InterfaceTraverser; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.Index; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; public interface JungleTree { @@ -16,8 +17,8 @@ public InterfaceTraverser getTraverser(); public JungleTreeEditor getLocalTreeEditor(); public TreeNode getRootNode(); - public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex(); - public TreeMap<TreeNode,TreeNode> getParentIndex(); + public Index getIndex(); + public ParentIndex getParentIndex(); public IndexJungleTreeEditor getIndexTreeEditor(); public Iterable<TreeOperation> getLog(); public long revision();
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/App.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/App.java Sat Nov 22 15:25:09 2014 +0900 @@ -2,7 +2,6 @@ import java.nio.ByteBuffer; -import fj.data.List; 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; @@ -35,8 +34,7 @@ TreeNode root = tree.getRootNode(); - List<ByteBuffer> valueList = root.getAttributes().get(key); - ByteBuffer v = valueList.head(); + 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 Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/Attributes.java Sat Nov 22 15:25:09 2014 +0900 @@ -1,12 +1,9 @@ package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core; import java.nio.ByteBuffer; -import java.util.Iterator; - -import fj.data.List; public interface Attributes { - public List<ByteBuffer> get(String key); - public Iterator<String> getString(String key); + public ByteBuffer get(String key); + public String getString(String key); }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/ChangeSet.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/ChangeSet.java Sat Nov 22 15:25:09 2014 +0900 @@ -1,11 +1,12 @@ package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store; -import fj.data.List; -import fj.data.TreeMap; + import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.Index; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; public interface ChangeSet { @@ -17,7 +18,7 @@ public String getTreeName(); public long revision(); - public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex(); + public Index getIndex(); public Iterable<TreeOperation> getOperations(); - public TreeMap<TreeNode, TreeNode> getParentIndex(); + public ParentIndex getParentIndex(); }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/IndexTreeEditor.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/IndexTreeEditor.java Sat Nov 22 15:25:09 2014 +0900 @@ -1,14 +1,9 @@ package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl; -import java.util.Iterator; -import javax.swing.plaf.basic.BasicInternalFrameTitlePane.SystemMenuBar; -import fj.P2; import fj.data.List; -import fj.data.Option; -import fj.data.TreeMap; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.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; @@ -19,8 +14,6 @@ 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.Triple; -import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexEditor; public class IndexTreeEditor { @@ -33,7 +26,7 @@ } - public Either<Error,Triple<LoggingNode, TreeMap<TreeNode, TreeNode>,TreeMap<String,TreeMap<String,List<TreeNode>>>>> edit(TreeNode root,NodePath path,NodeEditor editor,TreeMap<TreeNode, TreeNode> parentIndex, IndexEditor indexEditor) + public Either<Error,LoggingNode> edit(TreeNode root,NodePath path,NodeEditor editor) { DefaultEvaluator e = new DefaultEvaluator(path); Either<Error, Traversal> either = traverser.traverse(root,e); @@ -43,15 +36,14 @@ } Traversal t = either.b(); - Either<Error,Triple<LoggingNode, TreeMap<TreeNode, TreeNode>,TreeMap<String,TreeMap<String,List<TreeNode>>>>> ret = clone(t,editor,parentIndex, indexEditor); + Either<Error,LoggingNode> ret = clone(t,editor); return ret; } - private Either<Error,Triple<LoggingNode, TreeMap<TreeNode, TreeNode>,TreeMap<String,TreeMap<String,List<TreeNode>>>>> clone(Traversal t,NodeEditor editor , TreeMap<TreeNode, TreeNode> parentIndex, IndexEditor indexEditor) + private Either<Error,LoggingNode> clone(Traversal t,NodeEditor editor) { // copying nodes from bottom to root - TreeMap<TreeNode, TreeNode> newParentIndex = parentIndex; List<Direction<TreeNode>> path = List.nil(); for (Direction<TreeNode> direction : t) { path = path.cons(direction); @@ -60,14 +52,6 @@ // target Direction<TreeNode> targetDirection = path.head(); TreeNode target = targetDirection.getTarget(); - Iterator<TreeNode> targetDeleteChildren = target.getChildren().iterator(); - IndexEditor alreadyDeleteTargetIndexEditor = indexEditor.delete(target); - - for (;targetDeleteChildren.hasNext();) { - TreeNode targetDeleteChild = targetDeleteChildren.next(); - newParentIndex = newParentIndex.delete(targetDeleteChild); - } - Either<Error, LoggingNode> either = editor.edit(target); if (either.isA()) { @@ -80,26 +64,11 @@ int pos = targetDirection.getPosition(); TreeNode child = newWrap.getWrap(); - IndexEditor alreadyEditTargetIndexEditor = alreadyDeleteTargetIndexEditor.edit(child); - IndexEditor alreadyAddTargetIndexEditor = alreadyEditTargetIndexEditor.add(child); - Iterator<TreeNode> targetPutChildren = child.getChildren().iterator(); - - for (; targetPutChildren.hasNext();) { - TreeNode targetPutChild = targetPutChildren.next(); - newParentIndex = newParentIndex.set(targetPutChild, child); - } - for (Direction<TreeNode> parentDirection : path.tail()) { TreeNode updateTargetNode = parentDirection.getTarget(); TreeNodeChildren chs = updateTargetNode.getChildren(); - alreadyDeleteTargetIndexEditor = alreadyAddTargetIndexEditor.delete(updateTargetNode); - Iterator<TreeNode> deleteParentIndexChildren = chs.iterator(); - for (;deleteParentIndexChildren.hasNext();) { - TreeNode deleteParentIndexChild = deleteParentIndexChildren.next(); - newParentIndex = newParentIndex.delete(deleteParentIndexChild); - } Either<Error, TreeNode> ret = chs.replaceNode(pos, child); if (ret.isA()) { @@ -107,13 +76,6 @@ } TreeNode newParent = ret.b(); - alreadyAddTargetIndexEditor = alreadyDeleteTargetIndexEditor.add(newParent); - Iterator<TreeNode> putParentIndexChildren = newParent.getChildren().iterator(); - - for (;putParentIndexChildren.hasNext();) { - TreeNode putParentIndexChild = putParentIndexChildren.next(); - newParentIndex = newParentIndex.set(putParentIndexChild, newParent); - } child = newParent; pos = parentDirection.getPosition(); @@ -123,9 +85,7 @@ LoggingNode logNode = editor.wrap(newRoot, newWrap.getOperationLog()); - TreeMap<String,TreeMap<String,List<TreeNode>>> indexList = alreadyAddTargetIndexEditor.getIndex(); - Triple<LoggingNode, TreeMap<TreeNode, TreeNode>,TreeMap<String,TreeMap<String,List<TreeNode>>>> triple = new Triple<LoggingNode, TreeMap<TreeNode, TreeNode>,TreeMap<String,TreeMap<String,List<TreeNode>>>>(logNode,newParentIndex,indexList); - return DefaultEither.newB(triple); + return DefaultEither.newB(logNode); } }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/TreeNodeAttributes.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/TreeNodeAttributes.java Sat Nov 22 15:25:09 2014 +0900 @@ -12,6 +12,6 @@ { public Either<Error,TreeNode> delete(String key); public Either<Error,TreeNode> put(String key,ByteBuffer value); - public TreeMap<String, List<ByteBuffer>> getAttributesAsRawMap(); + public TreeMap<String,ByteBuffer> getAttributesAsRawMap(); public List<String> getKeys(); }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/logger/LoggingAttributes.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/logger/LoggingAttributes.java Sat Nov 22 15:25:09 2014 +0900 @@ -2,7 +2,6 @@ import java.nio.ByteBuffer; -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.operations.DeleteAttributeOperation; @@ -23,7 +22,7 @@ log = _log; } - public List<ByteBuffer> get(String _key) + public ByteBuffer get(String _key) { TreeNodeAttributes attributes = wrap.getAttributes(); return attributes.get(_key);
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultChangeSet.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultChangeSet.java Sat Nov 22 15:25:09 2014 +0900 @@ -1,11 +1,11 @@ package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction; -import fj.data.List; -import fj.data.TreeMap; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.Index; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; public class DefaultChangeSet implements ChangeSet { @@ -15,10 +15,10 @@ private final String uuid; private final String treeName; private final long revision; - private final TreeMap<String, TreeMap<String, List<TreeNode>>> index; - private final TreeMap<TreeNode,TreeNode> parentIndex; + private final Index index; + private final ParentIndex parentIndex; - public DefaultChangeSet(TreeNode _node,ChangeSet _prev,ChangeList _log,String _uuid, String _treeName, long _revision, TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode,TreeNode> parentIndex) + public DefaultChangeSet(TreeNode _node,ChangeSet _prev,ChangeList _log,String _uuid, String _treeName, long _revision, Index index,ParentIndex parentIndex) { this.root = _node; this.previous = _prev; @@ -74,13 +74,13 @@ } @Override - public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() { + public Index getIndex() { return index; } @Override - public TreeMap<TreeNode, TreeNode> getParentIndex() { + public ParentIndex getParentIndex() { return parentIndex; }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultJungleTreeEditor.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultJungleTreeEditor.java Sat Nov 22 15:25:09 2014 +0900 @@ -2,8 +2,7 @@ import java.nio.ByteBuffer; -import fj.data.List; -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; @@ -24,6 +23,8 @@ 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; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.Index; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; public class DefaultJungleTreeEditor implements JungleTreeEditor { @@ -31,22 +32,22 @@ private final TreeNode root; private final TreeEditor editor; private final TreeOperationLog log; - private final TreeMap<String, TreeMap<String, List<TreeNode>>> index; - private final TreeMap<TreeNode,TreeNode> parentIndex; + private final Index index; + private final ParentIndex parentIndex; // public DefaultJungleTreeEditor(TreeNode root) // { // this(root,txManager,_editor,new DefaultTreeOperationLog()); // } - public DefaultJungleTreeEditor(TreeNode _root,TransactionManager _txManager,TreeEditor _editor, TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode,TreeNode> parentIndex) + public DefaultJungleTreeEditor(TreeNode _root,TransactionManager _txManager,TreeEditor _editor, Index index,ParentIndex parentIndex) { this(_root,_txManager,_editor,new DefaultTreeOperationLog(),index,parentIndex); } - public DefaultJungleTreeEditor(TreeNode newNode,TransactionManager _txManager,TreeEditor _editor,TreeOperationLog _log, TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode,TreeNode> parentIndex) + public DefaultJungleTreeEditor(TreeNode newNode,TransactionManager _txManager,TreeEditor _editor,TreeOperationLog _log, Index index,ParentIndex parentIndex) { this.root = newNode; this.txManager = _txManager;
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java Sat Nov 22 15:25:09 2014 +0900 @@ -2,8 +2,6 @@ import java.util.Iterator; -import fj.data.List; -import fj.data.TreeMap; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.Result; @@ -16,6 +14,8 @@ import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultError; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.Index; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; public class DefaultTransactionManager implements TransactionManager { @@ -34,7 +34,7 @@ } @Override - public Either<Error,TransactionManager> commit(TreeNode _newRoot,final TreeOperationLog _log, TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode,TreeNode> parentIndex) + public Either<Error,TransactionManager> commit(TreeNode _newRoot,final TreeOperationLog _log, Index index,ParentIndex parentIndex) { ChangeSet cs = tip.getChangeSet(); long currentRevision = cs.revision();
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNode.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNode.java Sat Nov 22 15:25:09 2014 +0900 @@ -12,18 +12,18 @@ { //private final DefaultNode wrap; private List<TreeNode> children; - private TreeMap<String,List<ByteBuffer>> attrs; + private TreeMap<String,ByteBuffer> attrs; private OperationLog log; private static final List<TreeNode> NIL_LIST = List.nil(); - private static final TreeMap<String,List<ByteBuffer>> NIL_MAP = TreeMap.empty(Ord.stringOrd); + private static final TreeMap<String,ByteBuffer> NIL_MAP = TreeMap.empty(Ord.stringOrd); public DefaultTreeNode() { this(NIL_LIST,NIL_MAP); } - public DefaultTreeNode(List<TreeNode> _children,TreeMap<String,List<ByteBuffer>> _attrs) + public DefaultTreeNode(List<TreeNode> _children,TreeMap<String,ByteBuffer> _attrs) { attrs = _attrs; children = _children;
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeAttribute.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeAttribute.java Sat Nov 22 15:25:09 2014 +0900 @@ -1,12 +1,10 @@ package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction; import java.nio.ByteBuffer; -import java.util.Iterator; import fj.data.List; import fj.data.Option; import fj.data.TreeMap; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NulIterator; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNodeAttributes; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultOperationLog; @@ -16,105 +14,80 @@ import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; -public class DefaultTreeNodeAttribute implements TreeNodeAttributes { - public List<TreeNode> children; - public TreeMap<String, List<ByteBuffer>> attrs; - OperationLog log; - - public DefaultTreeNodeAttribute(List<TreeNode> _children, TreeMap<String, List<ByteBuffer>> _attrs) { - children = _children; - attrs = _attrs; - log = new DefaultOperationLog(); - } +public class DefaultTreeNodeAttribute implements TreeNodeAttributes +{ + public List<TreeNode> children; + public TreeMap<String,ByteBuffer> attrs; + OperationLog log ; + + public DefaultTreeNodeAttribute(List<TreeNode> _children,TreeMap<String,ByteBuffer> _attrs) + { + children = _children; + attrs = _attrs; + log = new DefaultOperationLog(); + } + + public DefaultTreeNodeAttribute(List<TreeNode> _children,TreeMap<String,ByteBuffer> _attrs,OperationLog _log) + { + children = _children; + attrs = _attrs; + log = _log; + } - public DefaultTreeNodeAttribute(List<TreeNode> _children, TreeMap<String, List<ByteBuffer>> _attrs, OperationLog _log) { - children = _children; - attrs = _attrs; - log = _log; - } + @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 (!attrs.contains(_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 TreeMap<String, List<ByteBuffer>> getAttributesAsRawMap() { - return attrs; - } + @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.set(_key,_value); + TreeNode newNode = new DefaultTreeNode(children,newMap); + return DefaultEither.newB(newNode); + } - @Override - public Either<Error, TreeNode> delete(String _key) { - if (_key == null) { - return DefaultEither.newA(NodeEditorError.NULL_VALUE_NOT_ALLOWED); - } + @Override + public ByteBuffer get(String _key) + { + if (_key == null) { + return null; + } + + Option<ByteBuffer> result = attrs.get(_key); + return result.isSome() ? result.some() : null; + } - if (!attrs.contains(_key)) { - return DefaultEither.newA(NodeEditorError.DELETE_KEY_NOT_FOUND); + @Override + public String getString(String key) { + ByteBuffer attribute = get(key); + if (attribute != null) + return new String(attribute.array()); + return null; } - TreeMap<String, List<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); - } - Option<List<ByteBuffer>> attrsListOp = attrs.get(_key); - - List<ByteBuffer> newAttrsList; - if (attrsListOp.isNone()) { - List<ByteBuffer> attrsList = List.nil(); - newAttrsList = attrsList.cons(_value); - } else { - List<ByteBuffer> attrsList = attrsListOp.some(); - newAttrsList = attrsList.cons(_value); - } - - TreeMap<String, List<ByteBuffer>> newMap = attrs.set(_key, newAttrsList); - TreeNode newNode = new DefaultTreeNode(children, newMap); - return DefaultEither.newB(newNode); - } - - @Override - public List<ByteBuffer> get(String _key) { - if (_key == null) { - return List.nil(); + @Override + public List<String> getKeys() { + return attrs.keys(); } - - Option<List<ByteBuffer>> result = attrs.get(_key); - return result.isSome() ? result.some() : List.nil(); - } - - @Override - public Iterator<String> getString(String key) { - List<ByteBuffer> attributeList = get(key); - if (attributeList == null) - return new NulIterator<>(); - - return new Iterator<String>() { - - List<ByteBuffer> iteratorAttributeList = attributeList; - ByteBuffer attribute; - - @Override - public boolean hasNext() { - if (!iteratorAttributeList.isEmpty()) { - attribute = iteratorAttributeList.head(); - iteratorAttributeList = iteratorAttributeList.tail(); - return true; - } - return false; - } - - @Override - public String next() { - return new String(attribute.array()); - } - - }; - } - - @Override - public List<String> getKeys() { - return attrs.keys(); - } }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeChildren.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeChildren.java Sat Nov 22 15:25:09 2014 +0900 @@ -25,9 +25,9 @@ } public List<TreeNode> children; - public TreeMap<String,List<ByteBuffer>> attrs; + public TreeMap<String,ByteBuffer> attrs; - public DefaultTreeNodeChildren(List<TreeNode> _children,TreeMap<String,List<ByteBuffer>> _attrs) + public DefaultTreeNodeChildren(List<TreeNode> _children,TreeMap<String,ByteBuffer> _attrs) { children = _children; attrs = _attrs; @@ -47,7 +47,6 @@ public List<TreeNode> getChildrenAsRawList(){ return children; } - @Override public Either<Error,TreeNode> addNewChildAt(int _pos) { @@ -107,7 +106,8 @@ @Override public Either<Error,TreeNode> at(int _pos) { - if(!boundaryCheck(_pos + 1)){ + System.out.println(children.length()); + if(children.length() < _pos + 1){ return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS); }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/IndexJungleTreeEditor.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/IndexJungleTreeEditor.java Sat Nov 22 15:25:09 2014 +0900 @@ -1,8 +1,9 @@ package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction; import java.nio.ByteBuffer; +import java.util.Iterator; -import fj.data.List; +import fj.P2; 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; @@ -24,50 +25,58 @@ 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; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Triple; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.TreeMapOrd; import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.DefaultIndexEditor; import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.DeleteChildIndexEditor; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.Index; import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexEditor; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; public class IndexJungleTreeEditor implements JungleTreeEditor { private final TransactionManager txManager; private final TreeNode root; + private final TreeNode oldRoot; private final IndexTreeEditor editor; private final TreeOperationLog log; - private TreeMap<String, TreeMap<String, List<TreeNode>>> index; - private TreeMap<TreeNode, TreeNode> parentIndex; + private final TreeOperationLog tmpLog; + private Index index; + private ParentIndex parentIndex; - public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() { + public Index getIndex() { return index; } - - - public IndexJungleTreeEditor(TreeNode _root, TransactionManager _txManager, IndexTreeEditor treeEditor, - TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode, TreeNode> parentIndex) { - this(_root, _txManager, treeEditor, new DefaultTreeOperationLog(), index,parentIndex); + public IndexJungleTreeEditor(TreeNode _root, TreeNode oldRoot, TransactionManager _txManager, + IndexTreeEditor treeEditor, Index index, ParentIndex parentIndex) { + this(_root, oldRoot, _txManager, treeEditor, new DefaultTreeOperationLog(), new DefaultTreeOperationLog(), index, + parentIndex); } - public IndexJungleTreeEditor(TreeNode newNode, TransactionManager _txManager, IndexTreeEditor _editor, - TreeOperationLog _log, TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode, TreeNode> parentIndex) { + public IndexJungleTreeEditor(TreeNode _root, TreeNode oldRoot, TransactionManager _txManager, + IndexTreeEditor treeEditor, TreeOperationLog log, Index index, ParentIndex parentIndex) { + this(_root, oldRoot, _txManager, treeEditor, log, new DefaultTreeOperationLog(), index, parentIndex); + } + + public IndexJungleTreeEditor(TreeNode newNode, TreeNode oldRoot, TransactionManager _txManager, + IndexTreeEditor _editor, TreeOperationLog _log, TreeOperationLog tmpLog, Index index, ParentIndex parentIndex) { this.root = newNode; + this.oldRoot = oldRoot; this.txManager = _txManager; this.editor = _editor; this.log = _log; this.index = index; this.parentIndex = parentIndex; + this.tmpLog = tmpLog; } - public Either<Error, IndexJungleTreeEditor> _edit(final NodePath _path, NodeEditor _e, IndexEditor indexEditor) { - Either<Error,Triple<LoggingNode, TreeMap<TreeNode, TreeNode>,TreeMap<String,TreeMap<String,List<TreeNode>>>>> either = editor.edit(root, _path, _e, parentIndex, indexEditor); + Either<Error, LoggingNode> either = editor.edit(root, _path, _e); if (either.isA()) { return DefaultEither.newA(either.a()); } - LoggingNode newLogging = either.b().getA(); - TreeMap<TreeNode,TreeNode> newParentIndex = either.b().getB(); - TreeMap<String,TreeMap<String,List<TreeNode>>> newIndex = either.b().getC(); + LoggingNode newLogging = either.b(); OperationLog newLog = newLogging.getOperationLog(); TreeNode newNode = newLogging.getWrap(); @@ -80,8 +89,9 @@ Iterable<TreeOperation> iterable = new IterableConverter<TreeOperation, NodeOperation>(newLog, converter); DefaultTreeOperationLog treeOperationLog = new DefaultTreeOperationLog(iterable, newLog.length()); - TreeOperationLog newTreeOpLog = log.append(treeOperationLog); - IndexJungleTreeEditor newIndexTreeEditor = new IndexJungleTreeEditor(newNode, txManager, this.editor,newTreeOpLog, newIndex, newParentIndex); + TreeOperationLog newTmpLog = tmpLog.append(treeOperationLog); + IndexJungleTreeEditor newIndexTreeEditor = new IndexJungleTreeEditor(newNode, oldRoot, txManager, this.editor, log, + newTmpLog, index, parentIndex); return DefaultEither.newB(newIndexTreeEditor); } @@ -134,17 +144,105 @@ @Override public Either<Error, JungleTreeEditor> success() { - Either<Error, TransactionManager> either = txManager.commit(root, log, index,parentIndex); + Pair<ParentIndex, Index> newIndexPair = editIndex(tmpLog); + ParentIndex newParentIndex = newIndexPair.left(); + Index newIndex = newIndexPair.right(); + TreeOperationLog newLog = log.append(tmpLog); + Either<Error, TransactionManager> either = txManager.commit(root, newLog, newIndex, newParentIndex); if (either.isA()) { return DefaultEither.newA(either.a()); } - TransactionManager newTxManager = either.b(); - JungleTreeEditor newTreeEditor = new IndexJungleTreeEditor(root, newTxManager, editor, index,parentIndex); + TransactionManager newTxManager = either.b(); + JungleTreeEditor newTreeEditor = new IndexJungleTreeEditor(root, root, newTxManager, editor, index, parentIndex); return DefaultEither.newB(newTreeEditor); } + private Pair<ParentIndex, Index> editIndex(TreeOperationLog tmpLog) { + TreeMap<TreeNode, TreeNode> putParentNodeMap = TreeMap.empty(TreeMapOrd.treeNodeOrd); + TreeMap<TreeNode, TreeNode> deleteParentNodeMap = TreeMap.empty(TreeMapOrd.treeNodeOrd); + + for (TreeOperation log : tmpLog) { + + NodePath targetNodePath = log.getNodePath(); + putParentNodeMap = getTargetNode(TreeMap.empty(TreeMapOrd.treeNodeOrd), root, targetNodePath); + deleteParentNodeMap = getTargetNode(TreeMap.empty(TreeMapOrd.treeNodeOrd), oldRoot, targetNodePath); + System.out.println(log.getNodePath().toString()); + } + + Pair<ParentIndex, Index> indexPair = new Pair<ParentIndex, Index>(parentIndex, index); + if (!deleteParentNodeMap.isEmpty()) + indexPair = deleteIndexAttribute(putParentNodeMap, indexPair); + + if (!putParentNodeMap.isEmpty()) + indexPair = putIndexAttribute(putParentNodeMap, indexPair); + + ParentIndex newParentIndex = indexPair.left(); + Index newIndex = indexPair.right(); + Pair<ParentIndex, Index> newIndexPair = new Pair<ParentIndex, Index>(newParentIndex, newIndex); + return newIndexPair; + } + + private Pair<ParentIndex, Index> deleteIndexAttribute(TreeMap<TreeNode, TreeNode> deleteParentNodeMap, + Pair<ParentIndex, Index> indexPair) { + + Iterator<P2<TreeNode, TreeNode>> parentNodeIterator = deleteParentNodeMap.iterator(); + ParentIndex newParentIndex = indexPair.left(); + Index newIndex = indexPair.right(); + + for (; parentNodeIterator.hasNext();) { + TreeNode parentNode = parentNodeIterator.next()._1(); + newIndex = newIndex.deleteNodeAll(parentNode); + newParentIndex = newParentIndex.deleteAllChildren(parentNode); + } + + Pair<ParentIndex, Index> newIndexPair = new Pair<ParentIndex, Index>(newParentIndex, newIndex); + return newIndexPair; + } + + private Pair<ParentIndex, Index> putIndexAttribute(TreeMap<TreeNode, TreeNode> putParentNodeMap, + Pair<ParentIndex, Index> indexPair) { + Iterator<P2<TreeNode, TreeNode>> parentNodeIterator = putParentNodeMap.iterator(); + ParentIndex newParentIndex = indexPair.left(); + Index newIndex = indexPair.right(); + + for (; parentNodeIterator.hasNext();) { + + TreeNode parentNode = parentNodeIterator.next()._1(); + newIndex = newIndex.putNodeAll(parentNode); + newParentIndex = newParentIndex.addAllChildren(parentNode); + + } + Pair<ParentIndex, Index> newIndexPair = new Pair<ParentIndex, Index>(newParentIndex, newIndex); + return newIndexPair; + } + + private TreeMap<TreeNode, TreeNode> getTargetNode(TreeMap<TreeNode, TreeNode> treeNodeMap, TreeNode node, + NodePath path) { + if (path.size() == 0) + return treeNodeMap; + + Pair<Integer, NodePath> pathNode = path.pop(); + + if (pathNode.left() == -1) { + TreeMap<TreeNode, TreeNode> newTreeNodeMap = treeNodeMap.set(node, node); + return getTargetNode(newTreeNodeMap, node, pathNode.right()); + } + + Either<Error, TreeNode> either = node.getChildren().at(pathNode.left()); + if (either.isA()) + return treeNodeMap; + + TreeNode child = either.b(); + TreeMap<TreeNode, TreeNode> newTreeNodeMap = treeNodeMap.set(child, child); + if (pathNode.right().size() == 0) + return newTreeNodeMap; + + return getTargetNode(newTreeNodeMap, child, pathNode.right()); + + } + @Override public String getID() { return txManager.getUUID();
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/TransactionManager.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/TransactionManager.java Sat Nov 22 15:25:09 2014 +0900 @@ -1,15 +1,16 @@ package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction; -import fj.data.List; -import fj.data.TreeMap; + import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.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; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.Index; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; public interface TransactionManager { - public Either<Error,TransactionManager> commit(TreeNode _newRoot,TreeOperationLog _log, TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode,TreeNode> parentIndex); + public Either<Error,TransactionManager> commit(TreeNode _newRoot,TreeOperationLog _log, Index index,ParentIndex parentIndex); public String getUUID(); public long getRevision(); }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java Sat Nov 22 15:25:09 2014 +0900 @@ -14,22 +14,23 @@ 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.Index; import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexManager; public class InterfaceTraverser { // InterfaceTraverser traverser; TreeNode node; - TreeMap<String, TreeMap<String, List<TreeNode>>> index; + Index index; IndexManager indexManager; public InterfaceTraverser(TreeNode _root, IndexManager indexManager) { this.node = _root; - this.index = TreeMap.empty(Ord.stringOrd); + this.index = new Index(); this.indexManager = indexManager; } - public InterfaceTraverser(TreeNode _root, TreeMap<String, TreeMap<String, List<TreeNode>>> index, + public InterfaceTraverser(TreeNode _root, Index index, IndexManager indexManager) { this.node = _root; this.index = index; @@ -40,11 +41,11 @@ indexManager.commit(index); } - public TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> getIndex() { + public Index getIndex() { return index; } - public void setIndex(TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index) { + public void setIndex(Index index) { this.index = index; }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DefaultIndexEditor.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DefaultIndexEditor.java Sat Nov 22 15:25:09 2014 +0900 @@ -9,19 +9,19 @@ public class DefaultIndexEditor implements IndexEditor { - TreeMap<String, TreeMap<String, List<TreeNode>>> indexTreeMap; + Index index; - public DefaultIndexEditor(TreeMap<String, TreeMap<String, List<TreeNode>>> indexTreeMap) { - this.indexTreeMap = indexTreeMap; + public DefaultIndexEditor(Index index) { + this.index = index; } @Override public IndexEditor delete(TreeNode node) { TreeNodeAttributes attribute = node.getAttributes(); List<String> keys = attribute.getKeys(); - TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexTreeMap = indexTreeMap; + Index newIndexTreeMap = index; for (String key : keys) { - Option<TreeMap<String, List<TreeNode>>> indexOp = indexTreeMap.get(key); + Option<TreeMap<String, List<TreeNode>>> indexOp = index.get(key); if (indexOp.isSome()) { TreeMap<String, List<TreeNode>> index = indexOp.some(); String value = attribute.getString(key); @@ -34,10 +34,7 @@ newNodeList = newNodeList.cons(indexingNode); } TreeMap<String, List<TreeNode>> newIndex; -// if (newNodeList.isEmpty()) -// newIndex = index.delete(value); -// else - newIndex = index.set(value, newNodeList); + newIndex = index.set(value, newNodeList); newIndexTreeMap = newIndexTreeMap.set(key, newIndex); } @@ -51,9 +48,9 @@ public IndexEditor add(TreeNode node) { TreeNodeAttributes attribute = node.getAttributes(); List<String> keys = attribute.getKeys(); - TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexTreeMap = indexTreeMap; + TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexTreeMap = index; for (String key : keys) { - Option<TreeMap<String, List<TreeNode>>> indexOp = indexTreeMap.get(key); + Option<TreeMap<String, List<TreeNode>>> indexOp = index.get(key); if (indexOp.isSome()) { TreeMap<String, List<TreeNode>> index = indexOp.some(); String value = attribute.getString(key); @@ -86,7 +83,7 @@ @Override public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() { - return indexTreeMap; + return index; } @Override
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DeleteChildIndexEditor.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/DeleteChildIndexEditor.java Sat Nov 22 15:25:09 2014 +0900 @@ -13,11 +13,11 @@ public class DeleteChildIndexEditor implements IndexEditor { - TreeMap<String, TreeMap<String, List<TreeNode>>> indexTreeMap; + Index index; int pos; - public DeleteChildIndexEditor(int pos, TreeMap<String, TreeMap<String, List<TreeNode>>> indexTreeMap) { - this.indexTreeMap = indexTreeMap; + public DeleteChildIndexEditor(int pos, Index index) { + this.index = index; this.pos = pos; } @@ -25,9 +25,9 @@ public IndexEditor delete(TreeNode node) { TreeNodeAttributes attribute = node.getAttributes(); List<String> keys = attribute.getKeys(); - TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexTreeMap = indexTreeMap; + TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexTreeMap = index; for (String key : keys) { - Option<TreeMap<String, List<TreeNode>>> indexOp = indexTreeMap.get(key); + Option<TreeMap<String, List<TreeNode>>> indexOp = index.get(key); if (indexOp.isSome()) { TreeMap<String, List<TreeNode>> index = indexOp.some(); String value = attribute.getString(key); @@ -54,9 +54,9 @@ public IndexEditor add(TreeNode node) { TreeNodeAttributes attribute = node.getAttributes(); List<String> keys = attribute.getKeys(); - TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexTreeMap = indexTreeMap; + TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexTreeMap = index; for (String key : keys) { - Option<TreeMap<String, List<TreeNode>>> indexOp = indexTreeMap.get(key); + Option<TreeMap<String, List<TreeNode>>> indexOp = index.get(key); if (indexOp.isSome()) { TreeMap<String, List<TreeNode>> index = indexOp.some(); String value = attribute.getString(key); @@ -89,13 +89,13 @@ @Override public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() { - return indexTreeMap; + return index; } @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; + TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexTreeMap = index; for (; nodeSearcher.hasNext();) { TreeNode deleteNode = nodeSearcher.next().left();
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/Index.java Sat Nov 22 15:25:09 2014 +0900 @@ -0,0 +1,156 @@ +package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index; + +import java.util.Iterator; + +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; +import fj.Ord; +import fj.P2; +import fj.data.List; +import fj.data.Option; +import fj.data.TreeMap; + +public class Index { + + TreeMap<String, TreeMap<String, List<TreeNode>>> indexList; + + public Index() { + this.indexList = TreeMap.empty(Ord.stringOrd); + } + + public Index(TreeMap<String, TreeMap<String, List<TreeNode>>> indexList) { + this.indexList = indexList; + } + + public Index(Index indexList) { + this.indexList = indexList.getIndex(); + } + + public Index set(String key, String value, TreeNode node) { + Option<TreeMap<String, List<TreeNode>>> indexOp = indexList.get(key); + if (indexOp.isNone()) + return this; + + TreeMap<String, List<TreeNode>> index = indexOp.some(); + Option<List<TreeNode>> nodeListOp = index.get(value); + + List<TreeNode> newNodeList; + if (nodeListOp.isSome()) { + List<TreeNode> nodeList = nodeListOp.some(); + newNodeList = nodeList.cons(node); + } else { + List<TreeNode> nodeList = List.nil(); + newNodeList = nodeList.cons(node); + } + TreeMap<String, List<TreeNode>> newIndex = index.set(value, newNodeList); + TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexList = indexList.set(key, newIndex); + return new Index(newIndexList); + } + + public Index delete(String key, String value, TreeNode node) { + Option<TreeMap<String, List<TreeNode>>> indexOp = indexList.get(key); + if (indexOp.isNone()) + return this; + + TreeMap<String, List<TreeNode>> index = indexOp.some(); + TreeMap<String, List<TreeNode>> newIndex = index; + Option<List<TreeNode>> nodeListOp = index.get(value); + if (nodeListOp.isSome()) { + List<TreeNode> nodeList = nodeListOp.some(); + List<TreeNode> newNodeList = List.nil(); + for (TreeNode indexingNode : nodeList) { + if (indexingNode.equals(node)) + newNodeList = newNodeList.cons(indexingNode); + } + + newIndex = index.set(value, newNodeList); + } else { + return this; + } + TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexList = indexList.set(key, newIndex); + return new Index(newIndexList); + } + + public Index deleteNodeAll(TreeNode node) { + List<String> keys = node.getAttributes().getKeys(); + TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexList = indexList; + + for (String key : keys) { + Option<TreeMap<String, List<TreeNode>>> indexOp = indexList.get(key); + if (indexOp.isNone()) + continue; + + TreeMap<String, List<TreeNode>> index = indexOp.some(); + Iterator<P2<String, List<TreeNode>>> indexIterator = index.iterator(); + + TreeMap<String, List<TreeNode>> newIndex = index; + for (; indexIterator.hasNext();) { + List<TreeNode> newNodeList = List.nil(); + P2<String, List<TreeNode>> NodeListP2 = indexIterator.next(); + String value = NodeListP2._1(); + List<TreeNode> targetNodeList = NodeListP2._2(); + for (TreeNode targetNode : targetNodeList) { + if (!node.equals(targetNode)) + newNodeList = newNodeList.cons(targetNode); + } + newIndex = newIndex.set(value, newNodeList); + } + newIndexList = indexList.set(key, newIndex); + } + + return new Index(newIndexList); + } + + + public Index putNodeAll(TreeNode node) { + List<String> keys = node.getAttributes().getKeys(); + TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexList = indexList; + + for (String key : keys) { + + String value = node.getAttributes().getString(key); + if (value == null) + continue; + + Option<TreeMap<String, List<TreeNode>>> indexOp = indexList.get(key); + if (indexOp.isNone()) + continue; + + TreeMap<String, List<TreeNode>> index = indexOp.some(); + Option<List<TreeNode>> nodeListOp = index.get(value); + TreeMap<String, List<TreeNode>> newIndex = index; + + if (nodeListOp.isNone()) { + List<TreeNode> newNodeList = List.nil(); + newNodeList = newNodeList.cons(node); + newIndex = newIndex.set(value, newNodeList); + } else { + List<TreeNode> newNodeList = nodeListOp.some(); + newNodeList = newNodeList.cons(node); + newIndex = newIndex.set(value, newNodeList); + } + + newIndexList = newIndexList.set(key, newIndex); + } + return new Index(newIndexList); + } + + public List<TreeNode> get(String key, String value) { + Option<TreeMap<String, List<TreeNode>>> indexOp = indexList.get(key); + if (indexOp.isNone()) + return List.nil(); + + TreeMap<String, List<TreeNode>> index = indexOp.some(); + Option<List<TreeNode>> nodeListOp = index.get(value); + + if (nodeListOp.isNone()) + return List.nil(); + + return nodeListOp.some(); + } + + + private TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() { + return indexList; + } + +}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexManager.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexManager.java Sat Nov 22 15:25:09 2014 +0900 @@ -1,8 +1,7 @@ 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.impl.TreeNode; @@ -19,7 +18,7 @@ this.reservation = reservation; } - public void commit(TreeMap<String, TreeMap<String, List<TreeNode>>> index){ + public void commit(Index index){ TreeContext tc = reservation.get(); ChangeSet cs = tc.getChangeSet(); TreeNode root = cs.getRoot(); @@ -28,7 +27,7 @@ String uuid = cs.uuid(); String treeName = cs.getTreeName(); long revision = cs.revision(); - TreeMap<TreeNode, TreeNode> parentIndex = cs.getParentIndex(); + ParentIndex parentIndex = cs.getParentIndex(); DefaultChangeSet newCs = new DefaultChangeSet(root, prev, cl, uuid, treeName, revision, index, parentIndex); DefaultTreeContext newTs = new DefaultTreeContext(root, newCs); reservation.set(newTs);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/ParentIndex.java Sat Nov 22 15:25:09 2014 +0900 @@ -0,0 +1,68 @@ +package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index; + +import java.util.Iterator; + +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNodeChildren; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.TreeMapOrd; +import fj.data.Option; +import fj.data.TreeMap; + +public class ParentIndex { + + private final TreeMap<TreeNode, TreeNode> parentIndex; + + public ParentIndex() { + parentIndex = TreeMap.empty(TreeMapOrd.treeNodeOrd); + } + + public ParentIndex(TreeMap<TreeNode, TreeNode> parentIndex) { + this.parentIndex = parentIndex; + } + + public ParentIndex(ParentIndex parentIndex) { + this.parentIndex = parentIndex.getParentIndex(); + } + + private TreeMap<TreeNode, TreeNode> getParentIndex() { + return parentIndex; + } + + public Option<TreeNode> get(TreeNode child) { + Option<TreeNode> parentOp = parentIndex.get(child); + return parentOp; + } + + public ParentIndex set(TreeNode child, TreeNode parent){ + TreeMap<TreeNode, TreeNode> newParentIndex = parentIndex.set(child,parent); + return new ParentIndex(newParentIndex); + } + + public ParentIndex delete(TreeNode child) { + TreeMap<TreeNode, TreeNode> newParentIndex = parentIndex.delete(child); + return new ParentIndex(newParentIndex); + } + + public ParentIndex deleteAllChildren(TreeNode parentNode) { + TreeNodeChildren children = parentNode.getChildren(); + Iterator<TreeNode> childrenIterator = children.iterator(); + TreeMap<TreeNode, TreeNode> newParentIndex = parentIndex; + for (; childrenIterator.hasNext();) { + TreeNode child = childrenIterator.next(); + newParentIndex = newParentIndex.delete(child); + } + return new ParentIndex(newParentIndex); + } + + public ParentIndex addAllChildren(TreeNode parentNode) { + TreeNodeChildren children = parentNode.getChildren(); + Iterator<TreeNode> childrenIterator = children.iterator(); + TreeMap<TreeNode, TreeNode> newParentIndex = parentIndex; + for (; childrenIterator.hasNext();) { + TreeNode child = childrenIterator.next(); + newParentIndex = newParentIndex.set(child, parentNode); + } + return new ParentIndex(newParentIndex); + } + +}
--- a/src/test/java/DefaultJungleTreeTest.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/test/java/DefaultJungleTreeTest.java Sat Nov 22 15:25:09 2014 +0900 @@ -1,6 +1,5 @@ import java.nio.ByteBuffer; -import fj.data.List; 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; @@ -47,8 +46,7 @@ // check the value ; TreeNode node = tree.getRootNode(); - List<ByteBuffer> valueList = node.getAttributes().get(key); - ByteBuffer v = valueList.head(); + ByteBuffer v = node.getAttributes().get(key); Assert.assertEquals(0,v.compareTo(value)); Assert.assertEquals(1,tree.revision()); // editor2 must fail transction
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/AttributesTest.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/AttributesTest.java Sat Nov 22 15:25:09 2014 +0900 @@ -12,10 +12,10 @@ public abstract class AttributesTest extends TestCase { @SuppressWarnings("unchecked") - public static List<P2<String,List<ByteBuffer>>> ENTRIES = List.list( - P.p("KEY1",List.list(ByteBuffer.wrap("VALUE1".getBytes()))), - P.p("KEY2",List.list(ByteBuffer.wrap("VALUE2".getBytes()))), - P.p("KEY3",List.list(ByteBuffer.wrap("VALUE3".getBytes()))) + public static 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 abstract Attributes instance(); @@ -24,12 +24,10 @@ { Attributes attrs = instance(); - for(P2<String,List<ByteBuffer>> entry : ENTRIES){ + for(P2<String,ByteBuffer> entry : ENTRIES){ String key = entry._1(); - List<ByteBuffer> expectList = entry._2(); - List<ByteBuffer> actualList = attrs.get(key); - ByteBuffer expect = expectList.head(); - ByteBuffer actual = actualList.head(); + ByteBuffer expect = entry._2(); + 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/GetOldTreeTest.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/GetOldTreeTest.java Sat Nov 22 15:25:09 2014 +0900 @@ -2,7 +2,6 @@ import java.nio.ByteBuffer; -import java.util.Iterator; import org.junit.Test; @@ -36,37 +35,13 @@ Assert.assertFalse(successEither.isA()); editor = successEither.b(); } - - JungleTreeEditor newEditor = tree.getTreeEditor(); - JungleTreeEditor newPutEditor = newEditor.putAttribute(path.add(9), "test", ByteBuffer.wrap("kanagawa".getBytes())).b(); - newPutEditor.success(); - + System.out.println(tree.revision()); TreeNode root = tree.getRootNode(); - Either<Error, TreeNode> childNodeEither = root.getChildren().at(9); - Assert.assertTrue(childNodeEither.isB()); - TreeNode child = childNodeEither.b(); - Iterator<String> valueIterator = child.getAttributes().getString("test"); - Assert.assertTrue(valueIterator.hasNext()); - String value = valueIterator.next(); - Assert.assertEquals(value,"kanagawa"); - - JungleTree oldTree1 = tree.getOldTree(10).b(); + Assert.assertTrue(root.getChildren().at(9).isB()); - TreeNode oldRoot1 = oldTree1.getRootNode(); - Either<Error, TreeNode> oldChildNodeEither = oldRoot1.getChildren().at(9); - Assert.assertTrue(oldChildNodeEither.isB()); - - TreeNode oldChildNode = oldChildNodeEither.b(); - Iterator<String> oldValueIterator = oldChildNode.getAttributes().getString("test"); - Assert.assertTrue(oldValueIterator.hasNext()); - String oldValue = oldValueIterator.next(); - Assert.assertEquals(oldValue,"tatsuki"); - - - JungleTree oldTree2 = tree.getOldTree(9).b(); - TreeNode oldRoot2 = oldTree2.getRootNode(); - Assert.assertTrue(oldRoot2.getChildren().at(9).isA()); - - + 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/impl/treeeditor/DefaultTreeEditorTest.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/impl/treeeditor/DefaultTreeEditorTest.java Sat Nov 22 15:25:09 2014 +0900 @@ -1,9 +1,7 @@ package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.impl.treeeditor; import java.nio.ByteBuffer; -import java.util.Iterator; -import fj.data.List; 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; @@ -55,16 +53,15 @@ DefaultTraverser traverser = new DefaultTraverser(); for(DefaultNodePath part : path.inits()){ - System.out.println(part.toString()); Either<Error,Traversal> either = traverser.traverse(newRoot,new DefaultEvaluator(part)); if(either.isA()){ Assert.fail(); } TreeNode target = either.b().destination(); String expected = part.toString(); - Iterator<String> actualIterator = target.getAttributes().getString(key); - Assert.assertTrue(actualIterator.hasNext()); - Assert.assertEquals(expected,actualIterator.next()); + String actual = new String(target.getAttributes().get(key).array()); + + Assert.assertEquals(expected,actual); } for(DefaultNodePath part : path.inits()){ @@ -73,9 +70,9 @@ Assert.fail(); } TreeNode target = either.b().destination(); - System.out.println(part.toString()); - List<ByteBuffer> actualList = target.getAttributes().get(key); - Assert.assertTrue(actualList.isEmpty()); + ByteBuffer actual = target.getAttributes().get(key); + + Assert.assertNull(actual); } }
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/nodeeditor/DeleteAttributeAtTest.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/nodeeditor/DeleteAttributeAtTest.java Sat Nov 22 15:25:09 2014 +0900 @@ -2,7 +2,6 @@ import java.nio.ByteBuffer; -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.logger.LoggingNode; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.DeleteAttribute; @@ -32,7 +31,7 @@ Assert.fail(); } LoggingNode newNode = either2.b(); - List<ByteBuffer> retList = newNode.getAttributes().get(key); - Assert.assertTrue(retList.isEmpty()); + ByteBuffer ret = newNode.getAttributes().get(key); + Assert.assertNull(ret); } }
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/nodeeditor/PutAttributeTest.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/core/nodeeditor/PutAttributeTest.java Sat Nov 22 15:25:09 2014 +0900 @@ -4,7 +4,6 @@ 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.logger.LoggingNode; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.PutAttribute; @@ -28,8 +27,7 @@ } LoggingNode newNode = either.b(); - List<ByteBuffer> retList = newNode.getAttributes().get(key); - ByteBuffer ret = retList.head(); + ByteBuffer ret = newNode.getAttributes().get(key); Assert.assertEquals(0,ret.compareTo(value)); } }
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/impl/clonable/DefaultTreeNodeAttributesTest.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/impl/clonable/DefaultTreeNodeAttributesTest.java Sat Nov 22 15:25:09 2014 +0900 @@ -10,6 +10,7 @@ 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.transaction.DefaultTreeNodeAttribute; import junit.framework.TestCase; import junit.framework.TestSuite; @@ -26,9 +27,9 @@ public static DefaultTreeNode instance() { List<TreeNode> rawList = List.nil(); - TreeMap<String,List<ByteBuffer>> rawMap = TreeMap.empty(Ord.stringOrd); + TreeMap<String,ByteBuffer> rawMap = TreeMap.empty(Ord.stringOrd); - for(P2<String,List<ByteBuffer>> entry : AttributesTest.ENTRIES){ + for(P2<String,ByteBuffer> entry : AttributesTest.ENTRIES){ rawMap = rawMap.set(entry._1(),entry._2()); }
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/impl/node/DefaultAttributesTest.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/impl/node/DefaultAttributesTest.java Sat Nov 22 15:25:09 2014 +0900 @@ -19,11 +19,11 @@ public TreeNodeAttributes instance() { List<TreeNode> rawList = List.nil(); - TreeMap<String,List<ByteBuffer>> rawMap = TreeMap.empty(Ord.stringOrd); + TreeMap<String,ByteBuffer> rawMap = TreeMap.empty(Ord.stringOrd); // add attributes - for(P2<String, List<ByteBuffer>> entry : ENTRIES){ + for(P2<String, ByteBuffer> entry : ENTRIES){ rawMap = rawMap.set(entry._1(),entry._2()); } @@ -34,22 +34,22 @@ public void testGetAttributesAsRawMap() { TreeNodeAttributes attrs = instance(); - TreeMap<String,List<ByteBuffer>> rawMap = attrs.getAttributesAsRawMap(); + TreeMap<String,ByteBuffer> rawMap = attrs.getAttributesAsRawMap(); // testing rawmap is not null. Assert.assertNotNull(rawMap); // testing rawmap has correct key values. - for(P2<String,List<ByteBuffer>> entry : ENTRIES){ + for(P2<String,ByteBuffer> entry : ENTRIES){ String key = entry._1(); - ByteBuffer value = entry._2().head(); + ByteBuffer value = entry._2(); - Option<List<ByteBuffer>> option = rawMap.get(key); + Option<ByteBuffer> option = rawMap.get(key); if(option.isNone()){ Assert.fail(); } - ByteBuffer actual = option.some().head(); + ByteBuffer actual = option.some(); Assert.assertEquals(0,actual.compareTo(value)); } }
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/impl/node/DefaultChildrenTest.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/impl/node/DefaultChildrenTest.java Sat Nov 22 15:25:09 2014 +0900 @@ -23,7 +23,7 @@ rawList = rawList.cons(new DefaultTreeNode()); } - TreeMap<String,List<ByteBuffer>> rawMap = TreeMap.empty(Ord.stringOrd); + TreeMap<String,ByteBuffer> rawMap = TreeMap.empty(Ord.stringOrd); return new DefaultTreeNode(rawList,rawMap).getChildren(); }
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/impl/node/DefaultNodeTest.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/impl/node/DefaultNodeTest.java Sat Nov 22 15:25:09 2014 +0900 @@ -30,7 +30,7 @@ public static DefaultTreeNode instance() { List<TreeNode> rawList = List.nil(); - TreeMap<String,List<ByteBuffer>> rawMap = TreeMap.empty(Ord.stringOrd); + TreeMap<String,ByteBuffer> rawMap = TreeMap.empty(Ord.stringOrd); DefaultTreeNode node = new DefaultTreeNode(rawList,rawMap); return node;
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverse/TraverserTest.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverse/TraverserTest.java Sat Nov 22 15:25:09 2014 +0900 @@ -43,8 +43,7 @@ Traversal traversal = ret.b(); TreeNode target = traversal.destination(); String expect = path.toString(); - List<ByteBuffer> valueList = target.getAttributes().get(key); - ByteBuffer value = valueList.head(); + ByteBuffer value = target.getAttributes().get(key); String actual = new String(value.array()); Assert.assertEquals(expect,actual); @@ -53,7 +52,7 @@ for(Direction<TreeNode> d : traversal){ DefaultNodePath part = parts.head(); parts = parts.tail(); - value = d.getTarget().getAttributes().get(key).head(); + value = d.getTarget().getAttributes().get(key); String actualCurrentPathStr = new String(value.array()); String expectCurrentPathStr = part.toString(); Assert.assertEquals(expectCurrentPathStr,actualCurrentPathStr);
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/ParentIndexTest.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/index/ParentIndexTest.java Sat Nov 22 15:25:09 2014 +0900 @@ -10,13 +10,10 @@ 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.traverser.DefaultTraverser; +import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; import junit.framework.Assert; - import org.junit.Test; - -import fj.data.List; import fj.data.Option; -import fj.data.TreeMap; public class ParentIndexTest { @@ -28,14 +25,14 @@ JungleTreeEditor editor = tree.getIndexTreeEditor(); DefaultNodePath path = new DefaultNodePath(); editor = editor.addNewChildAt(path, 0).b(); - - + for (int num = 0; num < 5; num++) { - editor = editor.addNewChildAt(path.add(0), num).b().success().b(); - editor = editor.putAttribute(path.add(0).add(num), "test",ByteBuffer.wrap("test".getBytes())).b().success().b(); + editor = editor.addNewChildAt(path.add(0), num).b(); + editor = editor.putAttribute(path.add(0).add(num), "test", ByteBuffer.wrap("test".getBytes())).b(); + editor = editor.success().b(); } - - TreeMap<TreeNode, TreeNode> parentIndex = tree.getParentIndex(); + + ParentIndex parentIndex = tree.getParentIndex(); TreeNode node = tree.getRootNode(); for (int num = 0; node.getChildren().size() != 0; num++) { Iterator<TreeNode> children = node.getChildren().iterator(); @@ -52,9 +49,9 @@ TreeNode oldNode = oldRoot.getChildren().at(0).b(); Option<TreeNode> oldParentOp = parentIndex.get(oldNode); Assert.assertTrue(oldParentOp.isNone()); - TreeMap<TreeNode, TreeNode> oldTreeParentIndex = oldTree.getParentIndex(); + ParentIndex oldTreeParentIndex = oldTree.getParentIndex(); oldParentOp = oldTreeParentIndex.get(oldNode); Assert.assertTrue(oldParentOp.isSome()); - + } }
--- a/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/query/SearchQueryTest.java Fri Nov 21 12:49:28 2014 +0900 +++ b/src/test/java/jp/ac/u_ryukyu/ie/cr/tatsuki/query/SearchQueryTest.java Sat Nov 22 15:25:09 2014 +0900 @@ -1,9 +1,11 @@ package jp.ac.u_ryukyu.ie.cr.tatsuki.query; import java.nio.ByteBuffer; +import java.security.KeyStore.Entry.Attribute; import java.util.Iterator; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungleTree; 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; @@ -18,6 +20,7 @@ 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.PathNodeIndexIterator; import org.junit.Assert; import org.junit.Test; @@ -28,7 +31,7 @@ public class SearchQueryTest { - @Test + @Test public void SearchQueryTest() { Jungle jungle = new DefaultJungle(null, "hogehoge",new DefaultTraverser()); jungle.createNewTree("tree"); @@ -36,21 +39,17 @@ createTree(tree); tree.getRootNode(); InterfaceTraverser ifTraverser = tree.getTraverser(); - TreeMap<String, TreeMap<String, List< NodePath>>> cheackIndex = ifTraverser.getIndex(); + TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> cheackIndex = ifTraverser.getIndex(); Assert.assertTrue(cheackIndex.isEmpty()); Iterator<Pair<TreeNode, NodePath>> searchNode = ifTraverser.find( (TreeNode node) -> { - List<ByteBuffer> attributeList = node.getAttributes().get(key); - if(attributeList.isNotEmpty()){ - for (ByteBuffer attribute : attributeList) { + ByteBuffer attribute = node.getAttributes().get(key); + if(attribute != null){ byte[] byteAttribute = attribute.array(); String str = new String(byteAttribute); System.out.println("attribute = " + str); - if (str.equals("<-1,0,1>")) - return true; - continue; - } + return str.equals("<-1,0,1>"); } return false; } @@ -58,62 +57,60 @@ while (searchNode.hasNext()){ - TreeNode node = searchNode.next().left(); - Assert.assertTrue(compare(node,"<-1,0,1>")); + Assert.assertTrue(compare(searchNode.next().left(),"<-1,0,1>")); } - TreeMap<String, TreeMap<String, List<NodePath>>> index = ifTraverser.getIndex(); - Option<TreeMap<String, List<NodePath>>> opIndex = index.get(key); + 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<NodePath>> innerIndex = opIndex.some(); + TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = opIndex.some(); Assert.assertTrue(!innerIndex.get("<-1,0,0>").isNone()); } + + + public boolean compare(TreeNode compareNode, String compareAttribute) { + String labName = compareNode.getAttributes().getString(key); + if (labName.equals(compareAttribute)) + return true; + return false; + } - public boolean compare(TreeNode compareNode, String compareAttribute) { - Iterator<String> labNameIterator = compareNode.getAttributes().getString(key); - Assert.assertTrue(labNameIterator.hasNext()); - String labName = labNameIterator.next(); - 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); - 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); + } + } - 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(); - } + 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(); + } }