Mercurial > hg > Members > tatsuki > JungleXMLReader

comparison src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/JuGrix.java @ 31:7f70341a78bc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
all function use index
author one
date Sat, 08 Nov 2014 06:31:14 +0900
parents f45b1c839753
children b8d86bc46b51
comparison
equal deleted inserted replaced
30:f45b1c839753 31:7f70341a78bc
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 7
8 import org.apache.commons.collections.OrderedBidiMap;
9 import org.omg.CORBA.OBJ_ADAPTER;
10
8 import ac.jp.u_ryukyu.cr.ie.tatsuki.xmlReader.loadXml; 11 import ac.jp.u_ryukyu.cr.ie.tatsuki.xmlReader.loadXml;
9 import fj.Ord; 12 import fj.Ord;
10 import fj.P2; 13 import fj.P2;
11 import fj.data.TreeMap; 14 import fj.data.TreeMap;
15 import jp.ac.u_ryukyu.cr.ie.tatsuki.functionTest.PersonIdsTest;
12 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree; 16 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
13 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; 17 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
14 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; 18 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
15 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser; 19 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
16 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; 20 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
62 return true; 66 return true;
63 return false; 67 return false;
64 68
65 } 69 }
66 70
71
72
67 public Iterator<String> personIds(String orgId, LinkedList<String> roleIds) { 73 public Iterator<String> personIds(String orgId, LinkedList<String> roleIds) {
68 return personIdsSearch(orgId, roleIds).iterator(); 74 TreeMap<String, String> personIds = TreeMap.empty(Ord.stringOrd);
69 } 75 TreeMap<String, String> personIdsTreeMap = personIdsSearch(orgId, roleIds, personIds);
70 76
71 public LinkedList<String> personIdLink(String orgId, LinkedList<String> roleIds) { 77 if (personIdsTreeMap.isEmpty())
72 return personIdsSearch(orgId, roleIds); 78 return new NullIterator();
79
80 Iterator<P2<String, String>> personIdsIterator = personIdsTreeMap.iterator();
81 return new Iterator<String>() {
82
83 @Override
84 public boolean hasNext() {
85 if (personIdsIterator.hasNext())
86 return true;
87 return false;
88 }
89
90 @Override
91 public String next() {
92 return personIdsIterator.next()._1();
93 }
94
95 };
73 } 96 }
74 97
75 public Iterator<String> personIds(LinkedList<String> orgIds, LinkedList<String> roleIds) { 98 public Iterator<String> personIds(LinkedList<String> orgIds, LinkedList<String> roleIds) {
76 99
77 LinkedList<String> personIds = new LinkedList<String>(); 100 TreeMap<String, String> personIds = TreeMap.empty(Ord.stringOrd);
78
79 for (String orgId : orgIds) { 101 for (String orgId : orgIds) {
80 personIds.addAll(personIdsSearch(orgId, roleIds)); 102 personIds = personIdsSearch(orgId, roleIds, personIds);
81 } 103 }
82 return personIds.iterator(); 104
83 } 105 if (personIds.isEmpty())
84 106 return new NullIterator();
85 private LinkedList<String> personIdsSearch(String id, LinkedList<String> roleIds) { 107
108 Iterator<P2<String, String>> personIdsIterator = personIds.iterator();
109 return new Iterator<String>() {
110
111 @Override
112 public boolean hasNext() {
113 if (personIdsIterator.hasNext())
114 return true;
115 return false;
116 }
117
118 @Override
119 public String next() {
120 return personIdsIterator.next()._1();
121 }
122
123 };
124 }
125
126 private TreeMap<String, String> personIdsSearch(String id, LinkedList<String> roleIds, TreeMap<String, String> orgIds) {
86 127
87 if (!filter(id, roleIds)) 128 if (!filter(id, roleIds))
88 return new LinkedList<String>(); 129 return orgIds;
89 130
90 InterfaceTraverser personTraverser = personTree.getTraverser(); 131 InterfaceTraverser personTraverser = personTree.getTraverser();
91 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = personTraverser.find((TreeNode node) -> { 132 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = personTraverser.findAll((TreeNode node) -> {
92 String personId = node.getAttributes().getString("element"); 133 String personId = node.getAttributes().getString("element");
93 if (personId == null) 134 if (personId == null)
94 return false; 135 return false;
95 if (personId.equals("Person")) 136 if (personId.equals("Person"))
96 return true; 137 return true;
97 return false; 138 return false;
98 }, "element", "Person"); 139 }, "Person-id");
99
100 LinkedList<String> names = new LinkedList<String>();
101 140
102 for (; pairPersonIterator.hasNext();) { 141 for (; pairPersonIterator.hasNext();) {
103 142
104 Pair<TreeNode, NodePath> pairPerson = pairPersonIterator.next(); 143 Pair<TreeNode, NodePath> pairPerson = pairPersonIterator.next();
105 Iterator<Pair<TreeNode, NodePath>> pairIdIterator = personTraverser.findInSubTree((TreeNode node) -> { 144 Iterator<Pair<TreeNode, NodePath>> pairIdIterator = personTraverser.findInSubTree((TreeNode node) -> {
106 String personId = node.getAttributes().getString("text"); 145 String personId = node.getAttributes().getString("text-organizationRefId");
107 if (personId == null) 146 if (personId == null)
108 return false; 147 return false;
109 if (personId.equals(id)) 148 if (personId.equals(id))
110 return true; 149 return true;
111 return false; 150 return false;
112 }, pairPerson, "text", id); 151 }, pairPerson, "text-organizationRefId", id);
113 152
114 if (pairIdIterator.hasNext()) { 153 if (pairIdIterator.hasNext()) {
115 String name = pairPerson.left().getAttributes().getString("id"); 154 String name = pairPerson.left().getAttributes().getString("Person-id");
116 names.add(name); 155 if (name != null)
117 } 156 orgIds = orgIds.set(name, name);
118 } 157 }
119 return names; 158 }
159 return orgIds;
120 } 160 }
121 161
122 public boolean filter(String orgId, LinkedList<String> roleIds) { 162 public boolean filter(String orgId, LinkedList<String> roleIds) {
123 if (roleIds == null) 163 if (roleIds == null)
124 return true; 164 return true;
132 String personId = node.getAttributes().getString("element"); 172 String personId = node.getAttributes().getString("element");
133 if (personId == null) 173 if (personId == null)
134 return false; 174 return false;
135 if (!personId.equals("Organization")) 175 if (!personId.equals("Organization"))
136 return false; 176 return false;
137 String compareOrgId = node.getAttributes().getString("id"); 177 String compareOrgId = node.getAttributes().getString("Organization-id");
138 if (compareOrgId == null) 178 if (compareOrgId == null)
139 return false; 179 return false;
140 if (compareOrgId.equals(orgId)) 180 if (compareOrgId.equals(orgId))
141 return true; 181 return true;
142 return false; 182 return false;
143 }, "id", orgId); 183 }, "Organization-id", orgId);
144 184
145 if (!orgNodeIterator.hasNext()) 185 if (!orgNodeIterator.hasNext())
146 return false; 186 return false;
147 187
148 Pair<TreeNode, NodePath> searchNodePair = orgNodeIterator.next(); 188 Pair<TreeNode, NodePath> searchNodePair = orgNodeIterator.next();
166 } 206 }
167 207
168 private boolean rdeFilter(String id, Pair<TreeNode, NodePath> searchNodePair) { 208 private boolean rdeFilter(String id, Pair<TreeNode, NodePath> searchNodePair) {
169 209
170 InterfaceTraverser orgTraverser = organizationTree.getTraverser(); 210 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
171 Iterator<Pair<TreeNode, NodePath>> pairIdIterator = orgTraverser.findInSubTree((TreeNode node) -> { 211 Iterator<Pair<TreeNode, NodePath>> pairIdIterator = orgTraverser.findInSubTreeAllValue((TreeNode node) -> {
172 String element = node.getAttributes().getString("element"); 212 String element = node.getAttributes().getString("element");
173 if (element == null) 213 if (element == null)
174 return false; 214 return false;
175 if (!element.equals("roleRefId")) 215 if (!element.equals("roleRefId"))
176 return false; 216 return false;
177 String roleId = node.getAttributes().getString("text"); 217 String roleId = node.getAttributes().getString("text-roleRefId");
178 if (roleId != null) 218 if (roleId != null)
179 return true; 219 return true;
180 return false; 220 return false;
181 }, searchNodePair, "element", "roleRefId"); 221 }, searchNodePair, "text-roleRefId");
182 222
183 TreeMap<String, String> idMap = TreeMap.empty(Ord.stringOrd); 223 TreeMap<String, String> idMap = TreeMap.empty(Ord.stringOrd);
184 for (; pairIdIterator.hasNext();) { 224 for (; pairIdIterator.hasNext();) {
185 String roleId = pairIdIterator.next().left().getAttributes().getString("text"); 225 String roleId = pairIdIterator.next().left().getAttributes().getString("text-roleRefId");
186 idMap = idMap.set(roleId, roleId); 226 idMap = idMap.set(roleId, roleId);
187 } 227 }
188 228
189 Iterator<P2<String, String>> ids = idMap.iterator(); 229 Iterator<P2<String, String>> ids = idMap.iterator();
190 InterfaceTraverser roleTraverser = roleTree.getTraverser(); 230 InterfaceTraverser roleTraverser = roleTree.getTraverser();
195 String element = node.getAttributes().getString("element"); 235 String element = node.getAttributes().getString("element");
196 if (element == null) 236 if (element == null)
197 return false; 237 return false;
198 if (!element.equals("Role")) 238 if (!element.equals("Role"))
199 return false; 239 return false;
200 String compareRoleId = node.getAttributes().getString("id"); 240 String compareRoleId = node.getAttributes().getString("Role-id");
201 if (compareRoleId == null) 241 if (compareRoleId == null)
202 return false; 242 return false;
203 if (compareRoleId.equals(roleId)) 243 if (compareRoleId.equals(roleId))
204 return true; 244 return true;
205 return false; 245 return false;
206 }, "id", roleId); 246 }, "Role-id", roleId);
207 // -----------------------------------------bug------------------------------------------ 247
208 for (; roleNodeIterator.hasNext();) { 248 for (; roleNodeIterator.hasNext();) {
209 Pair<TreeNode, NodePath> rolePair = roleNodeIterator.next(); 249 Pair<TreeNode, NodePath> rolePair = roleNodeIterator.next();
210 Iterator<Pair<TreeNode, NodePath>> rdeNodeIterator = roleTraverser.findInSubTree((TreeNode node) -> { 250 Iterator<Pair<TreeNode, NodePath>> rdeNodeIterator = roleTraverser.findInSubTree((TreeNode node) -> {
211 String elementName = node.getAttributes().getString("element"); 251 String elementName = node.getAttributes().getString("element");
212 if (elementName == null) 252 if (elementName == null)
213 return false; 253 return false;
214 if (!elementName.equals("roleDescriptionElementRefIds")) 254 if (!elementName.equals("roleDescriptionElementRefIds"))
215 return false; 255 return false;
216 String rdeId = node.getAttributes().getString("text"); 256 String rdeId = node.getAttributes().getString("text-roleDescriptionElementRefIds");
217 if (rdeId == null) 257 if (rdeId == null)
218 return false; 258 return false;
219 Pattern personPattern = Pattern.compile(id); 259 Pattern personPattern = Pattern.compile(id);
220 Matcher personMacher = personPattern.matcher(rdeId); 260 Matcher personMacher = personPattern.matcher(rdeId);
221 if (personMacher.find()) 261 if (personMacher.find())
222 return true; 262 return true;
223 return false; 263 return false;
224 }, rolePair, "text", "id"); 264 }, rolePair, "text-roleDescriptionElementRefIds", id);
225 265
226 if (!rdeNodeIterator.hasNext()) 266 if (!rdeNodeIterator.hasNext())
227 return false; 267 return false;
228 } 268 }
229 269
239 String elementName = node.getAttributes().getString("element"); 279 String elementName = node.getAttributes().getString("element");
240 if (elementName == null) 280 if (elementName == null)
241 return false; 281 return false;
242 if (!elementName.equals("roleRefIds")) 282 if (!elementName.equals("roleRefIds"))
243 return false; 283 return false;
244 String roleId = node.getAttributes().getString("text"); 284 String roleId = node.getAttributes().getString("text-roleRefIds");
245 if (roleId == null) 285 if (roleId == null)
246 return false; 286 return false;
247 if (roleId.equals(id)) 287 if (roleId.equals(id))
248 return true; 288 return true;
249 return false; 289 return false;
250 }, searchNodePair, "text", id); 290 }, searchNodePair, "text-roleRefIds", id);
251 291
252 if (pairIdIterator.hasNext()) { 292 if (pairIdIterator.hasNext()) {
253 System.out.println(pairIdIterator.next().left().getAttributes().getString("text")); 293 System.out.println(pairIdIterator.next().left().getAttributes().getString("text-roleRefIds"));
254 return false; 294 return false;
255 } 295 }
256 return true; 296 return true;
257 } 297 }
258 298
279 String nodeElement = node.getAttributes().getString("element"); 319 String nodeElement = node.getAttributes().getString("element");
280 if (nodeElement == null) 320 if (nodeElement == null)
281 return false; 321 return false;
282 if (!nodeElement.equals(element)) 322 if (!nodeElement.equals(element))
283 return false; 323 return false;
284 String nodeId = node.getAttributes().getString("id"); 324 String nodeId = node.getAttributes().getString(element + "-id");
285 if (nodeId == null) 325 if (nodeId == null)
286 return false; 326 return false;
287 if (nodeId.equals(id)) 327 if (nodeId.equals(id))
288 return true; 328 return true;
289 return false; 329 return false;
290 }, "id", id); 330 }, element + "-id", id);
291 331
292 LinkedList<String> ids = new LinkedList<String>(); 332 TreeMap<String, String> idsTreeMap = TreeMap.empty(Ord.stringOrd);
333 ;
293 334
294 for (; searchTargetIterator.hasNext();) { 335 for (; searchTargetIterator.hasNext();) {
295 336
296 Pair<TreeNode, NodePath> searchTargetPair = searchTargetIterator.next(); 337 Pair<TreeNode, NodePath> searchTargetPair = searchTargetIterator.next();
297 Iterator<Pair<TreeNode, NodePath>> pairIdIterator = ifTraverser.findInSubTree((TreeNode node) -> { 338 Iterator<Pair<TreeNode, NodePath>> pairIdIterator = ifTraverser.findInSubTreeAllValue((TreeNode node) -> {
298 String nodeElement = node.getAttributes().getString("element"); 339 String nodeElement = node.getAttributes().getString("element");
299 if (nodeElement == null) 340 if (nodeElement == null)
300 return false; 341 return false;
301 if (!nodeElement.equals("roleRefId")) 342 if (!nodeElement.equals("roleRefId"))
302 return false; 343 return false;
303 String nodeId = node.getAttributes().getString("text"); 344 String nodeId = node.getAttributes().getString("text-roleRefId");
304 if (nodeId != null) 345 if (nodeId != null)
305 return true; 346 return true;
306 return false; 347 return false;
307 }, searchTargetPair, "element", "roleRefId"); 348 }, searchTargetPair, "text-roleRefId");
308 349
309 for (; pairIdIterator.hasNext();) { 350 for (; pairIdIterator.hasNext();) {
310 Pair<TreeNode, NodePath> idNodePath = pairIdIterator.next(); 351 Pair<TreeNode, NodePath> idNodePath = pairIdIterator.next();
311 String attribute = idNodePath.left().getAttributes().getString("text"); 352 String attribute = idNodePath.left().getAttributes().getString("text-roleRefId");
312 353 idsTreeMap = idsTreeMap.set(attribute, attribute);
313 Iterator<String> checkList = ids.iterator(); 354 }
314 for (; checkList.hasNext();) { 355 }
315 if (checkList.next().equals(attribute)) 356
316 attribute = null; 357 if (idsTreeMap.isEmpty())
317 } 358 return new NullIterator();
318 359
319 if (attribute != null) { 360 Iterator<P2<String, String>> ids = idsTreeMap.iterator();
320 ids.add(attribute); 361 return new Iterator<String>() {
321 System.out.println("-------------------------" + attribute + "-------------------------"); 362
322 } 363 @Override
323 } 364 public boolean hasNext() {
324 } 365 if (ids.hasNext())
325 return ids.iterator(); 366 return true;
367 return false;
368 }
369
370 @Override
371 public String next() {
372 return ids.next()._1();
373 }
374
375 };
326 } 376 }
327 377
328 public Iterator<String> competentRoleId(String personId) { 378 public Iterator<String> competentRoleId(String personId) {
329 379
330 InterfaceTraverser ifTraverser = personTree.getTraverser(); 380 InterfaceTraverser ifTraverser = personTree.getTraverser();
407 return false; 457 return false;
408 }, person, "text-priority"); 458 }, person, "text-priority");
409 459
410 LinkedList<String> idList = new LinkedList<String>(); 460 LinkedList<String> idList = new LinkedList<String>();
411 for (; targetPairIterator.hasNext();) { 461 for (; targetPairIterator.hasNext();) {
412 Pair<TreeNode,NodePath> targetPair = targetPairIterator.next(); 462 Pair<TreeNode, NodePath> targetPair = targetPairIterator.next();
413 TreeNode targetNode = targetPair.left(); 463 TreeNode targetNode = targetPair.left();
414 int priority = Integer.parseInt(targetNode.getAttributes().getString("text-priority")); 464 int priority = Integer.parseInt(targetNode.getAttributes().getString("text-priority"));
415 if (priority > 0) { 465 if (priority > 0) {
416 NodePath targetPath = targetPair.right(); 466 NodePath targetPath = targetPair.right();
417 Pair<Integer, NodePath> searchPair = targetPath.last(); 467 Pair<Integer, NodePath> searchPair = targetPath.last();
424 474
425 return idList.iterator(); 475 return idList.iterator();
426 } 476 }
427 477
428 public Iterator<String> deepPersonIds(String orgId, LinkedList<String> filterIds) { 478 public Iterator<String> deepPersonIds(String orgId, LinkedList<String> filterIds) {
429 479 TreeMap<String, String> personIdsTreeMap = TreeMap.empty(Ord.stringOrd);
430 Iterator<String> childrensIterator = deepChildOrganizationIds(orgId, new LinkedList<String>()); 480 Iterator<String> childrensIterator = deepParentOrganizationIdsPlus(orgId, filterIds);
481
431 if (!childrensIterator.hasNext()) 482 if (!childrensIterator.hasNext())
432 return new NullIterator(); 483 return new NullIterator();
433 484
434 LinkedList<String> childrenPersonList = new LinkedList<String>();
435 // childrenPersonList.addAll(personIdLink(orgId, filterIds));
436 for (; childrensIterator.hasNext();) { 485 for (; childrensIterator.hasNext();) {
437 String id = childrensIterator.next(); 486 String id = childrensIterator.next();
438 childrenPersonList.addAll(personIdLink(id, filterIds)); 487 personIdsTreeMap = personIdsSearch(id, filterIds,personIdsTreeMap);
439 } 488 }
440 489
441 return childrenPersonList.iterator(); 490 if (personIdsTreeMap.isEmpty())
491 return new NullIterator();
492
493 Iterator<P2<String, String>> personIds = personIdsTreeMap.iterator();
494 return new Iterator<String>() {
495
496 @Override
497 public boolean hasNext() {
498 if (personIds.hasNext())
499 return true;
500 return false;
501 }
502
503 @Override
504 public String next() {
505 return personIds.next()._1();
506 }
507 };
442 } 508 }
443 509
444 public Iterator<String> deepChildOrganizationIdsPlus(String orgId, LinkedList<String> filterIds) { 510 public Iterator<String> deepChildOrganizationIdsPlus(String orgId, LinkedList<String> filterIds) {
445 LinkedList<String> orgList = new LinkedList<String>(); 511 TreeMap<String, String> orgIdsTreeMap = TreeMap.empty(Ord.stringOrd);
446 if (filter(orgId, filterIds)) 512 if (filter(orgId, filterIds))
447 orgList.add(orgId); 513 orgIdsTreeMap = orgIdsTreeMap.set(orgId, orgId);
448 orgList.addAll(_deepChildOrganizationIds(orgId, filterIds)); 514 orgIdsTreeMap = _deepChildOrganizationIds(orgId, filterIds, orgIdsTreeMap);
449 return orgList.iterator(); 515
516 if (orgIdsTreeMap.isEmpty())
517 return new NullIterator();
518
519 Iterator<P2<String, String>> orgIds = orgIdsTreeMap.iterator();
520 return new Iterator<String>() {
521
522 @Override
523 public boolean hasNext() {
524 if (orgIds.hasNext())
525 return true;
526 return false;
527 }
528
529 @Override
530 public String next() {
531 return orgIds.next()._1();
532 }
533 };
450 } 534 }
451 535
452 public Iterator<String> deepChildOrganizationIds(String orgId, LinkedList<String> filterIds) { 536 public Iterator<String> deepChildOrganizationIds(String orgId, LinkedList<String> filterIds) {
453 return _deepChildOrganizationIds(orgId, filterIds).iterator(); 537
454 } 538 TreeMap<String, String> orgIdsTreeMap = TreeMap.empty(Ord.stringOrd);
455 539 TreeMap<String, String> newOrgIdsTreeMap = _deepChildOrganizationIds(orgId, filterIds, orgIdsTreeMap);
456 public LinkedList<String> _deepChildOrganizationIds(String orgId, LinkedList<String> filterIds) { 540 if (newOrgIdsTreeMap.isEmpty())
541 return new NullIterator();
542
543 Iterator<P2<String, String>> orgIds = newOrgIdsTreeMap.iterator();
544 return new Iterator<String>() {
545
546 @Override
547 public String next() {
548 return orgIds.next()._1();
549 }
550
551 @Override
552 public boolean hasNext() {
553 if (orgIds.hasNext())
554 return true;
555 return false;
556 }
557 };
558 }
559
560 public TreeMap<String, String> _deepChildOrganizationIds(String orgId, LinkedList<String> filterIds,
561 TreeMap<String, String> orgIdsTreeMap) {
457 562
458 Iterator<String> childrensIterator = childOrganizationIds(orgId, new LinkedList<String>()); 563 Iterator<String> childrensIterator = childOrganizationIds(orgId, new LinkedList<String>());
459 if (!childrensIterator.hasNext()) 564 if (!childrensIterator.hasNext())
460 return new LinkedList<String>(); 565 return orgIdsTreeMap;
461 566
462 LinkedList<String> childrenList = new LinkedList<String>();
463 for (; childrensIterator.hasNext();) { 567 for (; childrensIterator.hasNext();) {
464 String childrenId = childrensIterator.next(); 568 String childrenId = childrensIterator.next();
465 if (filter(childrenId, filterIds)) 569 if (filter(childrenId, filterIds))
466 childrenList.add(childrenId); 570 orgIdsTreeMap = orgIdsTreeMap.set(childrenId, childrenId);
467 childrenList.addAll(_deepChildOrganizationIds(childrenId, filterIds)); 571 orgIdsTreeMap = _deepChildOrganizationIds(childrenId, filterIds, orgIdsTreeMap);
468 } 572 }
469 573
470 return childrenList; 574 return orgIdsTreeMap;
471 } 575 }
472 576
473 public Iterator<String> childOrganizationIds(String orgId, LinkedList<String> filterIds) { 577 public Iterator<String> childOrganizationIds(String orgId, LinkedList<String> filterIds) {
578 TreeMap<String, String> childrenOrgIdTreeMap = TreeMap.empty(Ord.stringOrd);
579 TreeMap<String, String> newChildrenOrgIdTreeMap = _childOrganizationIds(orgId, filterIds, childrenOrgIdTreeMap);
580
581 if (newChildrenOrgIdTreeMap.isEmpty())
582 return new NullIterator();
583
584 Iterator<P2<String, String>> childrenOrgIdIterator = newChildrenOrgIdTreeMap.iterator();
585 return new Iterator<String>() {
586
587 @Override
588 public boolean hasNext() {
589 if (childrenOrgIdIterator.hasNext())
590 return true;
591 return false;
592 }
593
594 @Override
595 public String next() {
596 return childrenOrgIdIterator.next()._1();
597 }
598 };
599
600 }
601
602 public TreeMap<String, String> _childOrganizationIds(String orgId, LinkedList<String> filterIds,
603 TreeMap<String, String> childOrgIdsTreeMap) {
474 604
475 InterfaceTraverser orgTraverser = organizationTree.getTraverser(); 605 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
476 606
477 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = orgTraverser.find((TreeNode node) -> { 607 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = orgTraverser.find((TreeNode node) -> {
478 String nodeElement = node.getAttributes().getString("element"); 608 String nodeElement = node.getAttributes().getString("element");
487 return true; 617 return true;
488 return false; 618 return false;
489 }, "Organization-id", orgId); 619 }, "Organization-id", orgId);
490 620
491 if (!pairPersonIterator.hasNext()) 621 if (!pairPersonIterator.hasNext())
492 return new NullIterator(); 622 return childOrgIdsTreeMap;
493 623
494 Pair<TreeNode, NodePath> person = pairPersonIterator.next(); 624 Pair<TreeNode, NodePath> person = pairPersonIterator.next();
495 625
496 Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdsIterator = orgTraverser.findInSubTree((TreeNode node) -> { 626 Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdsIterator = orgTraverser.findInSubTree((TreeNode node) -> {
497 String nodeElement = node.getAttributes().getString("element"); 627 String nodeElement = node.getAttributes().getString("element");
501 return true; 631 return true;
502 return false; 632 return false;
503 }, person, "element", "childOrganizations"); 633 }, person, "element", "childOrganizations");
504 634
505 if (!chilrenOrgIdsIterator.hasNext()) 635 if (!chilrenOrgIdsIterator.hasNext())
506 return new NullIterator(); 636 return childOrgIdsTreeMap;
507 637
508 Pair<TreeNode, NodePath> chilerenOrgIds = chilrenOrgIdsIterator.next(); 638 Pair<TreeNode, NodePath> chilerenOrgIds = chilrenOrgIdsIterator.next();
509 639
510 Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdIterator = orgTraverser.findInSubTreeAllValue((TreeNode node) -> { 640 Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdIterator = orgTraverser.findInSubTreeAllValue((TreeNode node) -> {
511 String nodeElement = node.getAttributes().getString("element"); 641 String nodeElement = node.getAttributes().getString("element");
517 if (nodeElement != null) 647 if (nodeElement != null)
518 return true; 648 return true;
519 return false; 649 return false;
520 }, chilerenOrgIds, "text-organizationRefIds"); 650 }, chilerenOrgIds, "text-organizationRefIds");
521 651
522 LinkedList<String> ids = new LinkedList<String>();
523
524 for (; chilrenOrgIdIterator.hasNext();) { 652 for (; chilrenOrgIdIterator.hasNext();) {
525 String childrenOrgId = chilrenOrgIdIterator.next().left().getAttributes().getString("text-organizationRefIds"); 653 String childrenOrgId = chilrenOrgIdIterator.next().left().getAttributes().getString("text-organizationRefIds");
526 if (filter(childrenOrgId, filterIds)) 654 if (filter(childrenOrgId, filterIds))
527 ids.add(childrenOrgId); 655 childOrgIdsTreeMap = childOrgIdsTreeMap.set(childrenOrgId, childrenOrgId);
528 656
529 } 657 }
530 658
531 return ids.iterator(); 659 return childOrgIdsTreeMap;
532 } 660 }
533 661
534 public TreeNode getTarget(TreeNode node, NodePath path) { 662 public TreeNode getTarget(TreeNode node, NodePath path) {
535 TreeNode target; 663 TreeNode target;
536 Pair<Integer, NodePath> pathNode = path.pop(); 664 Pair<Integer, NodePath> pathNode = path.pop();
571 String element = node.getAttributes().getString("element"); 699 String element = node.getAttributes().getString("element");
572 if (element == null) 700 if (element == null)
573 return false; 701 return false;
574 if (!element.equals("Person")) 702 if (!element.equals("Person"))
575 return false; 703 return false;
576 String nodeId = node.getAttributes().getString("id"); 704 String nodeId = node.getAttributes().getString("Person-id");
577 if (nodeId == null) 705 if (nodeId == null)
578 return false; 706 return false;
579 if (nodeId.equals(personId)) 707 if (nodeId.equals(personId))
580 return true; 708 return true;
581 return false; 709 return false;
582 }, "id", personId); 710 }, "Person-id", personId);
583 711
584 if (!personIterator.hasNext()) 712 if (!personIterator.hasNext())
585 return ""; 713 return "";
586 714
587 Pair<TreeNode, NodePath> targetNode = personIterator.next(); 715 Pair<TreeNode, NodePath> targetNode = personIterator.next();
590 String element = node.getAttributes().getString("element"); 718 String element = node.getAttributes().getString("element");
591 if (element == null) 719 if (element == null)
592 return false; 720 return false;
593 if (!element.equals("roleRefId")) 721 if (!element.equals("roleRefId"))
594 return false; 722 return false;
595 String compareRoleId = node.getAttributes().getString("text"); 723 String compareRoleId = node.getAttributes().getString("text-roleRefId");
596 if (compareRoleId == null) 724 if (compareRoleId == null)
597 return false; 725 return false;
598 if (compareRoleId.equals(roleId)) 726 if (compareRoleId.equals(roleId))
599 return true; 727 return true;
600 return false; 728 return false;
601 }, targetNode, "element", "roleRefId"); 729 }, targetNode, "text-roleRefId",roleId);
602 730
603 for (; priorityIterator.hasNext();) { 731 for (; priorityIterator.hasNext();) {
604 Pair<TreeNode, NodePath> priorityPair = priorityIterator.next(); 732 Pair<TreeNode, NodePath> priorityPair = priorityIterator.next();
605 NodePath roleNodePath = priorityPair.right(); 733 NodePath roleNodePath = priorityPair.right();
606 Pair<Integer, NodePath> last = roleNodePath.last(); 734 Pair<Integer, NodePath> last = roleNodePath.last();
607 NodePath priorityNodePath = last.right().add(last.left() - 1); 735 NodePath priorityNodePath = last.right().add(last.left() - 1);
608 TreeNode priorityNode = getTarget(targetNode.left(), priorityNodePath); 736 TreeNode priorityNode = getTarget(personTree.getRootNode(), priorityNodePath);
609 if (priorityNode.getAttributes().getString("element").equals("priority")) 737 if (priorityNode.getAttributes().getString("element").equals("priority"))
610 return priorityNode.getAttributes().getString("text"); 738 return priorityNode.getAttributes().getString("text-priority");
611 } 739 }
612 return ""; 740 return "";
613 } 741 }
614 742
615 public Iterator<String> parentOrganizationIds(String orgId, LinkedList<String> filterIds) { 743 public Iterator<String> parentOrganizationIds(String orgId, LinkedList<String> filterIds) {
616 return _parentOrganizationIds(orgId, filterIds).iterator(); 744 return _parentOrganizationIds(orgId, filterIds);
617 } 745 }
618 746
619 public LinkedList<String> _parentOrganizationIds(String orgId, LinkedList<String> filterIds) { 747 public Iterator<String> _parentOrganizationIds(String orgId, LinkedList<String> filterIds) {
620 748
621 InterfaceTraverser orgTraverser = organizationTree.getTraverser(); 749 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
622 Iterator<Pair<TreeNode, NodePath>> orgIterator = orgTraverser.find((TreeNode node) -> { 750 Iterator<Pair<TreeNode, NodePath>> orgIterator = orgTraverser.find((TreeNode node) -> {
623 String element = node.getAttributes().getString("element"); 751 String element = node.getAttributes().getString("element");
624 if (element == null) 752 if (element == null)
625 return false; 753 return false;
626 if (!element.equals("Organization")) 754 if (!element.equals("Organization"))
627 return false; 755 return false;
628 String nodeId = node.getAttributes().getString("id"); 756 String nodeId = node.getAttributes().getString("Organization-id");
629 if (nodeId == null) 757 if (nodeId == null)
630 return false; 758 return false;
631 if (nodeId.equals(orgId)) 759 if (nodeId.equals(orgId))
632 return true; 760 return true;
633 return false; 761 return false;
634 }, "element", "Organization"); 762 }, "Organization-id", orgId);
635 763
636 if (!orgIterator.hasNext()) 764 if (!orgIterator.hasNext())
637 return new LinkedList<String>(); 765 return new NullIterator();
638 766
639 Pair<TreeNode, NodePath> orgNode = orgIterator.next(); 767 Pair<TreeNode, NodePath> orgNode = orgIterator.next();
640 768
641 Iterator<Pair<TreeNode, NodePath>> parentOrgIterator = orgTraverser.findInSubTree((TreeNode node) -> { 769 Iterator<Pair<TreeNode, NodePath>> parentOrgIterator = orgTraverser.findInSubTree((TreeNode node) -> {
642 String element = node.getAttributes().getString("element"); 770 String element = node.getAttributes().getString("element");
645 if (element.equals("parentOrganizations")) 773 if (element.equals("parentOrganizations"))
646 return true; 774 return true;
647 return false; 775 return false;
648 }, orgNode, "element", "parentOrganizations"); 776 }, orgNode, "element", "parentOrganizations");
649 777
650 LinkedList<String> parentIds = new LinkedList<String>(); 778 TreeMap<String, String> parentIdsTreeMap = TreeMap.empty(Ord.stringOrd);
651 779
652 for (; parentOrgIterator.hasNext();) { 780 for (; parentOrgIterator.hasNext();) {
653 Pair<TreeNode, NodePath> parentOrgNode = parentOrgIterator.next(); 781 Pair<TreeNode, NodePath> parentOrgNode = parentOrgIterator.next();
654 782
655 Iterator<Pair<TreeNode, NodePath>> parentNodeIterator = orgTraverser.findInSubTree((TreeNode node) -> { 783 Iterator<Pair<TreeNode, NodePath>> parentNodeIterator = orgTraverser.findInSubTreeAllValue((TreeNode node) -> {
656 String element = node.getAttributes().getString("element"); 784 String element = node.getAttributes().getString("element");
657 if (element == null) 785 if (element == null)
658 return false; 786 return false;
659 if (!element.equals("organizationRefId")) 787 if (!element.equals("organizationRefId"))
660 return false; 788 return false;
661 String parentId = node.getAttributes().getString("text"); 789 String parentId = node.getAttributes().getString("text-organizationRefId");
662 if (parentId != null) 790 if (parentId != null)
663 return true; 791 return true;
664 return false; 792 return false;
665 }, parentOrgNode, "element", "organizationRefId"); 793 }, parentOrgNode, "text-organizationRefId");
666 794
667 for (; parentNodeIterator.hasNext();) { 795 for (; parentNodeIterator.hasNext();) {
668 String parentId = parentNodeIterator.next().left().getAttributes().getString("text"); 796 String parentId = parentNodeIterator.next().left().getAttributes().getString("text-organizationRefId");
669 if (filter(parentId, filterIds)) 797 if (filter(parentId, filterIds))
670 parentIds.add(parentId); 798 parentIdsTreeMap = parentIdsTreeMap.set(parentId, parentId);
671 } 799 }
672 800
673 } 801 }
674 802
675 return parentIds; 803 Iterator<P2<String, String>> parentIds = parentIdsTreeMap.iterator();
804 if (parentIdsTreeMap.isEmpty())
805 return new NullIterator();
806 else
807 return new Iterator<String>() {
808
809 @Override
810 public boolean hasNext() {
811 if (parentIds.hasNext())
812 return true;
813 return false;
814 }
815
816 @Override
817 public String next() {
818 return parentIds.next()._1();
819 }
820
821 };
676 } 822 }
677 823
678 public Iterator<String> deepParentOrganizationIds(String orgId, LinkedList<String> filterIds) { 824 public Iterator<String> deepParentOrganizationIds(String orgId, LinkedList<String> filterIds) {
679 return _deepParentOrganizationIds(orgId, filterIds).iterator(); 825 TreeMap<String, String> parentIdsTreeMap = TreeMap.empty(Ord.stringOrd);
680 } 826 Iterator<P2<String, String>> parentIds = _deepParentOrganizationIds(orgId, filterIds, parentIdsTreeMap).iterator();
681 827 return new Iterator<String>() {
682 public LinkedList<String> _deepParentOrganizationIds(String orgId, LinkedList<String> filterIds) { 828
829 @Override
830 public boolean hasNext() {
831 if (parentIds.hasNext())
832 return true;
833 return false;
834 }
835
836 @Override
837 public String next() {
838 return parentIds.next()._1();
839 }
840
841 };
842 }
843
844 public TreeMap<String, String> _deepParentOrganizationIds(String orgId, LinkedList<String> filterIds,
845 TreeMap<String, String> orgIds) {
683 846
684 Iterator<String> parentIds = parentOrganizationIds(orgId, filterIds); 847 Iterator<String> parentIds = parentOrganizationIds(orgId, filterIds);
685 if (!parentIds.hasNext()) 848 if (!parentIds.hasNext())
686 return new LinkedList<String>(); 849 return orgIds;
687
688 LinkedList<String> parentIdList = new LinkedList<String>();
689 850
690 for (; parentIds.hasNext();) { 851 for (; parentIds.hasNext();) {
691 String parentId = parentIds.next(); 852 String parentId = parentIds.next();
692 if (filter(parentId, filterIds)) 853 if (filter(parentId, filterIds))
693 parentIdList.add(parentId); 854 orgIds = orgIds.set(parentId, parentId);
694 parentIdList.addAll(_deepParentOrganizationIds(parentId, filterIds)); 855 orgIds = _deepParentOrganizationIds(parentId, filterIds, orgIds);
695 } 856 }
696 return parentIdList; 857 return orgIds;
697 } 858 }
698 859
699 public Iterator<String> deepParentOrganizationIdsPlus(String id, LinkedList<String> filterIds) { 860 public Iterator<String> deepParentOrganizationIdsPlus(String id, LinkedList<String> filterIds) {
700 LinkedList<String> parentIds = new LinkedList<String>(); 861 TreeMap<String, String> parentIdsTreeMap = TreeMap.empty(Ord.stringOrd);
701 if (filter(id, filterIds)) 862 if (filter(id, filterIds))
702 parentIds.add(id); 863 parentIdsTreeMap = parentIdsTreeMap.set(id, id);
703 parentIds.addAll(_deepParentOrganizationIds(id, filterIds)); 864 parentIdsTreeMap = _deepParentOrganizationIds(id, filterIds, parentIdsTreeMap);
704 return parentIds.iterator(); 865
866 if (parentIdsTreeMap.isEmpty())
867 return new NullIterator();
868
869 Iterator<P2<String, String>> personIds = parentIdsTreeMap.iterator();
870 return new Iterator<String>() {
871
872 @Override
873 public boolean hasNext() {
874 if (personIds.hasNext())
875 return true;
876 return false;
877 }
878
879 @Override
880 public String next() {
881 return personIds.next()._1();
882 }
883
884 };
705 } 885 }
706 886
707 public String stringPathToId(String args) { 887 public String stringPathToId(String args) {
708 String[] splitPath = args.split(":"); 888 String[] splitPath = args.split(":");
709 889
714 894
715 final String StrPath = str; 895 final String StrPath = str;
716 896
717 InterfaceTraverser traverser = null; 897 InterfaceTraverser traverser = null;
718 TreeNode root = null; 898 TreeNode root = null;
899 String elementName = null;
719 if (splitPath[0].equals("r")) { 900 if (splitPath[0].equals("r")) {
720 traverser = roleTree.getTraverser(); 901 traverser = roleTree.getTraverser();
721 root = roleTree.getRootNode(); 902 root = roleTree.getRootNode();
903 elementName = "Role";
722 } 904 }
723 if (splitPath[0].equals("rde")) { 905 if (splitPath[0].equals("rde")) {
724 traverser = rdeTree.getTraverser(); 906 traverser = rdeTree.getTraverser();
725 root = rdeTree.getRootNode(); 907 root = rdeTree.getRootNode();
908 elementName = "RoleDescriptionElement";
726 } 909 }
727 910
728 Iterator<Pair<TreeNode, NodePath>> idIterator = traverser.find((TreeNode node) -> { 911 Iterator<Pair<TreeNode, NodePath>> idIterator = traverser.find((TreeNode node) -> {
729 String element = node.getAttributes().getString("element"); 912 String element = node.getAttributes().getString("element");
730 if (element == null) 913 if (element == null)
731 return false; 914 return false;
732 if (!element.equals("path")) 915 if (!element.equals("path"))
733 return false; 916 return false;
734 String pathString = node.getAttributes().getString("text"); 917 String pathString = node.getAttributes().getString("text-path");
735 if (pathString == null) 918 if (pathString == null)
736 return false; 919 return false;
737 if (pathString.equals(StrPath)) 920 if (pathString.equals(StrPath))
738 return true; 921 return true;
739 return false; 922 return false;
740 }, "text", "StrPath"); 923 }, "text-path", StrPath);
741 924
742 if (!idIterator.hasNext()) 925 if (!idIterator.hasNext())
743 return ""; 926 return "";
744 927
745 Pair<TreeNode, NodePath> nodePair = idIterator.next(); 928 Pair<TreeNode, NodePath> nodePair = idIterator.next();
746 NodePath path = nodePair.right(); 929 NodePath path = nodePair.right();
747 NodePath targetPath = path.last().right(); 930 NodePath targetPath = path.last().right();
748 931
749 TreeNode targetNode = getTarget(root, targetPath); 932 TreeNode targetNode = getTarget(root, targetPath);
750 String targetId = targetNode.getAttributes().getString("id"); 933 String targetId = targetNode.getAttributes().getString(elementName + "-id");
751 return targetId; 934 return targetId;
752 } 935 }
753 936
754 public Iterator<String> roleDescriptionElementIds(String id, LinkedList<String> filterIds) { 937 public Iterator<String> roleDescriptionElementIds(String id, LinkedList<String> filterIds) {
755 938
756 Iterator<String> orgIds = deepParentOrganizationIdsPlus(id, filterIds); 939 Iterator<String> orgIds = deepParentOrganizationIdsPlus(id, filterIds);
757 940
758 LinkedList<String> rdeIds = new LinkedList<String>(); 941 TreeMap<String,String> rdeIdsTreeMap = TreeMap.empty(Ord.stringOrd);
759 942
760 for (; orgIds.hasNext();) { 943 for (; orgIds.hasNext();) {
761 String orgId = orgIds.next(); 944 String orgId = orgIds.next();
762 Iterator<String> roleIds = roleIds(orgId); 945 Iterator<String> roleIds = roleIds(orgId);
763 for (; roleIds.hasNext();) { 946 for (; roleIds.hasNext();) {
764 String roleId = roleIds.next(); 947 String roleId = roleIds.next();
765 String rdeId = getRde(roleId); 948 Iterator<String> rdeIds = getRde(roleId);
766 String[] rdeSplit = rdeId.split(" "); 949 for (;rdeIds.hasNext();) {
767 for (String rde : rdeSplit) { 950 String rdeId = rdeIds.next();
768 if (!rde.equals("")) 951 rdeIdsTreeMap = rdeIdsTreeMap.set(rdeId,rdeId);
769 rdeIds.add(rde);
770 } 952 }
771 } 953 }
772 } 954 }
773 955 if (rdeIdsTreeMap.isEmpty())
774 return rdeIds.iterator(); 956 return new NullIterator();
775 } 957
776 958 Iterator<P2<String, String>> rdeIds = rdeIdsTreeMap.iterator();
777 private String getRde(String roleId) { 959 return new Iterator<String>() {
960
961 @Override
962 public boolean hasNext() {
963 if (rdeIds.hasNext())
964 return true;
965 return false;
966 }
967
968 @Override
969 public String next() {
970 return rdeIds.next()._1();
971 }
972 };
973 }
974
975 private Iterator<String> getRde(String roleId) {
778 976
779 InterfaceTraverser traverser = roleTree.getTraverser(); 977 InterfaceTraverser traverser = roleTree.getTraverser();
780 978
781 Iterator<Pair<TreeNode, NodePath>> roleIterator = traverser.find((TreeNode node) -> { 979 Iterator<Pair<TreeNode, NodePath>> roleIterator = traverser.find((TreeNode node) -> {
782 String element = node.getAttributes().getString("element"); 980 String element = node.getAttributes().getString("element");
783 if (element == null) 981 if (element == null)
784 return false; 982 return false;
785 if (!element.equals("Role")) 983 if (!element.equals("Role"))
786 return false; 984 return false;
787 String id = node.getAttributes().getString("id"); 985 String id = node.getAttributes().getString("Role-id");
788 if (id == null) 986 if (id == null)
789 return false; 987 return false;
790 if (id.equals(roleId)) 988 if (id.equals(roleId))
791 return true; 989 return true;
792 return false; 990 return false;
793 }, "id", roleId); 991 }, "Role-id", roleId);
794 992
795 if (!roleIterator.hasNext()) 993 if (!roleIterator.hasNext())
796 return ""; 994 return new NullIterator();
797 995
798 Pair<TreeNode, NodePath> roleNode = roleIterator.next(); 996 Pair<TreeNode, NodePath> roleNode = roleIterator.next();
799 997
800 Iterator<Pair<TreeNode, NodePath>> rdeIterator = traverser.findInSubTree((TreeNode node) -> { 998 Iterator<Pair<TreeNode, NodePath>> rdeIterator = traverser.findInSubTreeAllValue((TreeNode node) -> {
801 String element = node.getAttributes().getString("element"); 999 String element = node.getAttributes().getString("element");
802 if (element == null) 1000 if (element == null)
803 return false; 1001 return false;
804 if (!element.equals("roleDescriptionElementRefIds")) 1002 if (!element.equals("roleDescriptionElementRefIds"))
805 return false; 1003 return false;
806 String rde = node.getAttributes().getString("text"); 1004 String rde = node.getAttributes().getString("text-roleDescriptionElementRefIds");
807 if (rde != null) 1005 if (rde != null)
808 return true; 1006 return true;
809 return false; 1007 return false;
810 }, roleNode, "element", "roleDescriptionElementRefIds"); 1008 }, roleNode, "text-roleDescriptionElementRefIds");
811 1009
812 if (!rdeIterator.hasNext()) 1010 if (!rdeIterator.hasNext())
813 return ""; 1011 return new NullIterator();
814 1012
815 return rdeIterator.next().left().getAttributes().getString("text"); 1013 return new Iterator<String>() {
1014
1015 @Override
1016 public boolean hasNext() {
1017 if (rdeIterator.hasNext())
1018 return true;
1019 return false;
1020 }
1021
1022 @Override
1023 public String next() {
1024 return rdeIterator.next().left().getAttributes().getString("text-roleDescriptionElementRefIds");
1025 }
1026 };
1027
816 } 1028 }
817 1029
818 } 1030 }