Mercurial > hg > Members > tatsuki > bench > jungle-core

comparison src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/IndexJungleTreeEditor.java @ 149:feb2346ace19

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
refactor ParentIndex
author one
date Sat, 22 Nov 2014 12:08:35 +0900
parents 371b6ddb78f2
children d9fbddf77bf6
comparison
equal deleted inserted replaced
147:af67dd0b5ba2 149:feb2346ace19
1 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction; 1 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction;
2 2
3 import java.nio.ByteBuffer; 3 import java.nio.ByteBuffer;
4 4 import java.util.Iterator;
5
6 import fj.P2;
5 import fj.data.List; 7 import fj.data.List;
6 import fj.data.TreeMap; 8 import fj.data.TreeMap;
7 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor; 9 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
8 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; 10 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
9 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.IndexTreeEditor; 11 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.IndexTreeEditor;
10 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; 12 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
13 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNodeChildren;
11 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultTreeOperationLog; 14 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultTreeOperationLog;
12 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode; 15 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
13 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog; 16 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog;
14 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog; 17 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.TreeOperationLog;
15 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation; 18 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DefaultTreeOperation;
22 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.PutAttribute; 25 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.PutAttribute;
23 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither; 26 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
24 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; 27 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
25 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; 28 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
26 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.IterableConverter; 29 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.IterableConverter;
27 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Triple; 30 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
31 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.TreeMapOrd;
28 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.DefaultIndexEditor; 32 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.DefaultIndexEditor;
29 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.DeleteChildIndexEditor; 33 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.DeleteChildIndexEditor;
30 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexEditor; 34 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexEditor;
35 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
31 36
32 public class IndexJungleTreeEditor implements JungleTreeEditor { 37 public class IndexJungleTreeEditor implements JungleTreeEditor {
33 private final TransactionManager txManager; 38 private final TransactionManager txManager;
34 private final TreeNode root; 39 private final TreeNode root;
40 private final TreeNode oldRoot;
35 private final IndexTreeEditor editor; 41 private final IndexTreeEditor editor;
36 private final TreeOperationLog log; 42 private final TreeOperationLog log;
43 private final TreeOperationLog tmpLog;
37 private TreeMap<String, TreeMap<String, List<TreeNode>>> index; 44 private TreeMap<String, TreeMap<String, List<TreeNode>>> index;
38 private TreeMap<TreeNode, TreeNode> parentIndex; 45 private ParentIndex parentIndex;
39 46
40 public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() { 47 public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
41 return index; 48 return index;
42 } 49 }
43 50
44 51 public IndexJungleTreeEditor(TreeNode _root, TreeNode oldRoot, TransactionManager _txManager,
45 52 IndexTreeEditor treeEditor, TreeMap<String, TreeMap<String, List<TreeNode>>> index,
46 public IndexJungleTreeEditor(TreeNode _root, TransactionManager _txManager, IndexTreeEditor treeEditor, 53 ParentIndex parentIndex) {
47 TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode, TreeNode> parentIndex) { 54 this(_root, oldRoot, _txManager, treeEditor, new DefaultTreeOperationLog(), new DefaultTreeOperationLog(), index, parentIndex);
48 this(_root, _txManager, treeEditor, new DefaultTreeOperationLog(), index,parentIndex); 55 }
49 } 56
50 57 public IndexJungleTreeEditor(TreeNode _root, TreeNode oldRoot, TransactionManager _txManager,
51 public IndexJungleTreeEditor(TreeNode newNode, TransactionManager _txManager, IndexTreeEditor _editor, 58 IndexTreeEditor treeEditor, TreeOperationLog log, TreeMap<String, TreeMap<String, List<TreeNode>>> index,
52 TreeOperationLog _log, TreeMap<String, TreeMap<String, List<TreeNode>>> index,TreeMap<TreeNode, TreeNode> parentIndex) { 59 ParentIndex parentIndex) {
60 this(_root, oldRoot, _txManager, treeEditor, log, new DefaultTreeOperationLog(), index, parentIndex);
61 }
62
63 public IndexJungleTreeEditor(TreeNode newNode, TreeNode oldRoot, TransactionManager _txManager,
64 IndexTreeEditor _editor, TreeOperationLog _log, TreeOperationLog tmpLog,
65 TreeMap<String, TreeMap<String, List<TreeNode>>> index, ParentIndex parentIndex) {
53 this.root = newNode; 66 this.root = newNode;
67 this.oldRoot = oldRoot;
54 this.txManager = _txManager; 68 this.txManager = _txManager;
55 this.editor = _editor; 69 this.editor = _editor;
56 this.log = _log; 70 this.log = _log;
57 this.index = index; 71 this.index = index;
58 this.parentIndex = parentIndex; 72 this.parentIndex = parentIndex;
59 } 73 this.tmpLog = tmpLog;
60 74 }
61 75
62 public Either<Error, IndexJungleTreeEditor> _edit(final NodePath _path, NodeEditor _e, IndexEditor indexEditor) { 76 public Either<Error, IndexJungleTreeEditor> _edit(final NodePath _path, NodeEditor _e, IndexEditor indexEditor) {
63 Either<Error,Triple<LoggingNode, TreeMap<TreeNode, TreeNode>,TreeMap<String,TreeMap<String,List<TreeNode>>>>> either = editor.edit(root, _path, _e, parentIndex, indexEditor); 77 Either<Error, LoggingNode> either = editor.edit(root, _path, _e);
64 if (either.isA()) { 78 if (either.isA()) {
65 return DefaultEither.newA(either.a()); 79 return DefaultEither.newA(either.a());
66 } 80 }
67 81
68 LoggingNode newLogging = either.b().getA(); 82 LoggingNode newLogging = either.b();
69 TreeMap<TreeNode,TreeNode> newParentIndex = either.b().getB();
70 TreeMap<String,TreeMap<String,List<TreeNode>>> newIndex = either.b().getC();
71 OperationLog newLog = newLogging.getOperationLog(); 83 OperationLog newLog = newLogging.getOperationLog();
72 TreeNode newNode = newLogging.getWrap(); 84 TreeNode newNode = newLogging.getWrap();
73 85
74 IterableConverter.Converter<TreeOperation, NodeOperation> converter = new IterableConverter.Converter<TreeOperation, NodeOperation>() { 86 IterableConverter.Converter<TreeOperation, NodeOperation> converter = new IterableConverter.Converter<TreeOperation, NodeOperation>() {
75 @Override 87 @Override
78 } 90 }
79 }; 91 };
80 92
81 Iterable<TreeOperation> iterable = new IterableConverter<TreeOperation, NodeOperation>(newLog, converter); 93 Iterable<TreeOperation> iterable = new IterableConverter<TreeOperation, NodeOperation>(newLog, converter);
82 DefaultTreeOperationLog treeOperationLog = new DefaultTreeOperationLog(iterable, newLog.length()); 94 DefaultTreeOperationLog treeOperationLog = new DefaultTreeOperationLog(iterable, newLog.length());
83 TreeOperationLog newTreeOpLog = log.append(treeOperationLog); 95 TreeOperationLog newTmpLog = tmpLog.append(treeOperationLog);
84 IndexJungleTreeEditor newIndexTreeEditor = new IndexJungleTreeEditor(newNode, txManager, this.editor,newTreeOpLog, newIndex, newParentIndex); 96 IndexJungleTreeEditor newIndexTreeEditor = new IndexJungleTreeEditor(newNode, oldRoot, txManager, this.editor, log,
97 newTmpLog, index, parentIndex);
85 return DefaultEither.newB(newIndexTreeEditor); 98 return DefaultEither.newB(newIndexTreeEditor);
86 } 99 }
87 100
88 @Override 101 @Override
89 public Either<Error, JungleTreeEditor> addNewChildAt(NodePath _path, int _pos) { 102 public Either<Error, JungleTreeEditor> addNewChildAt(NodePath _path, int _pos) {
132 return newEither; 145 return newEither;
133 } 146 }
134 147
135 @Override 148 @Override
136 public Either<Error, JungleTreeEditor> success() { 149 public Either<Error, JungleTreeEditor> success() {
137 Either<Error, TransactionManager> either = txManager.commit(root, log, index,parentIndex); 150 ParentIndex newParentIndex = editParentIndex(tmpLog);
151 TreeOperationLog newLog = log.append(tmpLog);
152 Either<Error, TransactionManager> either = txManager.commit(root, newLog, index, newParentIndex);
138 if (either.isA()) { 153 if (either.isA()) {
139 return DefaultEither.newA(either.a()); 154 return DefaultEither.newA(either.a());
140 } 155 }
141 156
142 TransactionManager newTxManager = either.b(); 157 TransactionManager newTxManager = either.b();
143 JungleTreeEditor newTreeEditor = new IndexJungleTreeEditor(root, newTxManager, editor, index,parentIndex); 158 JungleTreeEditor newTreeEditor = new IndexJungleTreeEditor(root, root, newTxManager, editor, index, parentIndex);
144 159
145 return DefaultEither.newB(newTreeEditor); 160 return DefaultEither.newB(newTreeEditor);
161 }
162
163 private ParentIndex editParentIndex(TreeOperationLog tmpLog) {
164 TreeMap<TreeNode, TreeNode> putParentNodeMap = TreeMap.empty(TreeMapOrd.treeNodeOrd);
165 TreeMap<TreeNode, TreeNode> deleteParentNodeMap = TreeMap.empty(TreeMapOrd.treeNodeOrd);
166 for (TreeOperation log : tmpLog) {
167
168 NodePath targetNodePath = log.getNodePath();
169 putParentNodeMap = getTargetNode(TreeMap.empty(TreeMapOrd.treeNodeOrd), root, targetNodePath);
170 deleteParentNodeMap = getTargetNode(TreeMap.empty(TreeMapOrd.treeNodeOrd), oldRoot, targetNodePath);
171 System.out.println(log.getNodePath().toString());
172 }
173
174 ParentIndex newParentIndex = parentIndex;
175 if (!deleteParentNodeMap.isEmpty())
176 newParentIndex = deleteParentIndex(putParentNodeMap, newParentIndex);
177
178
179 if (!putParentNodeMap.isEmpty())
180 newParentIndex = putParentIndex(putParentNodeMap,newParentIndex);
181
182 return newParentIndex;
183 }
184
185 private ParentIndex deleteParentIndex(TreeMap<TreeNode, TreeNode> deleteParentNodeMap, ParentIndex editParentIndex) {
186 Iterator<P2<TreeNode, TreeNode>> parentNodeIterator = deleteParentNodeMap.iterator();
187 ParentIndex newParentIndex = editParentIndex;
188
189 for (; parentNodeIterator.hasNext();) {
190 TreeNode parentNode = parentNodeIterator.next()._1();
191 TreeNodeChildren children = parentNode.getChildren();
192 Iterator<TreeNode> childrenIterator = children.iterator();
193
194 for (; childrenIterator.hasNext();) {
195 TreeNode child = childrenIterator.next();
196 newParentIndex = newParentIndex.delete(child);
197 }
198 }
199 return newParentIndex;
200 }
201
202 private ParentIndex putParentIndex(TreeMap<TreeNode, TreeNode> putParentNodeMap,ParentIndex editParentIndex) {
203 Iterator<P2<TreeNode, TreeNode>> parentNodeIterator = putParentNodeMap.iterator();
204 ParentIndex newParentIndex = editParentIndex;
205
206 for (; parentNodeIterator.hasNext();) {
207 TreeNode parentNode = parentNodeIterator.next()._1();
208 TreeNodeChildren children = parentNode.getChildren();
209 Iterator<TreeNode> childrenIterator = children.iterator();
210
211 for (; childrenIterator.hasNext();) {
212 TreeNode child = childrenIterator.next();
213 newParentIndex = newParentIndex.set(child, parentNode);
214 }
215 }
216 return newParentIndex;
217 }
218
219 private TreeMap<TreeNode, TreeNode> getTargetNode(TreeMap<TreeNode, TreeNode> treeNodeMap, TreeNode node,
220 NodePath path) {
221 if (path.size() == 0)
222 return treeNodeMap;
223
224 Pair<Integer, NodePath> pathNode = path.pop();
225
226 if (pathNode.left() == -1) {
227 TreeMap<TreeNode, TreeNode> newTreeNodeMap = treeNodeMap.set(node, node);
228 return getTargetNode(newTreeNodeMap, node, pathNode.right());
229 }
230
231 Either<Error, TreeNode> either = node.getChildren().at(pathNode.left());
232 if (either.isA())
233 return treeNodeMap;
234
235 TreeNode child = either.b();
236 TreeMap<TreeNode, TreeNode> newTreeNodeMap = treeNodeMap.set(child, child);
237 if (pathNode.right().size() == 0)
238 return newTreeNodeMap;
239
240 return getTargetNode(newTreeNodeMap, child, pathNode.right());
241
146 } 242 }
147 243
148 @Override 244 @Override
149 public String getID() { 245 public String getID() {
150 return txManager.getUUID(); 246 return txManager.getUUID();