Mercurial > hg > Members > tatsuki > JungleXMLReader

comparison src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/JuGrix.java @ 41:037731e99d6e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
fit JungleCore 144
author one
date Mon, 17 Nov 2014 18:47:10 +0900
parents 22edfb7f47ad
children 1bdd50e26fac
comparison
equal deleted inserted replaced
40:59a7d2cffc86 41:037731e99d6e
2 2
3 import java.util.Iterator; 3 import java.util.Iterator;
4 import java.util.LinkedList; 4 import java.util.LinkedList;
5 import java.util.regex.Matcher; 5 import java.util.regex.Matcher;
6 import java.util.regex.Pattern; 6 import java.util.regex.Pattern;
7
8 import javax.lang.model.element.Element;
7 9
8 import ac.jp.u_ryukyu.cr.ie.tatsuki.xmlReader.LoadXml; 10 import ac.jp.u_ryukyu.cr.ie.tatsuki.xmlReader.LoadXml;
9 import fj.Ord; 11 import fj.Ord;
10 import fj.P2; 12 import fj.P2;
11 import fj.data.TreeMap; 13 import fj.data.TreeMap;
43 45
44 } catch (Exception e) { 46 } catch (Exception e) {
45 e.printStackTrace(); 47 e.printStackTrace();
46 } 48 }
47 } 49 }
50
48 public boolean isActive(String id) { 51 public boolean isActive(String id) {
49 52
50 InterfaceTraverser personTraverser = personTree.getTraverser(); 53 InterfaceTraverser personTraverser = personTree.getTraverser();
51 Iterator<Pair<TreeNode, NodePath>> personIdpairIterator = personTraverser.find((TreeNode node) -> { 54 Iterator<Pair<TreeNode, NodePath>> personIdpairIterator = personTraverser.find((TreeNode node) -> {
52 String personId = node.getAttributes().getString("Person-id"); 55 Iterator<String> personIdIterator = node.getAttributes().getString("Person-id");
53 if (personId == null) 56 if (personIdIterator.hasNext()) {
54 return false; 57 if (personIdIterator.next().equals(id))
55 if (personId.equals(id)) 58 return true;
56 return true; 59 }
57 return false; 60 return false;
58 }, "Person-id", id); 61 }, "Person-id", id);
59 62
60 if (personIdpairIterator.hasNext()) 63 if (personIdpairIterator.hasNext())
61 return true; 64 return true;
62 return false; 65 return false;
63 66
64 } 67 }
65
66 68
67 public Iterator<String> personIds(String orgId, LinkedList<String> roleIds) { 69 public Iterator<String> personIds(String orgId, LinkedList<String> roleIds) {
68 70
69 Iterator<String> parentOrgIdIterator = parentOrganizationIds(orgId, roleIds); 71 Iterator<String> parentOrgIdIterator = parentOrganizationIds(orgId, roleIds);
70 TreeMap<String, String> personIdsTreeMap = TreeMap.empty(Ord.stringOrd); 72 TreeMap<String, String> personIdsTreeMap = TreeMap.empty(Ord.stringOrd);
71 73
72 if (filter(orgId, roleIds)) 74 if (filter(orgId, roleIds))
73 personIdsTreeMap = personIdsSearch(orgId, personIdsTreeMap); 75 personIdsTreeMap = personIdsSearch(orgId, personIdsTreeMap);
74 76
75 for (; parentOrgIdIterator.hasNext();) { 77 for (; parentOrgIdIterator.hasNext();) {
76 personIdsTreeMap = personIdsSearch(parentOrgIdIterator.next(), personIdsTreeMap); 78 personIdsTreeMap = personIdsSearch(parentOrgIdIterator.next(), personIdsTreeMap);
95 } 97 }
96 98
97 }; 99 };
98 } 100 }
99 101
100
101 public Iterator<String> personIds(LinkedList<String> orgIds, LinkedList<String> roleIds) { 102 public Iterator<String> personIds(LinkedList<String> orgIds, LinkedList<String> roleIds) {
102 103
103 TreeMap<String, String> personIds = TreeMap.empty(Ord.stringOrd); 104 TreeMap<String, String> personIds = TreeMap.empty(Ord.stringOrd);
104 for (String orgId : orgIds) { 105 for (String orgId : orgIds) {
105 personIds = personIdsSearch(orgId, personIds); 106 personIds = personIdsSearch(orgId, personIds);
128 return personId; 129 return personId;
129 } 130 }
130 131
131 }; 132 };
132 } 133 }
133 134
134 private TreeMap<String, String> personIdsSearch(String orgId, TreeMap<String, String> orgIdsTreeMap) { 135 private TreeMap<String, String> personIdsSearch(String orgId, TreeMap<String, String> orgIdsTreeMap) {
135 136
136 InterfaceTraverser personTraverser = personTree.getTraverser(); 137 InterfaceTraverser personTraverser = personTree.getTraverser();
137 138
138 Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.findAll((TreeNode node) -> { 139 Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.findAll((TreeNode node) -> {
139 String personId = node.getAttributes().getString("element"); 140 Iterator<String> personIdIterator = node.getAttributes().getString("element");
140 if (personId == null) 141 for (; personIdIterator.hasNext();) {
141 return false; 142 if (personIdIterator.next().equals("Person"))
142 if (personId.equals("Person")) 143 return true;
143 return true; 144 }
144 return false; 145 return false;
145 }, "Person-id"); 146 }, "Person-id");
146 147
147 for (; personIdPairIterator.hasNext();) { 148 for (; personIdPairIterator.hasNext();) {
148 149
149 Pair<TreeNode, NodePath> personIdPair = personIdPairIterator.next(); 150 Pair<TreeNode, NodePath> personIdPair = personIdPairIterator.next();
150 151
151 Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = personTraverser.findInSubTree((TreeNode node) -> { 152 Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = personTraverser.findInSubTree((TreeNode node) -> {
152 String personId = node.getAttributes().getString("text-organizationRefId"); 153 Iterator<String> personIdIterator = node.getAttributes().getString("text-organizationRefId");
153 if (personId == null) 154 for (; personIdIterator.hasNext();) {
154 return false; 155 if (personIdIterator.next().equals(orgId))
155 if (personId.equals(orgId)) 156 return true;
156 return true; 157 }
157 return false; 158 return false;
158 }, personIdPair, "text-organizationRefId", orgId); 159 }, personIdPair, "text-organizationRefId", orgId);
159 160
160 if (orgIdPairIterator.hasNext()) { 161 if (orgIdPairIterator.hasNext()) {
161 String personId = personIdPair.left().getAttributes().getString("Person-id"); 162 Iterator<String> personIdIterator = personIdPair.left().getAttributes().getString("Person-id");
162 if (personId != null) 163 if (personIdIterator.hasNext()) {
164 String personId = personIdIterator.next();
163 orgIdsTreeMap = orgIdsTreeMap.set(personId, personId); 165 orgIdsTreeMap = orgIdsTreeMap.set(personId, personId);
166 }
164 } 167 }
165 } 168 }
166 return orgIdsTreeMap; 169 return orgIdsTreeMap;
167 } 170 }
168 171
169
170
171
172 public boolean filter(String orgId, LinkedList<String> roleIds) { 172 public boolean filter(String orgId, LinkedList<String> roleIds) {
173 173
174 if (roleIds == null) 174 if (roleIds == null)
175 return true; 175 return true;
176 176
177 if (roleIds.isEmpty()) 177 if (roleIds.isEmpty())
178 return true; 178 return true;
179 179
180 InterfaceTraverser orgTraverser = organizationTree.getTraverser(); 180 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
181 181
182 Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = orgTraverser.find((TreeNode node) -> { 182 Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = orgTraverser.find((TreeNode node) -> {
183 String personId = node.getAttributes().getString("element"); 183 Iterator<String> personIdIterator = node.getAttributes().getString("element");
184 if (personId == null) 184 for (; personIdIterator.hasNext();) {
185 return false; 185 if (!personIdIterator.next().equals("Organization"))
186 if (!personId.equals("Organization")) 186 continue;
187 return false; 187 Iterator<String> compareOrgIdIterator = node.getAttributes().getString("Organization-id");
188 String compareOrgId = node.getAttributes().getString("Organization-id"); 188 for (; compareOrgIdIterator.hasNext();) {
189 if (compareOrgId == null) 189 if (compareOrgIdIterator.next().equals(orgId))
190 return false; 190 return true;
191 if (compareOrgId.equals(orgId)) 191 }
192 return true; 192 }
193 return false; 193 return false;
194 }, "Organization-id", orgId); 194 }, "Organization-id", orgId);
195 195
196 if (!orgIdPairIterator.hasNext()) 196 if (!orgIdPairIterator.hasNext())
197 return false; 197 return false;
213 return false; 213 return false;
214 } 214 }
215 } 215 }
216 return true; 216 return true;
217 } 217 }
218 218
219 private boolean rdeFilter(String filterRdeId, Pair<TreeNode, NodePath> searchNodePair) { 219 private boolean rdeFilter(String filterRdeId, Pair<TreeNode, NodePath> searchNodePair) {
220 220
221 InterfaceTraverser orgTraverser = organizationTree.getTraverser(); 221 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
222 222
223 Iterator<Pair<TreeNode, NodePath>> orgRoleIdPairIterator = orgTraverser.findInSubTreeAllValue((TreeNode node) -> { 223 Iterator<Pair<TreeNode, NodePath>> orgRoleIdPairIterator = orgTraverser.findInSubTreeAllValue((TreeNode node) -> {
224 String element = node.getAttributes().getString("element"); 224 Iterator<String> element = node.getAttributes().getString("element");
225 if (element == null) 225 if (!element.hasNext())
226 return false; 226 return false;
227 if (!element.equals("roleRefId")) 227 if (!element.next().equals("roleRefId"))
228 return false; 228 return false;
229 String roleId = node.getAttributes().getString("text-roleRefId"); 229 Iterator<String> roleId = node.getAttributes().getString("text-roleRefId");
230 if (roleId != null) 230 if (roleId.hasNext())
231 return true; 231 return true;
232 return false; 232 return false;
233 }, searchNodePair, "text-roleRefId"); 233 }, searchNodePair, "text-roleRefId");
234 234
235 TreeMap<String, String> orgRoleIdMap = TreeMap.empty(Ord.stringOrd); 235 TreeMap<String, String> orgRoleIdMap = TreeMap.empty(Ord.stringOrd);
236 236
237 for (; orgRoleIdPairIterator.hasNext();) { 237 for (; orgRoleIdPairIterator.hasNext();) {
238 String roleId = orgRoleIdPairIterator.next().left().getAttributes().getString("text-roleRefId"); 238 Iterator<String> roleIdIterator = orgRoleIdPairIterator.next().left().getAttributes().getString("text-roleRefId");
239 orgRoleIdMap = orgRoleIdMap.set(roleId, roleId); 239 for (; roleIdIterator.hasNext();) {
240 String roleId = roleIdIterator.next();
241 orgRoleIdMap = orgRoleIdMap.set(roleId, roleId);
242 }
240 } 243 }
241 244
242 Iterator<P2<String, String>> orgRoleIdP2Iterator = orgRoleIdMap.iterator(); 245 Iterator<P2<String, String>> orgRoleIdP2Iterator = orgRoleIdMap.iterator();
243 InterfaceTraverser roleTraverser = roleTree.getTraverser(); 246 InterfaceTraverser roleTraverser = roleTree.getTraverser();
244 247
245 for (; orgRoleIdP2Iterator.hasNext();) { 248 for (; orgRoleIdP2Iterator.hasNext();) {
246 String orgRoleId = orgRoleIdP2Iterator.next()._1(); 249 String orgRoleId = orgRoleIdP2Iterator.next()._1();
247 250
248 Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = roleTraverser.find((TreeNode node) -> { 251 Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = roleTraverser.find((TreeNode node) -> {
249 String element = node.getAttributes().getString("element"); 252 Iterator<String> element = node.getAttributes().getString("element");
250 if (element == null) 253 if (!element.hasNext())
251 return false; 254 return false;
252 if (!element.equals("Role")) 255 if (!element.next().equals("Role"))
253 return false; 256 return false;
254 String compareRoleId = node.getAttributes().getString("Role-id"); 257 Iterator<String> compareRoleIdIterator = node.getAttributes().getString("Role-id");
255 if (compareRoleId == null) 258 for (; compareRoleIdIterator.hasNext();) {
256 return false; 259 if (compareRoleIdIterator.next().equals(orgRoleId))
257 if (compareRoleId.equals(orgRoleId)) 260 return true;
258 return true; 261 }
259 return false; 262 return false;
260 }, "Role-id", orgRoleId); 263 }, "Role-id", orgRoleId);
261 264
262 for (; roleIdPairIterator.hasNext();) { 265 for (; roleIdPairIterator.hasNext();) {
263 266
264 Pair<TreeNode, NodePath> rolePair = roleIdPairIterator.next(); 267 Pair<TreeNode, NodePath> rolePair = roleIdPairIterator.next();
265 Iterator<Pair<TreeNode, NodePath>> rdeIdPairIterator = roleTraverser.findInSubTree((TreeNode node) -> { 268 Iterator<Pair<TreeNode, NodePath>> rdeIdPairIterator = roleTraverser.findInSubTree((TreeNode node) -> {
266 String elementName = node.getAttributes().getString("element"); 269 Iterator<String> element = node.getAttributes().getString("element");
267 if (elementName == null) 270 if (!element.hasNext())
268 return false; 271 return false;
269 if (!elementName.equals("roleDescriptionElementRefIds")) 272 if (!element.next().equals("roleDescriptionElementRefIds"))
270 return false; 273 return false;
271 String rdeId = node.getAttributes().getString("text-roleDescriptionElementRefIds"); 274 Iterator<String> rdeIdIterator = node.getAttributes().getString("text-roleDescriptionElementRefIds");
272 if (rdeId == null) 275 for (; rdeIdIterator.hasNext();) {
273 return false; 276 if (rdeIdIterator.next().equals(filterRdeId))
274 if (rdeId.equals(filterRdeId)) 277 return true;
275 return true; 278 }
276 return false; 279 return false;
277 }, rolePair, "text-roleDescriptionElementRefIds", filterRdeId); 280 }, rolePair, "text-roleDescriptionElementRefIds", filterRdeId);
278 281
279 if (!rdeIdPairIterator.hasNext()) 282 if (!rdeIdPairIterator.hasNext())
280 return false; 283 return false;
281 } 284 }
282 285
283 } 286 }
284 return true; 287 return true;
285 } 288 }
286 289
287 public boolean roleFilter(String id, Pair<TreeNode, NodePath> searchNodePair) { 290 public boolean roleFilter(String id, Pair<TreeNode, NodePath> searchNodePair) {
288 // System.out.println(searchNodePair.getAttributes().getString("id")); 291 // System.out.println(searchNodePair.getAttributes().getString("id"));
289 InterfaceTraverser orgTraverser = organizationTree.getTraverser(); 292 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
290 293
291 Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = orgTraverser.findInSubTree((TreeNode node) -> { 294 Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = orgTraverser.findInSubTree((TreeNode node) -> {
292 String elementName = node.getAttributes().getString("element"); 295 Iterator<String> elementName = node.getAttributes().getString("element");
293 if (elementName == null) 296 if (!elementName.hasNext())
294 return false; 297 return false;
295 if (!elementName.equals("roleRefIds")) 298 if (!elementName.next().equals("roleRefIds"))
296 return false; 299 return false;
297 String roleId = node.getAttributes().getString("text-roleRefIds"); 300 Iterator<String> roleId = node.getAttributes().getString("text-roleRefIds");
298 if (roleId == null) 301 for (; roleId.hasNext();) {
299 return false; 302 if (roleId.next().equals(id))
300 if (roleId.equals(id)) 303 return true;
301 return true; 304 }
302 return false; 305 return false;
303 }, searchNodePair, "text-roleRefIds", id); 306 }, searchNodePair, "text-roleRefIds", id);
304 307
305 if (roleIdPairIterator.hasNext()) { 308 if (roleIdPairIterator.hasNext()) {
306 return false; 309 return false;
307 } 310 }
308 return true; 311 return true;
309 } 312 }
310 313
311 public Iterator<String> roleIds(String id) { 314 public Iterator<String> roleIds(String id) {
312 Pattern personPattern = Pattern.compile("p:"); 315 Pattern personPattern = Pattern.compile("p:");
313 Matcher personMacher = personPattern.matcher(id); 316 Matcher personMacher = personPattern.matcher(id);
314 if (personMacher.find()) { 317 if (personMacher.find()) {
315 return searchRoleIds(personTree, id, "Person"); 318 return searchRoleIds(personTree, id, "Person");
321 return searchRoleIds(organizationTree, id, "Organization"); 324 return searchRoleIds(organizationTree, id, "Organization");
322 } 325 }
323 326
324 return new NullIterator(); 327 return new NullIterator();
325 } 328 }
326
327 329
328 public Iterator<String> searchRoleIds(JungleTree tree, String id, String element) { 330 public Iterator<String> searchRoleIds(JungleTree tree, String id, String element) {
329 331
330 InterfaceTraverser traverser = tree.getTraverser(); 332 InterfaceTraverser traverser = tree.getTraverser();
331 333
332 Iterator<Pair<TreeNode, NodePath>> idPairIterator = traverser.find((TreeNode node) -> { 334 Iterator<Pair<TreeNode, NodePath>> idPairIterator = traverser.find((TreeNode node) -> {
333 String nodeElement = node.getAttributes().getString("element"); 335 Iterator<String> nodeElement = node.getAttributes().getString("element");
334 if (nodeElement == null) 336 if (!nodeElement.hasNext())
335 return false; 337 return false;
336 if (!nodeElement.equals(element)) 338 if (!nodeElement.next().equals(element))
337 return false; 339 return false;
338 String nodeId = node.getAttributes().getString(element + "-id"); 340 Iterator<String> nodeIdIterator = node.getAttributes().getString(element + "-id");
339 if (nodeId == null) 341 for (; nodeIdIterator.hasNext();) {
340 return false; 342 if (nodeIdIterator.next().equals(id))
341 if (nodeId.equals(id)) 343 return true;
342 return true; 344 }
343 return false; 345 return false;
344 }, element + "-id", id); 346 }, element + "-id", id);
345 347
346 TreeMap<String, String> idsTreeMap = TreeMap.empty(Ord.stringOrd); 348 TreeMap<String, String> idsTreeMap = TreeMap.empty(Ord.stringOrd);
347 ;
348 349
349 for (; idPairIterator.hasNext();) { 350 for (; idPairIterator.hasNext();) {
350 351
351 Pair<TreeNode, NodePath> targetPair = idPairIterator.next(); 352 Pair<TreeNode, NodePath> targetPair = idPairIterator.next();
352 353
353 Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = traverser.findInSubTreeAllValue((TreeNode node) -> { 354 Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = traverser.findInSubTreeAllValue((TreeNode node) -> {
354 String nodeElement = node.getAttributes().getString("element"); 355 Iterator<String> nodeElement = node.getAttributes().getString("element");
355 if (nodeElement == null) 356 if (!nodeElement.hasNext())
356 return false; 357 return false;
357 if (!nodeElement.equals("roleRefId")) 358 if (!nodeElement.next().equals("roleRefId"))
358 return false; 359 return false;
359 String nodeId = node.getAttributes().getString("text-roleRefId"); 360 Iterator<String> nodeIdIterator = node.getAttributes().getString("text-roleRefId");
360 if (nodeId != null) 361 if (nodeIdIterator.hasNext())
361 return true; 362 return true;
362 return false; 363 return false;
363 }, targetPair, "text-roleRefId"); 364 }, targetPair, "text-roleRefId");
364 365
365 for (; roleIdPairIterator.hasNext();) { 366 for (; roleIdPairIterator.hasNext();) {
366 Pair<TreeNode, NodePath> roleIdPair = roleIdPairIterator.next(); 367 Pair<TreeNode, NodePath> roleIdPair = roleIdPairIterator.next();
367 String roleId = roleIdPair.left().getAttributes().getString("text-roleRefId"); 368 Iterator<String> roleIdIterator = roleIdPair.left().getAttributes().getString("text-roleRefId");
368 idsTreeMap = idsTreeMap.set(roleId, roleId); 369 for (; roleIdIterator.hasNext();) {
370 String roleId = roleIdIterator.next();
371 idsTreeMap = idsTreeMap.set(roleId, roleId);
372 }
369 } 373 }
370 } 374 }
371 375
372 if (idsTreeMap.isEmpty()) 376 if (idsTreeMap.isEmpty())
373 return new NullIterator(); 377 return new NullIterator();
387 return ids.next()._1(); 391 return ids.next()._1();
388 } 392 }
389 393
390 }; 394 };
391 } 395 }
392
393 396
394 public Iterator<String> competentRoleId(String personId) { 397 public Iterator<String> competentRoleId(String personId) {
395 398
396 InterfaceTraverser personTraverser = personTree.getTraverser(); 399 InterfaceTraverser personTraverser = personTree.getTraverser();
397 Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.find((TreeNode node) -> { 400 Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.find((TreeNode node) -> {
398 String nodeElement = node.getAttributes().getString("element"); 401 Iterator<String> nodeElement = node.getAttributes().getString("element");
399 if (nodeElement == null) 402 if (!nodeElement.hasNext())
400 return false; 403 return false;
401 if (!nodeElement.equals("Person")) 404 if (!nodeElement.next().equals("Person"))
402 return false; 405 return false;
403 String nodeId = node.getAttributes().getString("Person-id"); 406 Iterator<String> nodeIdIterator = node.getAttributes().getString("Person-id");
404 if (nodeId == null) 407 if (!nodeIdIterator.hasNext())
405 return false; 408 return false;
406 if (nodeId.equals(personId)) 409 if (nodeIdIterator.next().equals(personId))
407 return true; 410 return true;
408 return false; 411 return false;
409 }, "Person-id", personId); 412 }, "Person-id", personId);
410 413
411 if (!personIdPairIterator.hasNext()) 414 if (!personIdPairIterator.hasNext())
412 return new NullIterator(); 415 return new NullIterator();
413 416
414 Pair<TreeNode, NodePath> personIdPair = personIdPairIterator.next(); 417 Pair<TreeNode, NodePath> personIdPair = personIdPairIterator.next();
415 418
416 Iterator<Pair<TreeNode, NodePath>> priorityPairIterator = personTraverser.findInSubTree((TreeNode node) -> { 419 Iterator<Pair<TreeNode, NodePath>> priorityPairIterator = personTraverser.findInSubTree((TreeNode node) -> {
417 String nodeElement = node.getAttributes().getString("element"); 420 Iterator<String> nodeElement = node.getAttributes().getString("element");
418 if (nodeElement == null) 421 if (!nodeElement.hasNext())
419 return false; 422 return false;
420 if (!nodeElement.equals("priority")) 423 if (!nodeElement.next().equals("priority"))
421 return false; 424 return false;
422 String priority = node.getAttributes().getString("text-priority"); 425 Iterator<String> priorityIterator = node.getAttributes().getString("text-priority");
423 if (priority == null) 426 for (; priorityIterator.hasNext();) {
424 return false; 427 if (priorityIterator.next().equals("0"))
425 if (priority.equals("0")) 428 return true;
426 return true; 429 }
427 return false; 430 return false;
428 }, personIdPair, "text-priority", "0"); 431 }, personIdPair, "text-priority", "0");
429 432
430 TreeMap<String, String> roleIdTreeMap = TreeMap.empty(Ord.stringOrd); 433 TreeMap<String, String> roleIdTreeMap = TreeMap.empty(Ord.stringOrd);
431 434
434 Pair<TreeNode, NodePath> priorityPair = priorityPairIterator.next(); 437 Pair<TreeNode, NodePath> priorityPair = priorityPairIterator.next();
435 NodePath priorityPath = priorityPair.right(); 438 NodePath priorityPath = priorityPair.right();
436 Pair<Integer, NodePath> removeLastPair = priorityPath.last(); 439 Pair<Integer, NodePath> removeLastPair = priorityPath.last();
437 NodePath roleIdNodePath = removeLastPair.right().add(removeLastPair.left() + 1); 440 NodePath roleIdNodePath = removeLastPair.right().add(removeLastPair.left() + 1);
438 TreeNode roleIdNode = getTarget(personTree.getRootNode(), roleIdNodePath); 441 TreeNode roleIdNode = getTarget(personTree.getRootNode(), roleIdNodePath);
439 String roleId = roleIdNode.getAttributes().getString("text-roleRefId"); 442 Iterator<String> roleIdIterator = roleIdNode.getAttributes().getString("text-roleRefId");
440 roleIdTreeMap = roleIdTreeMap.set(roleId, roleId); 443 for (; roleIdIterator.hasNext();) {
444 String roleId = roleIdIterator.next();
445 roleIdTreeMap = roleIdTreeMap.set(roleId, roleId);
446 }
441 } 447 }
442 Iterator<P2<String, String>> roleIdP2Iterator = roleIdTreeMap.iterator(); 448 Iterator<P2<String, String>> roleIdP2Iterator = roleIdTreeMap.iterator();
443 return new Iterator<String>() { 449 return new Iterator<String>() {
444 450
445 @Override 451 @Override
453 public String next() { 459 public String next() {
454 return roleIdP2Iterator.next()._1(); 460 return roleIdP2Iterator.next()._1();
455 } 461 }
456 }; 462 };
457 } 463 }
458 464
459 public Iterator<String> concurrentRoleIds(String personId) { 465 public Iterator<String> concurrentRoleIds(String personId) {
460 466
461 InterfaceTraverser personTraverser = personTree.getTraverser(); 467 InterfaceTraverser personTraverser = personTree.getTraverser();
462 Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.find((TreeNode node) -> { 468 Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.find((TreeNode node) -> {
463 String nodeElement = node.getAttributes().getString("element"); 469 Iterator<String> nodeElement = node.getAttributes().getString("element");
464 if (nodeElement == null) 470 if (!nodeElement.hasNext())
465 return false; 471 return false;
466 if (!nodeElement.equals("Person")) 472 if (!nodeElement.next().equals("Person"))
467 return false; 473 return false;
468 String nodeId = node.getAttributes().getString("Person-id"); 474 Iterator<String> nodeId = node.getAttributes().getString("Person-id");
469 if (nodeId == null) 475 for (; nodeId.hasNext();) {
470 return false; 476 if (nodeId.next().equals(personId))
471 if (nodeId.equals(personId)) 477 return true;
472 return true; 478 }
473 return false; 479 return false;
474 }, "Person-id", personId); 480 }, "Person-id", personId);
475 481
476 if (!personIdPairIterator.hasNext()) 482 if (!personIdPairIterator.hasNext())
477 return new NullIterator(); 483 return new NullIterator();
478 484
479 Pair<TreeNode, NodePath> personidPair = personIdPairIterator.next(); 485 Pair<TreeNode, NodePath> personidPair = personIdPairIterator.next();
480 486
481 Iterator<Pair<TreeNode, NodePath>> priorityPairIterator = personTraverser.findInSubTreeAllValue( 487 Iterator<Pair<TreeNode, NodePath>> priorityPairIterator = personTraverser.findInSubTreeAllValue(
482 (TreeNode node) -> { 488 (TreeNode node) -> {
483 String nodeElement = node.getAttributes().getString("element"); 489 Iterator<String> nodeElement = node.getAttributes().getString("element");
484 if (nodeElement == null) 490 if (!nodeElement.hasNext())
485 return false; 491 return false;
486 if (!nodeElement.equals("priority")) 492 if (!nodeElement.next().equals("priority"))
487 return false; 493 return false;
488 String priority = node.getAttributes().getString("text-priority"); 494 Iterator<String> priorityIterator = node.getAttributes().getString("text-priority");
489 if (priority != null) 495 if (priorityIterator.hasNext())
490 return true; 496 return true;
491 return false; 497 return false;
492 }, personidPair, "text-priority"); 498 }, personidPair, "text-priority");
493 499
494 TreeMap<String, String> roleIdTreeMap = TreeMap.empty(Ord.stringOrd); 500 TreeMap<String, String> roleIdTreeMap = TreeMap.empty(Ord.stringOrd);
495 501
496 for (; priorityPairIterator.hasNext();) { 502 for (; priorityPairIterator.hasNext();) {
497 503
498 Pair<TreeNode, NodePath> priorityPair = priorityPairIterator.next(); 504 Pair<TreeNode, NodePath> priorityPair = priorityPairIterator.next();
499 TreeNode priorityNode = priorityPair.left(); 505 TreeNode priorityNode = priorityPair.left();
500 int priority = Integer.parseInt(priorityNode.getAttributes().getString("text-priority")); 506 Iterator<String> priorityIterator = priorityNode.getAttributes().getString("text-priority");
501 if (priority > 0) { 507 for (; priorityIterator.hasNext();) {
502 NodePath priorityPath = priorityPair.right(); 508 int priority = Integer.parseInt(priorityIterator.next());
503 Pair<Integer, NodePath> removeLastPair = priorityPath.last(); 509 if (priority > 0) {
504 NodePath roleIdNodePath = removeLastPair.right().add(removeLastPair.left() + 1); 510 NodePath priorityPath = priorityPair.right();
505 TreeNode roleIdNode = getTarget(personTree.getRootNode(), roleIdNodePath); 511 Pair<Integer, NodePath> removeLastPair = priorityPath.last();
506 String roleId = roleIdNode.getAttributes().getString("text-roleRefId"); 512 NodePath roleIdNodePath = removeLastPair.right().add(removeLastPair.left() + 1);
507 roleIdTreeMap = roleIdTreeMap.set(roleId, roleId); 513 TreeNode roleIdNode = getTarget(personTree.getRootNode(), roleIdNodePath);
508 } 514 Iterator<String> roleIdIterator = roleIdNode.getAttributes().getString("text-roleRefId");
509 } 515 for (; roleIdIterator.hasNext();) {
516 String roleId = roleIdIterator.next();
517 roleIdTreeMap = roleIdTreeMap.set(roleId, roleId);
518 }
519 }
520 }
521 }
522
510 Iterator<P2<String, String>> roleIdP2Iterator = roleIdTreeMap.iterator(); 523 Iterator<P2<String, String>> roleIdP2Iterator = roleIdTreeMap.iterator();
511 return new Iterator<String>() { 524 return new Iterator<String>() {
512 525
513 @Override 526 @Override
514 public boolean hasNext() { 527 public boolean hasNext() {
521 public String next() { 534 public String next() {
522 return roleIdP2Iterator.next()._1(); 535 return roleIdP2Iterator.next()._1();
523 } 536 }
524 }; 537 };
525 } 538 }
526 539
527 public Iterator<String> deepPersonIds(String orgId, LinkedList<String> filterIds) { 540 public Iterator<String> deepPersonIds(String orgId, LinkedList<String> filterIds) {
528 541
529 TreeMap<String, String> personIdsTreeMap = TreeMap.empty(Ord.stringOrd); 542 TreeMap<String, String> personIdsTreeMap = TreeMap.empty(Ord.stringOrd);
530 Iterator<String> childrensIterator = deepChildOrganizationIdsPlus(orgId, filterIds); 543 Iterator<String> childrensIterator = deepChildOrganizationIdsPlus(orgId, filterIds);
531 544
532
533 if (!childrensIterator.hasNext()) 545 if (!childrensIterator.hasNext())
534 return new NullIterator(); 546 return new NullIterator();
535 547
536 for (; childrensIterator.hasNext();) { 548 for (; childrensIterator.hasNext();) {
537 String id = childrensIterator.next(); 549 String id = childrensIterator.next();
555 public String next() { 567 public String next() {
556 return personIds.next()._1(); 568 return personIds.next()._1();
557 } 569 }
558 }; 570 };
559 } 571 }
560
561 572
562 public Iterator<String> deepChildOrganizationIdsPlus(String orgId, LinkedList<String> filterIds) { 573 public Iterator<String> deepChildOrganizationIdsPlus(String orgId, LinkedList<String> filterIds) {
563 TreeMap<String, String> orgIdsTreeMap = TreeMap.empty(Ord.stringOrd); 574 TreeMap<String, String> orgIdsTreeMap = TreeMap.empty(Ord.stringOrd);
564 575
565 orgIdsTreeMap = orgIdsTreeMap.set(orgId, orgId); 576 orgIdsTreeMap = orgIdsTreeMap.set(orgId, orgId);
587 public String next() { 598 public String next() {
588 return childOrgId; 599 return childOrgId;
589 } 600 }
590 }; 601 };
591 } 602 }
592 603
593 public Iterator<String> deepChildOrganizationIds(String orgId, LinkedList<String> filterIds) { 604 public Iterator<String> deepChildOrganizationIds(String orgId, LinkedList<String> filterIds) {
594 605
595 TreeMap<String, String> orgIdsTreeMap = TreeMap.empty(Ord.stringOrd); 606 TreeMap<String, String> orgIdsTreeMap = TreeMap.empty(Ord.stringOrd);
596 TreeMap<String, String> newOrgIdsTreeMap = _deepChildOrganizationIds(orgId, orgIdsTreeMap); 607 TreeMap<String, String> newOrgIdsTreeMap = _deepChildOrganizationIds(orgId, orgIdsTreeMap);
597 if (newOrgIdsTreeMap.isEmpty()) 608 if (newOrgIdsTreeMap.isEmpty())
616 } 627 }
617 return false; 628 return false;
618 } 629 }
619 }; 630 };
620 } 631 }
621 632
622 public TreeMap<String, String> _deepChildOrganizationIds(String orgId, TreeMap<String, String> orgIdsTreeMap) { 633 public TreeMap<String, String> _deepChildOrganizationIds(String orgId, TreeMap<String, String> orgIdsTreeMap) {
623 634
624 TreeMap<String, String> childrenIdTreeMap = _childOrganizationIds(orgId, TreeMap.empty(Ord.stringOrd)); 635 TreeMap<String, String> childrenIdTreeMap = _childOrganizationIds(orgId, TreeMap.empty(Ord.stringOrd));
625 636
626 if (childrenIdTreeMap.isEmpty()) 637 if (childrenIdTreeMap.isEmpty())
671 public TreeMap<String, String> _childOrganizationIds(String orgId, TreeMap<String, String> childOrgIdsTreeMap) { 682 public TreeMap<String, String> _childOrganizationIds(String orgId, TreeMap<String, String> childOrgIdsTreeMap) {
672 683
673 InterfaceTraverser orgTraverser = organizationTree.getTraverser(); 684 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
674 685
675 Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = orgTraverser.find((TreeNode node) -> { 686 Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = orgTraverser.find((TreeNode node) -> {
676 String nodeElement = node.getAttributes().getString("element"); 687 Iterator<String> nodeElement = node.getAttributes().getString("element");
677 if (nodeElement == null) 688 if (!nodeElement.hasNext())
678 return false; 689 return false;
679 if (!nodeElement.equals("Organization")) 690 if (!nodeElement.next().equals("Organization"))
680 return false; 691 return false;
681 String nodeId = node.getAttributes().getString("Organization-id"); 692 Iterator<String> nodeIdIterator = node.getAttributes().getString("Organization-id");
682 if (nodeId == null) 693 for (; nodeIdIterator.hasNext();) {
683 return false; 694 if (nodeIdIterator.next().equals(orgId))
684 if (nodeId.equals(orgId)) 695 return true;
685 return true; 696 }
686 return false; 697 return false;
687 }, "Organization-id", orgId); 698 }, "Organization-id", orgId);
688 699
689 if (!orgIdPairIterator.hasNext()) 700 if (!orgIdPairIterator.hasNext())
690 return childOrgIdsTreeMap; 701 return childOrgIdsTreeMap;
691 702
692 Pair<TreeNode, NodePath> orgIdPair = orgIdPairIterator.next(); 703 Pair<TreeNode, NodePath> orgIdPair = orgIdPairIterator.next();
693 704
694 Iterator<Pair<TreeNode, NodePath>> chilrenOrgPairIterator = orgTraverser.findInSubTree((TreeNode node) -> { 705 Iterator<Pair<TreeNode, NodePath>> chilrenOrgPairIterator = orgTraverser.findInSubTree((TreeNode node) -> {
695 String nodeElement = node.getAttributes().getString("element"); 706 Iterator<String> nodeElement = node.getAttributes().getString("element");
696 if (nodeElement == null) 707 if (!nodeElement.hasNext())
697 return false; 708 return false;
698 if (nodeElement.equals("childOrganizations")) 709 if (nodeElement.next().equals("childOrganizations"))
699 return true; 710 return true;
700 return false; 711 return false;
701 }, orgIdPair, "element", "childOrganizations"); 712 }, orgIdPair, "element", "childOrganizations");
702 713
703 if (!chilrenOrgPairIterator.hasNext()) 714 if (!chilrenOrgPairIterator.hasNext())
705 716
706 Pair<TreeNode, NodePath> chilerenOrg = chilrenOrgPairIterator.next(); 717 Pair<TreeNode, NodePath> chilerenOrg = chilrenOrgPairIterator.next();
707 718
708 Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdPairIterator = orgTraverser.findInSubTreeAllValue( 719 Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdPairIterator = orgTraverser.findInSubTreeAllValue(
709 (TreeNode node) -> { 720 (TreeNode node) -> {
710 String nodeElement = node.getAttributes().getString("element"); 721 Iterator<String> nodeElement = node.getAttributes().getString("element");
711 if (nodeElement == null) 722 if (!nodeElement.hasNext())
712 return false; 723 return false;
713 if (!nodeElement.equals("organizationRefIds")) 724 if (!nodeElement.next().equals("organizationRefIds"))
714 return false; 725 return false;
715 nodeElement = node.getAttributes().getString("text-organizationRefIds"); 726 Iterator<String> nodeText = node.getAttributes().getString("text-organizationRefIds");
716 if (nodeElement != null) 727 if (nodeText.hasNext())
717 return true; 728 return true;
718 return false; 729 return false;
719 }, chilerenOrg, "text-organizationRefIds"); 730 }, chilerenOrg, "text-organizationRefIds");
720 731
721 for (; chilrenOrgIdPairIterator.hasNext();) { 732 for (; chilrenOrgIdPairIterator.hasNext();) {
722 String childrenOrgId = chilrenOrgIdPairIterator.next().left().getAttributes() 733 Iterator<String> childrenOrgIdIterator = chilrenOrgIdPairIterator.next().left().getAttributes()
723 .getString("text-organizationRefIds"); 734 .getString("text-organizationRefIds");
724 childOrgIdsTreeMap = childOrgIdsTreeMap.set(childrenOrgId, childrenOrgId); 735 for (; childrenOrgIdIterator.hasNext();) {
725 736 String childrenOrgId = childrenOrgIdIterator.next();
737 childOrgIdsTreeMap = childOrgIdsTreeMap.set(childrenOrgId, childrenOrgId);
738 }
726 } 739 }
727 740
728 return childOrgIdsTreeMap; 741 return childOrgIdsTreeMap;
729 } 742 }
730 743
745 public String rolePriority(String personId, String roleId) { 758 public String rolePriority(String personId, String roleId) {
746 759
747 InterfaceTraverser personTraverser = personTree.getTraverser(); 760 InterfaceTraverser personTraverser = personTree.getTraverser();
748 761
749 Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.find((TreeNode node) -> { 762 Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.find((TreeNode node) -> {
750 String element = node.getAttributes().getString("element"); 763 Iterator<String> element = node.getAttributes().getString("element");
751 if (element == null) 764 if (!element.hasNext())
752 return false; 765 return false;
753 if (!element.equals("Person")) 766 if (!element.next().equals("Person"))
754 return false; 767 return false;
755 String nodePersonId = node.getAttributes().getString("Person-id"); 768 Iterator<String> nodePersonId = node.getAttributes().getString("Person-id");
756 if (nodePersonId == null) 769 for (; nodePersonId.hasNext();) {
757 return false; 770 if (nodePersonId.next().equals(personId))
758 if (nodePersonId.equals(personId)) 771 return true;
759 return true; 772 }
760 return false; 773 return false;
761 }, "Person-id", personId); 774 }, "Person-id", personId);
762 775
763 if (!personIdPairIterator.hasNext()) 776 if (!personIdPairIterator.hasNext())
764 return ""; 777 return "";
765 778
766 Pair<TreeNode, NodePath> targetPersonIdPair = personIdPairIterator.next(); 779 Pair<TreeNode, NodePath> targetPersonIdPair = personIdPairIterator.next();
767 780
768 Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = personTraverser.findInSubTree((TreeNode node) -> { 781 Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = personTraverser.findInSubTree((TreeNode node) -> {
769 String element = node.getAttributes().getString("element"); 782 Iterator<String> element = node.getAttributes().getString("element");
770 if (element == null) 783 if (!element.hasNext())
771 return false; 784 return false;
772 if (!element.equals("roleRefId")) 785 if (!element.next().equals("roleRefId"))
773 return false; 786 return false;
774 String compareRoleId = node.getAttributes().getString("text-roleRefId"); 787 Iterator<String> compareRoleId = node.getAttributes().getString("text-roleRefId");
775 if (compareRoleId == null) 788 for (; compareRoleId.hasNext();) {
776 return false; 789 if (compareRoleId.next().equals(roleId))
777 if (compareRoleId.equals(roleId)) 790 return true;
778 return true; 791 }
779 return false; 792 return false;
780 }, targetPersonIdPair, "text-roleRefId", roleId); 793 }, targetPersonIdPair, "text-roleRefId", roleId);
781 794
782 for (; roleIdPairIterator.hasNext();) { 795 for (; roleIdPairIterator.hasNext();) {
783 Pair<TreeNode, NodePath> roleIdPair = roleIdPairIterator.next(); 796 Pair<TreeNode, NodePath> roleIdPair = roleIdPairIterator.next();
784 NodePath roleIdNodePath = roleIdPair.right(); 797 NodePath roleIdNodePath = roleIdPair.right();
785 Pair<Integer, NodePath> removeLastPath = roleIdNodePath.last(); 798 Pair<Integer, NodePath> removeLastPath = roleIdNodePath.last();
786 NodePath priorityNodePath = removeLastPath.right().add(removeLastPath.left() - 1); 799 NodePath priorityNodePath = removeLastPath.right().add(removeLastPath.left() - 1);
787 TreeNode priorityNode = getTarget(personTree.getRootNode(), priorityNodePath); 800 TreeNode priorityNode = getTarget(personTree.getRootNode(), priorityNodePath);
788 if (priorityNode.getAttributes().getString("element").equals("priority")) 801 Iterator<String> element = priorityNode.getAttributes().getString("element");
789 return priorityNode.getAttributes().getString("text-priority"); 802 if (element.hasNext()) {
803 if (element.next().equals("priority")) {
804 Iterator<String> priority = priorityNode.getAttributes().getString("text-priority");
805 if (priority.hasNext())
806 return priority.next();
807 }
808 }
790 } 809 }
791 return ""; 810 return "";
792 } 811 }
793 812
794 public Iterator<String> parentOrganizationIds(String orgId, LinkedList<String> filterIds) { 813 public Iterator<String> parentOrganizationIds(String orgId, LinkedList<String> filterIds) {
821 840
822 public TreeMap<String, String> _parentOrganizationIds(String orgId) { 841 public TreeMap<String, String> _parentOrganizationIds(String orgId) {
823 842
824 InterfaceTraverser orgTraverser = organizationTree.getTraverser(); 843 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
825 Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = orgTraverser.find((TreeNode node) -> { 844 Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = orgTraverser.find((TreeNode node) -> {
826 String element = node.getAttributes().getString("element"); 845 Iterator<String> element = node.getAttributes().getString("element");
827 if (element == null) 846 if (!element.hasNext())
828 return false; 847 return false;
829 if (!element.equals("Organization")) 848 if (!element.next().equals("Organization"))
830 return false; 849 return false;
831 String nodeId = node.getAttributes().getString("Organization-id"); 850 Iterator<String> nodeIdIterator = node.getAttributes().getString("Organization-id");
832 if (nodeId == null) 851 for (; nodeIdIterator.hasNext();) {
833 return false; 852 if (nodeIdIterator.next().equals(orgId))
834 if (nodeId.equals(orgId)) 853 return true;
835 return true; 854 }
836 return false; 855 return false;
837 }, "Organization-id", orgId); 856 }, "Organization-id", orgId);
838 857
839 if (!orgIdPairIterator.hasNext()) 858 if (!orgIdPairIterator.hasNext())
840 return TreeMap.empty(Ord.stringOrd); 859 return TreeMap.empty(Ord.stringOrd);
841 860
842 Pair<TreeNode, NodePath> orgNode = orgIdPairIterator.next(); 861 Pair<TreeNode, NodePath> orgNode = orgIdPairIterator.next();
843 862
844 Iterator<Pair<TreeNode, NodePath>> parentOrgPairIterator = orgTraverser.findInSubTree((TreeNode node) -> { 863 Iterator<Pair<TreeNode, NodePath>> parentOrgPairIterator = orgTraverser.findInSubTree((TreeNode node) -> {
845 String element = node.getAttributes().getString("element"); 864 Iterator<String> element = node.getAttributes().getString("element");
846 if (element == null) 865 if (!element.hasNext())
847 return false; 866 return false;
848 if (element.equals("parentOrganizations")) 867 if (element.next().equals("parentOrganizations"))
849 return true; 868 return true;
850 return false; 869 return false;
851 }, orgNode, "element", "parentOrganizations"); 870 }, orgNode, "element", "parentOrganizations");
852 871
853 TreeMap<String, String> parentIdsTreeMap = TreeMap.empty(Ord.stringOrd); 872 TreeMap<String, String> parentIdsTreeMap = TreeMap.empty(Ord.stringOrd);
855 for (; parentOrgPairIterator.hasNext();) { 874 for (; parentOrgPairIterator.hasNext();) {
856 Pair<TreeNode, NodePath> parentOrgNode = parentOrgPairIterator.next(); 875 Pair<TreeNode, NodePath> parentOrgNode = parentOrgPairIterator.next();
857 876
858 Iterator<Pair<TreeNode, NodePath>> parentOrgIdPairIterator = orgTraverser.findInSubTreeAllValue( 877 Iterator<Pair<TreeNode, NodePath>> parentOrgIdPairIterator = orgTraverser.findInSubTreeAllValue(
859 (TreeNode node) -> { 878 (TreeNode node) -> {
860 String element = node.getAttributes().getString("element"); 879 Iterator<String> element = node.getAttributes().getString("element");
861 if (element == null) 880 if (!element.hasNext())
862 return false; 881 return false;
863 if (!element.equals("organizationRefId")) 882 if (!element.next().equals("organizationRefId"))
864 return false; 883 return false;
865 String parentId = node.getAttributes().getString("text-organizationRefId"); 884 Iterator<String> parentIdIterator = node.getAttributes().getString("text-organizationRefId");
866 if (parentId != null) 885 if (parentIdIterator.hasNext())
867 return true; 886 return true;
868 return false; 887 return false;
869 }, parentOrgNode, "text-organizationRefId"); 888 }, parentOrgNode, "text-organizationRefId");
870 889
871 for (; parentOrgIdPairIterator.hasNext();) { 890 for (; parentOrgIdPairIterator.hasNext();) {
872 String parentId = parentOrgIdPairIterator.next().left().getAttributes().getString("text-organizationRefId"); 891 Iterator<String> parentIdIterator = parentOrgIdPairIterator.next().left().getAttributes()
873 parentIdsTreeMap = parentIdsTreeMap.set(parentId, parentId); 892 .getString("text-organizationRefId");
893 for (; parentIdIterator.hasNext();) {
894 String parentId = parentIdIterator.next();
895 parentIdsTreeMap = parentIdsTreeMap.set(parentId, parentId);
896 }
874 } 897 }
875 898
876 } 899 }
877 900
878 return parentIdsTreeMap; 901 return parentIdsTreeMap;
980 root = rdeTree.getRootNode(); 1003 root = rdeTree.getRootNode();
981 elementName = "RoleDescriptionElement"; 1004 elementName = "RoleDescriptionElement";
982 } 1005 }
983 1006
984 Iterator<Pair<TreeNode, NodePath>> PathNameIterator = traverser.find((TreeNode node) -> { 1007 Iterator<Pair<TreeNode, NodePath>> PathNameIterator = traverser.find((TreeNode node) -> {
985 String element = node.getAttributes().getString("element"); 1008 Iterator<String> element = node.getAttributes().getString("element");
986 if (element == null) 1009 if (!element.hasNext())
987 return false; 1010 return false;
988 if (!element.equals("path")) 1011 if (!element.next().equals("path"))
989 return false; 1012 return false;
990 String pathString = node.getAttributes().getString("text-path"); 1013 Iterator<String> pathStringIterator = node.getAttributes().getString("text-path");
991 if (pathString == null) 1014 for (; pathStringIterator.hasNext();) {
992 return false; 1015 if (pathStringIterator.next().equals(StrPath))
993 if (pathString.equals(StrPath)) 1016 return true;
994 return true; 1017 }
995 return false; 1018 return false;
996 }, "text-path", StrPath); 1019 }, "text-path", StrPath);
997 1020
998 if (!PathNameIterator.hasNext()) 1021 if (!PathNameIterator.hasNext())
999 return ""; 1022 return "";
1001 Pair<TreeNode, NodePath> pathNamePair = PathNameIterator.next(); 1024 Pair<TreeNode, NodePath> pathNamePair = PathNameIterator.next();
1002 NodePath pathNamePath = pathNamePair.right(); 1025 NodePath pathNamePath = pathNamePair.right();
1003 NodePath pathNameIdPath = pathNamePath.last().right(); 1026 NodePath pathNameIdPath = pathNamePath.last().right();
1004 1027
1005 TreeNode pathNameIdNode = getTarget(root, pathNameIdPath); 1028 TreeNode pathNameIdNode = getTarget(root, pathNameIdPath);
1006 String pathNameId = pathNameIdNode.getAttributes().getString(elementName + "-id"); 1029 Iterator<String> pathNameIdIterator = pathNameIdNode.getAttributes().getString(elementName + "-id");
1007 return pathNameId; 1030 if (pathNameIdIterator.hasNext())
1031 return pathNameIdIterator.next();
1032 return "";
1008 } 1033 }
1009 1034
1010 public Iterator<String> roleDescriptionElementIds(String id, LinkedList<String> filterIds) { 1035 public Iterator<String> roleDescriptionElementIds(String id, LinkedList<String> filterIds) {
1011 1036
1012 Iterator<String> orgIdsIterator = deepParentOrganizationIdsPlus(id, filterIds); 1037 Iterator<String> orgIdsIterator = deepParentOrganizationIdsPlus(id, filterIds);
1048 private Iterator<String> getRde(String roleId) { 1073 private Iterator<String> getRde(String roleId) {
1049 1074
1050 InterfaceTraverser traverser = roleTree.getTraverser(); 1075 InterfaceTraverser traverser = roleTree.getTraverser();
1051 1076
1052 Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = traverser.find((TreeNode node) -> { 1077 Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = traverser.find((TreeNode node) -> {
1053 String element = node.getAttributes().getString("element"); 1078 Iterator<String> element = node.getAttributes().getString("element");
1054 if (element == null) 1079 if (!element.hasNext())
1055 return false; 1080 return false;
1056 if (!element.equals("Role")) 1081 if (!element.next().equals("Role"))
1057 return false; 1082 return false;
1058 String id = node.getAttributes().getString("Role-id"); 1083 Iterator<String> idIterator = node.getAttributes().getString("Role-id");
1059 if (id == null) 1084 for (; idIterator.hasNext();) {
1060 return false; 1085 if (idIterator.next().equals(roleId))
1061 if (id.equals(roleId)) 1086 return true;
1087 }
1088 return false;
1089 }, "Role-id", roleId);
1090
1091 if (!roleIdPairIterator.hasNext())
1092 return new NullIterator();
1093
1094 Pair<TreeNode, NodePath> roleIdPair = roleIdPairIterator.next();
1095
1096 Iterator<Pair<TreeNode, NodePath>> rdeIdPairIterator = traverser.findInSubTreeAllValue((TreeNode node) -> {
1097 Iterator<String> element = node.getAttributes().getString("element");
1098 if (!element.hasNext())
1099 return false;
1100 if (!element.next().equals("roleDescriptionElementRefIds"))
1101 return false;
1102 Iterator<String> rdeIterator = node.getAttributes().getString("text-roleDescriptionElementRefIds");
1103 if (rdeIterator.hasNext())
1062 return true; 1104 return true;
1063 return false; 1105 return false;
1064 }, "Role-id", roleId);
1065
1066 if (!roleIdPairIterator.hasNext())
1067 return new NullIterator();
1068
1069 Pair<TreeNode, NodePath> roleIdPair = roleIdPairIterator.next();
1070
1071 Iterator<Pair<TreeNode, NodePath>> rdeIdPairIterator = traverser.findInSubTreeAllValue((TreeNode node) -> {
1072 String element = node.getAttributes().getString("element");
1073 if (element == null)
1074 return false;
1075 if (!element.equals("roleDescriptionElementRefIds"))
1076 return false;
1077 String rde = node.getAttributes().getString("text-roleDescriptionElementRefIds");
1078 if (rde != null)
1079 return true;
1080 return false;
1081 }, roleIdPair, "text-roleDescriptionElementRefIds"); 1106 }, roleIdPair, "text-roleDescriptionElementRefIds");
1082 1107
1083 if (!rdeIdPairIterator.hasNext()) 1108 if (!rdeIdPairIterator.hasNext())
1084 return new NullIterator(); 1109 return new NullIterator();
1085 1110
1086 return new Iterator<String>() { 1111 Iterator<String> rdeIdIterator = rdeIdPairIterator.next().left().getAttributes().getString("text-roleDescriptionElementRefIds");
1087
1088 @Override
1089 public boolean hasNext() {
1090 if (rdeIdPairIterator.hasNext())
1091 return true;
1092 return false;
1093 }
1094
1095 @Override
1096 public String next() {
1097 return rdeIdPairIterator.next().left().getAttributes().getString("text-roleDescriptionElementRefIds");
1098 }
1099 };
1100
1101 }
1102 1112
1113 return new Iterator<String>() {
1114 String rdeId = "";
1115
1116 @Override
1117 public boolean hasNext() {
1118 if (rdeIdIterator.hasNext()) {
1119 rdeId = rdeIdIterator.next();
1120 return true;
1121 }
1122 return false;
1123 }
1124
1125 @Override
1126 public String next() {
1127 return rdeId;
1128 }
1129 };
1130
1131 }
1103 1132
1104 public TreeNode getTarget(TreeNode node, NodePath path) { 1133 public TreeNode getTarget(TreeNode node, NodePath path) {
1105 TreeNode target; 1134 TreeNode target;
1106 Pair<Integer, NodePath> popPath = path.pop(); 1135 Pair<Integer, NodePath> popPath = path.pop();
1107 int num = popPath.left(); 1136 int num = popPath.left();
1119 1148
1120 target = getTarget(child, popPath.right()); 1149 target = getTarget(child, popPath.right());
1121 return target; 1150 return target;
1122 } 1151 }
1123 1152
1124
1125 } 1153 }