# HG changeset patch
# User one
# Date 1414445687 -32400
# Node ID ef3fae2e7f0c49a61be2bb99122fb126d73b0114
# Parent  6f9439ca3eb52bb7c45ac9c929f5ac7cc3bb9e8e
add ReadXmlNodeCreateIndexJandler and ReadXmlPutAttributeCreate
query use Index but 13/15 error

diff -r 6f9439ca3eb5 -r ef3fae2e7f0c src/main/java/ac/jp/u_ryukyu/cr/ie/tatsuki/xmlReader/ReadXmlNodeCreateIndexHandler.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/ac/jp/u_ryukyu/cr/ie/tatsuki/xmlReader/ReadXmlNodeCreateIndexHandler.java	Tue Oct 28 06:34:47 2014 +0900
@@ -0,0 +1,75 @@
+package ac.jp.u_ryukyu.cr.ie.tatsuki.xmlReader;
+
+import java.nio.ByteBuffer;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
+
+import org.xml.sax.*;
+import org.xml.sax.helpers.*;
+
+public class ReadXmlNodeCreateIndexHandler extends DefaultHandler {
+  private JungleTree tree;
+  private JungleTreeEditor editor;
+  private NodePath path;
+
+  public ReadXmlNodeCreateIndexHandler(JungleTree tree) {
+    this.tree = tree;
+    this.editor = tree.getTreeEditor();
+    this.path = new DefaultNodePath().add(-1);
+  }
+
+  @Override
+  public void startElement(String uri, String localName, String qName, Attributes attributes) {
+    Pair<Integer, NodePath> nodePair = path.last();
+    path = nodePair.right();
+    int num = nodePair.left() + 1;
+
+    Either<Error, JungleTreeEditor> either = editor.addNewChildAt(path, num);
+    if (either.isA()) {
+      // error
+    }
+    this.editor = either.b();
+
+    path = path.add(num);
+    path = path.add(-1);
+  }
+
+
+  @Override
+  public void endElement(String namespaceURI, String localName, String qName) {
+    path = path.tail();
+    if (namespaceURI != "") {
+      // System.out.println("namespaceURI= " + namespaceURI);
+    }
+    if (localName != "") {
+      // System.out.println("localName= " + localName);
+    }
+
+    if (qName != "") {
+      // System.out.println("qName= " + qName);
+    }
+  }
+
+
+  @Override
+  public void endDocument() {
+    Either<Error, JungleTreeEditor> either = editor.success();
+    if (either.isA()) {
+      // error
+    }
+    // System.out.println("end");
+  }
+
+  public JungleTree getTree() {
+    return tree;
+  }
+
+}
diff -r 6f9439ca3eb5 -r ef3fae2e7f0c src/main/java/ac/jp/u_ryukyu/cr/ie/tatsuki/xmlReader/ReadXmlPutAttributeCreateIndex.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/ac/jp/u_ryukyu/cr/ie/tatsuki/xmlReader/ReadXmlPutAttributeCreateIndex.java	Tue Oct 28 06:34:47 2014 +0900
@@ -0,0 +1,124 @@
+package ac.jp.u_ryukyu.cr.ie.tatsuki.xmlReader;
+
+import java.nio.ByteBuffer;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
+import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
+
+import org.xml.sax.*;
+import org.xml.sax.helpers.*;
+
+import fj.test.reflect.Name;
+
+public class ReadXmlPutAttributeCreateIndex extends DefaultHandler {
+  private JungleTree tree;
+  private JungleTreeEditor editor;
+  private NodePath path;
+  
+  public ReadXmlPutAttributeCreateIndex(JungleTree tree){
+    this.tree = tree;
+    this.editor = tree.getIndexTreeEditor();
+    this.path = new DefaultNodePath().add(-1);
+  }
+  
+  @Override
+  public void startElement(String uri, String localName,String qName, Attributes attributes) {
+    Pair<Integer, NodePath> nodePair = path.last();
+    path = nodePair.right();
+    int num = nodePair.left() + 1;    
+    path = path.add(num);
+    //System.out.println(path.toString());
+
+    
+    if (uri != "") {
+    //  System.out.println("namespaceURI= " + uri);
+    }
+
+    if (localName != "") {
+    //  System.out.println("localName= " + localName);
+    }
+
+    if (qName != "") {
+    //  System.out.println("qName= " + qName);
+      Either<Error, JungleTreeEditor> newEither = editor.putAttribute(path, "element", ByteBuffer.wrap(qName.getBytes()));
+      if (newEither.isA()) {
+        //error       
+      }
+      this.editor = newEither.b();
+    }
+
+    if (attributes.getLength() != 0) {
+      for (int count = 0 ;attributes.getLength() > count; count++) {
+    //    System.out.println(attributes.getLocalName(count) + " = " + attributes.getValue(count));
+        String key = attributes.getLocalName(count);
+        String value = attributes.getValue(count);
+        ByteBuffer bValue = ByteBuffer.wrap(value.getBytes());
+        Either<Error, JungleTreeEditor> newEither = editor.putAttribute(path,key , bValue);
+        if (newEither.isA()) {
+          //error
+        }
+        this.editor = newEither.b();
+      }
+    }
+    path = path.add(-1);
+  }
+
+  @Override
+  public void characters(char[] ch, int start, int length) {
+      String str = new String(ch, start, length);
+      Pattern pattern = Pattern.compile("\n");
+      Matcher macher = pattern.matcher(str);
+      
+      if (!macher.find()) {
+        Pair<Integer, NodePath> nodePair = path.last();
+        NodePath onePath = nodePair.right();
+        //System.out.println(str);
+        Either<Error, JungleTreeEditor> newEither = editor.putAttribute(onePath, "text", ByteBuffer.wrap(str.getBytes()));
+        if (newEither.isA()) {
+          //error
+        }
+        this.editor = newEither.b();
+    }
+  }
+
+  @Override
+  public void endElement(String namespaceURI, String localName, String qName) {
+    path = path.tail();
+    if (namespaceURI != "") {
+    //  System.out.println("namespaceURI= " + namespaceURI);
+    }
+    if (localName != "") {
+    //  System.out.println("localName= " + localName);
+    }
+
+    if (qName != "") {
+    //  System.out.println("qName= " + qName);
+    }
+  }
+
+  @Override
+  public void startDocument() {
+  //  System.out.println("start");
+  }
+
+  @Override
+  public void endDocument() {
+    Either<Error, JungleTreeEditor> either = editor.success();
+    if (either.isA()) {
+      //error
+    }
+  //  System.out.println("end");
+  }
+
+  public JungleTree getTree(){
+    return tree;
+  }
+
+}
diff -r 6f9439ca3eb5 -r ef3fae2e7f0c src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/JuGrix.java
--- a/src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/JuGrix.java	Mon Oct 27 18:06:23 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/JuGrix.java	Tue Oct 28 06:34:47 2014 +0900
@@ -17,825 +17,795 @@
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
 
 public class JuGrix {
-	
-	JungleTree personTree;
-	JungleTree organizationTree;
-	JungleTree roleTree;
-	JungleTree rdeTree;
-	public JuGrix(){
-		try{
-			loadXml reader = new loadXml();
-			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();
-		}
-	}
-	
-	public boolean isActive(String id){
-		
-		InterfaceTraverser ifTraverser = personTree.getTraverser();
-		Iterator<Pair<TreeNode,NodePath>> pairIterator = ifTraverser.find(
-				(TreeNode node) -> {
-					String personId = node.getAttributes().getString("id");
-					if (personId == null)
-						return false;
-					if (personId.equals(id)) 
-						return true;
-					return false;
-				}
-				,"id",id);
+
+  JungleTree personTree;
+  JungleTree organizationTree;
+  JungleTree roleTree;
+  JungleTree rdeTree;
+
+  public JuGrix() {
+    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");
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+
+  public boolean isActive(String id) {
+
+    InterfaceTraverser ifTraverser = personTree.getTraverser();
+    Iterator<Pair<TreeNode, NodePath>> pairIterator = ifTraverser.find((TreeNode node) -> {
+      String personId = node.getAttributes().getString("id");
+      if (personId == null)
+        return false;
+      if (personId.equals(id))
+        return true;
+      return false;
+    }, "id", id);
+
+    if (pairIterator.hasNext())
+      return true;
+    return false;
+
+  }
+
+  public Iterator<String> personIds(String orgId, LinkedList<String> roleIds) {
+    return personIdsSearch(orgId, roleIds).iterator();
+  }
+
+  public LinkedList<String> personIdLink(String orgId, LinkedList<String> roleIds) {
+    return personIdsSearch(orgId, roleIds);
+  }
+
+  public Iterator<String> personIds(LinkedList<String> orgIds, LinkedList<String> roleIds) {
+
+    LinkedList<String> personIds = new LinkedList<String>();
+
+    for (String orgId : orgIds) {
+      personIds.addAll(personIdsSearch(orgId, roleIds));
+    }
+    return personIds.iterator();
+  }
+
+  private LinkedList<String> personIdsSearch(String id, LinkedList<String> roleIds) {
+
+    if (!filter(id, roleIds))
+      return new LinkedList<String>();
+
+    InterfaceTraverser personTraverser = personTree.getTraverser();
+    Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = personTraverser.find((TreeNode node) -> {
+      String personId = node.getAttributes().getString("element");
+      if (personId == null)
+        return false;
+      if (personId.equals("Person"))
+        return true;
+      return false;
+    }, "element", "Person");
+
+    LinkedList<String> names = new LinkedList<String>();
+
+    for (; pairPersonIterator.hasNext();) {
+
+      Pair<TreeNode, NodePath> pairPerson = pairPersonIterator.next();
+      Iterator<Pair<TreeNode, NodePath>> pairIdIterator = personTraverser.findInSubTree((TreeNode node) -> {
+        String personId = node.getAttributes().getString("text");
+        if (personId == null)
+          return false;
+        if (personId.equals(id))
+          return true;
+        return false;
+      }, pairPerson, "text", id);
+
+      if (pairIdIterator.hasNext()) {
+        String name = pairPerson.left().getAttributes().getString("id");
+        names.add(name);
+      }
+    }
+    return names;
+  }
+
+  public boolean filter(String orgId, LinkedList<String> roleIds) {
+    if (roleIds == null)
+      return true;
+
+    InterfaceTraverser orgTraverser = organizationTree.getTraverser();
+
+    Iterator<Pair<TreeNode, NodePath>> orgNodeIterator = orgTraverser.find((TreeNode node) -> {
+      String personId = node.getAttributes().getString("element");
+      if (personId == null)
+        return false;
+      if (!personId.equals("Organization"))
+        return false;
+      String compareOrgId = node.getAttributes().getString("id");
+      if (compareOrgId == null)
+        return false;
+      if (compareOrgId.equals(orgId))
+        return true;
+      return false;
+    }, "id", orgId);
+
+    if (!orgNodeIterator.hasNext())
+      return false;
+
+    Pair<TreeNode, NodePath> searchNode = orgNodeIterator.next();
+
+    for (String id : roleIds) {
+      Pattern personPattern = Pattern.compile("r:");
+      Matcher personMacher = personPattern.matcher(id);
+      if (personMacher.find()) {
+        if (!roleFilter(id, searchNode))
+          return false;
+      }
+
+      Pattern organizationPattern = Pattern.compile("rde:");
+      Matcher organizationMacher = organizationPattern.matcher(id);
+      if (organizationMacher.find()) {
+        if (!rdeFilter(id, searchNode))
+          return false;
+      }
+    }
+    return true;
+  }
+
+  private boolean rdeFilter(String id, Pair<TreeNode, NodePath> targetNode) {
+
+    InterfaceTraverser orgTraverser = organizationTree.getTraverser();
+    Iterator<Pair<TreeNode, NodePath>> pairIdIterator = orgTraverser.findInSubTree((TreeNode node) -> {
+      String element = node.getAttributes().getString("element");
+      if (element == null)
+        return false;
+      if (!element.equals("roleRefId"))
+        return false;
+      String roleId = node.getAttributes().getString("text");
+      if (roleId != null)
+        return true;
+      return false;
+    }, targetNode, "element", "roleRefId");
+
+    TreeMap<String, String> idMap = TreeMap.empty(Ord.stringOrd);
+    for (; pairIdIterator.hasNext();) {
+      String roleId = pairIdIterator.next().left().getAttributes().getString("text");
+      idMap = idMap.set(roleId, roleId);
+    }
+
+    Iterator<P2<String, String>> ids = idMap.iterator();
+    InterfaceTraverser roleTraverser = roleTree.getTraverser();
+
+    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;
+        if (!element.equals("Role"))
+          return false;
+        String compareRoleId = node.getAttributes().getString("id");
+        if (compareRoleId == null)
+          return false;
+        if (compareRoleId.equals(roleId))
+          return true;
+        return false;
+      }, "id", roleId);
+      
+      // -----------------------------------------bug------------------------------------------
+      for (; roleNodeIterator.hasNext();) {
+        Iterator<Pair<TreeNode, NodePath>> rdeNodeIterator = roleTraverser.findInSubTree((TreeNode node) -> {
+          String elementName = node.getAttributes().getString("element");
+          if (elementName == null)
+            return false;
+          if (!elementName.equals("roleDescriptionElementRefIds"))
+            return false;
+          String rdeId = node.getAttributes().getString("text");
+          if (rdeId == null)
+            return false;
+          Pattern personPattern = Pattern.compile(id);
+          Matcher personMacher = personPattern.matcher(rdeId);
+          if (personMacher.find())
+            return true;
+          return false;
+        }, roleNodeIterator.next(), "text", "id");
+
+        if (!rdeNodeIterator.hasNext())
+          return false;
+      }
+
+    }
+    return true;
+  }
+
+  public boolean roleFilter(String id, Pair<TreeNode, NodePath> orgPathNodePair) {
+    InterfaceTraverser orgTraverser = organizationTree.getTraverser();
+
+    Iterator<Pair<TreeNode, NodePath>> pairIdIterator = orgTraverser.findInSubTree((TreeNode node) -> {
+      String elementName = node.getAttributes().getString("element");
+      if (elementName == null)
+        return false;
+      if (!elementName.equals("roleRefIds"))
+        return false;
+      String roleId = node.getAttributes().getString("text");
+      if (roleId == null)
+        return false;
+      if (roleId.equals(id))
+        return true;
+      return false;
+    }, orgPathNodePair, "text", id);
+
+    if (pairIdIterator.hasNext()) {
+      System.out.println(pairIdIterator.next().left().getAttributes().getString("text"));
+      return true;
+    }
+    return false;
+  }
+
+  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("id");
+      if (nodeId == null)
+        return false;
+      if (nodeId.equals(id))
+        return true;
+      return false;
+    }, "id", id);
+
+    LinkedList<String> ids = new LinkedList<String>();
+
+    for (; searchTargetIterator.hasNext();) {
+
+      Pair<TreeNode, NodePath> searchTargetPair = searchTargetIterator.next();
+      Iterator<Pair<TreeNode, NodePath>> pairIdIterator = ifTraverser.findInSubTree((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");
+        if (nodeId != null)
+          return true;
+        return false;
+      }, searchTargetPair, "element", "roleRefId");
+
+      
+      for (; pairIdIterator.hasNext();) {
+        Pair<TreeNode, NodePath> idNodePath = pairIdIterator.next();
+        String attribute = idNodePath.left().getAttributes().getString("text");
+
+        Iterator<String> checkList = ids.iterator();
+        for (; checkList.hasNext();) {
+          if (checkList.next().equals(attribute))
+            attribute = null;
+        }
+
+        if (attribute != null) {
+          ids.add(attribute);
+          //System.out.println("-------------------------" + attribute + "-------------------------");
+        }
+      }
+    }
+    return ids.iterator();
+  }
+
+  public Iterator<String> competentRoleId(String personId) {
+
+    InterfaceTraverser ifTraverser = personTree.getTraverser();
+    Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchPerson(personId, ifTraverser);
+
+    if (!pairPersonIterator.hasNext())
+      return new NullIterator();
+     Pair<TreeNode, NodePath> personPathNodePair = pairPersonIterator.next();
+     TreeNode person = personPathNodePair.left();
+     
+    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");
+      if (priority == null)
+        return false;
+      if (priority.equals("0"))
+        return true;
+      return false;
+    }, personPathNodePair, "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);
+      String id = targetNode.getAttributes().getString("text");
+      idList.add(id);
+    }
+
+    return idList.iterator();
+  }
+
+  public Iterator<String> concurrentRoleIds(String personId) {
+
+    InterfaceTraverser ifTraverser = personTree.getTraverser();
+    Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchPerson(personId, ifTraverser);
+
+    if (!pairPersonIterator.hasNext())
+      return new NullIterator();
+    
+    Pair<TreeNode, NodePath> personNodePathPair = pairPersonIterator.next();
+    TreeNode person = personNodePathPair.left();
+    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");
+      if (priority == null)
+        return false;
+      if (!priority.equals("0"))
+        return true;
+      return false;
+    }, personNodePathPair, "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);
+      String id = targetNode.getAttributes().getString("text");
+      idList.add(id);
+    }
+
+    return idList.iterator();
+  }
 
