Mercurial > hg > Members > tatsuki > JungleXMLReader

comparison src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/JuGrix.java @ 28:ed831b2fc156

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
temporarily stored
author one
date Fri, 07 Nov 2014 02:20:07 +0900
parents ef3fae2e7f0c
children 626e56f749a9
comparison
equal deleted inserted replaced
27:095813055f19 28:ed831b2fc156
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 ac.jp.u_ryukyu.cr.ie.tatsuki.xmlReader.loadXml;
8 import fj.Ord; 9 import fj.Ord;
9 import fj.P2; 10 import fj.P2;
10 import fj.data.TreeMap; 11 import fj.data.TreeMap;
11 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree; 12 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
12 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; 13 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
21 JungleTree personTree; 22 JungleTree personTree;
22 JungleTree organizationTree; 23 JungleTree organizationTree;
23 JungleTree roleTree; 24 JungleTree roleTree;
24 JungleTree rdeTree; 25 JungleTree rdeTree;
25 26
26 public JuGrix() { 27 public JuGrix(boolean index) {
28
27 try { 29 try {
28 loadXml reader = new loadXml(); 30 loadXml reader = new loadXml();
29 personTree = reader.loadTestDataCreateIndex("Person.xml"); 31
30 organizationTree = reader.loadTestDataCreateIndex("Organization.xml"); 32 if (index == true) {
31 roleTree = reader.loadTestDataCreateIndex("Role.xml"); 33 personTree = reader.loadTestDataCreateIndex("Person.xml");
32 rdeTree = reader.loadTestDataCreateIndex("RoleDescriptionElement.xml"); 34 organizationTree = reader.loadTestDataCreateIndex("Organization.xml");
35 roleTree = reader.loadTestDataCreateIndex("Role.xml");
36 rdeTree = reader.loadTestDataCreateIndex("RoleDescriptionElement.xml");
37 } else {
38 personTree = reader.loadTestData("Person.xml");
39 organizationTree = reader.loadTestData("Organization.xml");
40 roleTree = reader.loadTestData("Role.xml");
41 rdeTree = reader.loadTestData("RoleDescriptionElement.xml");
42 }
43
33 } catch (Exception e) { 44 } catch (Exception e) {
34 e.printStackTrace(); 45 e.printStackTrace();
35 } 46 }
36 } 47 }
37 48
109 } 120 }
110 121
111 public boolean filter(String orgId, LinkedList<String> roleIds) { 122 public boolean filter(String orgId, LinkedList<String> roleIds) {
112 if (roleIds == null) 123 if (roleIds == null)
113 return true; 124 return true;
125
126 if (roleIds.isEmpty())
127 return true;
114 128
115 InterfaceTraverser orgTraverser = organizationTree.getTraverser(); 129 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
116 130
117 Iterator<Pair<TreeNode, NodePath>> orgNodeIterator = orgTraverser.find((TreeNode node) -> { 131 Iterator<Pair<TreeNode, NodePath>> orgNodeIterator = orgTraverser.find((TreeNode node) -> {
118 String personId = node.getAttributes().getString("element"); 132 String personId = node.getAttributes().getString("element");
129 }, "id", orgId); 143 }, "id", orgId);
130 144
131 if (!orgNodeIterator.hasNext()) 145 if (!orgNodeIterator.hasNext())
132 return false; 146 return false;
133 147
134 Pair<TreeNode, NodePath> searchNode = orgNodeIterator.next(); 148 Pair<TreeNode, NodePath> searchNodePair = orgNodeIterator.next();
135 149
136 for (String id : roleIds) { 150 for (String id : roleIds) {
137 Pattern personPattern = Pattern.compile("r:"); 151 Pattern personPattern = Pattern.compile("r:");
138 Matcher personMacher = personPattern.matcher(id); 152 Matcher personMacher = personPattern.matcher(id);
139 if (personMacher.find()) { 153 if (personMacher.find()) {
140 if (!roleFilter(id, searchNode)) 154 if (roleFilter(id, searchNodePair))
141 return false; 155 return false;
142 } 156 }
143 157
144 Pattern organizationPattern = Pattern.compile("rde:"); 158 Pattern organizationPattern = Pattern.compile("rde:");
145 Matcher organizationMacher = organizationPattern.matcher(id); 159 Matcher organizationMacher = organizationPattern.matcher(id);
146 if (organizationMacher.find()) { 160 if (organizationMacher.find()) {
147 if (!rdeFilter(id, searchNode)) 161 if (!rdeFilter(id, searchNodePair))
148 return false; 162 return false;
149 } 163 }
150 } 164 }
151 return true; 165 return true;
152 } 166 }
153 167
154 private boolean rdeFilter(String id, Pair<TreeNode, NodePath> targetNode) { 168 private boolean rdeFilter(String id, Pair<TreeNode, NodePath> searchNodePair) {
155 169
156 InterfaceTraverser orgTraverser = organizationTree.getTraverser(); 170 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
157 Iterator<Pair<TreeNode, NodePath>> pairIdIterator = orgTraverser.findInSubTree((TreeNode node) -> { 171 Iterator<Pair<TreeNode, NodePath>> pairIdIterator = orgTraverser.findInSubTree((TreeNode node) -> {
158 String element = node.getAttributes().getString("element"); 172 String element = node.getAttributes().getString("element");
159 if (element == null) 173 if (element == null)
162 return false; 176 return false;
163 String roleId = node.getAttributes().getString("text"); 177 String roleId = node.getAttributes().getString("text");
164 if (roleId != null) 178 if (roleId != null)
165 return true; 179 return true;
166 return false; 180 return false;
167 }, targetNode, "element", "roleRefId"); 181 }, searchNodePair, "element", "roleRefId");
168 182
169 TreeMap<String, String> idMap = TreeMap.empty(Ord.stringOrd); 183 TreeMap<String, String> idMap = TreeMap.empty(Ord.stringOrd);
170 for (; pairIdIterator.hasNext();) { 184 for (; pairIdIterator.hasNext();) {
171 String roleId = pairIdIterator.next().left().getAttributes().getString("text"); 185 String roleId = pairIdIterator.next().left().getAttributes().getString("text");
172 idMap = idMap.set(roleId, roleId); 186 idMap = idMap.set(roleId, roleId);
175 Iterator<P2<String, String>> ids = idMap.iterator(); 189 Iterator<P2<String, String>> ids = idMap.iterator();
176 InterfaceTraverser roleTraverser = roleTree.getTraverser(); 190 InterfaceTraverser roleTraverser = roleTree.getTraverser();
177 191
178 for (; ids.hasNext();) { 192 for (; ids.hasNext();) {
179 String roleId = ids.next()._1(); 193 String roleId = ids.next()._1();
180
181 Iterator<Pair<TreeNode, NodePath>> roleNodeIterator = roleTraverser.find((TreeNode node) -> { 194 Iterator<Pair<TreeNode, NodePath>> roleNodeIterator = roleTraverser.find((TreeNode node) -> {
182 String element = node.getAttributes().getString("element"); 195 String element = node.getAttributes().getString("element");
183 if (element == null) 196 if (element == null)
184 return false; 197 return false;
185 if (!element.equals("Role")) 198 if (!element.equals("Role"))
189 return false; 202 return false;
190 if (compareRoleId.equals(roleId)) 203 if (compareRoleId.equals(roleId))
191 return true; 204 return true;
192 return false; 205 return false;
193 }, "id", roleId); 206 }, "id", roleId);
194
195 // -----------------------------------------bug------------------------------------------ 207 // -----------------------------------------bug------------------------------------------
196 for (; roleNodeIterator.hasNext();) { 208 for (; roleNodeIterator.hasNext();) {
209 Pair<TreeNode, NodePath> rolePair = roleNodeIterator.next();
197 Iterator<Pair<TreeNode, NodePath>> rdeNodeIterator = roleTraverser.findInSubTree((TreeNode node) -> { 210 Iterator<Pair<TreeNode, NodePath>> rdeNodeIterator = roleTraverser.findInSubTree((TreeNode node) -> {
198 String elementName = node.getAttributes().getString("element"); 211 String elementName = node.getAttributes().getString("element");
199 if (elementName == null) 212 if (elementName == null)
200 return false; 213 return false;
201 if (!elementName.equals("roleDescriptionElementRefIds")) 214 if (!elementName.equals("roleDescriptionElementRefIds"))
206 Pattern personPattern = Pattern.compile(id); 219 Pattern personPattern = Pattern.compile(id);
207 Matcher personMacher = personPattern.matcher(rdeId); 220 Matcher personMacher = personPattern.matcher(rdeId);
208 if (personMacher.find()) 221 if (personMacher.find())
209 return true; 222 return true;
210 return false; 223 return false;
211 }, roleNodeIterator.next(), "text", "id"); 224 }, rolePair, "text", "id");
212 225
213 if (!rdeNodeIterator.hasNext()) 226 if (!rdeNodeIterator.hasNext())
214 return false; 227 return false;
215 } 228 }
216 229
217 } 230 }
218 return true; 231 return true;
219 } 232 }
220 233
221 public boolean roleFilter(String id, Pair<TreeNode, NodePath> orgPathNodePair) { 234 public boolean roleFilter(String id, Pair<TreeNode, NodePath> searchNodePair) {
235 //System.out.println(searchNodePair.getAttributes().getString("id"));
222 InterfaceTraverser orgTraverser = organizationTree.getTraverser(); 236 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
223 237
224 Iterator<Pair<TreeNode, NodePath>> pairIdIterator = orgTraverser.findInSubTree((TreeNode node) -> { 238 Iterator<Pair<TreeNode, NodePath>> pairIdIterator = orgTraverser.findInSubTree((TreeNode node) -> {
225 String elementName = node.getAttributes().getString("element"); 239 String elementName = node.getAttributes().getString("element");
226 if (elementName == null) 240 if (elementName == null)
231 if (roleId == null) 245 if (roleId == null)
232 return false; 246 return false;
233 if (roleId.equals(id)) 247 if (roleId.equals(id))
234 return true; 248 return true;
235 return false; 249 return false;
236 }, orgPathNodePair, "text", id); 250 }, searchNodePair, "text", id);
237 251
238 if (pairIdIterator.hasNext()) { 252 if (pairIdIterator.hasNext()) {
239 System.out.println(pairIdIterator.next().left().getAttributes().getString("text")); 253 System.out.println(pairIdIterator.next().left().getAttributes().getString("text"));
240 return true; 254 return false;
241 } 255 }
242 return false; 256 return true;
243 } 257 }
244 258
245 public Iterator<String> roleIds(String id) { 259 public Iterator<String> roleIds(String id) {
246 Pattern personPattern = Pattern.compile("p:"); 260 Pattern personPattern = Pattern.compile("p:");
247 Matcher personMacher = personPattern.matcher(id); 261 Matcher personMacher = personPattern.matcher(id);
290 if (nodeId != null) 304 if (nodeId != null)
291 return true; 305 return true;
292 return false; 306 return false;
293 }, searchTargetPair, "element", "roleRefId"); 307 }, searchTargetPair, "element", "roleRefId");
294 308
295
296 for (; pairIdIterator.hasNext();) { 309 for (; pairIdIterator.hasNext();) {
297 Pair<TreeNode, NodePath> idNodePath = pairIdIterator.next(); 310 Pair<TreeNode, NodePath> idNodePath = pairIdIterator.next();
298 String attribute = idNodePath.left().getAttributes().getString("text"); 311 String attribute = idNodePath.left().getAttributes().getString("text");
299 312
300 Iterator<String> checkList = ids.iterator(); 313 Iterator<String> checkList = ids.iterator();
303 attribute = null; 316 attribute = null;
304 } 317 }
305 318
306 if (attribute != null) { 319 if (attribute != null) {
307 ids.add(attribute); 320 ids.add(attribute);
308 //System.out.println("-------------------------" + attribute + "-------------------------"); 321 System.out.println("-------------------------" + attribute + "-------------------------");
309 } 322 }
310 } 323 }
311 } 324 }
312 return ids.iterator(); 325 return ids.iterator();
313 } 326 }
314 327
315 public Iterator<String> competentRoleId(String personId) { 328 public Iterator<String> competentRoleId(String personId) {
316 329
317 InterfaceTraverser ifTraverser = personTree.getTraverser(); 330 InterfaceTraverser ifTraverser = personTree.getTraverser();
318 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchPerson(personId, ifTraverser); 331 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = ifTraverser.find((TreeNode node) -> {
332 String nodeElement = node.getAttributes().getString("element");
333 if (nodeElement == null)
334 return false;
335 if (!nodeElement.equals("Person"))
336 return false;
337 String nodeId = node.getAttributes().getString("Person-id");
338 if (nodeId == null)
339 return false;
340 if (nodeId.equals(personId))
341 return true;
342 return false;
343 }, "Person-id", personId);
319 344
320 if (!pairPersonIterator.hasNext()) 345 if (!pairPersonIterator.hasNext())
321 return new NullIterator(); 346 return new NullIterator();
322 Pair<TreeNode, NodePath> personPathNodePair = pairPersonIterator.next(); 347 Pair<TreeNode, NodePath> person = pairPersonIterator.next();
323 TreeNode person = personPathNodePair.left(); 348
324
325 Iterator<Pair<TreeNode, NodePath>> targetPairIterator = ifTraverser.findInSubTree((TreeNode node) -> { 349 Iterator<Pair<TreeNode, NodePath>> targetPairIterator = ifTraverser.findInSubTree((TreeNode node) -> {
326 String nodeElement = node.getAttributes().getString("element"); 350 String nodeElement = node.getAttributes().getString("element");
327 if (nodeElement == null) 351 if (nodeElement == null)
328 return false; 352 return false;
329 if (!nodeElement.equals("priority")) 353 if (!nodeElement.equals("priority"))
330 return false; 354 return false;
331 String priority = node.getAttributes().getString("text"); 355 String priority = node.getAttributes().getString("text-priority");
332 if (priority == null) 356 if (priority == null)
333 return false; 357 return false;
334 if (priority.equals("0")) 358 if (priority.equals("0"))
335 return true; 359 return true;
336 return false; 360 return false;
337 }, personPathNodePair, "text", "0"); 361 }, person, "text-priority", "0");
338 362
339 LinkedList<String> idList = new LinkedList<String>(); 363 LinkedList<String> idList = new LinkedList<String>();
340 for (; targetPairIterator.hasNext();) { 364 for (; targetPairIterator.hasNext();) {
341 NodePath searchPath = targetPairIterator.next().right(); 365 NodePath searchPath = targetPairIterator.next().right();
342 Pair<Integer, NodePath> searchPair = searchPath.last(); 366 Pair<Integer, NodePath> searchPair = searchPath.last();
343 NodePath targetPath = searchPair.right().add(searchPair.left() + 1); 367 NodePath targetPath = searchPair.right().add(searchPair.left() + 1);
344 TreeNode targetNode = getTarget(person, targetPath); 368 TreeNode targetNode = getTarget(personTree.getRootNode(), targetPath);
345 String id = targetNode.getAttributes().getString("text"); 369 // TreeNode targetNode = getTarget(person.left(), targetPath);
370 String id = targetNode.getAttributes().getString("text-roleRefId");
346 idList.add(id); 371 idList.add(id);
347 } 372 }
348 373
349 return idList.iterator(); 374 return idList.iterator();
350 } 375 }
354 InterfaceTraverser ifTraverser = personTree.getTraverser(); 379 InterfaceTraverser ifTraverser = personTree.getTraverser();
355 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchPerson(personId, ifTraverser); 380 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchPerson(personId, ifTraverser);
356 381
357 if (!pairPersonIterator.hasNext()) 382 if (!pairPersonIterator.hasNext())
358 return new NullIterator(); 383 return new NullIterator();
359 384 Pair<TreeNode, NodePath> person = pairPersonIterator.next();
360 Pair<TreeNode, NodePath> personNodePathPair = pairPersonIterator.next(); 385
361 TreeNode person = personNodePathPair.left();
362 Iterator<Pair<TreeNode, NodePath>> targetPairIterator = ifTraverser.findInSubTree((TreeNode node) -> { 386 Iterator<Pair<TreeNode, NodePath>> targetPairIterator = ifTraverser.findInSubTree((TreeNode node) -> {
363 String nodeElement = node.getAttributes().getString("element"); 387 String nodeElement = node.getAttributes().getString("element");
364 if (nodeElement == null) 388 if (nodeElement == null)
365 return false; 389 return false;
366 if (!nodeElement.equals("priority")) 390 if (!nodeElement.equals("priority"))
369 if (priority == null) 393 if (priority == null)
370 return false; 394 return false;
371 if (!priority.equals("0")) 395 if (!priority.equals("0"))
372 return true; 396 return true;
373 return false; 397 return false;
374 }, personNodePathPair, "text", "0"); 398 }, person, "text", "0");
375 399
376
377 LinkedList<String> idList = new LinkedList<String>(); 400 LinkedList<String> idList = new LinkedList<String>();
378 for (; targetPairIterator.hasNext();) { 401 for (; targetPairIterator.hasNext();) {
379 NodePath searchPath = targetPairIterator.next().right(); 402 NodePath searchPath = targetPairIterator.next().right();
380 Pair<Integer, NodePath> searchPair = searchPath.last(); 403 Pair<Integer, NodePath> searchPair = searchPath.last();
381 NodePath targetPath = searchPair.right().add(searchPair.left() + 1); 404 NodePath targetPath = searchPair.right().add(searchPair.left() + 1);
382 TreeNode targetNode = getTarget(person, targetPath); 405 TreeNode targetNode = getTarget(person.left(), targetPath);
383 String id = targetNode.getAttributes().getString("text"); 406 String id = targetNode.getAttributes().getString("text");
384 idList.add(id); 407 idList.add(id);
385 } 408 }
386 409
387 return idList.iterator(); 410 return idList.iterator();
388 } 411 }
389 412
390 private Iterator<Pair<TreeNode, NodePath>> searchPerson(String personId, InterfaceTraverser ifTraverser) {
391 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = ifTraverser.find((TreeNode node) -> {
392 String nodeElement = node.getAttributes().getString("element");
393 if (nodeElement == null)
394 return false;
395 if (!nodeElement.equals("Person"))
396 return false;
397 String nodeId = node.getAttributes().getString("id");
398 if (nodeId == null)
399 return false;
400 if (nodeId.equals(personId))
401 return true;
402 return false;
403 }, "element", "Person");
404 return pairPersonIterator;
405 }
406 413
407 public Iterator<String> deepPersonIds(String orgId, LinkedList<String> filterIds) { 414 public Iterator<String> deepPersonIds(String orgId, LinkedList<String> filterIds) {
408 415
409 Iterator<String> childrensIterator = deepChildOrganizationIds(orgId, new LinkedList<String>()); 416 Iterator<String> childrensIterator = deepChildOrganizationIds(orgId, new LinkedList<String>());
410 if (!childrensIterator.hasNext()) 417 if (!childrensIterator.hasNext())
448 455
449 return childrenList; 456 return childrenList;
450 } 457 }
451 458
452 public Iterator<String> childOrganizationIds(String orgId, LinkedList<String> filterIds) { 459 public Iterator<String> childOrganizationIds(String orgId, LinkedList<String> filterIds) {
453 if (!filter(orgId, filterIds)) 460
454 return new NullIterator();
455 InterfaceTraverser orgTraverser = organizationTree.getTraverser(); 461 InterfaceTraverser orgTraverser = organizationTree.getTraverser();
462
456 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = orgTraverser.find((TreeNode node) -> { 463 Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = orgTraverser.find((TreeNode node) -> {
457 String nodeElement = node.getAttributes().getString("element"); 464 String nodeElement = node.getAttributes().getString("element");
458 if (nodeElement == null) 465 if (nodeElement == null)
459 return false; 466 return false;
460 if (!nodeElement.equals("Organization")) 467 if (!nodeElement.equals("Organization"))
461 return false; 468 return false;
462 String nodeId = node.getAttributes().getString("id"); 469 String nodeId = node.getAttributes().getString("Organization-id");
463 if (nodeId == null) 470 if (nodeId == null)
464 return false; 471 return false;
465 if (nodeId.equals(orgId)) 472 if (nodeId.equals(orgId))
466 return true; 473 return true;
467 return false; 474 return false;
468 }, "id", orgId); 475 }, "Organization-id", orgId);
469 476
470 if (!pairPersonIterator.hasNext()) 477 if (!pairPersonIterator.hasNext())
471 return new NullIterator(); 478 return new NullIterator();
472 Pair<TreeNode, NodePath> personPathNodePair = pairPersonIterator.next(); 479
480 Pair<TreeNode, NodePath> person = pairPersonIterator.next();
473 481
474 Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdsIterator = orgTraverser.findInSubTree((TreeNode node) -> { 482 Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdsIterator = orgTraverser.findInSubTree((TreeNode node) -> {
475 String nodeElement = node.getAttributes().getString("element"); 483 String nodeElement = node.getAttributes().getString("element");
476 if (nodeElement == null) 484 if (nodeElement == null)
477 return false; 485 return false;
478 if (nodeElement.equals("childOrganizations")) 486 if (nodeElement.equals("childOrganizations"))
479 return true; 487 return true;
480 return false; 488 return false;
481 }, personPathNodePair, "element", "childOrganizations"); 489 }, person, "element", "childOrganizations");
482 490
483 if (!chilrenOrgIdsIterator.hasNext()) 491 if (!chilrenOrgIdsIterator.hasNext())
484 return new NullIterator(); 492 return new NullIterator();
485 493
486 Pair<TreeNode, NodePath> chilerenOrgIdsPathNodePair = chilrenOrgIdsIterator.next(); 494 Pair<TreeNode, NodePath> chilerenOrgIds = chilrenOrgIdsIterator.next();
487 495
488 Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdIterator = orgTraverser.findInSubTreeAllValue((TreeNode node) -> { 496 Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdIterator = orgTraverser.findInSubTree((TreeNode node) -> {
489 String nodeElement = node.getAttributes().getString("element"); 497 String nodeElement = node.getAttributes().getString("element");
490 if (nodeElement == null) 498 if (nodeElement == null)
491 return false; 499 return false;
492 if (!nodeElement.equals("organizationRefIds")) 500 if (!nodeElement.equals("organizationRefIds"))
493 return false; 501 return false;
494 nodeElement = node.getAttributes().getString("text"); 502 nodeElement = node.getAttributes().getString("text-organizationRefIds");
495 if (nodeElement != null) 503 if (nodeElement != null)
496 return true; 504 return true;
497 return false; 505 return false;
498 }, chilerenOrgIdsPathNodePair, "text"); 506 }, chilerenOrgIds, "text-organizationRefIds", null);
499 507
500 LinkedList<String> ids = new LinkedList<String>(); 508 LinkedList<String> ids = new LinkedList<String>();
501 509
502 for (; chilrenOrgIdIterator.hasNext();) { 510 for (; chilrenOrgIdIterator.hasNext();) {
503 Pair<TreeNode, NodePath> aaa = chilrenOrgIdIterator.next(); 511 String childrenOrgId = chilrenOrgIdIterator.next().left().getAttributes().getString("text-organizationRefIds");
504 String path = aaa.right().toString(); 512 if (filter(childrenOrgId, filterIds))
505 String id = aaa.left().getAttributes().getString("text"); 513 ids.add(childrenOrgId);
506 ids.add(id); 514
507 } 515 }
508 516
509 return ids.iterator(); 517 return ids.iterator();
510 } 518 }
511 519
542 } 550 }
543 551
544 } 552 }
545 553
546 public String rolePriority(String personId, String roleId) { 554 public String rolePriority(String personId, String roleId) {
547
548 InterfaceTraverser personTraverser = personTree.getTraverser(); 555 InterfaceTraverser personTraverser = personTree.getTraverser();
549 Iterator<Pair<TreeNode, NodePath>> personIterator = personTraverser.find((TreeNode node) -> { 556 Iterator<Pair<TreeNode, NodePath>> personIterator = personTraverser.find((TreeNode node) -> {
550 String element = node.getAttributes().getString("element"); 557 String element = node.getAttributes().getString("element");
551 if (element == null) 558 if (element == null)
552 return false; 559 return false;
561 }, "id", personId); 568 }, "id", personId);
562 569
563 if (!personIterator.hasNext()) 570 if (!personIterator.hasNext())
564 return ""; 571 return "";
565 572
566 Pair<TreeNode, NodePath> targetPersonPathNodePair = personIterator.next(); 573 Pair<TreeNode, NodePath> targetNode = personIterator.next();
567 TreeNode targetPersonNode = targetPersonPathNodePair.left(); 574
568
569 Iterator<Pair<TreeNode, NodePath>> priorityIterator = personTraverser.findInSubTree((TreeNode node) -> { 575 Iterator<Pair<TreeNode, NodePath>> priorityIterator = personTraverser.findInSubTree((TreeNode node) -> {
570 String element = node.getAttributes().getString("element"); 576 String element = node.getAttributes().getString("element");
571 if (element == null) 577 if (element == null)
572 return false; 578 return false;
573 if (!element.equals("roleRefId")) 579 if (!element.equals("roleRefId"))
576 if (compareRoleId == null) 582 if (compareRoleId == null)
577 return false; 583 return false;
578 if (compareRoleId.equals(roleId)) 584 if (compareRoleId.equals(roleId))
579 return true; 585 return true;
580 return false; 586 return false;
581 }, targetPersonPathNodePair, "element", "roleRefId"); 587 }, targetNode, "element", "roleRefId");
582 588
583 for (; priorityIterator.hasNext();) { 589 for (; priorityIterator.hasNext();) {
584 Pair<TreeNode, NodePath> priorityPair = priorityIterator.next(); 590 Pair<TreeNode, NodePath> priorityPair = priorityIterator.next();
585 NodePath roleNodePath = priorityPair.right(); 591 NodePath roleNodePath = priorityPair.right();
586 Pair<Integer, NodePath> last = roleNodePath.last(); 592 Pair<Integer, NodePath> last = roleNodePath.last();
587 NodePath priorityNodePath = last.right().add(last.left() - 1); 593 NodePath priorityNodePath = last.right().add(last.left() - 1);
588 TreeNode priorityNode = getTarget(targetPersonNode, priorityNodePath); 594 TreeNode priorityNode = getTarget(targetNode.left(), priorityNodePath);
589 if (priorityNode.getAttributes().getString("element").equals("priority")) 595 if (priorityNode.getAttributes().getString("element").equals("priority"))
590 return priorityNode.getAttributes().getString("text"); 596 return priorityNode.getAttributes().getString("text");
591 } 597 }
592 return ""; 598 return "";
593 } 599 }
614 }, "element", "Organization"); 620 }, "element", "Organization");
615 621
616 if (!orgIterator.hasNext()) 622 if (!orgIterator.hasNext())
617 return new LinkedList<String>(); 623 return new LinkedList<String>();
618 624
625 Pair<TreeNode, NodePath> orgNode = orgIterator.next();
626
619 Iterator<Pair<TreeNode, NodePath>> parentOrgIterator = orgTraverser.findInSubTree((TreeNode node) -> { 627 Iterator<Pair<TreeNode, NodePath>> parentOrgIterator = orgTraverser.findInSubTree((TreeNode node) -> {
620 String element = node.getAttributes().getString("element"); 628 String element = node.getAttributes().getString("element");
621 if (element == null) 629 if (element == null)
622 return false; 630 return false;
623 if (element.equals("parentOrganizations")) 631 if (element.equals("parentOrganizations"))
624 return true; 632 return true;
625 return false; 633 return false;
626 }, orgIterator.next(), "element", "parentOrganizations"); 634 }, orgNode, "element", "parentOrganizations");
627 635
628 LinkedList<String> parentIds = new LinkedList<String>(); 636 LinkedList<String> parentIds = new LinkedList<String>();
629 637
630 for (; parentOrgIterator.hasNext();) { 638 for (; parentOrgIterator.hasNext();) {
631 Pair<TreeNode, NodePath> parentOrgPathNodePair = parentOrgIterator.next(); 639 Pair<TreeNode, NodePath> parentOrgNode = parentOrgIterator.next();
632 640
633 Iterator<Pair<TreeNode, NodePath>> parentNodeIterator = orgTraverser.findInSubTree((TreeNode node) -> { 641 Iterator<Pair<TreeNode, NodePath>> parentNodeIterator = orgTraverser.findInSubTree((TreeNode node) -> {
634 String element = node.getAttributes().getString("element"); 642 String element = node.getAttributes().getString("element");
635 if (element == null) 643 if (element == null)
636 return false; 644 return false;
638 return false; 646 return false;
639 String parentId = node.getAttributes().getString("text"); 647 String parentId = node.getAttributes().getString("text");
640 if (parentId != null) 648 if (parentId != null)
641 return true; 649 return true;
642 return false; 650 return false;
643 }, parentOrgPathNodePair, "element", "organizationRefId"); 651 }, parentOrgNode, "element", "organizationRefId");
644 652
645 for (; parentNodeIterator.hasNext();) { 653 for (; parentNodeIterator.hasNext();) {
646 String parentId = parentNodeIterator.next().left().getAttributes().getString("text"); 654 String parentId = parentNodeIterator.next().left().getAttributes().getString("text");
647 if (filter(parentId, filterIds)) 655 if (filter(parentId, filterIds))
648 parentIds.add(parentId); 656 parentIds.add(parentId);
728 String targetId = targetNode.getAttributes().getString("id"); 736 String targetId = targetNode.getAttributes().getString("id");
729 return targetId; 737 return targetId;
730 } 738 }
731 739
732 public Iterator<String> roleDescriptionElementIds(String id, LinkedList<String> filterIds) { 740 public Iterator<String> roleDescriptionElementIds(String id, LinkedList<String> filterIds) {
733 Pattern personPattern = Pattern.compile("p:");
734 Matcher personMacher = personPattern.matcher(id);
735 if (personMacher.find()) {
736 return searchRoleIds(personTree, id, "Person");
737 }
738
739 Pattern organizationPattern = Pattern.compile("o:");
740 Matcher organizationMacher = organizationPattern.matcher(id);
741 if (organizationMacher.find()) {
742 return _roleDescriptionElementIds(id, filterIds);
743 }
744
745 return null;
746 }
747
748 public Iterator<String> _roleDescriptionElementIds(String id, LinkedList<String> filterIds) {
749 741
750 Iterator<String> orgIds = deepParentOrganizationIdsPlus(id, filterIds); 742 Iterator<String> orgIds = deepParentOrganizationIdsPlus(id, filterIds);
751 743
752 LinkedList<String> rdeIds = new LinkedList<String>(); 744 LinkedList<String> rdeIds = new LinkedList<String>();
753 745
787 }, "id", roleId); 779 }, "id", roleId);
788 780
789 if (!roleIterator.hasNext()) 781 if (!roleIterator.hasNext())
790 return ""; 782 return "";
791 783
784 Pair<TreeNode, NodePath> roleNode = roleIterator.next();
792 785
793 Iterator<Pair<TreeNode, NodePath>> rdeIterator = traverser.findInSubTree((TreeNode node) -> { 786 Iterator<Pair<TreeNode, NodePath>> rdeIterator = traverser.findInSubTree((TreeNode node) -> {
794 String element = node.getAttributes().getString("element"); 787 String element = node.getAttributes().getString("element");
795 if (element == null) 788 if (element == null)
796 return false; 789 return false;
798 return false; 791 return false;
799 String rde = node.getAttributes().getString("text"); 792 String rde = node.getAttributes().getString("text");
800 if (rde != null) 793 if (rde != null)
801 return true; 794 return true;
802 return false; 795 return false;
803 }, roleIterator.next(), "element", "roleDescriptionElementRefIds"); 796 }, roleNode, "element", "roleDescriptionElementRefIds");
804 797
805 if (!rdeIterator.hasNext()) 798 if (!rdeIterator.hasNext())
806 return ""; 799 return "";
807 800
808 return rdeIterator.next().left().getAttributes().getString("text"); 801 return rdeIterator.next().left().getAttributes().getString("text");