--- a/src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/JuGrix.java	Wed Oct 29 15:48:19 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/JuGrix.java	Fri Nov 07 02:20:07 2014 +0900
@@ -5,6 +5,7 @@
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import ac.jp.u_ryukyu.cr.ie.tatsuki.xmlReader.loadXml;
 import fj.Ord;
 import fj.P2;
 import fj.data.TreeMap;
@@ -23,13 +24,23 @@
   JungleTree roleTree;
   JungleTree rdeTree;
 
-  public JuGrix() {
+  public JuGrix(boolean index) {
+
     try {
       loadXml reader = new loadXml();
-      personTree = reader.loadTestDataCreateIndex("Person.xml");
-      organizationTree = reader.loadTestDataCreateIndex("Organization.xml");
-      roleTree = reader.loadTestDataCreateIndex("Role.xml");
-      rdeTree = reader.loadTestDataCreateIndex("RoleDescriptionElement.xml");
+
+      if (index == true) {
+        personTree = reader.loadTestDataCreateIndex("Person.xml");
+        organizationTree = reader.loadTestDataCreateIndex("Organization.xml");
+        roleTree = reader.loadTestDataCreateIndex("Role.xml");
+        rdeTree = reader.loadTestDataCreateIndex("RoleDescriptionElement.xml");
+      } else {
+        personTree = reader.loadTestData("Person.xml");
+        organizationTree = reader.loadTestData("Organization.xml");
+        roleTree = reader.loadTestData("Role.xml");
+        rdeTree = reader.loadTestData("RoleDescriptionElement.xml");
+      }
+      
     } catch (Exception e) {
       e.printStackTrace();
     }
@@ -111,6 +122,9 @@
   public boolean filter(String orgId, LinkedList<String> roleIds) {
     if (roleIds == null)
       return true;
+    
+    if (roleIds.isEmpty())
+      return true;
 
     InterfaceTraverser orgTraverser = organizationTree.getTraverser();
 
@@ -131,27 +145,27 @@
     if (!orgNodeIterator.hasNext())
       return false;
 
-    Pair<TreeNode, NodePath> searchNode = orgNodeIterator.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, searchNode))
+        if (roleFilter(id, searchNodePair))
           return false;
       }
 
       Pattern organizationPattern = Pattern.compile("rde:");
       Matcher organizationMacher = organizationPattern.matcher(id);
       if (organizationMacher.find()) {
-        if (!rdeFilter(id, searchNode))
+        if (!rdeFilter(id, searchNodePair))
           return false;
       }
     }
     return true;
   }
 
-  private boolean rdeFilter(String id, Pair<TreeNode, NodePath> targetNode) {
+  private boolean rdeFilter(String id, Pair<TreeNode, NodePath> searchNodePair) {
 
     InterfaceTraverser orgTraverser = organizationTree.getTraverser();
     Iterator<Pair<TreeNode, NodePath>> pairIdIterator = orgTraverser.findInSubTree((TreeNode node) -> {
@@ -164,7 +178,7 @@
       if (roleId != null)
         return true;
       return false;
-    }, targetNode, "element", "roleRefId");
+    }, searchNodePair, "element", "roleRefId");
 
     TreeMap<String, String> idMap = TreeMap.empty(Ord.stringOrd);
     for (; pairIdIterator.hasNext();) {
@@ -177,7 +191,6 @@
 
     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)
@@ -191,9 +204,9 @@
           return true;
         return false;
       }, "id", roleId);
-      
       // -----------------------------------------bug------------------------------------------
       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)
@@ -208,7 +221,7 @@
           if (personMacher.find())
             return true;
           return false;
-        }, roleNodeIterator.next(), "text", "id");
+        }, rolePair, "text", "id");
 
         if (!rdeNodeIterator.hasNext())
           return false;
@@ -218,7 +231,8 @@
     return true;
   }
 