-		if (pairIterator.hasNext())
-			return true;
-		return false;
-		
-	}
-	
-	public Iterator<String> personIds(String orgId, LinkedList<String> roleIds){
-		return personIdsSearch(orgId, roleIds).iterator();
-	}
-	
-	public LinkedList<String> personIdLink(String orgId, LinkedList<String> roleIds){
-		return personIdsSearch(orgId, roleIds);
-	}
-	
-	public Iterator<String> personIds(LinkedList<String> orgIds ,LinkedList<String> roleIds){
-		
-		LinkedList<String> personIds = new LinkedList<String>();
+  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) {
+
+    Iterator<String> childrensIterator = deepChildOrganizationIds(orgId, new LinkedList<String>());
+    if (!childrensIterator.hasNext())
+      return new NullIterator();
+
+    LinkedList<String> childrenPersonList = new LinkedList<String>();
+    // childrenPersonList.addAll(personIdLink(orgId, filterIds));
+    for (; childrensIterator.hasNext();) {
+      String id = childrensIterator.next();
+      childrenPersonList.addAll(personIdLink(id, filterIds));
+    }
+
+    return childrenPersonList.iterator();
+  }
+
+  public Iterator<String> deepChildOrganizationIdsPlus(String orgId, LinkedList<String> filterIds) {
+    LinkedList<String> orgList = new LinkedList<String>();
+    if (filter(orgId, filterIds))
+      orgList.add(orgId);
+    orgList.addAll(_deepChildOrganizationIds(orgId, filterIds));
+    return orgList.iterator();
+  }
+
+  public Iterator<String> deepChildOrganizationIds(String orgId, LinkedList<String> filterIds) {
+    return _deepChildOrganizationIds(orgId, filterIds).iterator();
+  }
+
+  public LinkedList<String> _deepChildOrganizationIds(String orgId, LinkedList<String> filterIds) {
+
+    Iterator<String> childrensIterator = childOrganizationIds(orgId, new LinkedList<String>());
+    if (!childrensIterator.hasNext())
+      return new LinkedList<String>();
+
+    LinkedList<String> childrenList = new LinkedList<String>();
+    for (; childrensIterator.hasNext();) {
+      String childrenId = childrensIterator.next();
+      if (filter(childrenId, filterIds))
+        childrenList.add(childrenId);
+      childrenList.addAll(_deepChildOrganizationIds(childrenId, filterIds));
+    }
+
+    return childrenList;
+  }
+
+  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");
+      if (nodeId == null)
+        return false;
+      if (nodeId.equals(orgId))
+        return true;
+      return false;
+    }, "id", orgId);
+
+    if (!pairPersonIterator.hasNext())
+      return new NullIterator();
+    Pair<TreeNode, NodePath> personPathNodePair = pairPersonIterator.next();
+
+    Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdsIterator = orgTraverser.findInSubTree((TreeNode node) -> {
+      String nodeElement = node.getAttributes().getString("element");
+      if (nodeElement == null)
+        return false;
+      if (nodeElement.equals("childOrganizations"))
+        return true;
+      return false;
+    }, personPathNodePair, "element", "childOrganizations");
+
+    if (!chilrenOrgIdsIterator.hasNext())
+      return new NullIterator();
+
+     Pair<TreeNode, NodePath> chilerenOrgIdsPathNodePair = chilrenOrgIdsIterator.next();
+
+    Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdIterator = 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");
+      if (nodeElement != null)
+        return true;
+      return false;
+    }, chilerenOrgIdsPathNodePair, "text");
+
+    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);
+    }
+
+    return ids.iterator();
+  }
+
+  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);
+
+    Either<Error, TreeNode> either = node.getChildren().at(num);
+    if (either.isA())
+      return node;
+
+    TreeNode child = either.b();
+    if (pathNode.right().size() == 0)
+      return child;
+
+    target = getTarget(child, pathNode.right());
+    return target;
+  }
+
+  class NullIterator implements Iterator<String> {
+
+    @Override
+    public boolean hasNext() {
+      return false;
+    }
+
+    @Override
+    public String next() {
+      return null;
+    }
+
+  }
+
+  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");
+      if (element == null)
+        return false;
+      if (!element.equals("Person"))
+        return false;
+      String nodeId = node.getAttributes().getString("id");
+      if (nodeId == null)
+        return false;
+      if (nodeId.equals(personId))
+        return true;
+      return false;
+    }, "id", personId);
+
+    if (!personIterator.hasNext())
+      return "";
+
+     Pair<TreeNode, NodePath> targetPersonPathNodePair = personIterator.next();
+     TreeNode targetPersonNode = targetPersonPathNodePair.left();
+     
+    Iterator<Pair<TreeNode, NodePath>> priorityIterator = personTraverser.findInSubTree((TreeNode node) -> {
+      String element = node.getAttributes().getString("element");
+      if (element == null)
+        return false;
+      if (!element.equals("roleRefId"))
+        return false;
+      String compareRoleId = node.getAttributes().getString("text");
+      if (compareRoleId == null)
+        return false;
+      if (compareRoleId.equals(roleId))
+        return true;
+      return false;
+    }, targetPersonPathNodePair, "element", "roleRefId");
 
