Mercurial > hg > Database > jungle-sharp

comparison src/main/csharp/jp.ac.u-ryukyu.ie.cr/jungle-main/traverser/DefaultTraverser.cs @ 17:01a08cf4b2d9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Liq Files
author Kazuma
date Mon, 07 Nov 2016 01:05:24 +0900
parents abe0c247f5a5
children
comparison
equal deleted inserted replaced
16:8f1ce942abfc 17:01a08cf4b2d9
1 using System.Collections.Generic;
2 using System.Collections;
3 using UnityEngine;
4 using System;
5 // yet write.
6 public class DefaultTraverser : Traverser {
7
8
9 public Either<Error, Traversal> traverse(TreeNode _root, Evaluator _evaluator) {
10 // 無名クラスを書いてない
11 Children warper = new InnerChildren(_root, _evaluator);
12
13 Children chs = warper;
14 Either<Error, List<Direction<TreeNode>>> ret = _traverse(chs, _evaluator, -1);
15
16 if (ret.isA ()) {
17 return DefaultEither<Error, Traversal>.newA (ret.a ());
18 }
19
20 List<Direction<TreeNode>> list = ret.b ();
21 IEnumerator<Direction<TreeNode>> iterable = list.iterator ();
22 TreeNode destination = ret.b ().headList ().getTarget ();
23
24 Traversal traversal = new InnerTraversal (iterable, destination);
25
26 return DefaultEither<Error, Traversal>.newB (traversal);
27
28 }
29
30
31 private Either<Error, List<Direction<TreeNode>>> _traverse(Children _chs, Evaluator _evaluator, int _pos) {
32 int pos = _pos;
33 TreeNode ch;
34 for (int i = 0; i < _chs.size(); i++) {
35 Either<Error,TreeNode> either = _chs.at(i);
36 if (either.isA ()) {
37 break;
38 }
39
40 ch = either.b();
41 Evaluation e = _evaluator.evaluate (ch, pos);
42 Result r = e.results();
43
44 if (r == Result.ACCEPT) {
45 return _accept (ch, pos, e.evaluators ());
46 }
47
48 if (r == Result.GOAL) {
49 return DefaultEither<Error,List<Direction<TreeNode>>>.newB(_goal(ch, pos));
50 }
51
52 if (r == Result.BREAK) {
53 break;
54 }
55
56 if (r == Result.CONTINUE) {
57 pos++;
58 continue;
59 }
60
61 return DefaultEither<Error, List<Direction<TreeNode>>>.newA (TraverserError.UNDEFINED_OPERATOR);
62 }
63 return DefaultEither<Error, List<Direction<TreeNode>>>.newA (TraverserError.PATH_NOT_FOUND);
64 }
65
66
67 private List<Direction<TreeNode>> _goal( TreeNode _current, int _pos) {
68 Direction<TreeNode> d = new InnerDirection<TreeNode> (_pos, _current);
69
70 List<Direction<TreeNode>> list = new List<Direction<TreeNode>> ();
71 List<Direction<TreeNode>> newList = list.addLast (d);
72
73 return newList;
74 }
75
76
77 private Either<Error, List<Direction<TreeNode>>> _accept(TreeNode _current, int _pos,Evaluator _evaluator)
78 {
79 Children chs = _current.getChildren ();
80 Either<Error, List<Direction<TreeNode>>> either = _traverse (chs, _evaluator, 0);
81 if (either.isA ()) {
82 return either;
83 }
84 List<Direction<TreeNode>> list = either.b ();
85 Direction<TreeNode> d = new InnerDirection<TreeNode> (_pos, _current);
86
87 List<Direction<TreeNode>> newList = list.addLast (d);
88 return DefaultEither<Error,List<Direction<TreeNode>>>.newB (newList);
89 }
90
91 public class InnerTraversal : Traversal{
92 IEnumerator<Direction<TreeNode>> iterable;
93 TreeNode destination;
94
95 IEnumerator IEnumerable.GetEnumerator()
96 {
97 return this.GetEnumerator();
98 }
99
100 public IEnumerator<Direction<TreeNode>> GetEnumerator()
101 {
102 return iterable;
103 }
104
105
106 public InnerTraversal(IEnumerator<Direction<TreeNode>> _iterable, TreeNode _distination){
107 this.iterable = _iterable;
108 this.destination = _distination;
109 }
110
111
112 public TreeNode destinations() {
113 return destination;
114 }
115
116 }
117
118 public class InnerChildren : Children{
119 TreeNode root;
120 Evaluator evaluator;
121
122 public InnerChildren(TreeNode _root, Evaluator _evaluator){
123 this.root = _root;
124 this.evaluator = _evaluator;
125 }
126
127 public IEnumerator<TreeNode> iterator() {
128 List<TreeNode> list = new List<TreeNode> ();
129 return list.addLast (root).iterator ();
130 }
131
132 public int size() {
133 return 1;
134 }
135
136 public Either<Error, TreeNode> at(int _pos) {
137 if (_pos != 0) {
138 return DefaultEither<Error, TreeNode>.newA (NodeEditorError.INDEX_OUT_OF_BOUNDS);
139 }
140 return DefaultEither<Error, TreeNode>.newB (root);
141 }
142 }
143
144 public class InnerDirection<TreeNode> : Direction<TreeNode>{
145 int pos;
146 TreeNode current;
147
148 public InnerDirection(int _pos, TreeNode _current) {
149 this.pos = _pos;
150 this.current = _current;
151 }
152
153 public int getPosition() {
154 return pos;
155 }
156
157 public TreeNode getTarget(){
158 return current;
159 }
160 }
161
162 }