-  public boolean roleFilter(String id, Pair<TreeNode, NodePath> orgPathNodePair) {
+  public boolean roleFilter(String id, Pair<TreeNode, NodePath> searchNodePair) {
+    //System.out.println(searchNodePair.getAttributes().getString("id"));
     InterfaceTraverser orgTraverser = organizationTree.getTraverser();
 
     Iterator<Pair<TreeNode, NodePath>> pairIdIterator = orgTraverser.findInSubTree((TreeNode node) -> {
@@ -233,13 +247,13 @@
       if (roleId.equals(id))
         return true;
       return false;
-    }, orgPathNodePair, "text", id);
+    }, searchNodePair, "text", id);
 
     if (pairIdIterator.hasNext()) {
       System.out.println(pairIdIterator.next().left().getAttributes().getString("text"));
-      return true;
+      return false;
     }
-    return false;
+    return true;
   }
 
   public Iterator<String> roleIds(String id) {
@@ -292,7 +306,6 @@
         return false;
       }, searchTargetPair, "element", "roleRefId");
 
-      
       for (; pairIdIterator.hasNext();) {
         Pair<TreeNode, NodePath> idNodePath = pairIdIterator.next();
         String attribute = idNodePath.left().getAttributes().getString("text");
@@ -305,7 +318,7 @@
 
         if (attribute != null) {
           ids.add(attribute);
-          //System.out.println("-------------------------" + attribute + "-------------------------");
+          System.out.println("-------------------------" + attribute + "-------------------------");
         }
       }
     }
@@ -315,34 +328,46 @@
   public Iterator<String> competentRoleId(String personId) {
 
     InterfaceTraverser ifTraverser = personTree.getTraverser();
-    Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchPerson(personId, ifTraverser);
+    Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = ifTraverser.find((TreeNode node) -> {
+      String nodeElement = node.getAttributes().getString("element");
+      if (nodeElement == null)
+        return false;
+      if (!nodeElement.equals("Person"))
+        return false;
+      String nodeId = node.getAttributes().getString("Person-id");
+      if (nodeId == null)
+        return false;
+      if (nodeId.equals(personId))
+        return true;
+      return false;
+    }, "Person-id", personId);
 
     if (!pairPersonIterator.hasNext())
       return new NullIterator();
-     Pair<TreeNode, NodePath> personPathNodePair = pairPersonIterator.next();
-     TreeNode person = personPathNodePair.left();
-     
+    Pair<TreeNode, NodePath> person = pairPersonIterator.next();
+
     Iterator<Pair<TreeNode, NodePath>> targetPairIterator = ifTraverser.findInSubTree((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");
+      String priority = node.getAttributes().getString("text-priority");
       if (priority == null)
         return false;
       if (priority.equals("0"))
         return true;
       return false;
-    }, personPathNodePair, "text", "0");
+    }, person, "text-priority", "0");
 
     LinkedList<String> idList = new LinkedList<String>();
     for (; targetPairIterator.hasNext();) {
       NodePath searchPath = targetPairIterator.next().right();
       Pair<Integer, NodePath> searchPair = searchPath.last();
       NodePath targetPath = searchPair.right().add(searchPair.left() + 1);
-      TreeNode targetNode = getTarget(person, targetPath);
-      String id = targetNode.getAttributes().getString("text");
+      TreeNode targetNode = getTarget(personTree.getRootNode(), targetPath);
+      // TreeNode targetNode = getTarget(person.left(), targetPath);
+      String id = targetNode.getAttributes().getString("text-roleRefId");
       idList.add(id);
     }
 
@@ -356,9 +381,8 @@
 
     if (!pairPersonIterator.hasNext())
       return new NullIterator();
-    
-    Pair<TreeNode, NodePath> personNodePathPair = pairPersonIterator.next();
-    TreeNode person = personNodePathPair.left();
+    Pair<TreeNode, NodePath> person = pairPersonIterator.next();
+
     Iterator<Pair<TreeNode, NodePath>> targetPairIterator = ifTraverser.findInSubTree((TreeNode node) -> {
       String nodeElement = node.getAttributes().getString("element");
       if (nodeElement == null)
@@ -371,15 +395,14 @@
       if (!priority.equals("0"))
         return true;
       return false;
-    }, personNodePathPair, "text", "0");
+    }, person, "text", "0");
 
-    
     LinkedList<String> idList = new LinkedList<String>();
     for (; targetPairIterator.hasNext();) {
       NodePath searchPath = targetPairIterator.next().right();
       Pair<Integer, NodePath> searchPair = searchPath.last();
       NodePath targetPath = searchPair.right().add(searchPair.left() + 1);
-      TreeNode targetNode = getTarget(person, targetPath);
+      TreeNode targetNode = getTarget(person.left(), targetPath);
       String id = targetNode.getAttributes().getString("text");
       idList.add(id);
     }