-		for (String orgId : orgIds) {
-			personIds.addAll(personIdsSearch(orgId, roleIds));
-		}
-		return personIds.iterator();
-	}
-	
-	private LinkedList<String> personIdsSearch(String id, LinkedList<String> roleIds) {
-		
-		if (!filter(id, roleIds))
-			return new LinkedList<String>();
-			
-		InterfaceTraverser personTraverser = personTree.getTraverser();
-		Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = personTraverser.find(
-				(TreeNode node) -> {
-					String personId = node.getAttributes().getString("element");
-					if (personId == null)
-						return false;
-					if (personId.equals("Person")) 
-						return true;
-					return false;
-				}
-				,"element","Person");
-		
-		LinkedList<String> names = new LinkedList<String>();
-		
-		for (;pairPersonIterator.hasNext();) {
-			
-			Pair<TreeNode, NodePath> pairPerson = pairPersonIterator.next();
-			Iterator<Pair<TreeNode,NodePath>> pairIdIterator = personTraverser.findInSubTree(
-					(TreeNode node) -> {
-						String personId = node.getAttributes().getString("text");
-						if (personId == null)
-							return false;
-						if (personId.equals(id)) 
-							return true;
-						return false;
-					}
-					,pairPerson.left(),"text",id);
-			
-			if (pairIdIterator.hasNext()) {
-					String name = pairPerson.left().getAttributes().getString("id");
-					names.add(name);
-			}
-		}
-		return names;
-	}
+    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);
+      if (priorityNode.getAttributes().getString("element").equals("priority"))
+        return priorityNode.getAttributes().getString("text");
+    }
+    return "";
+  }
+
+  public Iterator<String> parentOrganizationIds(String orgId, LinkedList<String> filterIds) {
+    return _parentOrganizationIds(orgId, filterIds).iterator();
+  }
+
+  public LinkedList<String> _parentOrganizationIds(String orgId, LinkedList<String> filterIds) {
+
+    InterfaceTraverser orgTraverser = organizationTree.getTraverser();
+    Iterator<Pair<TreeNode, NodePath>> orgIterator = orgTraverser.find((TreeNode node) -> {
+      String element = node.getAttributes().getString("element");
+      if (element == null)
+        return false;
+      if (!element.equals("Organization"))
+        return false;
+      String nodeId = node.getAttributes().getString("id");
+      if (nodeId == null)
+        return false;
+      if (nodeId.equals(orgId))
+        return true;
+      return false;
+    }, "element", "Organization");
+
+    if (!orgIterator.hasNext())
+      return new LinkedList<String>();
+
+    Iterator<Pair<TreeNode, NodePath>> parentOrgIterator = orgTraverser.findInSubTree((TreeNode node) -> {
+      String element = node.getAttributes().getString("element");
+      if (element == null)
+        return false;
+      if (element.equals("parentOrganizations"))
+        return true;
+      return false;
+    }, orgIterator.next(), "element", "parentOrganizations");
+
+    LinkedList<String> parentIds = new LinkedList<String>();
+
+    for (; parentOrgIterator.hasNext();) {
+       Pair<TreeNode, NodePath> parentOrgPathNodePair = parentOrgIterator.next();
+
+      Iterator<Pair<TreeNode, NodePath>> parentNodeIterator = orgTraverser.findInSubTree((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");
+        if (parentId != null)
+          return true;
+        return false;
+      }, parentOrgPathNodePair, "element", "organizationRefId");
+
+      for (; parentNodeIterator.hasNext();) {
+        String parentId = parentNodeIterator.next().left().getAttributes().getString("text");
+        if (filter(parentId, filterIds))
+          parentIds.add(parentId);
+      }
+
+    }
+
+    return parentIds;
+  }
+
+  public Iterator<String> deepParentOrganizationIds(String orgId, LinkedList<String> filterIds) {
+    return _deepParentOrganizationIds(orgId, filterIds).iterator();
+  }
+
+  public LinkedList<String> _deepParentOrganizationIds(String orgId, LinkedList<String> filterIds) {
+
+    Iterator<String> parentIds = parentOrganizationIds(orgId, filterIds);
+    if (!parentIds.hasNext())
+      return new LinkedList<String>();
+
+    LinkedList<String> parentIdList = new LinkedList<String>();
+
+    for (; parentIds.hasNext();) {
+      String parentId = parentIds.next();
+      if (filter(parentId, filterIds))
+        parentIdList.add(parentId);
+      parentIdList.addAll(_deepParentOrganizationIds(parentId, filterIds));
+    }
+    return parentIdList;
+  }
+
+  public Iterator<String> deepParentOrganizationIdsPlus(String id, LinkedList<String> filterIds) {
+    LinkedList<String> parentIds = new LinkedList<String>();
+    if (filter(id, filterIds))
+      parentIds.add(id);
+    parentIds.addAll(_deepParentOrganizationIds(id, filterIds));
+    return parentIds.iterator();
+  }
+
+  public String stringPathToId(String args) {
+    String[] splitPath = args.split(":");
+
+    String str = splitPath[2];
+    for (int count = 3; count < splitPath.length; count++) {
+      str = str + ":" + splitPath[count];
+    }
+
+    final String StrPath = str;
+
+    InterfaceTraverser traverser = null;
+    TreeNode root = null;
+    if (splitPath[0].equals("r")) {
+      traverser = roleTree.getTraverser();
+      root = roleTree.getRootNode();
+    }
+    if (splitPath[0].equals("rde")) {
+      traverser = rdeTree.getTraverser();
+      root = rdeTree.getRootNode();
+    }
+
+    Iterator<Pair<TreeNode, NodePath>> idIterator = traverser.find((TreeNode node) -> {
+      String element = node.getAttributes().getString("element");
+      if (element == null)
+        return false;
+      if (!element.equals("path"))
+        return false;
+      String pathString = node.getAttributes().getString("text");
+      if (pathString == null)
+        return false;
+      if (pathString.equals(StrPath))
+        return true;
+      return false;
+    }, "text", "StrPath");
+
+    if (!idIterator.hasNext())
+      return "";
+
+    Pair<TreeNode, NodePath> nodePair = idIterator.next();
+    NodePath path = nodePair.right();
+    NodePath targetPath = path.last().right();
+
+    TreeNode targetNode = getTarget(root, targetPath);
+    String targetId = targetNode.getAttributes().getString("id");
+    return targetId;
+  }
+
+  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);
+
+    LinkedList<String> rdeIds = new LinkedList<String>();
+
+    for (; orgIds.hasNext();) {
+      String orgId = orgIds.next();
+      Iterator<String> roleIds = roleIds(orgId);
+      for (; roleIds.hasNext();) {
+        String roleId = roleIds.next();
+        String rdeId = getRde(roleId);
+        String[] rdeSplit = rdeId.split(" ");
+        for (String rde : rdeSplit) {
+          if (!rde.equals(""))
+            rdeIds.add(rde);
+        }
+      }
+    }
+
+    return rdeIds.iterator();
+  }
+
+  private String getRde(String roleId) {
+
+    InterfaceTraverser traverser = roleTree.getTraverser();
+
+    Iterator<Pair<TreeNode, NodePath>> roleIterator = traverser.find((TreeNode node) -> {
+      String element = node.getAttributes().getString("element");
+      if (element == null)
+        return false;
+      if (!element.equals("Role"))
+        return false;
+      String id = node.getAttributes().getString("id");
+      if (id == null)
+        return false;
+      if (id.equals(roleId))
+        return true;
+      return false;
+    }, "id", roleId);
+
+    if (!roleIterator.hasNext())
+      return "";
 
 
-	public boolean filter(String orgId, LinkedList<String> roleIds) {
-		if (roleIds == null)
-			return true;
-		 
-		InterfaceTraverser orgTraverser = organizationTree.getTraverser();
-		
-		Iterator<Pair<TreeNode,NodePath>> orgNodeIterator = orgTraverser.find(
-				(TreeNode node) -> {
-					String personId = node.getAttributes().getString("element");
-					if (personId == null)
-						return false;
-					if (!personId.equals("Organization")) 
-						return false;
-					 String compareOrgId = node.getAttributes().getString("id");
-					if (compareOrgId == null)
-						return false;
-					if (compareOrgId.equals(orgId))
-						return true;
-					return false;
-				},"id", orgId);
-		
-		if (!orgNodeIterator.hasNext())
-			return false;
-		
-		TreeNode searchNode = orgNodeIterator.next().left();
-		
-		for (String id : roleIds) {
-			Pattern personPattern = Pattern.compile("r:");
-			Matcher personMacher = personPattern.matcher(id);
-			if (personMacher.find()) {
-				if (!roleFilter(id , searchNode))
-					return false;
-			}
-			
-			Pattern organizationPattern = Pattern.compile("rde:");
-			Matcher organizationMacher = organizationPattern.matcher(id);
-			if (organizationMacher.find()) {
-				if (!rdeFilter(id,searchNode))
-					return false;
-			}
-		}
-		return true;
-	}
-
-	private boolean rdeFilter(String id, TreeNode targetNode) {
-		
-		InterfaceTraverser orgTraverser = organizationTree.getTraverser();
-		Iterator<Pair<TreeNode,NodePath>> pairIdIterator = orgTraverser.findInSubTree(
-				(TreeNode node) -> {
-					String element = node.getAttributes().getString("element");
-					if (element == null)
-						return false;
-					if (!element.equals("roleRefId")) 
-						return false;
-					String roleId = node.getAttributes().getString("text");
-					if (roleId != null)
-						return true;
-					return false;
-				}
-				,targetNode,"element", "roleRefId");
-		
-		TreeMap<String, String> idMap = TreeMap.empty(Ord.stringOrd);
-		for (; pairIdIterator.hasNext();) {
-			String roleId = pairIdIterator.next().left().getAttributes().getString("text");
-			idMap = idMap.set(roleId,roleId);
-		}
-		
-		Iterator<P2<String, String>> ids = idMap.iterator();
-		InterfaceTraverser roleTraverser = roleTree.getTraverser();
-		
-		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;
-						if (!element.equals("Role")) 
-							return false;
-						String compareRoleId = node.getAttributes().getString("id");
-						if (compareRoleId == null)
-							return false;
-						if (compareRoleId.equals(roleId))
-							return true;
-						return false;
-					}
-					,"id",roleId);
-			// -----------------------------------------bug------------------------------------------
-			for (;roleNodeIterator.hasNext();) {
-				TreeNode roleNode = roleNodeIterator.next().left();
-				Iterator<Pair<TreeNode,NodePath>> rdeNodeIterator = roleTraverser.findInSubTree(
-						(TreeNode node) -> {
-							String elementName = node.getAttributes().getString("element");
-							if (elementName == null)
-								return false;
-							if (!elementName.equals("roleDescriptionElementRefIds")) 
-								return false;
-							String rdeId = node.getAttributes().getString("text");
-							if (rdeId == null)
-								return false;
-							Pattern personPattern = Pattern.compile(id);
-							Matcher personMacher = personPattern.matcher(rdeId);
-							if (personMacher.find())
-								return true;
-							return false;
-						}
-						,roleNode,"text","id");
-					
-				if (!rdeNodeIterator.hasNext())
-					return false;
-			}
-			
-		}
-		return true;
-	}
-
-	public boolean roleFilter(String id, TreeNode orgNode) {
-		System.out.println(orgNode.getAttributes().getString("id"));
-		InterfaceTraverser orgTraverser = organizationTree.getTraverser();
-		
-		Iterator<Pair<TreeNode,NodePath>> pairIdIterator = orgTraverser.findInSubTree(
-				(TreeNode node) -> {
-					String elementName = node.getAttributes().getString("element");
-					if (elementName == null)
-						return false;
-					if (!elementName.equals("roleRefIds")) 
-						return false;
-					String roleId = node.getAttributes().getString("text");
-					if (roleId == null)
-						return false;
-					if (roleId.equals(id))
-						return true;
-					return false;
-				}
-				,orgNode,"text", id);
-		
-		if (pairIdIterator.hasNext()){
-			System.out.println(pairIdIterator.next().left().getAttributes().getString("text"));
-			return true;
-		}
-		return false;
-	}
-
-	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("id");
-					if (nodeId == null)
-						return false;
-					if (nodeId.equals(id)) 
-						return true;
-					return false;
-				}
-				,"id",id);
-		
-		LinkedList<String> ids = new LinkedList<String>();
-		
-		for (;searchTargetIterator.hasNext();) {
-			
-			Pair<TreeNode, NodePath> searchTargetPair = searchTargetIterator.next();
-			Iterator<Pair<TreeNode,NodePath>> pairIdIterator = ifTraverser.findInSubTree(
-					(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");
-						if (nodeId != null)
-							return true;
-						return false;
-					}
-					,searchTargetPair.left(),"element","roleRefId");
-			
-
-			for (;pairIdIterator.hasNext();){
-				Pair<TreeNode, NodePath> idNodePath = pairIdIterator.next();
-				String attribute = idNodePath.left().getAttributes().getString("text");
-				
-				Iterator<String> checkList = ids.iterator();
-				for (;checkList.hasNext();) {
-					if(checkList.next().equals(attribute))
-						attribute = null;
-				}
-				
-				if (attribute != null) {
-					ids.add(attribute);
-					System.out.println("-------------------------" + attribute + "-------------------------");
-				}
-			}
-		}
-		return ids.iterator();
-	}
-	
-	
-	public Iterator<String> competentRoleId(String personId) {
-		
-		InterfaceTraverser ifTraverser = personTree.getTraverser();
-		Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchPerson(personId, ifTraverser);
-		
-		if (!pairPersonIterator.hasNext()) 
-			return new NullIterator();
-		TreeNode person = pairPersonIterator.next().left();
-		
-		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");
-					if (priority == null)
-						return false;
-					if (priority.equals("0"))
-						return true;
-					return false;
-				}
-				,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);
-			String id = targetNode.getAttributes().getString("text");
-			idList.add(id);
-		}
-		
-		return idList.iterator();
-	}
+    Iterator<Pair<TreeNode, NodePath>> rdeIterator = traverser.findInSubTree((TreeNode node) -> {
+      String element = node.getAttributes().getString("element");
+      if (element == null)
+        return false;
+      if (!element.equals("roleDescriptionElementRefIds"))
+        return false;
+      String rde = node.getAttributes().getString("text");
+      if (rde != null)
+        return true;
+      return false;
+    }, roleIterator.next(), "element", "roleDescriptionElementRefIds");
 
