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

comparison src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/impl/logger/LoggingChildren.java @ 51:bc119c52d5cc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
modified LoggingNode package
author Shoshi TAMAKI
date Fri, 08 Feb 2013 02:21:00 +0900
parents 0a3bff2d9c89
children 8c6ff361b68a
comparison
equal deleted inserted replaced
50:0a3bff2d9c89 51:bc119c52d5cc
1 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger; 1 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger;
2 2
3 import java.util.Iterator; 3 import java.util.Iterator;
4 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.ClonableChildren;
5 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.ClonableNode;
6 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.AppendChildAtOperation; 4 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.AppendChildAtOperation;
7 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteChildAtOperation; 5 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteChildAtOperation;
8 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.Operation; 6 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
7 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableChildren;
8 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableNode;
9 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither; 9 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
10 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; 10 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
11 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; 11 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
12 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.IterableConverter; 12 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.IterableConverter;
13 13
14 public class LoggingChildren<T extends ClonableNode<T>> implements ClonableChildren<LoggingNode<T>> 14 public class LoggingChildren<T extends EditableNode<T>> implements EditableChildren<LoggingNode<T>>
15 { 15 {
16 private final ClonableChildren<T> wrap; 16 private final T wrap;
17 private final DefaultOperationLog log; 17 private final OperationLog log;
18 18
19 public LoggingChildren(ClonableChildren<T> _wrap,DefaultOperationLog _log) 19 public LoggingChildren(T _wrap,OperationLog _log)
20 { 20 {
21 wrap = _wrap; 21 wrap = _wrap;
22 log = _log; 22 log = _log;
23 } 23 }
24 24
25 @Override 25 @Override
26 public int size() 26 public int size()
27 { 27 {
28 return wrap.size(); 28 EditableChildren<T> children = wrap.getChildren();
29 return children.size();
29 } 30 }
30 31
31 @Override 32 @Override
32 public Iterator<LoggingNode<T>> iterator() 33 public Iterator<LoggingNode<T>> iterator()
33 { 34 {
35 EditableChildren<T> children = wrap.getChildren();
36
34 IterableConverter.Converter<LoggingNode<T>,T> converter = new IterableConverter.Converter<LoggingNode<T>,T>(){ 37 IterableConverter.Converter<LoggingNode<T>,T> converter = new IterableConverter.Converter<LoggingNode<T>,T>(){
35 @Override 38 @Override
36 public LoggingNode<T> conv(T _b) { 39 public LoggingNode<T> conv(T _b) {
37 return new LoggingNode<T>(_b,log); 40 return new LoggingNode<T>(_b,log);
38 } 41 }
39 }; 42 };
40 43
41 IterableConverter<LoggingNode<T>,T> iterable = new IterableConverter<LoggingNode<T>,T>(wrap,converter); 44 IterableConverter<LoggingNode<T>,T> iterable = new IterableConverter<LoggingNode<T>,T>(children,converter);
42 return iterable.iterator(); 45 return iterable.iterator();
46 }
47
48 public Either<Error,LoggingNode<T>> edit(NodeOperation _op)
49 {
50 Either<Error,T> either = _op.invoke(wrap);
51 if(either.isA()){
52 return DefaultEither.newA(either.a());
53 }
54
55 T newWrap = either.b();
56 OperationLog newLog = log.add(_op);
57 LoggingNode<T> newLoggingNode = new LoggingNode<T>(newWrap,newLog);
58 return DefaultEither.newB(newLoggingNode);
43 } 59 }
44 60
45 @Override 61 @Override
46 public Either<Error,LoggingNode<T>> addNewChildAt(final int _pos) 62 public Either<Error,LoggingNode<T>> addNewChildAt(final int _pos)
47 { 63 {
48 Either<Error,T> either = wrap.addNewChildAt(_pos); 64 NodeOperation addNewChildAt = new AppendChildAtOperation(_pos);
49 if(either.isA()){ 65 return edit(addNewChildAt);
50 return DefaultEither.newA(either.a());
51 }
52
53 Operation opAddChild = new AppendChildAtOperation(){
54 @Override
55 public int position(){
56 return _pos;
57 }
58 };
59
60 Logger newLog = log.add(opAddChild);
61 T newWrap = either.b();
62 LoggingNode<T> newLoggingNode = new LoggingNode<T>(newWrap,newLog);
63
64 return DefaultEither.newB(newLoggingNode);
65 } 66 }
66 67
67 @Override 68 @Override
68 public Either<Error,LoggingNode<T>> deleteChildAt(final int _pos) 69 public Either<Error,LoggingNode<T>> deleteChildAt(final int _pos)
69 { 70 {
70 Either<Error,T> either = wrap.deleteChildAt(_pos); 71 NodeOperation deleteChildAt = new DeleteChildAtOperation(_pos);
71 if(either.isA()){ 72 return edit(deleteChildAt);
72 return DefaultEither.newA(either.a());
73 }
74
75 Operation opDeleteChild = new DeleteChildAtOperation(){
76 @Override
77 public int position(){
78 return _pos;
79 }
80 };
81
82 Logger newLog = log.add(opDeleteChild);
83 LoggingNode<T> newLoggingNode = new LoggingNode<T>(either.b(),newLog);
84
85 return DefaultEither.newB(newLoggingNode);
86 }
87
88 @Override
89 public Either<Error,LoggingNode<T>> replaceNode(int _pos,LoggingNode<T> _replacement)
90 {
91 T target = _replacement.getWrapper();
92 Either<Error,T> e = wrap.replaceNode(_pos,target);
93 if(e.isA()){
94 return DefaultEither.newA(e.a());
95 }
96
97 T newWrap = e.b();
98 return DefaultEither.newB(new LoggingNode<T>(newWrap,log));
99 } 73 }
100 74
101 @Override 75 @Override
102 public Either<Error,LoggingNode<T>> at(int _pos) 76 public Either<Error,LoggingNode<T>> at(int _pos)
103 { 77 {
104 Either<Error,T> either = wrap.at(_pos); 78 EditableChildren<T> children = wrap.getChildren();
79 Either<Error,T> either = children.at(_pos);
105 if(either.isA()){ 80 if(either.isA()){
106 return DefaultEither.newA(either.a()); 81 return DefaultEither.newA(either.a());
107 } 82 }
108 83
109 T newWrap = either.b(); 84 T newWrap = either.b();
110 return DefaultEither.newB(new LoggingNode<T>(newWrap,log)); 85 return DefaultEither.newB(new LoggingNode<T>(newWrap,log));
111 } 86 }
112
113 @Override
114 public Either<Error, LoggingNode<T>> addNewChildAt(int _pos,LoggingNode<T> _newChild)
115 {
116 Either<Error,T> either = wrap.addNewChildAt(_pos,_newChild.getWrapper());
117 if(either.isA()){
118 return DefaultEither.newA(either.a());
119 }
120
121 T newWrap = either.b();
122 LoggingNode<T> newLoggingNode = new LoggingNode<T>(newWrap,log);
123 return DefaultEither.newB(newLoggingNode);
124 }
125 } 87 }