@@ -387,22 +410,6 @@
     return idList.iterator();
   }
 
-  private Iterator<Pair<TreeNode, NodePath>> searchPerson(String personId, InterfaceTraverser ifTraverser) {
-    Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = ifTraverser.find((TreeNode node) -> {
-      String nodeElement = node.getAttributes().getString("element");
-      if (nodeElement == null)
-        return false;
-      if (!nodeElement.equals("Person"))
-        return false;
-      String nodeId = node.getAttributes().getString("id");
-      if (nodeId == null)
-        return false;
-      if (nodeId.equals(personId))
-        return true;
-      return false;
-    }, "element", "Person");
-    return pairPersonIterator;
-  }
 
   public Iterator<String> deepPersonIds(String orgId, LinkedList<String> filterIds) {
 
@@ -450,26 +457,27 @@
   }
 
   public Iterator<String> childOrganizationIds(String orgId, LinkedList<String> filterIds) {
-    if (!filter(orgId, filterIds))
-      return new NullIterator();
+
     InterfaceTraverser orgTraverser = organizationTree.getTraverser();
+
     Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = orgTraverser.find((TreeNode node) -> {
       String nodeElement = node.getAttributes().getString("element");
       if (nodeElement == null)
         return false;
       if (!nodeElement.equals("Organization"))
         return false;
-      String nodeId = node.getAttributes().getString("id");
+      String nodeId = node.getAttributes().getString("Organization-id");
       if (nodeId == null)
         return false;
       if (nodeId.equals(orgId))
         return true;
       return false;
-    }, "id", orgId);
+    }, "Organization-id", orgId);
 
     if (!pairPersonIterator.hasNext())
       return new NullIterator();
-    Pair<TreeNode, NodePath> personPathNodePair = pairPersonIterator.next();
+
+    Pair<TreeNode, NodePath> person = pairPersonIterator.next();
 
     Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdsIterator = orgTraverser.findInSubTree((TreeNode node) -> {
       String nodeElement = node.getAttributes().getString("element");
@@ -478,32 +486,32 @@
       if (nodeElement.equals("childOrganizations"))
         return true;
       return false;
-    }, personPathNodePair, "element", "childOrganizations");
+    }, person, "element", "childOrganizations");
 
     if (!chilrenOrgIdsIterator.hasNext())
       return new NullIterator();
 
-     Pair<TreeNode, NodePath> chilerenOrgIdsPathNodePair = chilrenOrgIdsIterator.next();
+    Pair<TreeNode, NodePath> chilerenOrgIds = chilrenOrgIdsIterator.next();
 
-    Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdIterator = orgTraverser.findInSubTreeAllValue((TreeNode node) -> {
+    Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdIterator = orgTraverser.findInSubTree((TreeNode node) -> {
       String nodeElement = node.getAttributes().getString("element");
       if (nodeElement == null)
         return false;
       if (!nodeElement.equals("organizationRefIds"))
         return false;
-      nodeElement = node.getAttributes().getString("text");
+      nodeElement = node.getAttributes().getString("text-organizationRefIds");
       if (nodeElement != null)
         return true;
       return false;
-    }, chilerenOrgIdsPathNodePair, "text");
+    }, chilerenOrgIds, "text-organizationRefIds", null);
 
     LinkedList<String> ids = new LinkedList<String>();
 
     for (; chilrenOrgIdIterator.hasNext();) {
-      Pair<TreeNode, NodePath> aaa = chilrenOrgIdIterator.next();
-      String path = aaa.right().toString();
-      String id = aaa.left().getAttributes().getString("text");
-      ids.add(id);
+      String childrenOrgId = chilrenOrgIdIterator.next().left().getAttributes().getString("text-organizationRefIds");
+      if (filter(childrenOrgId, filterIds))
+        ids.add(childrenOrgId);
+
     }
 
     return ids.iterator();