-	
-	public Iterator<String> concurrentRoleIds(String personId) {
-		
-		InterfaceTraverser ifTraverser = personTree.getTraverser();
-		Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchPerson(
-				personId, ifTraverser);
-		
-		if (!pairPersonIterator.hasNext()) 
-			return new NullIterator();
-		TreeNode person = pairPersonIterator.next().left();
-		
-		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");
-					if (priority == null)
-						return false;
-					if (!priority.equals("0"))
-						return true;
-					return false;
-				}
-				,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);
-			String id = targetNode.getAttributes().getString("text");
-			idList.add(id);
-		}
-		
-		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) {
-		
-		Iterator<String> childrensIterator = deepChildOrganizationIds(orgId, new LinkedList<String>());
-		if (!childrensIterator.hasNext())
-			return new NullIterator();
-		
-		LinkedList<String> childrenPersonList = new LinkedList<String>();
-		//childrenPersonList.addAll(personIdLink(orgId, filterIds));
-		for (;childrensIterator.hasNext();) {
-			String id = childrensIterator.next();
-			childrenPersonList.addAll(personIdLink(id, filterIds));
-		}
-	
-		return childrenPersonList.iterator();
-	}
-	
-	public Iterator<String> deepChildOrganizationIdsPlus(String orgId, LinkedList<String> filterIds) {
-		LinkedList<String> orgList = new LinkedList<String>();
-		if (filter(orgId, filterIds))
-			orgList.add(orgId);
-		orgList.addAll(_deepChildOrganizationIds(orgId,filterIds));
-		return orgList.iterator();
-	}
-	
-	public Iterator<String> deepChildOrganizationIds(String orgId, LinkedList<String> filterIds) {
-		return _deepChildOrganizationIds(orgId,filterIds).iterator();
-	}
-	
-	public LinkedList<String> _deepChildOrganizationIds(String orgId, LinkedList<String> filterIds) {
-				
-		Iterator<String> childrensIterator = childOrganizationIds(orgId,new LinkedList<String>());
-		if (!childrensIterator.hasNext())
-			return new LinkedList<String>();
-		
-		LinkedList<String> childrenList = new LinkedList<String>();
-		for (;childrensIterator.hasNext();) {
-			String childrenId = childrensIterator.next();
-			if(filter(childrenId,filterIds))
-				childrenList.add(childrenId);
-			childrenList.addAll(_deepChildOrganizationIds(childrenId, filterIds));
-		}
-	
-		return childrenList;
-	}
-
-
-	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");
-					if (nodeId == null)
-						return false;
-					if (nodeId.equals(orgId)) 
-						return true;
-					return false;
-				},"id", orgId);
-		
-		if (!pairPersonIterator.hasNext()) 
-			return new NullIterator();
-		TreeNode person = pairPersonIterator.next().left();
-		
-		
-		Iterator<Pair<TreeNode,NodePath>> chilrenOrgIdsIterator = orgTraverser.findInSubTree(
-				(TreeNode node) -> {
-					String nodeElement = node.getAttributes().getString("element");
-					if (nodeElement == null)
-						return false;
-					if (nodeElement.equals("childOrganizations")) 
-						return true;
-					return false;
-				}
-				,person,"element","childOrganizations");
-		
-		if (!chilrenOrgIdsIterator.hasNext()) 
-			return new NullIterator();
-		
-		TreeNode chilerenOrgIds = chilrenOrgIdsIterator.next().left();
-		
-		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");
-					if (nodeElement != null)
-						return true;
-					return false;
-				}
-				,chilerenOrgIds, "element", "organizationRefIds");
-		
-		LinkedList<String> ids = new LinkedList<String>();
-		
-		for (;chilrenOrgIdIterator.hasNext();) {
-			ids.add(chilrenOrgIdIterator.next().left().getAttributes().getString("text"));
-		}
-		
-		return ids.iterator();
-	}
-	
-	
-	
-	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);
-			
-		Either<Error, TreeNode> either = node.getChildren().at(num);
-		if (either.isA())
-			return node;
-		
-		TreeNode child = either.b();
-		if (pathNode.right().size() == 0)
-			return child;
-		
-		target = getTarget(child,pathNode.right());
-		return target;
-	}
-	
-	class NullIterator implements Iterator<String>{
-
-		@Override
-		public boolean hasNext() {
-			return false;
-		}
-
-		@Override
-		public String next() {
-			return null;
-		}
-		
-	}
+    if (!rdeIterator.hasNext())
+      return "";
 
