|
7
|
1 package jp.ac.u_ryukyu.cr.ie.tatsuki.bbs;
|
|
|
2
|
|
|
3 import java.util.Iterator;
|
|
8
|
4 import java.util.regex.Matcher;
|
|
|
5 import java.util.regex.Pattern;
|
|
7
|
6
|
|
|
7 import fj.data.List;
|
|
8
|
8 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
|
|
7
|
9 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
|
|
|
10 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
|
|
|
11 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
|
|
|
12 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
|
|
9
|
13 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
|
|
|
14 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
|
|
7
|
15 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
|
|
|
16
|
|
|
17 public class JuGrix {
|
|
|
18
|
|
8
|
19 JungleTree personTree;
|
|
|
20 JungleTree organizationTree;
|
|
|
21 public JuGrix(){
|
|
|
22 try{
|
|
|
23 loadXml reader = new loadXml();
|
|
|
24 personTree = reader.loadTestData("Person.xml");
|
|
|
25 organizationTree = reader.loadTestData("Organization.xml");
|
|
|
26 } catch (Exception e) {
|
|
|
27 e.printStackTrace();
|
|
|
28 }
|
|
|
29 }
|
|
|
30 public boolean isActive(String id){
|
|
7
|
31
|
|
8
|
32 InterfaceTraverser ifTraverser = personTree.getTraverser();
|
|
7
|
33 Iterator<Pair<TreeNode,NodePath>> pairIterator = ifTraverser.find(
|
|
|
34 (TreeNode node) -> {
|
|
|
35 String personId = node.getAttributes().getString("id");
|
|
|
36 if (personId == null)
|
|
|
37 return false;
|
|
|
38 if (personId.equals(id))
|
|
|
39 return true;
|
|
|
40 return false;
|
|
|
41 }
|
|
|
42 ,"id",id);
|
|
|
43
|
|
|
44 if (pairIterator.hasNext())
|
|
|
45 return true;
|
|
|
46 return false;
|
|
|
47
|
|
|
48 }
|
|
|
49
|
|
8
|
50 public Iterator<String> personIds(String id){
|
|
7
|
51
|
|
8
|
52 List<String> names = personIdsSearch(id);
|
|
7
|
53 return names.iterator();
|
|
|
54 }
|
|
|
55
|
|
8
|
56 public Iterator<String> personIds(List<String> ids){
|
|
7
|
57
|
|
|
58 List<String> personIds = List.nil();
|
|
|
59
|
|
|
60 for (String id : ids) {
|
|
8
|
61 personIds = personIds.append(personIdsSearch(id));
|
|
7
|
62 }
|
|
|
63 return personIds.iterator();
|
|
|
64 }
|
|
|
65
|
|
8
|
66 private List<String> personIdsSearch(String id) {
|
|
|
67 InterfaceTraverser ifTraverser = personTree.getTraverser();
|
|
7
|
68 Iterator<Pair<TreeNode,NodePath>> pairPersonIterator = ifTraverser.find(
|
|
|
69 (TreeNode node) -> {
|
|
|
70 String personId = node.getAttributes().getString("element");
|
|
|
71 if (personId == null)
|
|
|
72 return false;
|
|
|
73 if (personId.equals("Person"))
|
|
|
74 return true;
|
|
|
75 return false;
|
|
|
76 }
|
|
|
77 ,"element","Person");
|
|
|
78
|
|
|
79 List<String> names = List.nil();
|
|
|
80 for (;pairPersonIterator.hasNext();) {
|
|
|
81
|
|
|
82 Pair<TreeNode, NodePath> pairPerson = pairPersonIterator.next();
|
|
|
83 Iterator<Pair<TreeNode,NodePath>> pairIdIterator = ifTraverser.find(
|
|
|
84 (TreeNode node) -> {
|
|
|
85 String personId = node.getAttributes().getString("text");
|
|
|
86 if (personId == null)
|
|
|
87 return false;
|
|
|
88 if (personId.equals(id))
|
|
|
89 return true;
|
|
|
90 return false;
|
|
|
91 }
|
|
|
92 ,pairPerson.left(),"text",id);
|
|
|
93 if (pairIdIterator.hasNext())
|
|
|
94 names = names.cons(pairPerson.left().getAttributes().getString("id"));
|
|
|
95
|
|
|
96 }
|
|
|
97 return names;
|
|
|
98 }
|
|
8
|
99
|
|
|
100 public Iterator<String> roleIds(String id) {
|
|
|
101 Pattern personPattern = Pattern.compile("p:");
|
|
|
102 Matcher personMacher = personPattern.matcher(id);
|
|
|
103 if (personMacher.find()) {
|
|
|
104 return searchRoleIds(personTree, id, "Person");
|
|
|
105 }
|
|
|
106
|
|
|
107 Pattern organizationPattern = Pattern.compile("o:");
|
|
|
108 Matcher organizationMacher = organizationPattern.matcher(id);
|
|
|
109 if (organizationMacher.find()) {
|
|
|
110 return searchRoleIds(organizationTree, id, "Organization");
|
|
|
111 }
|
|
|
112
|
|
|
113 return null;
|
|
|
114 }
|
|
7
|
115
|
|
8
|
116 public Iterator<String> searchRoleIds(JungleTree tree, String id, String element){
|
|
|
117
|
|
|
118 InterfaceTraverser ifTraverser = tree.getTraverser();
|
|
|
119 Iterator<Pair<TreeNode,NodePath>> searchTargetIterator = ifTraverser.find(
|
|
|
120 (TreeNode node) -> {
|
|
|
121 String nodeElement = node.getAttributes().getString("element");
|
|
|
122 if (nodeElement == null)
|
|
|
123 return false;
|
|
|
124 if (!nodeElement.equals(element))
|
|
|
125 return false;
|
|
|
126 String nodeId = node.getAttributes().getString("id");
|
|
|
127 if (nodeId == null)
|
|
|
128 return false;
|
|
|
129 if (nodeId.equals(id))
|
|
|
130 return true;
|
|
|
131 return false;
|
|
|
132 }
|
|
|
133 ,"id",id);
|
|
|
134
|
|
|
135 List<String> ids = List.nil();
|
|
9
|
136
|
|
8
|
137 for (;searchTargetIterator.hasNext();) {
|
|
|
138
|
|
|
139 Pair<TreeNode, NodePath> searchTargetPair = searchTargetIterator.next();
|
|
|
140 Iterator<Pair<TreeNode,NodePath>> pairIdIterator = ifTraverser.find(
|
|
|
141 (TreeNode node) -> {
|
|
|
142 String nodeElement = node.getAttributes().getString("element");
|
|
|
143 if (nodeElement == null)
|
|
|
144 return false;
|
|
|
145 if (!nodeElement.equals("roleRefId"))
|
|
|
146 return false;
|
|
|
147 String nodeId = node.getAttributes().getString("text");
|
|
|
148 if (nodeId != null)
|
|
|
149 return true;
|
|
|
150 return false;
|
|
|
151 }
|
|
|
152 ,searchTargetPair.left());
|
|
|
153
|
|
|
154
|
|
|
155 for (;pairIdIterator.hasNext();){
|
|
|
156 Pair<TreeNode, NodePath> idNodePath = pairIdIterator.next();
|
|
|
157 String attribute = idNodePath.left().getAttributes().getString("text");
|
|
|
158
|
|
|
159 Iterator<String> checkList = ids.iterator();
|
|
|
160 for (;checkList.hasNext();) {
|
|
|
161 if(checkList.next().equals(attribute))
|
|
|
162 attribute = null;
|
|
|
163 }
|
|
|
164
|
|
|
165 if (attribute != null) {
|
|
|
166 ids = ids.cons(attribute);
|
|
|
167 System.out.println("-------------------------" + attribute + "-------------------------");
|
|
|
168 }
|
|
|
169 }
|
|
|
170 }
|
|
|
171 return ids.iterator();
|
|
|
172 }
|
|
|
173
|
|
|
174
|
|
|
175 public Iterator<String> competentRoleId(String personId) {
|
|
|
176
|
|
|
177 InterfaceTraverser ifTraverser = personTree.getTraverser();
|
|
|
178 Iterator<Pair<TreeNode,NodePath>> pairPersonIterator = ifTraverser.find(
|
|
|
179 (TreeNode node) -> {
|
|
|
180 String nodeElement = node.getAttributes().getString("element");
|
|
|
181 if (nodeElement == null)
|
|
|
182 return false;
|
|
|
183 if (!nodeElement.equals("Person"))
|
|
|
184 return false;
|
|
|
185 String nodeId = node.getAttributes().getString("id");
|
|
|
186 if (nodeId == null)
|
|
|
187 return false;
|
|
|
188 if (nodeId.equals(personId))
|
|
|
189 return true;
|
|
|
190 return false;
|
|
|
191 }
|
|
|
192 ,"element","Person");
|
|
|
193
|
|
9
|
194 if (!pairPersonIterator.hasNext())
|
|
|
195 return new NullIterator();
|
|
|
196 TreeNode person = pairPersonIterator.next().left();
|
|
|
197
|
|
|
198 Iterator<Pair<TreeNode,NodePath>> targetPairIterator = ifTraverser.find(
|
|
|
199 (TreeNode node) -> {
|
|
|
200 String nodeElement = node.getAttributes().getString("element");
|
|
|
201 if (nodeElement == null)
|
|
|
202 return false;
|
|
|
203 if (!nodeElement.equals("priority"))
|
|
|
204 return false;
|
|
|
205 String priority = node.getAttributes().getString("text");
|
|
|
206 if (priority == null)
|
|
|
207 return false;
|
|
|
208 if (priority.equals("0"))
|
|
|
209 return true;
|
|
|
210 return false;
|
|
|
211 }
|
|
|
212 ,person);
|
|
|
213
|
|
|
214
|
|
|
215 List<String> idList = List.nil();
|
|
|
216 for (;targetPairIterator.hasNext();) {
|
|
|
217 NodePath searchPath = targetPairIterator.next().right();
|
|
|
218 Pair<Integer, NodePath> searchPair = searchPath.last();
|
|
|
219 NodePath targetPath = searchPair.right().add(searchPair.left() + 1);
|
|
|
220 TreeNode targetNode = getTarget(person, targetPath);
|
|
|
221 String id = targetNode.getAttributes().getString("text");
|
|
|
222 idList = idList.cons(id);
|
|
|
223 }
|
|
|
224
|
|
|
225 return idList.iterator();
|
|
8
|
226 }
|
|
7
|
227
|
|
10
|
228
|
|
|
229 public Iterator<String> concurrentRoleIds(String personId) {
|
|
|
230
|
|
|
231 InterfaceTraverser ifTraverser = personTree.getTraverser();
|
|
|
232 Iterator<Pair<TreeNode,NodePath>> pairPersonIterator = ifTraverser.find(
|
|
|
233 (TreeNode node) -> {
|
|
|
234 String nodeElement = node.getAttributes().getString("element");
|
|
|
235 if (nodeElement == null)
|
|
|
236 return false;
|
|
|
237 if (!nodeElement.equals("Person"))
|
|
|
238 return false;
|
|
|
239 String nodeId = node.getAttributes().getString("id");
|
|
|
240 if (nodeId == null)
|
|
|
241 return false;
|
|
|
242 if (nodeId.equals(personId))
|
|
|
243 return true;
|
|
|
244 return false;
|
|
|
245 }
|
|
|
246 ,"element","Person");
|
|
|
247
|
|
|
248 if (!pairPersonIterator.hasNext())
|
|
|
249 return new NullIterator();
|
|
|
250 TreeNode person = pairPersonIterator.next().left();
|
|
|
251
|
|
|
252 Iterator<Pair<TreeNode,NodePath>> targetPairIterator = ifTraverser.find(
|
|
|
253 (TreeNode node) -> {
|
|
|
254 String nodeElement = node.getAttributes().getString("element");
|
|
|
255 if (nodeElement == null)
|
|
|
256 return false;
|
|
|
257 if (!nodeElement.equals("priority"))
|
|
|
258 return false;
|
|
|
259 String priority = node.getAttributes().getString("text");
|
|
|
260 if (priority == null)
|
|
|
261 return false;
|
|
|
262 if (!priority.equals("0"))
|
|
|
263 return true;
|
|
|
264 return false;
|
|
|
265 }
|
|
|
266 ,person);
|
|
|
267
|
|
|
268
|
|
|
269 List<String> idList = List.nil();
|
|
|
270 for (;targetPairIterator.hasNext();) {
|
|
|
271 NodePath searchPath = targetPairIterator.next().right();
|
|
|
272 Pair<Integer, NodePath> searchPair = searchPath.last();
|
|
|
273 NodePath targetPath = searchPair.right().add(searchPair.left() + 1);
|
|
|
274 TreeNode targetNode = getTarget(person, targetPath);
|
|
|
275 String id = targetNode.getAttributes().getString("text");
|
|
|
276 idList = idList.cons(id);
|
|
|
277 }
|
|
|
278
|
|
|
279 return idList.iterator();
|
|
|
280 }
|
|
|
281
|
|
9
|
282 public TreeNode getTarget(TreeNode node , NodePath path){
|
|
|
283 TreeNode target;
|
|
|
284 Pair<Integer, NodePath> pathNode = path.pop();
|
|
|
285 int num = pathNode.left();
|
|
|
286 NodePath newPath = pathNode.right();
|
|
|
287 if (num == -1 && newPath.size() != 0)
|
|
|
288 return getTarget(node, newPath);
|
|
|
289
|
|
|
290 Either<Error, TreeNode> either = node.getChildren().at(num);
|
|
|
291 if (either.isA())
|
|
|
292 return node;
|
|
|
293
|
|
|
294 TreeNode child = either.b();
|
|
|
295 if (pathNode.right().size() == 0)
|
|
|
296 return child;
|
|
|
297
|
|
|
298 target = getTarget(child,pathNode.right());
|
|
|
299 return target;
|
|
|
300 }
|
|
10
|
301
|
|
9
|
302 class NullIterator implements Iterator<String>{
|
|
7
|
303
|
|
9
|
304 @Override
|
|
|
305 public boolean hasNext() {
|
|
|
306 return false;
|
|
|
307 }
|
|
|
308
|
|
|
309 @Override
|
|
|
310 public String next() {
|
|
|
311 return null;
|
|
|
312 }
|
|
|
313
|
|
|
314 }
|
|
10
|
315
|
|
7
|
316 }
|
