Mercurial > hg > Members > nobuyasu > jungle-network

comparison src/main/java/app/bbs/NetworkJungleBulletinBoard.java @ 177:6f104ab4eb81

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
fit jungle core but editMessage is not work
author tatsuki
date Mon, 01 Sep 2014 00:04:32 +0900
parents ac7d1070f449
children d6944d788121
comparison
equal deleted inserted replaced
176:ac7d1070f449 177:6f104ab4eb81
14 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle; 14 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
15 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree; 15 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
16 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor; 16 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
17 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.bbs.BoardMessage; 17 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.bbs.BoardMessage;
18 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Children; 18 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Children;
19 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Node;
20 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList; 19 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList;
21 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListReader; 20 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListReader;
22 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath; 21 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
23 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor; 22 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
24 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TraversableNodeWrapper; 23 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
25 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableNode; 24 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.DefaultOperationLog;
25 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog;
26 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation;
26 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditor; 27 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditor;
27 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultEvaluator; 28 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultEvaluator;
28 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser; 29 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
29 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Traversal; 30 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Traversal;
30 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither; 31 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
41 private AtomicInteger requestCounter; 42 private AtomicInteger requestCounter;
42 private long renewTime; 43 private long renewTime;
43 44
44 private NetworkJungleBulletinBoard(String _uuid, NetworkJournal _journal) { 45 private NetworkJungleBulletinBoard(String _uuid, NetworkJournal _journal) {
45 journal = _journal; 46 journal = _journal;
46 jungle = new NetworkDefaultJungle(journal, _uuid, new DefaultTreeEditor(new DefaultTraverser())); 47 jungle = new NetworkDefaultJungle(journal, _uuid,
48 new DefaultTreeEditor(new DefaultTraverser()));
47 BulletinBoardJungleManager.setJungle(jungle); 49 BulletinBoardJungleManager.setJungle(jungle);
48 persistentFlag = false; 50 persistentFlag = false;
49 requestCounter = BulletinBoardJungleManager.getRequestCounter(); 51 requestCounter = BulletinBoardJungleManager.getRequestCounter();
50 LOG_DIR = "./log"; 52 LOG_DIR = "./log";
51 renewTime = 0; 53 renewTime = 0;
55 this(_uuid, new AliceJournal()); 57 this(_uuid, new AliceJournal());
56 jungle.createNewTree("boards"); 58 jungle.createNewTree("boards");
57 } 59 }
58 60
59 public static NetworkBulletinBoard NewPersistentJungle(String _uuid) { 61 public static NetworkBulletinBoard NewPersistentJungle(String _uuid) {
60 NetworkJungleBulletinBoard board = new NetworkJungleBulletinBoard( _uuid, new PersistentJournal()); 62 NetworkJungleBulletinBoard board = new NetworkJungleBulletinBoard(
63 _uuid, new PersistentJournal());
61 board.persistentFlag = true; 64 board.persistentFlag = true;
62 return board; 65 return board;
63 } 66 }
64 67
65 public void init() { 68 public void init() {
107 JungleTree tree = jungle.getTreeByName(treeName); 110 JungleTree tree = jungle.getTreeByName(treeName);
108 if (tree == null) { 111 if (tree == null) {
109 tree = jungle.createNewTree(treeName); 112 tree = jungle.createNewTree(treeName);
110 } 113 }
111 JungleTreeEditor editor = tree.getLocalTreeEditor(); 114 JungleTreeEditor editor = tree.getLocalTreeEditor();
112 Either<Error, JungleTreeEditor> either = JungleUpdater.edit(editor, chList); 115 Either<Error, JungleTreeEditor> either = JungleUpdater.edit(editor,
116 chList);
113 editor = either.b(); 117 editor = either.b();
114 if (either.isA()) { 118 if (either.isA()) {
115 throw new IOException("Failed commit log recovery"); 119 throw new IOException("Failed commit log recovery");
116 } 120 }
117 editor.success(); 121 editor.success();
118 } 122 }
119 } 123 }
120 124
121 public Iterable<String> getBoards() { 125 public Iterable<String> getBoards() {
122 JungleTree tree = jungle.getTreeByName("boards"); 126 JungleTree tree = jungle.getTreeByName("boards");
123 Node node = tree.getRootNode(); 127 TreeNode node = tree.getRootNode();
124 Children<Node> chs = node.getChildren(); 128 Children<TreeNode> chs = node.getChildren();
125 129
126 IterableConverter.Converter<String, Node> converter = new IterableConverter.Converter<String, Node>() { 130 IterableConverter.Converter<String, TreeNode> converter = new IterableConverter.Converter<String, TreeNode>() {
127 public String conv(Node _b) { 131 public String conv(TreeNode _b) {
128 ByteBuffer e = _b.getAttributes().get("name"); 132 ByteBuffer e = _b.getAttributes().get("name");
129 System.out.println(new String(e.array())); 133 System.out.println(new String(e.array()));
130 return new String(e.array()); 134 return new String(e.array());
131 } 135 }
132 }; 136 };
133 137
134 return new IterableConverter<String, Node>(chs, converter); 138 return new IterableConverter<String, TreeNode>(chs, converter);
135 } 139 }
136 140
137 public long getRenewTime(String _boardName) { 141 public long getRenewTime(String _boardName) {
138 return renewTime; 142 return renewTime;
139 } 143 }
151 if (either.isA()) { 155 if (either.isA()) {
152 throw new IllegalStateException(); 156 throw new IllegalStateException();
153 } 157 }
154 editor = either.b(); 158 editor = either.b();
155 159
156 either = editor.putAttribute(root.add(0), "name",ByteBuffer.wrap(_name.getBytes())); 160 either = editor.putAttribute(root.add(0), "name",
161 ByteBuffer.wrap(_name.getBytes()));
157 if (either.isA()) { 162 if (either.isA()) {
158 throw new IllegalStateException(); 163 throw new IllegalStateException();
159 } 164 }
160 editor = either.b(); 165 editor = either.b();
161 final long timestamp = System.currentTimeMillis(); 166 final long timestamp = System.currentTimeMillis();
177 throw new IllegalStateException(); 182 throw new IllegalStateException();
178 } 183 }
179 editor = either.b(); 184 editor = either.b();
180 185
181 NodeEditor e = new NodeEditor() { 186 NodeEditor e = new NodeEditor() {
182 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) { 187 ByteBuffer tBuffer2 = ByteBuffer.allocate(16);
183 _e = _e.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b(); 188
184 _e = _e.getAttributes().put("mes", ByteBuffer.wrap(_initMessage.getBytes())).b(); 189 public <T extends TreeNode> Either<Error, TreeNode> edit(T _e) {
185 _e = _e.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b(); 190 TreeNode node = _e;
186 ByteBuffer tBuffer2 = ByteBuffer.allocate(16); 191 node = node.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
192 node = node.getAttributes().put("mes", ByteBuffer.wrap(_initMessage.getBytes())).b();
193 node = node.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
187 tBuffer2.putLong(timestamp); 194 tBuffer2.putLong(timestamp);
188 _e = _e.getAttributes().put("timestamp", tBuffer2).b(); 195 node = node.getAttributes().put("timestamp", tBuffer2).b();
189 return DefaultEither.newB(_e); 196 return DefaultEither.newB(node);
197 }
198
199 @Override
200 public OperationLog getLog() {
201 OperationLog op = new DefaultOperationLog();
202 op = op.add(new PutAttributeOperation("author", ByteBuffer.wrap(_author.getBytes())));
203 op = op.add(new PutAttributeOperation("mes", ByteBuffer.wrap(_initMessage.getBytes())));
204 op = op.add(new PutAttributeOperation("key", ByteBuffer.wrap(_editKey.getBytes())));
205 op = op.add(new PutAttributeOperation("timestamp", tBuffer2));
206 return op;
190 } 207 }
191 }; 208 };
192 209
193 either = editor.edit(root.add(0), e); 210 either = editor.edit(root.add(0), e);
194 if (either.isA()) { 211 if (either.isA()) {
201 public void createFolder(final String _board, final String _author, final String _message, final String _editKey, String _nodeNum) { 218 public void createFolder(final String _board, final String _author, final String _message, final String _editKey, String _nodeNum) {
202 JungleTree tree = jungle.getTreeByName(_board); 219 JungleTree tree = jungle.getTreeByName(_board);
203 if (tree == null) { 220 if (tree == null) {
204 throw new IllegalStateException(); 221 throw new IllegalStateException();
205 } 222 }
206 223
207 DefaultNodePath path = new DefaultNodePath(); 224 DefaultNodePath path = new DefaultNodePath();
208 try { 225 try {
209 for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) { 226 for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) {
210 if (!_nodeNum.substring(count, count + 1).equals("/")) 227 if (!_nodeNum.substring(count, count + 1).equals("/"))
211 path = path.add(Integer.parseInt(_nodeNum.substring(count, count + 1))); 228 path = path.add(Integer.parseInt(_nodeNum.substring(count,
229 count + 1)));
212 } 230 }
213 } catch (Exception _e) { 231 } catch (Exception _e) {
214 } 232 }
215 requestCounter.incrementAndGet(); 233 requestCounter.incrementAndGet();
216 Either<Error, JungleTreeEditor> either; 234 Either<Error, JungleTreeEditor> either;
217 final long timestamp = System.currentTimeMillis(); 235 final long timestamp = System.currentTimeMillis();
218 final ByteBuffer tBuffer = ByteBuffer.allocate(16); 236 final ByteBuffer tBuffer = ByteBuffer.allocate(16);
219 tBuffer.putLong(timestamp); 237 tBuffer.putLong(timestamp);
220 238
221 do { 239 do {
222 Node node = tree.getRootNode(); 240 TreeNode node = tree.getRootNode();
223 DefaultTraverser traverser = new DefaultTraverser(); 241 DefaultTraverser traverser = new DefaultTraverser();
224 TraversableNodeWrapper<Node> traversable = new TraversableNodeWrapper<Node>(node); 242 // TraversableNodeWrapper<Node> traversable = new
243 // TraversableNodeWrapper<Node>(node);
225 DefaultEvaluator evaluator = new DefaultEvaluator(path); 244 DefaultEvaluator evaluator = new DefaultEvaluator(path);
226 Either<Error, Traversal<TraversableNodeWrapper<Node>>> ret = traverser.traverse(traversable, evaluator); 245 Either<Error, Traversal<TreeNode>> ret = traverser.traverse(node,
246 evaluator);
227 if (ret.isA()) { 247 if (ret.isA()) {
228 Assert.fail(); 248 Assert.fail();
229 } 249 }
230 250
231 Traversal<TraversableNodeWrapper<Node>> traversal = ret.b(); 251 Traversal<TreeNode> traversal = ret.b();
232 TraversableNodeWrapper<Node> target = traversal.destination(); 252 TreeNode target = traversal.destination();
233 int size = target.getWrapped().getChildren().size(); 253 int size = target.getChildren().size();
234 JungleTreeEditor editor = tree.getTreeEditor(); 254 JungleTreeEditor editor = tree.getTreeEditor();
235 either = editor.addNewChildAt(path, size); 255 either = editor.addNewChildAt(path, size);
236 if (either.isA()) { 256 if (either.isA()) {
237 throw new IllegalStateException(); 257 throw new IllegalStateException();
238 } 258 }
239 editor = either.b(); 259 editor = either.b();
240 260
241 NodeEditor e = new NodeEditor() { 261 NodeEditor e = new NodeEditor() {
242 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) { 262
243 _e = _e.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b(); 263 public <T extends TreeNode> Either<Error, TreeNode> edit(T _e) {
244 _e = _e.getAttributes().put("timestamp", tBuffer).b(); 264 TreeNode node = _e;
245 return DefaultEither.newB(_e); 265 node = node.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
266 node = node.getAttributes().put("timestamp", tBuffer).b();
267 return DefaultEither.newB(node);
268 }
269
270 @Override
271 public OperationLog getLog() {
272 OperationLog op = new DefaultOperationLog();
273 op = op.add(new PutAttributeOperation("mes", ByteBuffer.wrap(_message.getBytes())));
274 op = op.add(new PutAttributeOperation("timestamp", tBuffer));
275 return op;
246 } 276 }
247 }; 277 };
248 path = path.add(size); 278 path = path.add(size);
249 either = editor.edit(path, e); 279 either = editor.edit(path, e);
250 if (either.isA()) { 280 if (either.isA()) {
266 Either<Error, JungleTreeEditor> either; 296 Either<Error, JungleTreeEditor> either;
267 final long timestamp = System.currentTimeMillis(); 297 final long timestamp = System.currentTimeMillis();
268 final ByteBuffer tBuffer = ByteBuffer.allocate(16); 298 final ByteBuffer tBuffer = ByteBuffer.allocate(16);
269 tBuffer.putLong(timestamp); 299 tBuffer.putLong(timestamp);
270 do { 300 do {
271 301
272 Node node = tree.getRootNode(); 302 TreeNode node = tree.getRootNode();
273 int size = node.getChildren().size(); 303 int size = node.getChildren().size();
274 DefaultNodePath path = new DefaultNodePath(); 304 DefaultNodePath path = new DefaultNodePath();
275 305
276 JungleTreeEditor editor = tree.getTreeEditor(); 306 JungleTreeEditor editor = tree.getTreeEditor();
277 either = editor.addNewChildAt(path, size); 307 either = editor.addNewChildAt(path, size);
279 throw new IllegalStateException(); 309 throw new IllegalStateException();
280 } 310 }
281 editor = either.b(); 311 editor = either.b();
282 312
283 NodeEditor e = new NodeEditor() { 313 NodeEditor e = new NodeEditor() {
284 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) { 314 public <T extends TreeNode> Either<Error, TreeNode> edit(T _e) {
285 _e = _e.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b(); 315 TreeNode node = _e;
286 _e = _e.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b(); 316 node = node.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
287 _e = _e.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b(); 317 node = node.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
288 _e = _e.getAttributes().put("timestamp", tBuffer).b(); 318 node = node.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
289 return DefaultEither.newB(_e); 319 node = node.getAttributes().put("timestamp", tBuffer).b();
320 return DefaultEither.newB(node);
321 }
322
323 @Override
324 public OperationLog getLog() {
325 OperationLog op = new DefaultOperationLog();
326 op = op.add(new PutAttributeOperation("author", ByteBuffer.wrap(_author.getBytes())));
327 op = op.add(new PutAttributeOperation("mes", ByteBuffer.wrap(_message.getBytes())));
328 op = op.add(new PutAttributeOperation("key", ByteBuffer.wrap(_editKey.getBytes())));
329 op = op.add(new PutAttributeOperation("timestamp", tBuffer));
330 return op;
290 } 331 }
291 }; 332 };
292 path = path.add(size); 333 path = path.add(size);
293 either = editor.edit(path, e); 334 either = editor.edit(path, e);
294 if (either.isA()) { 335 if (either.isA()) {
298 either = editor.success(); 339 either = editor.success();
299 } while (either.isA()); 340 } while (either.isA());
300 341
301 } 342 }
302 343
303 public void editMessage(String _board, String _nodeNum, final String _author, final String _message, final String _editKey) { 344 public void editMessage(String _board, String _nodeNum,final String _author, final String _message, final String _editKey) {
304 requestCounter.incrementAndGet(); 345 requestCounter.incrementAndGet();
305 final long timestamp = System.currentTimeMillis(); 346 final long timestamp = System.currentTimeMillis();
306 final ByteBuffer tBuffer = ByteBuffer.allocate(16); 347 final ByteBuffer tBuffer = ByteBuffer.allocate(16);
307 tBuffer.putLong(timestamp); 348 tBuffer.putLong(timestamp);
308 JungleTree tree = jungle.getTreeByName(_board); 349 JungleTree tree = jungle.getTreeByName(_board);
309 Either<Error, JungleTreeEditor> either = null; 350 Either<Error, JungleTreeEditor> either = null;
310 351
311 do { 352 do {
312 DefaultNodePath path = new DefaultNodePath(); 353 DefaultNodePath path = new DefaultNodePath();
313 try { 354 try {
314 for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) { 355 for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) {
315 if (!_nodeNum.substring(count, count + 1).equals("/")) 356 if (!_nodeNum.substring(count, count + 1).equals("/"))
316 path = path.add(Integer.parseInt(_nodeNum.substring(count,count + 1))); 357 path = path.add(Integer.parseInt(_nodeNum.substring(count, count + 1)));
317 } 358 }
318 } catch (Exception _e) { 359 } catch (Exception _e) {
319 } 360 }
320 JungleTreeEditor editor = tree.getTreeEditor(); 361 JungleTreeEditor editor = tree.getTreeEditor();
321 NodeEditor e = new NodeEditor() { 362 NodeEditor e = new NodeEditor() {
322 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) { 363 public <T extends TreeNode> Either<Error, TreeNode> edit(T _e) {
323 _e = _e.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b(); 364 TreeNode node = _e;
324 _e = _e.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b(); 365 System.out.println(new String(node.getAttributes().get("mes").array()));
325 _e = _e.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b(); 366 node = node.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
326 _e = _e.getAttributes().put("timestamp", tBuffer).b(); 367 node = node.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
327 return DefaultEither.newB(_e); 368 node = node.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
369 node = node.getAttributes().put("timestamp", tBuffer).b();
370 System.out.println(new String(node.getAttributes().get("mes").array()));
371 return DefaultEither.newB(node);
372 }
373
374 @Override
375 public OperationLog getLog() {
376 OperationLog op = new DefaultOperationLog();
377 op = op.add(new PutAttributeOperation("author", ByteBuffer.wrap(_author.getBytes())));
378 op = op.add(new PutAttributeOperation("mes", ByteBuffer.wrap(_message.getBytes())));
379 op = op.add(new PutAttributeOperation("key", ByteBuffer.wrap(_editKey.getBytes())));
380 op = op.add(new PutAttributeOperation("timestamp", tBuffer));
381 return op;
328 } 382 }
329 }; 383 };
330 either = editor.edit(path, e); 384 either = editor.edit(path, e);
331 if (either.isA()) { 385 if (either.isA()) {
332 throw new IllegalStateException(); 386 throw new IllegalStateException();
347 DefaultNodePath path = new DefaultNodePath(); 401 DefaultNodePath path = new DefaultNodePath();
348 do { 402 do {
349 try { 403 try {
350 for (int count = 0; _uuid.substring(count, count + 1) != null; count++) { 404 for (int count = 0; _uuid.substring(count, count + 1) != null; count++) {
351 if (!_uuid.substring(count, count + 1).equals("/")) 405 if (!_uuid.substring(count, count + 1).equals("/"))
352 path = path.add(Integer.parseInt(_uuid.substring(count, count + 1))); 406 path = path.add(Integer.parseInt(_uuid.substring(count,
407 count + 1)));
353 } 408 }
354 } catch (Exception _e) { 409 } catch (Exception _e) {
355 } 410 }
356 411
357 JungleTreeEditor editor = tree.getTreeEditor(); 412 JungleTreeEditor editor = tree.getTreeEditor();
358 NodeEditor e = new NodeEditor() { 413 NodeEditor e = new NodeEditor() {
359 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) { 414 String str;
360 String str = "0"; 415
416 public <T extends TreeNode> Either<Error, TreeNode> edit(T _e) {
417 TreeNode node = _e;
418 str = "0";
361 int count = 0; 419 int count = 0;
362 for (; _e.getAttributes().get("mes" + String.valueOf(count)) != null; count++) { 420 for (; _e.getAttributes().get("mes" + String.valueOf(count)) != null; count++) {
363 } 421 }
364 str = String.valueOf(count); 422 str = String.valueOf(count);
365 _e = _e.getAttributes().put("mes" + str, ByteBuffer.wrap(_message.getBytes())).b(); 423 node = node.getAttributes().put("mes" + str,ByteBuffer.wrap(_message.getBytes())).b();
366 _e = _e.getAttributes().put("timestamp" + str, tBuffer).b(); 424 node = node.getAttributes().put("timestamp" + str, tBuffer).b();
367 return DefaultEither.newB(_e); 425 return DefaultEither.newB(node);
426 }
427
428 @Override
429 public OperationLog getLog() {
430 OperationLog op = new DefaultOperationLog();
431 op = op.add(new PutAttributeOperation("mes" + str,ByteBuffer.wrap(_message.getBytes())));
432 op = op.add(new PutAttributeOperation("timestamp" + str,tBuffer));
433 return op;
368 } 434 }
369 }; 435 };
370 either = editor.edit(path, e); 436 either = editor.edit(path, e);
371 if (either.isA()) { 437 if (either.isA()) {
372 throw new IllegalStateException(); 438 throw new IllegalStateException();
386 DefaultNodePath path = new DefaultNodePath(); 452 DefaultNodePath path = new DefaultNodePath();
387 do { 453 do {
388 try { 454 try {
389 for (int count = 0; _path.substring(count, count + 1) != null; count++) { 455 for (int count = 0; _path.substring(count, count + 1) != null; count++) {
390 if (!_path.substring(count, count + 1).equals("/")) 456 if (!_path.substring(count, count + 1).equals("/"))
391 path = path.add(Integer.parseInt(_path.substring(count, count + 1))); 457 path = path.add(Integer.parseInt(_path.substring(count,
458 count + 1)));
392 } 459 }
393 } catch (Exception _e) { 460 } catch (Exception _e) {
394 } 461 }
395 462
396 JungleTreeEditor editor = tree.getTreeEditor(); 463 JungleTreeEditor editor = tree.getTreeEditor();
397 NodeEditor e = new NodeEditor() { 464 NodeEditor e = new NodeEditor() {
398 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) { 465 public <T extends TreeNode> Either<Error, TreeNode> edit(T _e) {
466 TreeNode node = _e;
399 // EnableNodeWrapper<T> node = _e.getWrap(); 467 // EnableNodeWrapper<T> node = _e.getWrap();
400 _e = _e.getAttributes().put("mes" + id, ByteBuffer.wrap(_message.getBytes())).b(); 468 node = node.getAttributes().put("mes" + id,ByteBuffer.wrap(_message.getBytes())).b();
401 _e = _e.getAttributes().put("timestamp" + id, tBuffer).b(); 469 node = node.getAttributes().put("timestamp" + id, tBuffer).b();
402 return DefaultEither.newB(_e); 470 return DefaultEither.newB(node);
471 }
472
473 @Override
474 public OperationLog getLog() {
475 OperationLog op = new DefaultOperationLog();
476 op = op.add(new PutAttributeOperation("mes"+ id, ByteBuffer.wrap(_message.getBytes())));
477 op = op.add(new PutAttributeOperation("timestamp"+ id, tBuffer));
478 return op;
403 } 479 }
404 }; 480 };
405 either = editor.edit(path, e); 481 either = editor.edit(path, e);
406 if (either.isA()) { 482 if (either.isA()) {
407 throw new IllegalStateException(); 483 throw new IllegalStateException();
408 } 484 }
409 editor = either.b(); 485 editor = either.b();
410 either = editor.success(); 486 either = editor.success();
411 } while (either.isA()); 487 } while (either.isA());
412 } 488 }
413 489
414
415 public void deleteNode(String _board, String _path, String _id) { 490 public void deleteNode(String _board, String _path, String _id) {
416 requestCounter.incrementAndGet(); 491 requestCounter.incrementAndGet();
417 int id = Integer.parseInt(_id); 492 int id = Integer.parseInt(_id);
418 final long timestamp = System.currentTimeMillis(); 493 final long timestamp = System.currentTimeMillis();
419 final ByteBuffer tBuffer = ByteBuffer.allocate(16); 494 final ByteBuffer tBuffer = ByteBuffer.allocate(16);
423 DefaultNodePath path = new DefaultNodePath(); 498 DefaultNodePath path = new DefaultNodePath();
424 do { 499 do {
425 try { 500 try {
426 for (int count = 0; _path.substring(count, count + 1) != null; count++) { 501 for (int count = 0; _path.substring(count, count + 1) != null; count++) {
427 if (!_path.substring(count, count + 1).equals("/")) 502 if (!_path.substring(count, count + 1).equals("/"))
428 path = path.add(Integer.parseInt(_path.substring(count, count + 1))); 503 path = path.add(Integer.parseInt(_path.substring(count,count + 1)));
429 } 504 }
430 } catch (Exception _e) { 505 } catch (Exception _e) {
431 } 506 }
432 507
433 JungleTreeEditor editor = tree.getTreeEditor(); 508 JungleTreeEditor editor = tree.getTreeEditor();
434 509
435 either = editor.deleteChildAt(path, id); 510 either = editor.deleteChildAt(path, id);
436 if (either.isA()) { 511 if (either.isA()) {
437 throw new IllegalStateException(); 512 throw new IllegalStateException();
438 } 513 }
439 editor = either.b(); 514 editor = either.b();
440 either = editor.success(); 515 either = editor.success();
441 } while (either.isA()); 516 } while (either.isA());
442 517
443 } 518 }
444 public void deleteAttribute(String _board, String _path ,final String id) { 519
520 public void deleteAttribute(String _board, String _path, final String id) {
445 requestCounter.incrementAndGet(); 521 requestCounter.incrementAndGet();
446 final long timestamp = System.currentTimeMillis(); 522 final long timestamp = System.currentTimeMillis();
447 final ByteBuffer tBuffer = ByteBuffer.allocate(16); 523 final ByteBuffer tBuffer = ByteBuffer.allocate(16);
448 tBuffer.putLong(timestamp); 524 tBuffer.putLong(timestamp);
449 JungleTree tree = jungle.getTreeByName(_board); 525 JungleTree tree = jungle.getTreeByName(_board);
451 DefaultNodePath path = new DefaultNodePath(); 527 DefaultNodePath path = new DefaultNodePath();
452 do { 528 do {
453 try { 529 try {
454 for (int count = 0; _path.substring(count, count + 1) != null; count++) { 530 for (int count = 0; _path.substring(count, count + 1) != null; count++) {
455 if (!_path.substring(count, count + 1).equals("/")) 531 if (!_path.substring(count, count + 1).equals("/"))
456 path = path.add(Integer.parseInt(_path.substring(count, count + 1))); 532 path = path.add(Integer.parseInt(_path.substring(count,
533 count + 1)));
457 } 534 }
458 } catch (Exception _e) { 535 } catch (Exception _e) {
459 System.out.println("屑"); 536 System.out.println("屑");
460 } 537 }
461 538
462 JungleTreeEditor editor = tree.getTreeEditor(); 539 JungleTreeEditor editor = tree.getTreeEditor();
463 NodeEditor e = new NodeEditor() { 540 NodeEditor e = new NodeEditor() {
464 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) { 541 public <T extends TreeNode> Either<Error, TreeNode> edit(T _e) {
465 _e = _e.getAttributes().delete("mes" + id ).b(); 542 TreeNode node = _e;
466 _e = _e.getAttributes().delete("timestamp" + id ).b(); 543 node = node.getAttributes().delete("mes" + id).b();
544 node = node.getAttributes().delete("timestamp" + id).b();
467 int count = Integer.parseInt(id); 545 int count = Integer.parseInt(id);
468 for (; _e.getAttributes().get("mes" + String.valueOf(count + 1)) != null;) { 546 for (; node.getAttributes().get("mes" + String.valueOf(count + 1)) != null;) {
469 _e = _e.getAttributes().put("mes" + count, _e.getAttributes().get("mes" + String.valueOf(count + 1))).b(); 547 node = node.getAttributes().put("mes" + count,_e.getAttributes().get("mes"+ String.valueOf(count + 1))).b();
470 _e = _e.getAttributes().put("timestamp" + count, tBuffer).b(); 548 node = node.getAttributes().put("timestamp" + count, tBuffer).b();
471 count++; 549 count++;
472 }
473 if(count != Integer.parseInt(id)){
474 _e = _e.getAttributes().delete("timestamp" + count ).b();
475 _e = _e.getAttributes().delete("mes" + count ).b();
476 } 550 }
477 551 if (count != Integer.parseInt(id)) {
478 return DefaultEither.newB(_e); 552 node = node.getAttributes().delete("timestamp" + count).b();
553 node = node.getAttributes().delete("mes" + count).b();
554 }
555
556 return DefaultEither.newB(node);
557 }
558
559 @Override
560 public OperationLog getLog() {
561 return new DefaultOperationLog();
479 } 562 }
480 }; 563 };
481 either = editor.edit(path, e); 564 either = editor.edit(path, e);
482 if (either.isA()) { 565 if (either.isA()) {
483 throw new IllegalStateException(); 566 throw new IllegalStateException();
484 } 567 }
485 editor = either.b(); 568 editor = either.b();
486 either = editor.success(); 569 either = editor.success();
487 } while (either.isA()); 570 } while (either.isA());
488 } 571 }
489 572
490 573 public void editMatrixMessage(String _board, String _uuid,
491 574 final String _author, final String _message, final String _editKey) {
492 public void editMatrixMessage(String _board, String _uuid, final String _author, final String _message, final String _editKey) {
493 requestCounter.incrementAndGet(); 575 requestCounter.incrementAndGet();
494 final long timestamp = System.currentTimeMillis(); 576 final long timestamp = System.currentTimeMillis();
495 final ByteBuffer tBuffer = ByteBuffer.allocate(16); 577 final ByteBuffer tBuffer = ByteBuffer.allocate(16);
496 tBuffer.putLong(timestamp); 578 tBuffer.putLong(timestamp);
497 JungleTree tree = jungle.getTreeByName(_board); 579 JungleTree tree = jungle.getTreeByName(_board);
500 DefaultNodePath path = new DefaultNodePath(); 582 DefaultNodePath path = new DefaultNodePath();
501 path = path.add(Integer.parseInt(_uuid)); 583 path = path.add(Integer.parseInt(_uuid));
502 584
503 JungleTreeEditor editor = tree.getTreeEditor(); 585 JungleTreeEditor editor = tree.getTreeEditor();
504 NodeEditor e = new NodeEditor() { 586 NodeEditor e = new NodeEditor() {
505 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) { 587 public <T extends TreeNode> Either<Error, TreeNode> edit(T _e) {
506 _e = _e.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b(); 588 TreeNode node = _e;
507 _e = _e.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b(); 589 node = node.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
508 _e = _e.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b(); 590 node = node.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
509 _e = _e.getAttributes().put("timestamp", tBuffer).b(); 591 node = node.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
510 return DefaultEither.newB(_e); 592 node = node.getAttributes().put("timestamp", tBuffer).b();
593 return DefaultEither.newB(node);
594 }
595
596 @Override
597 public OperationLog getLog() {
598 OperationLog op = new DefaultOperationLog();
599 op = op.add(new PutAttributeOperation("author", ByteBuffer.wrap(_author.getBytes())));
600 op = op.add(new PutAttributeOperation("mes", ByteBuffer.wrap(_message.getBytes())));
601 op = op.add(new PutAttributeOperation("key", ByteBuffer.wrap(_editKey.getBytes())));
602 op = op.add(new PutAttributeOperation("timestamp", tBuffer));
603 return op;
511 } 604 }
512 }; 605 };
513 either = editor.edit(path, e); 606 either = editor.edit(path, e);
514 if (either.isA()) { 607 if (either.isA()) {
515 throw new IllegalStateException(); 608 throw new IllegalStateException();
521 } 614 }
522 615
523 public Iterable<BoardMessage> getMessages(String _boardName) { 616 public Iterable<BoardMessage> getMessages(String _boardName) {
524 requestCounter.incrementAndGet(); 617 requestCounter.incrementAndGet();
525 JungleTree tree = jungle.getTreeByName(_boardName); 618 JungleTree tree = jungle.getTreeByName(_boardName);
526 Node node = tree.getRootNode(); 619 TreeNode node = tree.getRootNode();
527 Children<Node> chs = node.getChildren(); 620 Children<TreeNode> chs = node.getChildren();
528 final AtomicInteger counter = new AtomicInteger(0); 621 final AtomicInteger counter = new AtomicInteger(0);
529 IterableConverter.Converter<BoardMessage, Node> converter = new IterableConverter.Converter<BoardMessage, Node>() { 622 IterableConverter.Converter<BoardMessage, TreeNode> converter = new IterableConverter.Converter<BoardMessage, TreeNode>() {
530 public BoardMessage conv(Node _b) { 623 public BoardMessage conv(TreeNode _b) {
531 String uuid = Integer.toString(counter.get()); 624 String uuid = Integer.toString(counter.get());
532 String author = new String(_b.getAttributes().get("author") .array()); 625 String author = new String(_b.getAttributes().get("author").array());
533 String message = new String(_b.getAttributes().get("mes").array()); 626 String message = new String(_b.getAttributes().get("mes").array());
534 counter.incrementAndGet(); 627 counter.incrementAndGet();
535 return new BoardMessageImpl(author, message, uuid); 628 return new BoardMessageImpl(author, message, uuid);
536 } 629 }
537 }; 630 };
538 return new IterableConverter<BoardMessage, Node>(chs, converter); 631 return new IterableConverter<BoardMessage, TreeNode>(chs, converter);
539 } 632 }
540 633
541 public Iterable<BoardMessage> getFolder(String _boardName, String _nodeNum) { 634 public Iterable<BoardMessage> getFolder(String _boardName, String _nodeNum) {
542 635
543 DefaultNodePath path = new DefaultNodePath(); 636 DefaultNodePath path = new DefaultNodePath();
548 } 641 }
549 } catch (Exception _e) { 642 } catch (Exception _e) {
550 } 643 }
551 requestCounter.incrementAndGet(); 644 requestCounter.incrementAndGet();
552 JungleTree tree = jungle.getTreeByName(_boardName); 645 JungleTree tree = jungle.getTreeByName(_boardName);
553 Node node = tree.getRootNode(); 646 TreeNode node = tree.getRootNode();
554 647
555 DefaultTraverser traverser = new DefaultTraverser(); 648 DefaultTraverser traverser = new DefaultTraverser();
556 TraversableNodeWrapper<Node> traversable = new TraversableNodeWrapper<Node>(node); 649 // TraversableNodeWrapper<Node> traversable = new
650 // TraversableNodeWrapper<Node>(node);
557 DefaultEvaluator evaluator = new DefaultEvaluator(path); 651 DefaultEvaluator evaluator = new DefaultEvaluator(path);
558 Either<Error, Traversal<TraversableNodeWrapper<Node>>> ret = traverser.traverse(traversable, evaluator); 652 Either<Error, Traversal<TreeNode>> ret = traverser.traverse(node,
653 evaluator);
559 if (ret.isA()) { 654 if (ret.isA()) {
560 Assert.fail(); 655 Assert.fail();
561 } 656 }
562 657
563 Traversal<TraversableNodeWrapper<Node>> traversal = ret.b(); 658 Traversal<TreeNode> traversal = ret.b();
564 TraversableNodeWrapper<Node> target = traversal.destination(); 659 TreeNode target = traversal.destination();
565 Children<Node> chs = target.getWrapped().getChildren(); 660 Children<TreeNode> chs = target.getChildren();
566 661
567 final AtomicInteger counter = new AtomicInteger(0); 662 final AtomicInteger counter = new AtomicInteger(0);
568 IterableConverter.Converter<BoardMessage, Node> converter = new IterableConverter.Converter<BoardMessage, Node>() { 663 IterableConverter.Converter<BoardMessage, TreeNode> converter = new IterableConverter.Converter<BoardMessage, TreeNode>() {
569 public BoardMessage conv(Node _b) { 664 public BoardMessage conv(TreeNode _b) {
570 String uuid = Integer.toString(counter.get()); 665 String uuid = Integer.toString(counter.get());
571 String message = new String(_b.getAttributes().get("mes").array()); 666 String message = new String(_b.getAttributes().get("mes")
667 .array());
572 counter.incrementAndGet(); 668 counter.incrementAndGet();
573 return new BoardMessageImpl(null, message, uuid); 669 return new BoardMessageImpl(null, message, uuid);
574 } 670 }
575 }; 671 };
576 return new IterableConverter<BoardMessage, Node>(chs, converter); 672 return new IterableConverter<BoardMessage, TreeNode>(chs, converter);
577 } 673 }
578
579 674
580 public getAttributeImp getAttribute(String _boardName, String _nodeNum) { 675 public getAttributeImp getAttribute(String _boardName, String _nodeNum) {
581 676
582 DefaultNodePath path = new DefaultNodePath(); 677 DefaultNodePath path = new DefaultNodePath();
583 try { 678 try {
584 for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) { 679 for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) {
585 if (!_nodeNum.substring(count, count + 1).equals("/")) 680 if (!_nodeNum.substring(count, count + 1).equals("/"))
586 path = path.add(Integer.parseInt(_nodeNum.substring(count,count + 1))); 681 path = path.add(Integer.parseInt(_nodeNum.substring(count,
682 count + 1)));
587 } 683 }
588 } catch (Exception _e) { 684 } catch (Exception _e) {
589 } 685 }
590 requestCounter.incrementAndGet(); 686 requestCounter.incrementAndGet();
591 JungleTree tree = jungle.getTreeByName(_boardName); 687 JungleTree tree = jungle.getTreeByName(_boardName);
592 Node node = tree.getRootNode(); 688 TreeNode node = tree.getRootNode();
593 689
594 DefaultTraverser traverser = new DefaultTraverser(); 690 DefaultTraverser traverser = new DefaultTraverser();
595 TraversableNodeWrapper<Node> traversable = new TraversableNodeWrapper<Node>(node); 691 // TraversableNodeWrapper<Node> traversable = new
692 // TraversableNodeWrapper<Node>(node);
596 DefaultEvaluator evaluator = new DefaultEvaluator(path); 693 DefaultEvaluator evaluator = new DefaultEvaluator(path);
597 Either<Error, Traversal<TraversableNodeWrapper<Node>>> ret = traverser.traverse(traversable, evaluator); 694 Either<Error, Traversal<TreeNode>> ret = traverser.traverse(node,
695 evaluator);
598 if (ret.isA()) { 696 if (ret.isA()) {
599 Assert.fail(); 697 Assert.fail();
600 } 698 }
601 699
602 Traversal<TraversableNodeWrapper<Node>> traversal = ret.b(); 700 Traversal<TreeNode> traversal = ret.b();
603 TraversableNodeWrapper<Node> target = traversal.destination(); 701 TreeNode target = traversal.destination();
604 return new getAttributeImp(target.getWrapped()); 702 return new getAttributeImp(target);
605 } 703 }
606 704
607 public int getRequestNum() { 705 public int getRequestNum() {
608 return requestCounter.get(); 706 return requestCounter.get();
609 } 707 }
630 public String getUUID() { 728 public String getUUID() {
631 return uuid; 729 return uuid;
632 } 730 }
633 731
634 } 732 }
635 733
636 public String sanitize( String str ) { 734 public String sanitize(String str) {
637 if(str==null) { 735 if (str == null) {
638 return str; 736 return str;
639 } 737 }
640 str = str.replaceAll("&" , "&amp;" ); 738 str = str.replaceAll("&", "&amp;");
641 str = str.replaceAll("<" , "&lt;" ); 739 str = str.replaceAll("<", "&lt;");
642 str = str.replaceAll(">" , "&gt;" ); 740 str = str.replaceAll(">", "&gt;");
643 str = str.replaceAll("\"", "&quot;"); 741 str = str.replaceAll("\"", "&quot;");
644 str = str.replaceAll("'" , "&#39;" ); 742 str = str.replaceAll("'", "&#39;");
645 return str; 743 return str;
646 } 744 }
647
648 745
649 } 746 }