-	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");
-					if (element == null)
-						return false;
-					if (!element.equals("Person")) 
-						return false;
-					String nodeId = node.getAttributes().getString("id");
-					if (nodeId == null)
-						return false;
-					if (nodeId.equals(personId)) 
-						return true;
-					return false;
-				},"id",personId);
-		
-		if (!personIterator.hasNext())
-			return "";
-		
-		TreeNode targetNode = personIterator.next().left();
-	
-		Iterator<Pair<TreeNode,NodePath>> priorityIterator = personTraverser.findInSubTree(
-				(TreeNode node) -> {
-					String element = node.getAttributes().getString("element");
-					if (element == null)
-						return false;
-					if (!element.equals("roleRefId")) 
-						return false;
-					String compareRoleId = node.getAttributes().getString("text");
-					if (compareRoleId == null)
-						return false;
-					if (compareRoleId.equals(roleId)) 
-						return true;
-					return false;
-				},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(targetNode,priorityNodePath);
-			if (priorityNode.getAttributes().getString("element").equals("priority"))
-				return priorityNode.getAttributes().getString("text");
-		}
-		return "";
-	}
-
-	public Iterator<String> parentOrganizationIds(String orgId, LinkedList<String> filterIds) {
-		return _parentOrganizationIds(orgId, filterIds).iterator();
-	}
-	public LinkedList<String> _parentOrganizationIds(String orgId, LinkedList<String> filterIds) {
-		
-		InterfaceTraverser orgTraverser = organizationTree.getTraverser();
-		Iterator<Pair<TreeNode,NodePath>> orgIterator = orgTraverser.find(
-				(TreeNode node) -> {
-					String element = node.getAttributes().getString("element");
-					if (element == null)
-						return false;
-					if (!element.equals("Organization")) 
-						return false;
-					String nodeId = node.getAttributes().getString("id");
-					if (nodeId == null)
-						return false;
-					if (nodeId.equals(orgId)) 
-						return true;
-					return false;
-				},"element","Organization");
-		
-		if (!orgIterator.hasNext())
-			return new LinkedList<String>();
-		
-		TreeNode orgNode = orgIterator.next().left();
-		
-		Iterator<Pair<TreeNode,NodePath>> parentOrgIterator = orgTraverser.findInSubTree(
-				(TreeNode node) -> {
-					String element = node.getAttributes().getString("element");
-					if (element == null)
-						return false;
-					if (element.equals("parentOrganizations")) 
-						return true;
-					return false;
-				}, orgNode,"element", "parentOrganizations");
-		
-		LinkedList<String> parentIds = new LinkedList<String>();
-		
-		for (;parentOrgIterator.hasNext();) {
-			TreeNode parentOrgNode = parentOrgIterator.next().left();
-			
-			Iterator<Pair<TreeNode,NodePath>> parentNodeIterator = orgTraverser.findInSubTree(
-					(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");
-						if (parentId != null)
-							return true;
-						return false;
-					}, parentOrgNode,"element","organizationRefId");
-			
-			for (;parentNodeIterator.hasNext();) {
-				String parentId = parentNodeIterator.next().left().getAttributes().getString("text");
-				if (filter(parentId, filterIds))
-					parentIds.add(parentId);
-			}
-			
-			
-		}
-		
-		return parentIds;
-	}
-
-	public Iterator<String> deepParentOrganizationIds(String orgId, LinkedList<String> filterIds) {
-		return _deepParentOrganizationIds(orgId, filterIds).iterator();
-	}
-	
-	public LinkedList<String> _deepParentOrganizationIds(String orgId, LinkedList<String> filterIds) {
+    return rdeIterator.next().left().getAttributes().getString("text");
+  }
 
