Mercurial > hg > Members > nobuyasu > jungle-network

comparison src/main/java/app/bbs/NetworkJungleBulletinBoard.java @ 168:91f6dd655a01

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
refactoring
author tatsuki
date Tue, 29 Jul 2014 10:58:11 +0900
parents 564f683b7aef
children 54d68cda84c4
comparison
equal deleted inserted replaced
167:564f683b7aef 168:91f6dd655a01
41 private AtomicInteger requestCounter; 41 private AtomicInteger requestCounter;
42 private long renewTime; 42 private long renewTime;
43 43
44 private NetworkJungleBulletinBoard(String _uuid, NetworkJournal _journal) { 44 private NetworkJungleBulletinBoard(String _uuid, NetworkJournal _journal) {
45 journal = _journal; 45 journal = _journal;
46 jungle = new NetworkDefaultJungle(journal, _uuid, 46 jungle = new NetworkDefaultJungle(journal, _uuid, new DefaultTreeEditor(new DefaultTraverser()));
47 new DefaultTreeEditor(new DefaultTraverser()));
48 BulletinBoardJungleManager.setJungle(jungle); 47 BulletinBoardJungleManager.setJungle(jungle);
49 persistentFlag = false; 48 persistentFlag = false;
50 requestCounter = BulletinBoardJungleManager.getRequestCounter(); 49 requestCounter = BulletinBoardJungleManager.getRequestCounter();
51 LOG_DIR = "./log"; 50 LOG_DIR = "./log";
52 renewTime = 0; 51 renewTime = 0;
56 this(_uuid, new AliceJournal()); 55 this(_uuid, new AliceJournal());
57 jungle.createNewTree("boards"); 56 jungle.createNewTree("boards");
58 } 57 }
59 58
60 public static NetworkBulletinBoard NewPersistentJungle(String _uuid) { 59 public static NetworkBulletinBoard NewPersistentJungle(String _uuid) {
61 NetworkJungleBulletinBoard board = new NetworkJungleBulletinBoard( 60 NetworkJungleBulletinBoard board = new NetworkJungleBulletinBoard( _uuid, new PersistentJournal());
62 _uuid, new PersistentJournal());
63 board.persistentFlag = true; 61 board.persistentFlag = true;
64 return board; 62 return board;
65 } 63 }
66 64
67 public void init() { 65 public void init() {
109 JungleTree tree = jungle.getTreeByName(treeName); 107 JungleTree tree = jungle.getTreeByName(treeName);
110 if (tree == null) { 108 if (tree == null) {
111 tree = jungle.createNewTree(treeName); 109 tree = jungle.createNewTree(treeName);
112 } 110 }
113 JungleTreeEditor editor = tree.getLocalTreeEditor(); 111 JungleTreeEditor editor = tree.getLocalTreeEditor();
114 Either<Error, JungleTreeEditor> either = JungleUpdater.edit(editor, 112 Either<Error, JungleTreeEditor> either = JungleUpdater.edit(editor, chList);
115 chList);
116 editor = either.b(); 113 editor = either.b();
117 if (either.isA()) { 114 if (either.isA()) {
118 throw new IOException("Failed commit log recovery"); 115 throw new IOException("Failed commit log recovery");
119 } 116 }
120 editor.success(); 117 editor.success();
138 135
139 public long getRenewTime(String _boardName) { 136 public long getRenewTime(String _boardName) {
140 return renewTime; 137 return renewTime;
141 } 138 }
142 139
143 public void createBoards(final String _name, final String _author, 140 public void createBoards(final String _name, final String _author, final String _initMessage, final String _editKey) {
144 final String _initMessage, final String _editKey) {
145 requestCounter.incrementAndGet(); 141 requestCounter.incrementAndGet();
146 if (null == jungle.createNewTree(_name)) { 142 if (null == jungle.createNewTree(_name)) {
147 throw new IllegalStateException(); 143 throw new IllegalStateException();
148 } 144 }
149 145
154 if (either.isA()) { 150 if (either.isA()) {
155 throw new IllegalStateException(); 151 throw new IllegalStateException();
156 } 152 }
157 editor = either.b(); 153 editor = either.b();
158 154
159 either = editor.putAttribute(root.add(0), "name", 155 either = editor.putAttribute(root.add(0), "name",ByteBuffer.wrap(_name.getBytes()));
160 ByteBuffer.wrap(_name.getBytes()));
161 if (either.isA()) { 156 if (either.isA()) {
162 throw new IllegalStateException(); 157 throw new IllegalStateException();
163 } 158 }
164 editor = either.b(); 159 editor = either.b();
165 final long timestamp = System.currentTimeMillis(); 160 final long timestamp = System.currentTimeMillis();
182 } 177 }
183 editor = either.b(); 178 editor = either.b();
184 179
185 NodeEditor e = new NodeEditor() { 180 NodeEditor e = new NodeEditor() {
186 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) { 181 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) {
187 _e = _e.getAttributes() 182 _e = _e.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
188 .put("author", ByteBuffer.wrap(_author.getBytes())).b(); 183 _e = _e.getAttributes().put("mes", ByteBuffer.wrap(_initMessage.getBytes())).b();
189 _e = _e.getAttributes() 184 _e = _e.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
190 .put("mes", ByteBuffer.wrap(_initMessage.getBytes()))
191 .b();
192 _e = _e.getAttributes()
193 .put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
194 ByteBuffer tBuffer2 = ByteBuffer.allocate(16); 185 ByteBuffer tBuffer2 = ByteBuffer.allocate(16);
195 tBuffer2.putLong(timestamp); 186 tBuffer2.putLong(timestamp);
196 _e = _e.getAttributes().put("timestamp", tBuffer2).b(); 187 _e = _e.getAttributes().put("timestamp", tBuffer2).b();
197 return DefaultEither.newB(_e); 188 return DefaultEither.newB(_e);
198 } 189 }
204 } 195 }
205 either.b().success(); 196 either.b().success();
206 197
207 } 198 }
208 199
209 public void createFolder(final String _board, final String _author, 200 public void createFolder(final String _board, final String _author, final String _message, final String _editKey, String _nodeNum) {
210 final String _message, final String _editKey, String _nodeNum) {
211 JungleTree tree = jungle.getTreeByName(_board); 201 JungleTree tree = jungle.getTreeByName(_board);
212 if (tree == null) { 202 if (tree == null) {
213 throw new IllegalStateException(); 203 throw new IllegalStateException();
214 } 204 }
215 205
216 DefaultNodePath path = new DefaultNodePath(); 206 DefaultNodePath path = new DefaultNodePath();
217 try { 207 try {
218 for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) { 208 for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) {
219 if (!_nodeNum.substring(count, count + 1).equals("/")) 209 if (!_nodeNum.substring(count, count + 1).equals("/"))
220 path = path.add(Integer.parseInt(_nodeNum.substring(count, 210 path = path.add(Integer.parseInt(_nodeNum.substring(count, count + 1)));
221 count + 1)));
222 } 211 }
223 } catch (Exception _e) { 212 } catch (Exception _e) {
224 } 213 }
225 requestCounter.incrementAndGet(); 214 requestCounter.incrementAndGet();
226 Either<Error, JungleTreeEditor> either; 215 Either<Error, JungleTreeEditor> either;
227 final long timestamp = System.currentTimeMillis(); 216 final long timestamp = System.currentTimeMillis();
228 final ByteBuffer tBuffer = ByteBuffer.allocate(16); 217 final ByteBuffer tBuffer = ByteBuffer.allocate(16);
229 tBuffer.putLong(timestamp); 218 tBuffer.putLong(timestamp);
219
230 do { 220 do {
231 Node node = tree.getRootNode(); 221 Node node = tree.getRootNode();
232
233 DefaultTraverser traverser = new DefaultTraverser(); 222 DefaultTraverser traverser = new DefaultTraverser();
234 TraversableNodeWrapper<Node> traversable = new TraversableNodeWrapper<Node>( 223 TraversableNodeWrapper<Node> traversable = new TraversableNodeWrapper<Node>(node);
235 node);
236 DefaultEvaluator evaluator = new DefaultEvaluator(path); 224 DefaultEvaluator evaluator = new DefaultEvaluator(path);
237 Either<Error, Traversal<TraversableNodeWrapper<Node>>> ret = traverser 225 Either<Error, Traversal<TraversableNodeWrapper<Node>>> ret = traverser.traverse(traversable, evaluator);
238 .traverse(traversable, evaluator);
239 if (ret.isA()) { 226 if (ret.isA()) {
240 Assert.fail(); 227 Assert.fail();
241 } 228 }
242 229
243 Traversal<TraversableNodeWrapper<Node>> traversal = ret.b(); 230 Traversal<TraversableNodeWrapper<Node>> traversal = ret.b();
250 } 237 }
251 editor = either.b(); 238 editor = either.b();
252 239
253 NodeEditor e = new NodeEditor() { 240 NodeEditor e = new NodeEditor() {
254 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) { 241 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) {
255 _e = _e.getAttributes() 242 _e = _e.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
256 .put("author", ByteBuffer.wrap(_author.getBytes()))
257 .b();
258 _e = _e.getAttributes()
259 .put("mes", ByteBuffer.wrap(_message.getBytes()))
260 .b();
261 _e = _e.getAttributes()
262 .put("key", ByteBuffer.wrap(_editKey.getBytes()))
263 .b();
264 _e = _e.getAttributes().put("timestamp", tBuffer).b(); 243 _e = _e.getAttributes().put("timestamp", tBuffer).b();
265 return DefaultEither.newB(_e); 244 return DefaultEither.newB(_e);
266 } 245 }
267 }; 246 };
268 path = path.add(size); 247 path = path.add(size);
274 either = editor.success(); 253 either = editor.success();
275 } while (either.isA()); 254 } while (either.isA());
276 255
277 } 256 }
278 257
279 public void createBoardMessage(final String _board, final String _author, 258 public void createBoardMessage(final String _board, final String _author, final String _message, final String _editKey) {
280 final String _message, final String _editKey) {
281 requestCounter.incrementAndGet(); 259 requestCounter.incrementAndGet();
282 JungleTree tree = jungle.getTreeByName(_board); 260 JungleTree tree = jungle.getTreeByName(_board);
283 if (tree == null) { 261 if (tree == null) {
284 throw new IllegalStateException(); 262 throw new IllegalStateException();
285 } 263 }
287 Either<Error, JungleTreeEditor> either; 265 Either<Error, JungleTreeEditor> either;
288 final long timestamp = System.currentTimeMillis(); 266 final long timestamp = System.currentTimeMillis();
289 final ByteBuffer tBuffer = ByteBuffer.allocate(16); 267 final ByteBuffer tBuffer = ByteBuffer.allocate(16);
290 tBuffer.putLong(timestamp); 268 tBuffer.putLong(timestamp);
291 do { 269 do {
270
292 Node node = tree.getRootNode(); 271 Node node = tree.getRootNode();
293 int size = node.getChildren().size(); 272 int size = node.getChildren().size();
294 DefaultNodePath path = new DefaultNodePath(); 273 DefaultNodePath path = new DefaultNodePath();
295 274
296 JungleTreeEditor editor = tree.getTreeEditor(); 275 JungleTreeEditor editor = tree.getTreeEditor();
300 } 279 }
301 editor = either.b(); 280 editor = either.b();
302 281
303 NodeEditor e = new NodeEditor() { 282 NodeEditor e = new NodeEditor() {
304 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) { 283 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) {
305 _e = _e.getAttributes() 284 _e = _e.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
306 .put("author", ByteBuffer.wrap(_author.getBytes())) 285 _e = _e.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
307 .b(); 286 _e = _e.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
308 _e = _e.getAttributes()
309 .put("mes", ByteBuffer.wrap(_message.getBytes()))
310 .b();
311 _e = _e.getAttributes()
312 .put("key", ByteBuffer.wrap(_editKey.getBytes()))
313 .b();
314 _e = _e.getAttributes().put("timestamp", tBuffer).b(); 287 _e = _e.getAttributes().put("timestamp", tBuffer).b();
315 return DefaultEither.newB(_e); 288 return DefaultEither.newB(_e);
316 } 289 }
317 }; 290 };
318 path = path.add(size); 291 path = path.add(size);
324 either = editor.success(); 297 either = editor.success();
325 } while (either.isA()); 298 } while (either.isA());
326 299
327 } 300 }
328 301
329 public void editMessage(String _board, String _uuid, final String _author, 302 public void editMessage(String _board, String _uuid, final String _author, final String _message, final String _editKey) {
330 final String _message, final String _editKey) {
331 requestCounter.incrementAndGet(); 303 requestCounter.incrementAndGet();
332 final long timestamp = System.currentTimeMillis(); 304 final long timestamp = System.currentTimeMillis();
333 final ByteBuffer tBuffer = ByteBuffer.allocate(16); 305 final ByteBuffer tBuffer = ByteBuffer.allocate(16);
334 tBuffer.putLong(timestamp); 306 tBuffer.putLong(timestamp);
335 JungleTree tree = jungle.getTreeByName(_board); 307 JungleTree tree = jungle.getTreeByName(_board);
336 Either<Error, JungleTreeEditor> either = null; 308 Either<Error, JungleTreeEditor> either = null;
309
337 do { 310 do {
338 DefaultNodePath path = new DefaultNodePath(); 311 DefaultNodePath path = new DefaultNodePath();
339 path = path.add(Integer.parseInt(_uuid)); 312 path = path.add(Integer.parseInt(_uuid));
340 313
341 JungleTreeEditor editor = tree.getTreeEditor(); 314 JungleTreeEditor editor = tree.getTreeEditor();
342 NodeEditor e = new NodeEditor() { 315 NodeEditor e = new NodeEditor() {
343 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) { 316 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) {
344 _e = _e.getAttributes() 317 _e = _e.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
345 .put("author", ByteBuffer.wrap(_author.getBytes())) 318 _e = _e.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
346 .b(); 319 _e = _e.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
347 _e = _e.getAttributes()
348 .put("mes", ByteBuffer.wrap(_message.getBytes()))
349 .b();
350 _e = _e.getAttributes()
351 .put("key", ByteBuffer.wrap(_editKey.getBytes()))
352 .b();
353 _e = _e.getAttributes().put("timestamp", tBuffer).b(); 320 _e = _e.getAttributes().put("timestamp", tBuffer).b();
354 return DefaultEither.newB(_e); 321 return DefaultEither.newB(_e);
355 } 322 }
356 }; 323 };
357 either = editor.edit(path, e); 324 either = editor.edit(path, e);
362 either = editor.success(); 329 either = editor.success();
363 } while (either.isA()); 330 } while (either.isA());
364 renewTime = timestamp; 331 renewTime = timestamp;
365 } 332 }
366 333
367 public void createAttribute(String _board, String _uuid, 334 public void createAttribute(String _board, String _uuid, final String _author, final String _message, final String _editKey) {
368 final String _author, final String _message, final String _editKey) {
369 requestCounter.incrementAndGet(); 335 requestCounter.incrementAndGet();
370 final long timestamp = System.currentTimeMillis(); 336 final long timestamp = System.currentTimeMillis();
371 final ByteBuffer tBuffer = ByteBuffer.allocate(16); 337 final ByteBuffer tBuffer = ByteBuffer.allocate(16);
372 tBuffer.putLong(timestamp); 338 tBuffer.putLong(timestamp);
373 JungleTree tree = jungle.getTreeByName(_board); 339 JungleTree tree = jungle.getTreeByName(_board);
375 DefaultNodePath path = new DefaultNodePath(); 341 DefaultNodePath path = new DefaultNodePath();
376 do { 342 do {
377 try { 343 try {
378 for (int count = 0; _uuid.substring(count, count + 1) != null; count++) { 344 for (int count = 0; _uuid.substring(count, count + 1) != null; count++) {
379 if (!_uuid.substring(count, count + 1).equals("/")) 345 if (!_uuid.substring(count, count + 1).equals("/"))
380 path = path.add(Integer.parseInt(_uuid.substring(count, 346 path = path.add(Integer.parseInt(_uuid.substring(count, count + 1)));
381 count + 1)));
382 } 347 }
383 } catch (Exception _e) { 348 } catch (Exception _e) {
384 } 349 }
385 Node node = tree.getRootNode(); 350
386
387 DefaultTraverser traverser = new DefaultTraverser();
388 TraversableNodeWrapper<Node> traversable = new TraversableNodeWrapper<Node>(
389 node);
390 DefaultEvaluator evaluator = new DefaultEvaluator(path);
391 Either<Error, Traversal<TraversableNodeWrapper<Node>>> ret = traverser
392 .traverse(traversable, evaluator);
393 if (ret.isA()) {
394 Assert.fail();
395 }
396
397 Traversal<TraversableNodeWrapper<Node>> traversal = ret.b();
398 TraversableNodeWrapper<Node> target = traversal.destination();
399 final Node cheakNode = target.getWrapped();
400 System.out.println(cheakNode.getAttributes().get("attribute"));
401
402 JungleTreeEditor editor = tree.getTreeEditor(); 351 JungleTreeEditor editor = tree.getTreeEditor();
403 NodeEditor e = new NodeEditor() { 352 NodeEditor e = new NodeEditor() {
404 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) { 353 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) {
405 // EnableNodeWrapper<T> node = _e.getWrap(); 354 // EnableNodeWrapper<T> node = _e.getWrap();
406 String str = "0"; 355 String str = "0";
407 int count = 0; 356 int count = 0;
408 for (; _e.getAttributes().get("author" + String.valueOf(count)) != null; count++) { 357 for (; _e.getAttributes().get("mes" + String.valueOf(count)) != null; count++) {
409 } 358 }
410 str = String.valueOf(count); 359 str = String.valueOf(count);
411 _e = _e.getAttributes().put("author" + str, ByteBuffer.wrap(_author.getBytes())).b();
412 _e = _e.getAttributes().put("mes" + str, ByteBuffer.wrap(_message.getBytes())).b(); 360 _e = _e.getAttributes().put("mes" + str, ByteBuffer.wrap(_message.getBytes())).b();
413 _e = _e.getAttributes().put("key" + str, ByteBuffer.wrap(_editKey.getBytes())).b();
414 _e = _e.getAttributes().put("timestamp" + str, tBuffer).b(); 361 _e = _e.getAttributes().put("timestamp" + str, tBuffer).b();
415 return DefaultEither.newB(_e); 362 return DefaultEither.newB(_e);
416 } 363 }
417 }; 364 };
418 either = editor.edit(path, e); 365 either = editor.edit(path, e);
422 editor = either.b(); 369 editor = either.b();
423 either = editor.success(); 370 either = editor.success();
424 } while (either.isA()); 371 } while (either.isA());
425 } 372 }
426 373
427 public void editMatrixMessage(String _board, String _uuid, 374 public void editMatrixMessage(String _board, String _uuid, final String _author, final String _message, final String _editKey) {
428 final String _author, final String _message, final String _editKey) {
429 requestCounter.incrementAndGet(); 375 requestCounter.incrementAndGet();
430 final long timestamp = System.currentTimeMillis(); 376 final long timestamp = System.currentTimeMillis();
431 final ByteBuffer tBuffer = ByteBuffer.allocate(16); 377 final ByteBuffer tBuffer = ByteBuffer.allocate(16);
432 tBuffer.putLong(timestamp); 378 tBuffer.putLong(timestamp);
433 JungleTree tree = jungle.getTreeByName(_board); 379 JungleTree tree = jungle.getTreeByName(_board);
437 path = path.add(Integer.parseInt(_uuid)); 383 path = path.add(Integer.parseInt(_uuid));
438 384
439 JungleTreeEditor editor = tree.getTreeEditor(); 385 JungleTreeEditor editor = tree.getTreeEditor();
440 NodeEditor e = new NodeEditor() { 386 NodeEditor e = new NodeEditor() {
441 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) { 387 public <T extends EditableNode<T>> Either<Error, T> edit(T _e) {
442 _e = _e.getAttributes() 388 _e = _e.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
443 .put("author", ByteBuffer.wrap(_author.getBytes())) 389 _e = _e.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
444 .b(); 390 _e = _e.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
445 _e = _e.getAttributes()
446 .put("mes", ByteBuffer.wrap(_message.getBytes()))
447 .b();
448 _e = _e.getAttributes()
449 .put("key", ByteBuffer.wrap(_editKey.getBytes()))
450 .b();
451 _e = _e.getAttributes().put("timestamp", tBuffer).b(); 391 _e = _e.getAttributes().put("timestamp", tBuffer).b();
452 return DefaultEither.newB(_e); 392 return DefaultEither.newB(_e);
453 } 393 }
454 }; 394 };
455 either = editor.edit(path, e); 395 either = editor.edit(path, e);
469 Children<Node> chs = node.getChildren(); 409 Children<Node> chs = node.getChildren();
470 final AtomicInteger counter = new AtomicInteger(0); 410 final AtomicInteger counter = new AtomicInteger(0);
471 IterableConverter.Converter<BoardMessage, Node> converter = new IterableConverter.Converter<BoardMessage, Node>() { 411 IterableConverter.Converter<BoardMessage, Node> converter = new IterableConverter.Converter<BoardMessage, Node>() {
472 public BoardMessage conv(Node _b) { 412 public BoardMessage conv(Node _b) {
473 String uuid = Integer.toString(counter.get()); 413 String uuid = Integer.toString(counter.get());
474 String author = new String(_b.getAttributes().get("author") 414 String author = new String(_b.getAttributes().get("author") .array());
475 .array()); 415 String message = new String(_b.getAttributes().get("mes").array());
476 String message = new String(_b.getAttributes().get("mes")
477 .array());
478 counter.incrementAndGet(); 416 counter.incrementAndGet();
479 return new BoardMessageImpl(author, message, uuid); 417 return new BoardMessageImpl(author, message, uuid);
480 } 418 }
481 }; 419 };
482 return new IterableConverter<BoardMessage, Node>(chs, converter); 420 return new IterableConverter<BoardMessage, Node>(chs, converter);
486 424
487 DefaultNodePath path = new DefaultNodePath(); 425 DefaultNodePath path = new DefaultNodePath();
488 try { 426 try {
489 for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) { 427 for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) {
490 if (!_nodeNum.substring(count, count + 1).equals("/")) 428 if (!_nodeNum.substring(count, count + 1).equals("/"))
491 path = path.add(Integer.parseInt(_nodeNum.substring(count, 429 path = path.add(Integer.parseInt(_nodeNum.substring(count,count + 1)));
492 count + 1)));
493 }
494 } catch (Exception _e) {
495 }
496 requestCounter.incrementAndGet();
497 JungleTree tree = jungle.getTreeByName(_boardName);
498 Node node = tree.getRootNode();
499
500 DefaultTraverser traverser = new DefaultTraverser();
501 TraversableNodeWrapper<Node> traversable = new TraversableNodeWrapper<Node>(
502 node);
503 DefaultEvaluator evaluator = new DefaultEvaluator(path);
504 Either<Error, Traversal<TraversableNodeWrapper<Node>>> ret = traverser
505 .traverse(traversable, evaluator);
506 if (ret.isA()) {
507 Assert.fail();
508 }
509
510 Traversal<TraversableNodeWrapper<Node>> traversal = ret.b();
511 TraversableNodeWrapper<Node> target = traversal.destination();
512 Children<Node> chs = target.getWrapped().getChildren();
513
514 final AtomicInteger counter = new AtomicInteger(0);
515 IterableConverter.Converter<BoardMessage, Node> converter = new IterableConverter.Converter<BoardMessage, Node>() {
516 public BoardMessage conv(Node _b) {
517 String uuid = Integer.toString(counter.get());
518 String author = new String(_b.getAttributes().get("author").array());
519 String message = new String(_b.getAttributes().get("mes").array());
520 counter.incrementAndGet();
521 return new BoardMessageImpl(author, message, uuid);
522 }
523 };
524 return new IterableConverter<BoardMessage, Node>(chs, converter);
525 }
526
527
528 public getAttributeImp getAttribute(String _boardName, String _nodeNum) {
529
530 DefaultNodePath path = new DefaultNodePath();
531 try {
532 for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) {
533 if (!_nodeNum.substring(count, count + 1).equals("/"))
534 path = path.add(Integer.parseInt(_nodeNum.substring(count,
535 count + 1)));
536 } 430 }
537 } catch (Exception _e) { 431 } catch (Exception _e) {
538 } 432 }
539 requestCounter.incrementAndGet(); 433 requestCounter.incrementAndGet();
540 JungleTree tree = jungle.getTreeByName(_boardName); 434 JungleTree tree = jungle.getTreeByName(_boardName);
548 Assert.fail(); 442 Assert.fail();
549 } 443 }
550 444
551 Traversal<TraversableNodeWrapper<Node>> traversal = ret.b(); 445 Traversal<TraversableNodeWrapper<Node>> traversal = ret.b();
552 TraversableNodeWrapper<Node> target = traversal.destination(); 446 TraversableNodeWrapper<Node> target = traversal.destination();
447 Children<Node> chs = target.getWrapped().getChildren();
448
449 final AtomicInteger counter = new AtomicInteger(0);
450 IterableConverter.Converter<BoardMessage, Node> converter = new IterableConverter.Converter<BoardMessage, Node>() {
451 public BoardMessage conv(Node _b) {
452 String uuid = Integer.toString(counter.get());
453 String message = new String(_b.getAttributes().get("mes").array());
454 counter.incrementAndGet();
455 return new BoardMessageImpl(null, message, uuid);
456 }
457 };
458 return new IterableConverter<BoardMessage, Node>(chs, converter);
459 }
460
461
462 public getAttributeImp getAttribute(String _boardName, String _nodeNum) {
463
464 DefaultNodePath path = new DefaultNodePath();
465 try {
466 for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) {
467 if (!_nodeNum.substring(count, count + 1).equals("/"))
468 path = path.add(Integer.parseInt(_nodeNum.substring(count,count + 1)));
469 }
470 } catch (Exception _e) {
471 }
472 requestCounter.incrementAndGet();
473 JungleTree tree = jungle.getTreeByName(_boardName);
474 Node node = tree.getRootNode();
475
476 DefaultTraverser traverser = new DefaultTraverser();
477 TraversableNodeWrapper<Node> traversable = new TraversableNodeWrapper<Node>(node);
478 DefaultEvaluator evaluator = new DefaultEvaluator(path);
479 Either<Error, Traversal<TraversableNodeWrapper<Node>>> ret = traverser.traverse(traversable, evaluator);
480 if (ret.isA()) {
481 Assert.fail();
482 }
483
484 Traversal<TraversableNodeWrapper<Node>> traversal = ret.b();
485 TraversableNodeWrapper<Node> target = traversal.destination();
553 return new getAttributeImp(target.getWrapped()); 486 return new getAttributeImp(target.getWrapped());
554 } 487 }
555 488
556 public int getRequestNum() { 489 public int getRequestNum() {
557 return requestCounter.get(); 490 return requestCounter.get();