Mercurial > hg > Members > tatsuki > JungleXMLReader

changeset 35:0af5489d5406

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge with af6d03ba6ee5fc61e42da60b4a9e7b8f335e3d55
author one
date Sun, 09 Nov 2014 22:57:50 +0900
parents 96dcbd8e2fcb (diff) af6d03ba6ee5 (current diff)
children c6809d43da62
files src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/JuGrix.java src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/DeepChildOrganizationIdsTest.java
diffstat 7 files changed, 423 insertions(+), 362 deletions(-) [+]
line wrap: on
line diff
--- a/src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/JuGrix.java	Sun Nov 09 20:39:27 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/JuGrix.java	Sun Nov 09 22:57:50 2014 +0900
@@ -49,7 +49,7 @@
   public boolean isActive(String id) {
 
     InterfaceTraverser personTraverser = personTree.getTraverser();
-    Iterator<Pair<TreeNode, NodePath>> personIdsIterator = personTraverser.find((TreeNode node) -> {
+    Iterator<Pair<TreeNode, NodePath>> personIdpairIterator = personTraverser.find((TreeNode node) -> {
       String personId = node.getAttributes().getString("Person-id");
       if (personId == null)
         return false;
@@ -58,44 +58,22 @@
       return false;
     }, "Person-id", id);
 
-    if (personIdsIterator.hasNext())
+    if (personIdpairIterator.hasNext())
       return true;
     return false;
 
   }
 
-
-
   public Iterator<String> personIds(String orgId, LinkedList<String> roleIds) {
-    TreeMap<String, String> personIdsTreeMap = TreeMap.empty(Ord.stringOrd);
-    TreeMap<String, String> newPersonIdsTreeMap = personIdsSearch(orgId, roleIds, personIdsTreeMap);
-
-    if (newPersonIdsTreeMap.isEmpty())
-      return new NullIterator();
-
-    Iterator<P2<String, String>> personIdsIterator = newPersonIdsTreeMap.iterator();
-    return new Iterator<String>() {
 
-      @Override
-      public boolean hasNext() {
-        if (personIdsIterator.hasNext())
-          return true;
-        return false;
-      }
+    Iterator<String> parentOrgIdIterator = parentOrganizationIds(orgId, roleIds);
+    TreeMap<String, String> personIdsTreeMap = TreeMap.empty(Ord.stringOrd);
+    
+    if (filter(orgId, roleIds))
+      personIdsTreeMap = personIdsSearch(orgId, personIdsTreeMap);
 
-      @Override
-      public String next() {
-        return personIdsIterator.next()._1();
-      }
-
-    };
-  }
-
-  public Iterator<String> personIds(LinkedList<String> orgIds, LinkedList<String> roleIds) {
-
-    TreeMap<String, String> personIdsTreeMap = TreeMap.empty(Ord.stringOrd);
-    for (String orgId : orgIds) {
-      personIdsTreeMap = personIdsSearch(orgId, roleIds, personIdsTreeMap);
+    for (; parentOrgIdIterator.hasNext();) {
+      personIdsTreeMap = personIdsSearch(parentOrgIdIterator.next(), personIdsTreeMap);
     }
 
     if (personIdsTreeMap.isEmpty())
@@ -119,13 +97,44 @@
     };
   }
 
-  private TreeMap<String, String> personIdsSearch(String id, LinkedList<String> roleIds, TreeMap<String, String> orgIdsTreeMap) {
+  public Iterator<String> personIds(LinkedList<String> orgIds, LinkedList<String> roleIds) {
+
+    TreeMap<String, String> personIds = TreeMap.empty(Ord.stringOrd);
+    for (String orgId : orgIds) {
+      personIds = personIdsSearch(orgId, personIds);
+    }
+
+    if (personIds.isEmpty())
+      return new NullIterator();
+
+    Iterator<P2<String, String>> personIdsIterator = personIds.iterator();
+
+    return new Iterator<String>() {
+      String personId;
 
-    if (!filter(id, roleIds))
-      return orgIdsTreeMap;
+      @Override
+      public boolean hasNext() {
+        for (; personIdsIterator.hasNext();) {
+          personId = personIdsIterator.next()._1();
+          if (filter(personId, roleIds))
+            return true;
+        }
+        return false;
+      }
+
+      @Override
+      public String next() {
+        return personId;
+      }
+
+    };
+  }
+
+  private TreeMap<String, String> personIdsSearch(String orgId, TreeMap<String, String> orgIdsTreeMap) {
 
     InterfaceTraverser personTraverser = personTree.getTraverser();
-    Iterator<Pair<TreeNode, NodePath>> PersonIterator = personTraverser.findAll((TreeNode node) -> {
+
+    Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.findAll((TreeNode node) -> {
       String personId = node.getAttributes().getString("element");
       if (personId == null)
         return false;
@@ -134,20 +143,21 @@
       return false;
     }, "Person-id");
 
-    for (; PersonIterator.hasNext();) {
+    for (; personIdPairIterator.hasNext();) {
 
-      Pair<TreeNode, NodePath> person = PersonIterator.next();
-      Iterator<Pair<TreeNode, NodePath>> personIdIterator = personTraverser.findInSubTree((TreeNode node) -> {
+      Pair<TreeNode, NodePath> personIdPair = personIdPairIterator.next();
+
+      Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = personTraverser.findInSubTree((TreeNode node) -> {
         String personId = node.getAttributes().getString("text-organizationRefId");
         if (personId == null)
           return false;
-        if (personId.equals(id))
+        if (personId.equals(orgId))
           return true;
         return false;
-      }, person, "text-organizationRefId", id);
+      }, personIdPair, "text-organizationRefId", orgId);
 
-      if (personIdIterator.hasNext()) {
-        String personId = person.left().getAttributes().getString("Person-id");
+      if (orgIdPairIterator.hasNext()) {
+        String personId = personIdPair.left().getAttributes().getString("Person-id");
         if (personId != null)
           orgIdsTreeMap = orgIdsTreeMap.set(personId, personId);
       }
@@ -164,7 +174,7 @@
 
     InterfaceTraverser orgTraverser = organizationTree.getTraverser();
 
-    Iterator<Pair<TreeNode, NodePath>> orgIdsIterator = orgTraverser.find((TreeNode node) -> {
+    Iterator<Pair<TreeNode, NodePath>> orgNodeIterator = orgTraverser.find((TreeNode node) -> {
       String personId = node.getAttributes().getString("element");
       if (personId == null)
         return false;
@@ -178,33 +188,33 @@
       return false;
     }, "Organization-id", orgId);
 
-    if (!orgIdsIterator.hasNext())
+    if (!orgNodeIterator.hasNext())
       return false;
 
-    Pair<TreeNode, NodePath> orgIdNode = orgIdsIterator.next();
+    Pair<TreeNode, NodePath> searchNodePair = orgNodeIterator.next();
 
     for (String id : roleIds) {
       Pattern personPattern = Pattern.compile("r:");
       Matcher personMacher = personPattern.matcher(id);
       if (personMacher.find()) {
-        if (roleFilter(id, orgIdNode))
+        if (roleFilter(id, searchNodePair))
           return false;
       }
 
       Pattern organizationPattern = Pattern.compile("rde:");
       Matcher organizationMacher = organizationPattern.matcher(id);
       if (organizationMacher.find()) {
-        if (!rdeFilter(id, orgIdNode))
+        if (!rdeFilter(id, searchNodePair))
           return false;
       }
     }
     return true;
   }
 
-  private boolean rdeFilter(String id, Pair<TreeNode, NodePath> filteringNode) {
+  private boolean rdeFilter(String id, Pair<TreeNode, NodePath> searchNodePair) {
 
     InterfaceTraverser orgTraverser = organizationTree.getTraverser();
-    Iterator<Pair<TreeNode, NodePath>> roleIdIterator = orgTraverser.findInSubTreeAllValue((TreeNode node) -> {
+    Iterator<Pair<TreeNode, NodePath>> pairIdIterator = orgTraverser.findInSubTreeAllValue((TreeNode node) -> {
       String element = node.getAttributes().getString("element");
       if (element == null)
         return false;
@@ -214,21 +224,20 @@
       if (roleId != null)
         return true;
       return false;
-    }, filteringNode, "text-roleRefId");
+    }, searchNodePair, "text-roleRefId");
 
-    TreeMap<String, String> roleIdsTreeMap = TreeMap.empty(Ord.stringOrd);
-    for (; roleIdIterator.hasNext();) {
-      String roleId = roleIdIterator.next().left().getAttributes().getString("text-roleRefId");
-      roleIdsTreeMap = roleIdsTreeMap.set(roleId, roleId);
+    TreeMap<String, String> idMap = TreeMap.empty(Ord.stringOrd);
+    for (; pairIdIterator.hasNext();) {
+      String roleId = pairIdIterator.next().left().getAttributes().getString("text-roleRefId");
+      idMap = idMap.set(roleId, roleId);
     }
 
-    Iterator<P2<String, String>> roleIdP2Iterator = roleIdsTreeMap.iterator();
+    Iterator<P2<String, String>> ids = idMap.iterator();
     InterfaceTraverser roleTraverser = roleTree.getTraverser();
 
-    for (; roleIdP2Iterator.hasNext();) {
-      String roleId = roleIdP2Iterator.next()._1();
-      
-      Iterator<Pair<TreeNode, NodePath>> roleidPairIterator = roleTraverser.find((TreeNode node) -> {
+    for (; ids.hasNext();) {
+      String roleId = ids.next()._1();
+      Iterator<Pair<TreeNode, NodePath>> roleNodeIterator = roleTraverser.find((TreeNode node) -> {
         String element = node.getAttributes().getString("element");
         if (element == null)
           return false;
@@ -242,9 +251,9 @@
         return false;
       }, "Role-id", roleId);
 
-      for (; roleidPairIterator.hasNext();) {
-        Pair<TreeNode, NodePath> rolePair = roleidPairIterator.next();
-        Iterator<Pair<TreeNode, NodePath>> rdeIdPairIterator = roleTraverser.findInSubTree((TreeNode node) -> {
+      for (; roleNodeIterator.hasNext();) {
+        Pair<TreeNode, NodePath> rolePair = roleNodeIterator.next();
+        Iterator<Pair<TreeNode, NodePath>> rdeNodeIterator = roleTraverser.findInSubTree((TreeNode node) -> {
           String elementName = node.getAttributes().getString("element");
           if (elementName == null)
             return false;
@@ -260,7 +269,7 @@
           return false;
         }, rolePair, "text-roleDescriptionElementRefIds", id);
 
-        if (!rdeIdPairIterator.hasNext())
+        if (!rdeNodeIterator.hasNext())
           return false;
       }
 
@@ -272,7 +281,7 @@
     // System.out.println(searchNodePair.getAttributes().getString("id"));
     InterfaceTraverser orgTraverser = organizationTree.getTraverser();
 
-    Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = orgTraverser.findInSubTree((TreeNode node) -> {
+    Iterator<Pair<TreeNode, NodePath>> pairIdIterator = orgTraverser.findInSubTree((TreeNode node) -> {
       String elementName = node.getAttributes().getString("element");
       if (elementName == null)
         return false;
@@ -286,16 +295,98 @@
       return false;
     }, searchNodePair, "text-roleRefIds", id);
 
-    if (roleIdPairIterator.hasNext()) 
+    if (pairIdIterator.hasNext()) {
+      System.out.println(pairIdIterator.next().left().getAttributes().getString("text-roleRefIds"));
       return false;
+    }
     return true;
   }
 
+  public Iterator<String> roleIds(String id) {
+    Pattern personPattern = Pattern.compile("p:");
+    Matcher personMacher = personPattern.matcher(id);
+    if (personMacher.find()) {
+      return searchRoleIds(personTree, id, "Person");
+    }
+
+    Pattern organizationPattern = Pattern.compile("o:");
+    Matcher organizationMacher = organizationPattern.matcher(id);
+    if (organizationMacher.find()) {
+      return searchRoleIds(organizationTree, id, "Organization");
+    }
+
+    return new NullIterator();
+  }
+
+  public Iterator<String> searchRoleIds(JungleTree tree, String id, String element) {
+
+    InterfaceTraverser traverser = tree.getTraverser();
+
+    Iterator<Pair<TreeNode, NodePath>> idPairIterator = traverser.find((TreeNode node) -> {
+      String nodeElement = node.getAttributes().getString("element");
+      if (nodeElement == null)
+        return false;
+      if (!nodeElement.equals(element))
+        return false;
+      String nodeId = node.getAttributes().getString(element + "-id");
+      if (nodeId == null)
+        return false;
+      if (nodeId.equals(id))
+        return true;
+      return false;
+    }, element + "-id", id);
+
+    TreeMap<String, String> idsTreeMap = TreeMap.empty(Ord.stringOrd);
+    ;
+
+    for (; idPairIterator.hasNext();) {
+
+      Pair<TreeNode, NodePath> targetPair = idPairIterator.next();
+
+      Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = traverser.findInSubTreeAllValue((TreeNode node) -> {
+        String nodeElement = node.getAttributes().getString("element");
+        if (nodeElement == null)
+          return false;
+        if (!nodeElement.equals("roleRefId"))
+          return false;
+        String nodeId = node.getAttributes().getString("text-roleRefId");
+        if (nodeId != null)
+          return true;
+        return false;
+      }, targetPair, "text-roleRefId");
+
+      for (; roleIdPairIterator.hasNext();) {
+        Pair<TreeNode, NodePath> roleIdPair = roleIdPairIterator.next();
+        String roleId = roleIdPair.left().getAttributes().getString("text-roleRefId");
+        idsTreeMap = idsTreeMap.set(roleId, roleId);
+      }
+    }
+
+    if (idsTreeMap.isEmpty())
+      return new NullIterator();
+
+    Iterator<P2<String, String>> ids = idsTreeMap.iterator();
+    return new Iterator<String>() {
+
+      @Override
+      public boolean hasNext() {
+        if (ids.hasNext())
+          return true;
+        return false;
+      }
+
+      @Override
+      public String next() {
+        return ids.next()._1();
+      }
+
+    };
+  }
 
   public Iterator<String> competentRoleId(String personId) {
 
     InterfaceTraverser personTraverser = personTree.getTraverser();
-    Iterator<Pair<TreeNode, NodePath>> PersonIdPearIterator = personTraverser.find((TreeNode node) -> {
+    Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.find((TreeNode node) -> {
       String nodeElement = node.getAttributes().getString("element");
       if (nodeElement == null)
         return false;
@@ -309,10 +400,10 @@
       return false;
     }, "Person-id", personId);
 
-    if (!PersonIdPearIterator.hasNext())
+    if (!personIdPairIterator.hasNext())
       return new NullIterator();
-    
-    Pair<TreeNode, NodePath> personIdPair = PersonIdPearIterator.next();
+
+    Pair<TreeNode, NodePath> personIdPair = personIdPairIterator.next();
 
     Iterator<Pair<TreeNode, NodePath>> priorityPairIterator = personTraverser.findInSubTree((TreeNode node) -> {
       String nodeElement = node.getAttributes().getString("element");
@@ -328,41 +419,39 @@
       return false;
     }, personIdPair, "text-priority", "0");
 
-    TreeMap<String,String> priorityTreeMap = TreeMap.empty(Ord.stringOrd);
+    TreeMap<String, String> roleIdTreeMap = TreeMap.empty(Ord.stringOrd);
+
     for (; priorityPairIterator.hasNext();) {
-      NodePath priorityNodePath = priorityPairIterator.next().right();
-      Pair<Integer, NodePath> removeTailPriorityNodePath = priorityNodePath.last();
-      NodePath roleIdNodePath = removeTailPriorityNodePath.right().add(removeTailPriorityNodePath.left() + 1);
+
+      Pair<TreeNode, NodePath> priorityPair = priorityPairIterator.next();
+      NodePath priorityPath = priorityPair.right();
+      Pair<Integer, NodePath> removeLastPair = priorityPath.last();
+      NodePath roleIdNodePath = removeLastPair.right().add(removeLastPair.left() + 1);
       TreeNode roleIdNode = getTarget(personTree.getRootNode(), roleIdNodePath);
       String roleId = roleIdNode.getAttributes().getString("text-roleRefId");
-      priorityTreeMap = priorityTreeMap.set(roleId,roleId);
+      roleIdTreeMap = roleIdTreeMap.set(roleId, roleId);
     }
-
-    if (priorityTreeMap.isEmpty())
-      return new NullIterator();
-    
-    Iterator<P2<String, String>> priorityIterator = priorityTreeMap.iterator();
+    Iterator<P2<String, String>> roleIdP2Iterator = roleIdTreeMap.iterator();
     return new Iterator<String>() {
 
       @Override
       public boolean hasNext() {
-        if (priorityIterator.hasNext())
+        if (roleIdP2Iterator.hasNext())
           return true;
         return false;
       }
 
       @Override
       public String next() {
-        return priorityIterator.next()._1();
+        return roleIdP2Iterator.next()._1();
       }
     };
-  } 
-  
+  }
 
   public Iterator<String> concurrentRoleIds(String personId) {
 
     InterfaceTraverser personTraverser = personTree.getTraverser();
-    Iterator<Pair<TreeNode, NodePath>> PersonIdPairIterator = personTraverser.find((TreeNode node) -> {
+    Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.find((TreeNode node) -> {
       String nodeElement = node.getAttributes().getString("element");
       if (nodeElement == null)
         return false;
@@ -376,41 +465,40 @@
       return false;
     }, "Person-id", personId);
 
-    if (!PersonIdPairIterator.hasNext())
+    if (!personIdPairIterator.hasNext())
       return new NullIterator();
-    
-    Pair<TreeNode, NodePath> personIdPair = PersonIdPairIterator.next();
+
+    Pair<TreeNode, NodePath> personidPair = personIdPairIterator.next();
 
-    Iterator<Pair<TreeNode, NodePath>> priorityPairIterator = personTraverser.findInSubTreeAllValue((TreeNode node) -> {
-      String nodeElement = node.getAttributes().getString("element");
-      if (nodeElement == null)
-        return false;
-      if (!nodeElement.equals("priority"))
-        return false;
-      String priority = node.getAttributes().getString("text-priority");
-      if (priority != null)
-        return true;
-      return false;
-    }, personIdPair, "text-priority");
+    Iterator<Pair<TreeNode, NodePath>> priorityPairIterator = personTraverser.findInSubTreeAllValue(
+        (TreeNode node) -> {
+          String nodeElement = node.getAttributes().getString("element");
+          if (nodeElement == null)
+            return false;
+          if (!nodeElement.equals("priority"))
+            return false;
+          String priority = node.getAttributes().getString("text-priority");
+          if (priority != null)
+            return true;
+          return false;
+        }, personidPair, "text-priority");
 
-    TreeMap<String,String> roleIdTreeMap = TreeMap.empty(Ord.stringOrd);
+    TreeMap<String, String> roleIdTreeMap = TreeMap.empty(Ord.stringOrd);
+
     for (; priorityPairIterator.hasNext();) {
+
       Pair<TreeNode, NodePath> priorityPair = priorityPairIterator.next();
       TreeNode priorityNode = priorityPair.left();
       int priority = Integer.parseInt(priorityNode.getAttributes().getString("text-priority"));
-      
       if (priority > 0) {
-        NodePath priorityNodePath = priorityPair.right();
-        Pair<Integer, NodePath> removeTailPriorityNodePath = priorityNodePath.last();
-        NodePath roleIdNodePath = removeTailPriorityNodePath.right().add(removeTailPriorityNodePath.left() + 1);
+        NodePath priorityPath = priorityPair.right();
+        Pair<Integer, NodePath> removeLastPair = priorityPath.last();
+        NodePath roleIdNodePath = removeLastPair.right().add(removeLastPair.left() + 1);
         TreeNode roleIdNode = getTarget(personTree.getRootNode(), roleIdNodePath);
         String roleId = roleIdNode.getAttributes().getString("text-roleRefId");
-        roleIdTreeMap = roleIdTreeMap.set(roleId,roleId);
+        roleIdTreeMap = roleIdTreeMap.set(roleId, roleId);
       }
     }
-    if (roleIdTreeMap.isEmpty())
-      return new NullIterator();
-    
     Iterator<P2<String, String>> roleIdP2Iterator = roleIdTreeMap.iterator();
     return new Iterator<String>() {
 
@@ -426,65 +514,69 @@
         return roleIdP2Iterator.next()._1();
       }
     };
-    
   }
 
   public Iterator<String> deepPersonIds(String orgId, LinkedList<String> filterIds) {
+    
     TreeMap<String, String> personIdsTreeMap = TreeMap.empty(Ord.stringOrd);
-    Iterator<String> childrenOrgIdIterator = deepParentOrganizationIdsPlus(orgId, filterIds);
+    Iterator<String> childrensIterator = deepChildOrganizationIdsPlus(orgId, filterIds);
     
-    if (!childrenOrgIdIterator.hasNext())
+    
+    if (!childrensIterator.hasNext())
       return new NullIterator();
 
-    for (; childrenOrgIdIterator.hasNext();) {
-      String childrenOrgId = childrenOrgIdIterator.next();
-      personIdsTreeMap = personIdsSearch(childrenOrgId, filterIds,personIdsTreeMap);
+    for (; childrensIterator.hasNext();) {
+      String id = childrensIterator.next();
+      personIdsTreeMap = personIdsSearch(id, personIdsTreeMap);
     }
 
     if (personIdsTreeMap.isEmpty())
       return new NullIterator();
-    
-    Iterator<P2<String, String>> personIdsP2Iterator = personIdsTreeMap.iterator();
+
+    Iterator<P2<String, String>> personIds = personIdsTreeMap.iterator();
     return new Iterator<String>() {
 
       @Override
       public boolean hasNext() {
-        if (personIdsP2Iterator.hasNext())
+        if (personIds.hasNext())
           return true;
         return false;
       }
 
       @Override
       public String next() {
-        return personIdsP2Iterator.next()._1();
+        return personIds.next()._1();
       }
     };
   }
 
   public Iterator<String> deepChildOrganizationIdsPlus(String orgId, LinkedList<String> filterIds) {
     TreeMap<String, String> orgIdsTreeMap = TreeMap.empty(Ord.stringOrd);
-    
-    if (filter(orgId, filterIds))
-      orgIdsTreeMap = orgIdsTreeMap.set(orgId, orgId);
-    
-    orgIdsTreeMap = _deepChildOrganizationIds(orgId, filterIds, orgIdsTreeMap);
+
+    orgIdsTreeMap = orgIdsTreeMap.set(orgId, orgId);
+    orgIdsTreeMap = _deepChildOrganizationIds(orgId, orgIdsTreeMap);
 
     if (orgIdsTreeMap.isEmpty())
       return new NullIterator();
 
-    Iterator<P2<String, String>> orgIds = orgIdsTreeMap.iterator();
+    Iterator<P2<String, String>> orgIdsP2Iterator = orgIdsTreeMap.iterator();
     return new Iterator<String>() {
 
+      String childOrgId;
+
       @Override
       public boolean hasNext() {
-        if (orgIds.hasNext())
-          return true;
+        for (; orgIdsP2Iterator.hasNext();) {
+          childOrgId = orgIdsP2Iterator.next()._1();
+          if (filter(childOrgId, filterIds))
+            return true;
+        }
         return false;
       }
 
       @Override
       public String next() {
-        return orgIds.next()._1();
+        return childOrgId;
       }
     };
   }
@@ -492,77 +584,86 @@
   public Iterator<String> deepChildOrganizationIds(String orgId, LinkedList<String> filterIds) {
 
     TreeMap<String, String> orgIdsTreeMap = TreeMap.empty(Ord.stringOrd);
-    TreeMap<String, String> newOrgIdsTreeMap = _deepChildOrganizationIds(orgId, filterIds, orgIdsTreeMap);
-    
+    TreeMap<String, String> newOrgIdsTreeMap = _deepChildOrganizationIds(orgId, orgIdsTreeMap);
     if (newOrgIdsTreeMap.isEmpty())
       return new NullIterator();
 
-    Iterator<P2<String, String>> orgIdsP2Iterator = newOrgIdsTreeMap.iterator();
+    Iterator<P2<String, String>> orgIdP2Iterator = newOrgIdsTreeMap.iterator();
+
     return new Iterator<String>() {
+      String childOrgId;
 
       @Override
       public String next() {
-        return orgIdsP2Iterator.next()._1();
+        return childOrgId;
       }
 
       @Override
       public boolean hasNext() {
-        if (orgIdsP2Iterator.hasNext())
-          return true;
+        for (; orgIdP2Iterator.hasNext();) {
+          childOrgId = orgIdP2Iterator.next()._1();
+          if (filter(childOrgId, filterIds))
+            return true;
+        }
         return false;
       }
     };
   }
 
-  public TreeMap<String, String> _deepChildOrganizationIds(String orgId, LinkedList<String> filterIds,
-      TreeMap<String, String> orgIdsTreeMap) {
+  public TreeMap<String, String> _deepChildOrganizationIds(String orgId, TreeMap<String, String> orgIdsTreeMap) {
 
-    Iterator<String> childrenOrgIdIterator = childOrganizationIds(orgId,filterIds);
-    if (!childrenOrgIdIterator.hasNext())
+    TreeMap<String, String> childrenIdTreeMap = _childOrganizationIds(orgId, TreeMap.empty(Ord.stringOrd));
+
+    if (childrenIdTreeMap.isEmpty())
       return orgIdsTreeMap;
 
-    for (; childrenOrgIdIterator.hasNext();) {
-      String childrenOrgId = childrenOrgIdIterator.next();
-      if (filter(childrenOrgId, filterIds))
-        orgIdsTreeMap = orgIdsTreeMap.set(childrenOrgId, childrenOrgId);
-      orgIdsTreeMap = _deepChildOrganizationIds(childrenOrgId, filterIds, orgIdsTreeMap);
+    Iterator<P2<String, String>> childrenIdIterator = childrenIdTreeMap.iterator();
+
+    for (; childrenIdIterator.hasNext();) {
+      String childrenId = childrenIdIterator.next()._1();
+      orgIdsTreeMap = orgIdsTreeMap.set(childrenId, childrenId);
+      orgIdsTreeMap = _deepChildOrganizationIds(childrenId, orgIdsTreeMap);
     }
 
     return orgIdsTreeMap;
   }
 
   public Iterator<String> childOrganizationIds(String orgId, LinkedList<String> filterIds) {
-    
     TreeMap<String, String> childrenOrgIdTreeMap = TreeMap.empty(Ord.stringOrd);
-    TreeMap<String, String> newChildrenOrgIdTreeMap = _childOrganizationIds(orgId, filterIds, childrenOrgIdTreeMap);
+    TreeMap<String, String> newChildrenOrgIdTreeMap = _childOrganizationIds(orgId, childrenOrgIdTreeMap);
 
     if (newChildrenOrgIdTreeMap.isEmpty())
       return new NullIterator();
 
-    Iterator<P2<String, String>> childrenOrgIdP2Iterator = newChildrenOrgIdTreeMap.iterator();
+    Iterator<P2<String, String>> childrenOrgIdIterator = newChildrenOrgIdTreeMap.iterator();
+
     return new Iterator<String>() {
+      String childOrgId;
 
       @Override
       public boolean hasNext() {
-        if (childrenOrgIdP2Iterator.hasNext())
-          return true;
+
+        if (childrenOrgIdIterator.hasNext()) {
+          childOrgId = childrenOrgIdIterator.next()._1();
+          if (filter(childOrgId, filterIds))
+            return true;
+        }
         return false;
       }
 
       @Override
       public String next() {
-        return childrenOrgIdP2Iterator.next()._1();
+        return childOrgId;
       }
     };
 
   }
 
-  public TreeMap<String, String> _childOrganizationIds(String orgId, LinkedList<String> filterIds,
-      TreeMap<String, String> childOrgIdsTreeMap) {
+  public TreeMap<String, String> _childOrganizationIds(String orgId, TreeMap<String, String> childOrgIdsTreeMap) {
 
     InterfaceTraverser orgTraverser = organizationTree.getTraverser();
 
-    Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = orgTraverser.find((TreeNode node) -> {
+    Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = orgTraverser.find((TreeNode node) -> {
       String nodeElement = node.getAttributes().getString("element");
       if (nodeElement == null)
         return false;
@@ -576,50 +677,53 @@
       return false;
     }, "Organization-id", orgId);
 
-    if (!personIdPairIterator.hasNext())
+    if (!orgIdPairIterator.hasNext())
       return childOrgIdsTreeMap;
 
-    Pair<TreeNode, NodePath> personIdPair = personIdPairIterator.next();
+    Pair<TreeNode, NodePath> orgIdPair = orgIdPairIterator.next();
 
-    Iterator<Pair<TreeNode, NodePath>> childOrgPairIterator = orgTraverser.findInSubTree((TreeNode node) -> {
+    Iterator<Pair<TreeNode, NodePath>> chilrenOrgPairIterator = orgTraverser.findInSubTree((TreeNode node) -> {
       String nodeElement = node.getAttributes().getString("element");
       if (nodeElement == null)
         return false;
       if (nodeElement.equals("childOrganizations"))
         return true;
       return false;
-    }, personIdPair, "element", "childOrganizations");
+    }, orgIdPair, "element", "childOrganizations");
 
-    if (!childOrgPairIterator.hasNext())
+    if (!chilrenOrgPairIterator.hasNext())
       return childOrgIdsTreeMap;
 
-    Pair<TreeNode, NodePath> chilerenOrgIdPair = childOrgPairIterator.next();
+    Pair<TreeNode, NodePath> chilerenOrg = chilrenOrgPairIterator.next();
 
-    Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdPairIterator = orgTraverser.findInSubTreeAllValue((TreeNode node) -> {
-      String nodeElement = node.getAttributes().getString("element");
-      if (nodeElement == null)
-        return false;
-      if (!nodeElement.equals("organizationRefIds"))
-        return false;
-      nodeElement = node.getAttributes().getString("text-organizationRefIds");
-      if (nodeElement != null)
-        return true;
-      return false;
-    }, chilerenOrgIdPair, "text-organizationRefIds");
+    Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdPairIterator = orgTraverser.findInSubTreeAllValue(
+        (TreeNode node) -> {
+          String nodeElement = node.getAttributes().getString("element");
+          if (nodeElement == null)
+            return false;
+          if (!nodeElement.equals("organizationRefIds"))
+            return false;
+          nodeElement = node.getAttributes().getString("text-organizationRefIds");
+          if (nodeElement != null)
+            return true;
+          return false;
+        }, chilerenOrg, "text-organizationRefIds");
 
     for (; chilrenOrgIdPairIterator.hasNext();) {
-      String childOrgId = chilrenOrgIdPairIterator.next().left().getAttributes().getString("text-organizationRefIds");
-      if (filter(childOrgId, filterIds))
-        childOrgIdsTreeMap = childOrgIdsTreeMap.set(childOrgId, childOrgId);
+      String childrenOrgId = chilrenOrgIdPairIterator.next().left().getAttributes()
+          .getString("text-organizationRefIds");
+      childOrgIdsTreeMap = childOrgIdsTreeMap.set(childrenOrgId, childrenOrgId);
 
     }
+
     return childOrgIdsTreeMap;
   }
 
-  public TreeNode getTarget(TreeNode node, NodePath targetPath) {
-    Pair<Integer, NodePath> removeHeadPath = targetPath.pop();
-    int num = removeHeadPath.left();
-    NodePath newPath = removeHeadPath.right();
+  public TreeNode getTarget(TreeNode node, NodePath path) {
+    TreeNode target;
+    Pair<Integer, NodePath> pathNode = path.pop();
+    int num = pathNode.left();
+    NodePath newPath = pathNode.right();
     if (num == -1 && newPath.size() != 0)
       return getTarget(node, newPath);
 
@@ -628,10 +732,10 @@
       return node;
 
     TreeNode child = either.b();
-    if (removeHeadPath.right().size() == 0)
+    if (pathNode.right().size() == 0)
       return child;
 
-    TreeNode target = getTarget(child, removeHeadPath.right());
+    target = getTarget(child, pathNode.right());
     return target;
   }
 
@@ -650,17 +754,19 @@
   }
 
   public String rolePriority(String personId, String roleId) {
+
     InterfaceTraverser personTraverser = personTree.getTraverser();
+
     Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.find((TreeNode node) -> {
       String element = node.getAttributes().getString("element");
       if (element == null)
         return false;
       if (!element.equals("Person"))
         return false;
-      String nodeId = node.getAttributes().getString("Person-id");
-      if (nodeId == null)
+      String nodePersonId = node.getAttributes().getString("Person-id");
+      if (nodePersonId == null)
         return false;
-      if (nodeId.equals(personId))
+      if (nodePersonId.equals(personId))
         return true;
       return false;
     }, "Person-id", personId);
@@ -668,7 +774,7 @@
     if (!personIdPairIterator.hasNext())
       return "";
 
-    Pair<TreeNode, NodePath> personIdPair = personIdPairIterator.next();
+    Pair<TreeNode, NodePath> targetPersonIdPair = personIdPairIterator.next();
 
     Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = personTraverser.findInSubTree((TreeNode node) -> {
       String element = node.getAttributes().getString("element");
@@ -682,28 +788,52 @@
       if (compareRoleId.equals(roleId))
         return true;
       return false;
-    }, personIdPair, "text-roleRefId",roleId);
+    }, targetPersonIdPair, "text-roleRefId", roleId);
 
     for (; roleIdPairIterator.hasNext();) {
       Pair<TreeNode, NodePath> roleIdPair = roleIdPairIterator.next();
-      NodePath roleNodePath = roleIdPair.right();
-      Pair<Integer, NodePath> removeLastNodePath = roleNodePath.last();
-      NodePath priorityNodePath = removeLastNodePath.right().add(removeLastNodePath.left() - 1);
+      NodePath roleIdNodePath = roleIdPair.right();
+      Pair<Integer, NodePath> removeLastPath = roleIdNodePath.last();
+      NodePath priorityNodePath = removeLastPath.right().add(removeLastPath.left() - 1);
       TreeNode priorityNode = getTarget(personTree.getRootNode(), priorityNodePath);
       if (priorityNode.getAttributes().getString("element").equals("priority"))
         return priorityNode.getAttributes().getString("text-priority");
     }
     return "";
   }
-//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
   public Iterator<String> parentOrganizationIds(String orgId, LinkedList<String> filterIds) {
-    return _parentOrganizationIds(orgId, filterIds);
+
+    TreeMap<String, String> parentIdsTreeMap = _parentOrganizationIds(orgId);
+    if (parentIdsTreeMap.isEmpty())
+      return new NullIterator();
+
+    Iterator<P2<String, String>> parentIdP2Iterator = parentIdsTreeMap.iterator();
+    return new Iterator<String>() {
+      String parentId;
+
+      @Override
+      public boolean hasNext() {
+        for (; parentIdP2Iterator.hasNext();) {
+          parentId = parentIdP2Iterator.next()._1();
+          if (filter(parentId, filterIds))
+            return true;
+        }
+        return false;
+      }
+
+      @Override
+      public String next() {
+        return parentId;
+      }
+
+    };
   }
 
-  public Iterator<String> _parentOrganizationIds(String orgId, LinkedList<String> filterIds) {
+  public TreeMap<String, String> _parentOrganizationIds(String orgId) {
 
     InterfaceTraverser orgTraverser = organizationTree.getTraverser();
-    Iterator<Pair<TreeNode, NodePath>> orgIterator = orgTraverser.find((TreeNode node) -> {
+    Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = orgTraverser.find((TreeNode node) -> {
       String element = node.getAttributes().getString("element");
       if (element == null)
         return false;
@@ -717,12 +847,12 @@
       return false;
     }, "Organization-id", orgId);
 
-    if (!orgIterator.hasNext())
-      return new NullIterator();
+    if (!orgIdPairIterator.hasNext())
+      return TreeMap.empty(Ord.stringOrd);
 
-    Pair<TreeNode, NodePath> orgNode = orgIterator.next();
+    Pair<TreeNode, NodePath> orgNode = orgIdPairIterator.next();
 
-    Iterator<Pair<TreeNode, NodePath>> parentOrgIterator = orgTraverser.findInSubTree((TreeNode node) -> {
+    Iterator<Pair<TreeNode, NodePath>> parentOrgPairIterator = orgTraverser.findInSubTree((TreeNode node) -> {
       String element = node.getAttributes().getString("element");
       if (element == null)
         return false;
@@ -733,108 +863,106 @@
 
     TreeMap<String, String> parentIdsTreeMap = TreeMap.empty(Ord.stringOrd);
 
-    for (; parentOrgIterator.hasNext();) {
-      Pair<TreeNode, NodePath> parentOrgNode = parentOrgIterator.next();
+    for (; parentOrgPairIterator.hasNext();) {
+      Pair<TreeNode, NodePath> parentOrgNode = parentOrgPairIterator.next();
 
-      Iterator<Pair<TreeNode, NodePath>> parentNodeIterator = orgTraverser.findInSubTreeAllValue((TreeNode node) -> {
-        String element = node.getAttributes().getString("element");
-        if (element == null)
-          return false;
-        if (!element.equals("organizationRefId"))
-          return false;
-        String parentId = node.getAttributes().getString("text-organizationRefId");
-        if (parentId != null)
-          return true;
-        return false;
-      }, parentOrgNode, "text-organizationRefId");
+      Iterator<Pair<TreeNode, NodePath>> parentOrgIdPairIterator = orgTraverser.findInSubTreeAllValue(
+          (TreeNode node) -> {
+            String element = node.getAttributes().getString("element");
+            if (element == null)
+              return false;
+            if (!element.equals("organizationRefId"))
+              return false;
+            String parentId = node.getAttributes().getString("text-organizationRefId");
+            if (parentId != null)
+              return true;
+            return false;
+          }, parentOrgNode, "text-organizationRefId");
 
-      for (; parentNodeIterator.hasNext();) {
-        String parentId = parentNodeIterator.next().left().getAttributes().getString("text-organizationRefId");
-        if (filter(parentId, filterIds))
-          parentIdsTreeMap = parentIdsTreeMap.set(parentId, parentId);
+      for (; parentOrgIdPairIterator.hasNext();) {
+        String parentId = parentOrgIdPairIterator.next().left().getAttributes().getString("text-organizationRefId");
+        parentIdsTreeMap = parentIdsTreeMap.set(parentId, parentId);
       }
 
     }
 
-    Iterator<P2<String, String>> parentIds = parentIdsTreeMap.iterator();
-    if (parentIdsTreeMap.isEmpty())
-      return new NullIterator();
-    else
-      return new Iterator<String>() {
+    return parentIdsTreeMap;
 
-        @Override
-        public boolean hasNext() {
-          if (parentIds.hasNext())
-            return true;
-          return false;
-        }
-
-        @Override
-        public String next() {
-          return parentIds.next()._1();
-        }
-
-      };
   }
 
   public Iterator<String> deepParentOrganizationIds(String orgId, LinkedList<String> filterIds) {
     TreeMap<String, String> parentIdsTreeMap = TreeMap.empty(Ord.stringOrd);
-    Iterator<P2<String, String>> parentIds = _deepParentOrganizationIds(orgId, filterIds, parentIdsTreeMap).iterator();
+    TreeMap<String, String> newParentIdsTreeMap = _deepParentOrganizationIds(orgId, parentIdsTreeMap);
+
+    if (newParentIdsTreeMap.isEmpty())
+      return new NullIterator();
+
+    Iterator<P2<String, String>> parentIds = newParentIdsTreeMap.iterator();
+
     return new Iterator<String>() {
+      String parentOrgId;
 
       @Override
       public boolean hasNext() {
-        if (parentIds.hasNext())
-          return true;
+        for (; parentIds.hasNext();) {
+          parentOrgId = parentIds.next()._1();
+          if (filter(parentOrgId, filterIds))
+            return true;
+        }
         return false;
       }
 
       @Override
       public String next() {
-        return parentIds.next()._1();
+        return parentOrgId;
       }
 
     };
   }
 
-  public TreeMap<String, String> _deepParentOrganizationIds(String orgId, LinkedList<String> filterIds,
-      TreeMap<String, String> orgIds) {
+  public TreeMap<String, String> _deepParentOrganizationIds(String orgId, TreeMap<String, String> orgIds) {
 
-    Iterator<String> parentIds = parentOrganizationIds(orgId, filterIds);
-    if (!parentIds.hasNext())
+    TreeMap<String, String> parentIdsTreeMap = _parentOrganizationIds(orgId);
+
+    if (parentIdsTreeMap.isEmpty())
       return orgIds;
 
-    for (; parentIds.hasNext();) {
-      String parentId = parentIds.next();
-      if (filter(parentId, filterIds))
-        orgIds = orgIds.set(parentId, parentId);
-      orgIds = _deepParentOrganizationIds(parentId, filterIds, orgIds);
+    Iterator<P2<String, String>> parentIdsIterator = parentIdsTreeMap.iterator();
+    for (; parentIdsIterator.hasNext();) {
+      String parentId = parentIdsIterator.next()._1();
+      orgIds = orgIds.set(parentId, parentId);
+      orgIds = _deepParentOrganizationIds(parentId, orgIds);
     }
     return orgIds;
   }
 
   public Iterator<String> deepParentOrganizationIdsPlus(String id, LinkedList<String> filterIds) {
+
     TreeMap<String, String> parentIdsTreeMap = TreeMap.empty(Ord.stringOrd);
-    if (filter(id, filterIds))
-      parentIdsTreeMap = parentIdsTreeMap.set(id, id);
-    parentIdsTreeMap = _deepParentOrganizationIds(id, filterIds, parentIdsTreeMap);
+
+    parentIdsTreeMap = parentIdsTreeMap.set(id, id);
+    parentIdsTreeMap = _deepParentOrganizationIds(id, parentIdsTreeMap);
 
     if (parentIdsTreeMap.isEmpty())
       return new NullIterator();
 
     Iterator<P2<String, String>> personIds = parentIdsTreeMap.iterator();
     return new Iterator<String>() {
+      String parentOrgId;
 
       @Override
       public boolean hasNext() {
-        if (personIds.hasNext())
-          return true;
+        for (; personIds.hasNext();) {
+          parentOrgId = personIds.next()._1();
+          if (filter(parentOrgId, filterIds))
+            return true;
+        }
         return false;
       }
 
       @Override
       public String next() {
-        return personIds.next()._1();
+        return parentOrgId;
       }
 
     };
@@ -864,7 +992,7 @@
       elementName = "RoleDescriptionElement";
     }
 
-    Iterator<Pair<TreeNode, NodePath>> idIterator = traverser.find((TreeNode node) -> {
+    Iterator<Pair<TreeNode, NodePath>> PathNameIterator = traverser.find((TreeNode node) -> {
       String element = node.getAttributes().getString("element");
       if (element == null)
         return false;
@@ -878,39 +1006,39 @@
       return false;
     }, "text-path", StrPath);
 
-    if (!idIterator.hasNext())
+    if (!PathNameIterator.hasNext())
       return "";
 
-    Pair<TreeNode, NodePath> nodePair = idIterator.next();
-    NodePath path = nodePair.right();
-    NodePath targetPath = path.last().right();
+    Pair<TreeNode, NodePath> pathNamePair = PathNameIterator.next();
+    NodePath pathNamePath = pathNamePair.right();
+    NodePath pathNameIdPath = pathNamePath.last().right();
 
-    TreeNode targetNode = getTarget(root, targetPath);
-    String targetId = targetNode.getAttributes().getString(elementName + "-id");
-    return targetId;
+    TreeNode pathNameIdNode = getTarget(root, pathNameIdPath);
+    String pathNameId = pathNameIdNode.getAttributes().getString(elementName + "-id");
+    return pathNameId;
   }
 
   public Iterator<String> roleDescriptionElementIds(String id, LinkedList<String> filterIds) {
 
-    Iterator<String> orgIds = deepParentOrganizationIdsPlus(id, filterIds);
+    Iterator<String> orgIdsIterator = deepParentOrganizationIdsPlus(id, filterIds);
 
-   TreeMap<String,String> rdeIdsTreeMap = TreeMap.empty(Ord.stringOrd);
+    TreeMap<String, String> rdeIdsTreeMap = TreeMap.empty(Ord.stringOrd);
 
-    for (; orgIds.hasNext();) {
-      String orgId = orgIds.next();
-      Iterator<String> roleIds = roleIds(orgId);
-      for (; roleIds.hasNext();) {
-        String roleId = roleIds.next();
-        Iterator<String> rdeIds = getRde(roleId);
-        for (;rdeIds.hasNext();) {
-          String rdeId = rdeIds.next();
-          rdeIdsTreeMap = rdeIdsTreeMap.set(rdeId,rdeId);
+    for (; orgIdsIterator.hasNext();) {
+      String orgId = orgIdsIterator.next();
+      Iterator<String> roleIdIteraotr = roleIds(orgId);
+      for (; roleIdIteraotr.hasNext();) {
+        String roleId = roleIdIteraotr.next();
+        Iterator<String> rdeIdIterator = getRde(roleId);
+        for (; rdeIdIterator.hasNext();) {
+          String rdeId = rdeIdIterator.next();
+          rdeIdsTreeMap = rdeIdsTreeMap.set(rdeId, rdeId);
         }
       }
     }
     if (rdeIdsTreeMap.isEmpty())
       return new NullIterator();
-    
+
     Iterator<P2<String, String>> rdeIds = rdeIdsTreeMap.iterator();
     return new Iterator<String>() {
 
@@ -928,91 +1056,11 @@
     };
   }
 
-  
-  public Iterator<String> roleIds(String id) {
-    Pattern personPattern = Pattern.compile("p:");
-    Matcher personMacher = personPattern.matcher(id);
-    if (personMacher.find()) {
-      return searchRoleIds(personTree, id, "Person");
-    }
-
-    Pattern organizationPattern = Pattern.compile("o:");
-    Matcher organizationMacher = organizationPattern.matcher(id);
-    if (organizationMacher.find()) {
-      return searchRoleIds(organizationTree, id, "Organization");
-    }
-
-    return null;
-  }
-  
-  public Iterator<String> searchRoleIds(JungleTree tree, String id, String element) {
-
-    InterfaceTraverser ifTraverser = tree.getTraverser();
-    Iterator<Pair<TreeNode, NodePath>> searchTargetIterator = ifTraverser.find((TreeNode node) -> {
-      String nodeElement = node.getAttributes().getString("element");
-      if (nodeElement == null)
-        return false;
-      if (!nodeElement.equals(element))
-        return false;
-      String nodeId = node.getAttributes().getString(element + "-id");
-      if (nodeId == null)
-        return false;
-      if (nodeId.equals(id))
-        return true;
-      return false;
-    }, element + "-id", id);
-
-    TreeMap<String, String> idsTreeMap = TreeMap.empty(Ord.stringOrd);
-    ;
-
-    for (; searchTargetIterator.hasNext();) {
-
-      Pair<TreeNode, NodePath> searchTargetPair = searchTargetIterator.next();
-      Iterator<Pair<TreeNode, NodePath>> pairIdIterator = ifTraverser.findInSubTreeAllValue((TreeNode node) -> {
-        String nodeElement = node.getAttributes().getString("element");
-        if (nodeElement == null)
-          return false;
-        if (!nodeElement.equals("roleRefId"))
-          return false;
-        String nodeId = node.getAttributes().getString("text-roleRefId");
-        if (nodeId != null)
-          return true;
-        return false;
-      }, searchTargetPair, "text-roleRefId");
-
-      for (; pairIdIterator.hasNext();) {
-        Pair<TreeNode, NodePath> idNodePath = pairIdIterator.next();
-        String attribute = idNodePath.left().getAttributes().getString("text-roleRefId");
-        idsTreeMap = idsTreeMap.set(attribute, attribute);
-      }
-    }
-
-    if (idsTreeMap.isEmpty())
-      return new NullIterator();
-
-    Iterator<P2<String, String>> ids = idsTreeMap.iterator();
-    return new Iterator<String>() {
-
-      @Override
-      public boolean hasNext() {
-        if (ids.hasNext())
-          return true;
-        return false;
-      }
-
-      @Override
-      public String next() {
-        return ids.next()._1();
-      }
-
-    };
-  }
-  
   private Iterator<String> getRde(String roleId) {
 
     InterfaceTraverser traverser = roleTree.getTraverser();
 
-    Iterator<Pair<TreeNode, NodePath>> roleIterator = traverser.find((TreeNode node) -> {
+    Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = traverser.find((TreeNode node) -> {
       String element = node.getAttributes().getString("element");
       if (element == null)
         return false;
@@ -1026,12 +1074,12 @@
       return false;
     }, "Role-id", roleId);
 
-    if (!roleIterator.hasNext())
+    if (!roleIdPairIterator.hasNext())
       return new NullIterator();
 
-    Pair<TreeNode, NodePath> roleNode = roleIterator.next();
+    Pair<TreeNode, NodePath> roleIdPair = roleIdPairIterator.next();
 
-    Iterator<Pair<TreeNode, NodePath>> rdeIterator = traverser.findInSubTreeAllValue((TreeNode node) -> {
+    Iterator<Pair<TreeNode, NodePath>> rdeIdPairIterator = traverser.findInSubTreeAllValue((TreeNode node) -> {
       String element = node.getAttributes().getString("element");
       if (element == null)
         return false;
@@ -1041,26 +1089,26 @@
       if (rde != null)
         return true;
       return false;
-    }, roleNode, "text-roleDescriptionElementRefIds");
+    }, roleIdPair, "text-roleDescriptionElementRefIds");
 
-    if (!rdeIterator.hasNext())
+    if (!rdeIdPairIterator.hasNext())
       return new NullIterator();
 
     return new Iterator<String>() {
 
       @Override
       public boolean hasNext() {
-        if (rdeIterator.hasNext())
+        if (rdeIdPairIterator.hasNext())
           return true;
         return false;
       }
 
       @Override
       public String next() {
-        return rdeIterator.next().left().getAttributes().getString("text-roleDescriptionElementRefIds");
+        return rdeIdPairIterator.next().left().getAttributes().getString("text-roleDescriptionElementRefIds");
       }
     };
-       
+
   }
 
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/ChildOrganizationIdsTest.java	Sun Nov 09 20:39:27 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/ChildOrganizationIdsTest.java	Sun Nov 09 22:57:50 2014 +0900
@@ -17,16 +17,16 @@
 		Iterator<String> ids = jugrix.childOrganizationIds("o:2", list);
 		
 		Assert.assertTrue(ids.hasNext());
-
     Assert.assertEquals(ids.next(),"o:9");
+    Assert.assertTrue(ids.hasNext());
 		Assert.assertEquals(ids.next(),"o:3");
 		
     JuGrix indexJugrix = new JuGrix(true);
     ids = indexJugrix.childOrganizationIds("o:2", list);
     
     Assert.assertTrue(ids.hasNext());
-
     Assert.assertEquals(ids.next(),"o:9");
+    Assert.assertTrue(ids.hasNext());
     Assert.assertEquals(ids.next(),"o:3");
 	}
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/DeepChildOrganizationIdsTest.java	Sun Nov 09 20:39:27 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/DeepChildOrganizationIdsTest.java	Sun Nov 09 22:57:50 2014 +0900
@@ -27,7 +27,7 @@
 		Assert.assertTrue(childrenIds.hasNext());
 		childrenId = childrenIds.next();
 		Assert.assertEquals(childrenId, "o:4");
-		
+    Assert.assertFalse(childrenIds.hasNext());
 		
 		jugrix = new JuGrix(true);
     filterIds = new LinkedList<String>();
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/DeepParentOrganizationIdsPlusTest.java	Sun Nov 09 20:39:27 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/DeepParentOrganizationIdsPlusTest.java	Sun Nov 09 22:57:50 2014 +0900
@@ -15,13 +15,16 @@
 		LinkedList<String> filterIds = new LinkedList<String>();
 		//filterIds.add("r:2");
 		Iterator<String> childrenIds = jugrix.deepParentOrganizationIdsPlus("o:2", filterIds);
+		Assert.assertTrue(childrenIds.hasNext());
 		Assert.assertEquals(childrenIds.next(),"o:23");
+    Assert.assertTrue(childrenIds.hasNext());
 		Assert.assertEquals(childrenIds.next(),"o:22");
+    Assert.assertTrue(childrenIds.hasNext());
     Assert.assertEquals(childrenIds.next(),"o:2");
 		
 		filterIds.add("r:2");
 		childrenIds = jugrix.deepParentOrganizationIds("o:2", filterIds);
-		
+	  Assert.assertTrue(childrenIds.hasNext());
 		Assert.assertEquals(childrenIds.next(),"o:23");
 
 		
@@ -29,13 +32,16 @@
     filterIds = new LinkedList<String>();
     //filterIds.add("r:2");
     childrenIds = jugrix.deepParentOrganizationIdsPlus("o:2", filterIds);
+    Assert.assertTrue(childrenIds.hasNext());
     Assert.assertEquals(childrenIds.next(),"o:23");
+    Assert.assertTrue(childrenIds.hasNext());
     Assert.assertEquals(childrenIds.next(),"o:22");
+    Assert.assertTrue(childrenIds.hasNext());
     Assert.assertEquals(childrenIds.next(),"o:2");
     
     filterIds.add("r:2");
     childrenIds = jugrix.deepParentOrganizationIds("o:2", filterIds);
-    
+    Assert.assertTrue(childrenIds.hasNext());
     Assert.assertEquals(childrenIds.next(),"o:23");
 	}
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/DeepParentOrganizationIdsTest.java	Sun Nov 09 20:39:27 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/DeepParentOrganizationIdsTest.java	Sun Nov 09 22:57:50 2014 +0900
@@ -15,21 +15,28 @@
 		JuGrix jugrix = new JuGrix(false);
 		LinkedList<String> filterIds = new LinkedList<String>();
 		Iterator<String> childrenIds = jugrix.deepParentOrganizationIds("o:2", filterIds);
+		Assert.assertTrue(childrenIds.hasNext());
 		Assert.assertEquals(childrenIds.next(),"o:23");
+    Assert.assertTrue(childrenIds.hasNext());
 		Assert.assertEquals(childrenIds.next(),"o:22");
 		
 		filterIds.add("r:2");
 		childrenIds = jugrix.deepParentOrganizationIds("o:2", filterIds);
+    Assert.assertTrue(childrenIds.hasNext());
 		Assert.assertEquals(childrenIds.next(),"o:23");
 
 		jugrix = new JuGrix(true);
     filterIds = new LinkedList<String>();
     childrenIds = jugrix.deepParentOrganizationIds("o:2", filterIds);
+    Assert.assertTrue(childrenIds.hasNext());
     Assert.assertEquals(childrenIds.next(),"o:23");
+    Assert.assertTrue(childrenIds.hasNext());
     Assert.assertEquals(childrenIds.next(),"o:22");
     
+    
     filterIds.add("r:2");
     childrenIds = jugrix.deepParentOrganizationIds("o:2", filterIds);
+    Assert.assertTrue(childrenIds.hasNext());
     Assert.assertEquals(childrenIds.next(),"o:23");
 	}
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/DeepPersonIdsTest.java	Sun Nov 09 20:39:27 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/DeepPersonIdsTest.java	Sun Nov 09 22:57:50 2014 +0900
@@ -13,7 +13,7 @@
 		JuGrix jugrix = new JuGrix(false);
 		LinkedList<String> filterIds = new LinkedList<String>();
 		//filterIds.add("r:9");
-		Iterator<String> ids = jugrix.deepPersonIds("o:3",filterIds);
+		Iterator<String> ids = jugrix.deepPersonIds("o:2",filterIds);
 		System.out.println("------------------------------------------------");
 		for (;ids.hasNext();) {
 			System.out.println(ids.next());
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/PersonIdsTest.java	Sun Nov 09 20:39:27 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/PersonIdsTest.java	Sun Nov 09 22:57:50 2014 +0900
@@ -19,7 +19,7 @@
     filterIds.add("r:9");
     Iterator<String> ids = jugrix.personIds("o:2", filterIds);
 
-    ids.hasNext();
+    Assert.assertTrue(ids.hasNext());
     Assert.assertEquals(ids.next(), "p:45");
     Assert.assertEquals(ids.next(), "p:1");