-		
-		Iterator<String> parentIds = parentOrganizationIds(orgId, filterIds);
-		if (!parentIds.hasNext())
-			return new LinkedList<String>();
-		
-		LinkedList<String> parentIdList = new LinkedList<String>();
-		
-		for (;parentIds.hasNext();) {
-			String parentId = parentIds.next();
-			if (filter(parentId, filterIds))
-				parentIdList.add(parentId);
-			parentIdList.addAll(_deepParentOrganizationIds(parentId, filterIds));
-		}
-		return parentIdList;
-	}
-
-	public Iterator<String> deepParentOrganizationIdsPlus(String id,LinkedList<String> filterIds) {
-		LinkedList<String> parentIds = new LinkedList<String>();
-		if (filter(id, filterIds))
-			parentIds.add(id);
-		 parentIds.addAll(_deepParentOrganizationIds(id,filterIds));
-		return parentIds.iterator();
-	}
-
-	public String stringPathToId(String args) {
-		String[] splitPath = args.split(":");
-		
-		String str = splitPath[2];
-		for (int count = 3; count < splitPath.length;count++) {
-			str = str + ":" + splitPath[count];
-		}
-		
-		final String StrPath = str;
-		
-		InterfaceTraverser traverser = null;
-		TreeNode root = null ;
-		if (splitPath[0].equals("r")) {
-			traverser = roleTree.getTraverser();
-			root = roleTree.getRootNode();
-		}
-		if (splitPath[0].equals("rde")) {
-			traverser = rdeTree.getTraverser();
-			root = rdeTree.getRootNode();
-		}
-		
-		Iterator<Pair<TreeNode,NodePath>> idIterator = traverser.find(
-				(TreeNode node) -> {
-					String element = node.getAttributes().getString("element");
-					if (element == null)
-						return false;
-					if (!element.equals("path")) 
-						return false;
-					String pathString = node.getAttributes().getString("text");
-					if (pathString == null)
-						return false;
-					if (pathString.equals(StrPath))
-						return true;
-					return false;
-				}, "text","StrPath");
-		
-		if (!idIterator.hasNext()) 
-			return "";
-		
-		Pair<TreeNode, NodePath> nodePair = idIterator.next();
-		NodePath path = nodePair.right();
-		NodePath targetPath = path.last().right();
-		
-		TreeNode targetNode = getTarget(root, targetPath);
-		String targetId = targetNode.getAttributes().getString("id");
-		return targetId;
-	}
-
-	public Iterator<String> roleDescriptionElementIds(String id, LinkedList<String> filterIds) {
-		
-		 Iterator<String> orgIds = deepParentOrganizationIdsPlus(id, filterIds);
-		 
-		 LinkedList<String> rdeIds = new LinkedList<String>();
-		 
-		for (;orgIds.hasNext();) {
-			String orgId = orgIds.next();
-			Iterator<String> roleIds =  roleIds(orgId);
-			for (;roleIds.hasNext();) {
-				String roleId = roleIds.next();
-				String rdeId = getRde(roleId);
-				String[] rdeSplit = rdeId.split(" ");
-				for (String rde : rdeSplit) {
-					if (!rde.equals(""))
-						rdeIds.add(rde);
-				}
-			}
-		}
-		
-		return rdeIds.iterator();
-	}
-
-	private String getRde(String roleId) {
-		
-		InterfaceTraverser traverser = roleTree.getTraverser();
-		
-		Iterator<Pair<TreeNode,NodePath>> roleIterator = traverser.find(
-				(TreeNode node) -> {
-					String element = node.getAttributes().getString("element");
-					if (element == null)
-						return false;
-					if (!element.equals("Role")) 
-						return false;
-					String id = node.getAttributes().getString("id");
-					if (id == null)
-						return false;
-					if (id.equals(roleId))
-						return true;
-					return false;
-				},"id",roleId);
-		
-		if (!roleIterator.hasNext())
-			return "";
-		
-		TreeNode roleNode = roleIterator.next().left();
-		
-		Iterator<Pair<TreeNode,NodePath>> rdeIterator = traverser.findInSubTree(
-				(TreeNode node) -> {
-					String element = node.getAttributes().getString("element");
-					if (element == null)
-						return false;
-					if (!element.equals("roleDescriptionElementRefIds")) 
-						return false;
-					String rde = node.getAttributes().getString("text");
-					if (rde != null)
-						return true;
-					return false;
-				},roleNode,"element","roleDescriptionElementRefIds");
-		
-		if (!rdeIterator.hasNext())
-			return "";
-		
-		return rdeIterator.next().left().getAttributes().getString("text");
-	}
-
-	
 }