@@ -544,7 +552,6 @@
   }
 
   public String rolePriority(String personId, String roleId) {
-    
     InterfaceTraverser personTraverser = personTree.getTraverser();
     Iterator<Pair<TreeNode, NodePath>> personIterator = personTraverser.find((TreeNode node) -> {
       String element = node.getAttributes().getString("element");
@@ -563,9 +570,8 @@
     if (!personIterator.hasNext())
       return "";
 
-     Pair<TreeNode, NodePath> targetPersonPathNodePair = personIterator.next();
-     TreeNode targetPersonNode = targetPersonPathNodePair.left();
-     
+    Pair<TreeNode, NodePath> targetNode = personIterator.next();
+
     Iterator<Pair<TreeNode, NodePath>> priorityIterator = personTraverser.findInSubTree((TreeNode node) -> {
       String element = node.getAttributes().getString("element");
       if (element == null)
@@ -578,14 +584,14 @@
       if (compareRoleId.equals(roleId))
         return true;
       return false;
-    }, targetPersonPathNodePair, "element", "roleRefId");
+    }, targetNode, "element", "roleRefId");
 
     for (; priorityIterator.hasNext();) {
       Pair<TreeNode, NodePath> priorityPair = priorityIterator.next();
       NodePath roleNodePath = priorityPair.right();
       Pair<Integer, NodePath> last = roleNodePath.last();
       NodePath priorityNodePath = last.right().add(last.left() - 1);
-      TreeNode priorityNode = getTarget(targetPersonNode, priorityNodePath);
+      TreeNode priorityNode = getTarget(targetNode.left(), priorityNodePath);
       if (priorityNode.getAttributes().getString("element").equals("priority"))
         return priorityNode.getAttributes().getString("text");
     }
@@ -616,6 +622,8 @@
     if (!orgIterator.hasNext())
       return new LinkedList<String>();
 
+    Pair<TreeNode, NodePath> orgNode = orgIterator.next();
+
     Iterator<Pair<TreeNode, NodePath>> parentOrgIterator = orgTraverser.findInSubTree((TreeNode node) -> {
       String element = node.getAttributes().getString("element");
       if (element == null)
@@ -623,12 +631,12 @@
       if (element.equals("parentOrganizations"))
         return true;
       return false;
-    }, orgIterator.next(), "element", "parentOrganizations");
+    }, orgNode, "element", "parentOrganizations");
 
     LinkedList<String> parentIds = new LinkedList<String>();
 
     for (; parentOrgIterator.hasNext();) {
-       Pair<TreeNode, NodePath> parentOrgPathNodePair = parentOrgIterator.next();
+      Pair<TreeNode, NodePath> parentOrgNode = parentOrgIterator.next();
 
       Iterator<Pair<TreeNode, NodePath>> parentNodeIterator = orgTraverser.findInSubTree((TreeNode node) -> {
         String element = node.getAttributes().getString("element");
@@ -640,7 +648,7 @@
         if (parentId != null)
           return true;
         return false;
-      }, parentOrgPathNodePair, "element", "organizationRefId");
+      }, parentOrgNode, "element", "organizationRefId");
 
       for (; parentNodeIterator.hasNext();) {
         String parentId = parentNodeIterator.next().left().getAttributes().getString("text");
@@ -730,22 +738,6 @@
   }
 
   public Iterator<String> roleDescriptionElementIds(String id, LinkedList<String> filterIds) {
-    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 _roleDescriptionElementIds(id, filterIds);
-    }
-
-    return null;
-  }
-
-  public Iterator<String> _roleDescriptionElementIds(String id, LinkedList<String> filterIds) {
 
     Iterator<String> orgIds = deepParentOrganizationIdsPlus(id, filterIds);
 
@@ -789,6 +781,7 @@
     if (!roleIterator.hasNext())
       return "";
 
+    Pair<TreeNode, NodePath> roleNode = roleIterator.next();
 
     Iterator<Pair<TreeNode, NodePath>> rdeIterator = traverser.findInSubTree((TreeNode node) -> {
       String element = node.getAttributes().getString("element");
@@ -800,7 +793,7 @@
       if (rde != null)
         return true;
       return false;
-    }, roleIterator.next(), "element", "roleDescriptionElementRefIds");
+    }, roleNode, "element", "roleDescriptionElementRefIds");
 
     if (!rdeIterator.hasNext())
       return "";