diff -r 6f9439ca3eb5 -r ef3fae2e7f0c src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/loadXml.java
--- a/src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/loadXml.java	Mon Oct 27 18:06:23 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/loadXml.java	Tue Oct 28 06:34:47 2014 +0900
@@ -18,28 +18,56 @@
 import org.xml.sax.SAXException;
 
 import ac.jp.u_ryukyu.cr.ie.tatsuki.xmlReader.ReadXmlHandler;
+import ac.jp.u_ryukyu.cr.ie.tatsuki.xmlReader.ReadXmlNodeCreateIndexHandler;
+import ac.jp.u_ryukyu.cr.ie.tatsuki.xmlReader.ReadXmlPutAttributeCreateIndex;
 
 public class loadXml {
 
-	Jungle jungle;
-	SAXParserFactory saxParserFactory;
-	
-	public loadXml() {
-		saxParserFactory = SAXParserFactory.newInstance();
-		jungle = new DefaultJungle(null, "jungle", new DefaultTreeEditor(
-				new DefaultTraverser()));
-	}
+  Jungle jungle;
+  SAXParserFactory saxParserFactory;
+
+  public loadXml() {
+    saxParserFactory = SAXParserFactory.newInstance();
+    jungle = new DefaultJungle(null, "jungle", new DefaultTreeEditor(new DefaultTraverser()));
+  }
+
+  private JungleTree putTestDataCreate(String xmlName, JungleTree tree) throws FileNotFoundException,
+      SAXException, IOException, ParserConfigurationException {
+    SAXParser saxParser = saxParserFactory.newSAXParser();
+    ReadXmlPutAttributeCreateIndex readXmlHandler = new ReadXmlPutAttributeCreateIndex(tree);
+    saxParser.parse(new FileInputStream("xml/" + xmlName), readXmlHandler);
+    JungleTree newTree = readXmlHandler.getTree();
+
+    return newTree;
+
+  }
 
-	public JungleTree loadTestData(String xmlName)
-			throws FileNotFoundException, SAXException, IOException, ParserConfigurationException {
-		SAXParser saxParser = saxParserFactory.newSAXParser();
-		JungleTree tree = jungle.createNewTree(xmlName);
-		ReadXmlHandler readXmlHandler = new ReadXmlHandler(tree);
-		saxParser.parse(new FileInputStream("xml/" + xmlName), readXmlHandler);
-		JungleTree newTree = readXmlHandler.getTree();
+  private JungleTree createNodeTestData(String xmlName) throws FileNotFoundException, SAXException,
+      IOException, ParserConfigurationException {
+    SAXParser saxParser = saxParserFactory.newSAXParser();
+    JungleTree tree = jungle.createNewTree(xmlName);
+    ReadXmlNodeCreateIndexHandler readXmlHandler = new ReadXmlNodeCreateIndexHandler(tree);
+    saxParser.parse(new FileInputStream("xml/" + xmlName), readXmlHandler);
+    JungleTree nodeTree = readXmlHandler.getTree();
+    JungleTree newTree = putTestDataCreate(xmlName, nodeTree);
+    return newTree;
+  }
 
-		return newTree;
+  public JungleTree loadTestDataCreateIndex(String xmlName) throws FileNotFoundException, SAXException, IOException, ParserConfigurationException{
+    JungleTree newTree =  createNodeTestData(xmlName);
+    return newTree;
+  }
+  
+  public JungleTree loadTestData(String xmlName) throws FileNotFoundException, SAXException, IOException,
+      ParserConfigurationException {
+    SAXParser saxParser = saxParserFactory.newSAXParser();
+    JungleTree tree = jungle.createNewTree(xmlName);
+    ReadXmlHandler readXmlHandler = new ReadXmlHandler(tree);
+    saxParser.parse(new FileInputStream("xml/" + xmlName), readXmlHandler);
+    JungleTree newTree = readXmlHandler.getTree();
 
-	}
+    return newTree;
+
+  }
 
 }
diff -r 6f9439ca3eb5 -r ef3fae2e7f0c src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/deepParentOrganizationIdsPlusTest.java
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/deepParentOrganizationIdsPlusTest.java	Mon Oct 27 18:06:23 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/deepParentOrganizationIdsPlusTest.java	Tue Oct 28 06:34:47 2014 +0900
@@ -15,7 +15,7 @@
 		LinkedList<String> filterIds = new LinkedList<String>();
 		//filterIds.add("r:2");
 		Iterator<String> childrenIds = jugrix.deepParentOrganizationIdsPlus("o:2", filterIds);
-		
+	  Assert.assertEquals(childrenIds.next(),"o:2");
 		Assert.assertEquals(childrenIds.next(),"o:23");
 		Assert.assertEquals(childrenIds.next(),"o:22");
 		
diff -r 6f9439ca3eb5 -r ef3fae2e7f0c src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/deepParentOrganizationIdsTest.java
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/deepParentOrganizationIdsTest.java	Mon Oct 27 18:06:23 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/deepParentOrganizationIdsTest.java	Tue Oct 28 06:34:47 2014 +0900
@@ -14,8 +14,8 @@
 	public void deepParentOrganizationIds(){
 		JuGrix jugrix = new JuGrix();
 		LinkedList<String> filterIds = new LinkedList<String>();
-		Iterator<String> childrenIds = jugrix.deepParentOrganizationIdsPlus("o:2", filterIds);
-		Assert.assertEquals(childrenIds.next(),"o:2");
+		Iterator<String> childrenIds = jugrix.deepParentOrganizationIds("o:2", filterIds);
+	//	Assert.assertEquals(childrenIds.next(),"o:2");
 		Assert.assertEquals(childrenIds.next(),"o:23");
 		Assert.assertEquals(childrenIds.next(),"o:22");