changeset 43:1bdd50e26fac

Merge with 037731e99d6e876ecc1ef2d921d2ce5f71974376
author one
date Tue, 25 Nov 2014 12:12:17 +0900
parents c036d36c33af (diff) 037731e99d6e (current diff)
children 5e8eac03fed3
files src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/JuGrix.java src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/JungleBulletinBoard.java src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/ChildOrganizationIdsTest.java src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/PersonIdsTest.java src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/RoleDescriptionElementIdsTest.java src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/xmlReadTest/SaxTest.java
diffstat 24 files changed, 1580 insertions(+), 1800 deletions(-) [+]
line wrap: on
line diff
--- a/src/main/java/ac/jp/u_ryukyu/cr/ie/tatsuki/time/TimeMeasurementJuGrix.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/main/java/ac/jp/u_ryukyu/cr/ie/tatsuki/time/TimeMeasurementJuGrix.java	Tue Nov 25 12:12:17 2014 +0900
@@ -7,21 +7,21 @@
 
 public class TimeMeasurementJuGrix {
   
-  static int roopCount = 1000;
+  static int roopCount = 3;
   
   public static void main(String args[]) {
     
-    JuGrix jugrix = new JuGrix(false);
-    System.out.println("start : no index");
+    System.out.println("start : ");
     
     String orgId = "o:2";
     String personId = "p:1";
     LinkedList<String> filterIds = new LinkedList<String>();
     filterIds.add("r:5");
-    functions(jugrix, orgId, personId, filterIds);
     
     long sumTime = 0;
     for (int count = 0; count < roopCount; count++) {
+
+      JuGrix jugrix = new JuGrix();
       Random random = new Random();
       int ran = random.nextInt(30);
       orgId = "o:" + String.valueOf(ran);
@@ -34,25 +34,6 @@
     }
     System.out.println("合計 = " + sumTime + "s");
     System.out.println("end");
-    
-    jugrix = new JuGrix(true);
-    functions(jugrix, orgId, personId, filterIds);
-    System.out.println("start : use index");
-    sumTime = 0;
-    
-    for (int count = 0; count < roopCount; count++) {
-      Random random = new Random();
-      int ran = random.nextInt(30);
-      orgId = "o:" + String.valueOf(ran);
-      personId = "p:" + String.valueOf(ran);
-      long t1 = System.currentTimeMillis();
-      functions(jugrix, orgId, personId, filterIds);
-      long t2 = System.currentTimeMillis();
-      //System.out.println(count + "回目=" + (t2 - t1) + "s");
-      sumTime = sumTime + t2 - t1;
-    }
-    System.out.println("合計 = " + sumTime + "s");
-    System.out.println("end");
   }
   
   private static void functions(JuGrix jugrix, String orgId, String personId, LinkedList<String> filterIds) {
--- a/src/main/java/ac/jp/u_ryukyu/cr/ie/tatsuki/xmlReader/LoadXml.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/main/java/ac/jp/u_ryukyu/cr/ie/tatsuki/xmlReader/LoadXml.java	Tue Nov 25 12:12:17 2014 +0900
@@ -26,32 +26,6 @@
     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;
-
-  }
-
-  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;
-  }
-
-  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 {
--- a/src/main/java/ac/jp/u_ryukyu/cr/ie/tatsuki/xmlReader/ReadXmlNodeCreateIndexHandler.java	Mon Nov 17 18:47:10 2014 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,71 +0,0 @@
-package ac.jp.u_ryukyu.cr.ie.tatsuki.xmlReader;
-
-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;
-  }
-
-}
--- a/src/main/java/ac/jp/u_ryukyu/cr/ie/tatsuki/xmlReader/ReadXmlPutAttributeCreateIndex.java	Mon Nov 17 18:47:10 2014 +0900
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,128 +0,0 @@
-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 ReadXmlPutAttributeCreateIndex extends DefaultHandler {
-  private JungleTree tree;
-  private JungleTreeEditor editor;
-  private NodePath path;
-  private String elementName;
-
-  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);
-      elementName = 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 = elementName + "-" + 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()) {
-      String[] splitStrs = str.split(" ");
-      for (String splitStr : splitStrs) {
-        Pair<Integer, NodePath> nodePair = path.last();
-        NodePath onePath = nodePair.right();
-        Either<Error, JungleTreeEditor> newEither = editor.putAttribute(onePath, "text-" + elementName,
-            ByteBuffer.wrap(splitStr.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;
-  }
-
-}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/ac/jp/u_ryukyu/cr/ie/tatsuki/xmlReader/UpdateXmlHundler.java	Tue Nov 25 12:12:17 2014 +0900
@@ -0,0 +1,125 @@
+package ac.jp.u_ryukyu.cr.ie.tatsuki.xmlReader;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.xml.sax.*;
+import org.xml.sax.helpers.*;
+
+public class UpdateXmlHundler extends DefaultHandler {
+  private String elementName;
+  private boolean flag = false;
+  private PrintWriter pw;
+  private int count = 0;
+  String xmlStr = "";
+
+  public UpdateXmlHundler(String xml) throws IOException {
+    File file = new File("./XML/" + xml + ".xml");
+    pw = new PrintWriter(new BufferedWriter(new FileWriter(file)));
+
+  }
+
+  @Override
+  public void startElement(String uri, String localName, String qName, Attributes attributes) {
+    pw.print(xmlStr);
+    xmlStr = "<";
+    if (qName != "") {
+      // System.out.print("qName= " + qName);
+      elementName = qName;
+
+      if (elementName.equals("roleRefIds") || elementName.equals("organizationRefIds")
+          || elementName.equals("personRefIds") || elementName.equals("childrenRoleRefIds")
+          || elementName.equals("roleDescriptionElementRefIds"))
+        flag = true;
+      xmlStr = xmlStr + elementName;
+    }
+
+    if (attributes.getLength() != 0) {
+      for (int count = 0; attributes.getLength() > count; count++) {
+        String value = attributes.getValue(count);
+        xmlStr = xmlStr + " " + attributes.getLocalName(count) + "=\"" + value + "\"";
+      }
+    }
+    xmlStr = xmlStr + ">";
+    String tab = tab();
+    pw.print(tab + xmlStr);
+    count++;
+    xmlStr = "\n";
+  }
+
+  @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);
+    String[] split = str.split(" ");
+    if (!macher.find()) {
+      if (flag == true) {
+        flag = false;
+        for (String text : split) {
+          pw.println();
+          if (elementName.equals("roleRefIds"))
+            pw.print(tab() + "<roleRefId>" + text + "</roleRefId>");
+          if (elementName.equals("organizationRefIds"))
+            pw.print(tab() + "<organizationRefId>" + text + "</organizationRefId>");
+          if (elementName.equals("personRefIds"))
+            pw.print(tab() + "<personRefId>" + text + "</personRefId>");
+          if (elementName.equals("childrenRoleRefIds"))
+            pw.print(tab() + "<childrenRoleRefId>" + text + "</childrenRoleRefId>");
+          if (elementName.equals("roleDescriptionElementRefIds"))
+            pw.print(tab() + "<roleDescriptionElementRefId>" + text + "</roleDescriptionElementRefId>");
+        }
+        count--;
+        xmlStr = "\n" + tab();
+        count++;
+        return;
+      } else {
+        if (str.equals("松田賢一"))
+          System.out.println("aaaa");
+        pw.print(str);
+      }
+      xmlStr = "";
+      return;
+    }
+    if (flag == true) {
+      xmlStr = "";
+      flag = false;
+    }
+
+  }
+
+  @Override
+  public void endElement(String namespaceURI, String localName, String qName) {
+    count--;
+    if (xmlStr == "\n")
+      xmlStr = xmlStr + tab();
+    pw.print(xmlStr);
+    pw.print("</" + qName + ">");
+    xmlStr = "\n";
+  }
+
+  @Override
+  public void startDocument() {
+    // System.out.print("start");
+  }
+
+  @Override
+  public void endDocument() {
+    pw.close();
+    System.out.print("end");
+  }
+
+  private String tab() {
+    String tab = "";
+    for (int tabCount = 0; tabCount < count; tabCount++) {
+      tab = tab + "  ";
+    }
+    return tab;
+  }
+
+}
--- a/src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/JuGrix.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/JuGrix.java	Tue Nov 25 12:12:17 2014 +0900
@@ -2,22 +2,20 @@
 
 import java.util.Iterator;
 import java.util.LinkedList;
+import java.util.Stack;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import javax.lang.model.element.Element;
-
 import ac.jp.u_ryukyu.cr.ie.tatsuki.xmlReader.LoadXml;
 import fj.Ord;
 import fj.P2;
 import fj.data.TreeMap;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
-import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
 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 jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;
 
 public class JuGrix {
 
@@ -26,22 +24,14 @@
   JungleTree roleTree;
   JungleTree rdeTree;
 
-  public JuGrix(boolean index) {
+  public JuGrix() {
 
     try {
       LoadXml reader = new LoadXml();
-
-      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");
-      }
+      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();
@@ -51,12 +41,12 @@
   public boolean isActive(String id) {
 
     InterfaceTraverser personTraverser = personTree.getTraverser();
-    Iterator<Pair<TreeNode, NodePath>> personIdpairIterator = personTraverser.find((TreeNode node) -> {
-      Iterator<String> personIdIterator = node.getAttributes().getString("Person-id");
-      if (personIdIterator.hasNext()) {
-        if (personIdIterator.next().equals(id))
-          return true;
-      }
+    Iterator<TreeNode> personIdpairIterator = personTraverser.find((TreeNode node) -> {
+      String personId = node.getAttributes().getString("Person-id");
+      if (personId == null)
+        return false;
+      if (personId.equals(id))
+        return true;
       return false;
     }, "Person-id", id);
 
@@ -66,329 +56,244 @@
 
   }
 
-  public Iterator<String> personIds(String orgId, LinkedList<String> roleIds) {
+  public Iterator<String> personIds(String orgId, LinkedList<String> filterIds) {
+
+    InterfaceTraverser orgTraverser = organizationTree.getTraverser();
 
-    Iterator<String> parentOrgIdIterator = parentOrganizationIds(orgId, roleIds);
-    TreeMap<String, String> personIdsTreeMap = TreeMap.empty(Ord.stringOrd);
+    Iterator<TreeNode> orgIdNodeIterator = orgTraverser.find((TreeNode node) -> {
+      String nodeElement = node.getAttributes().getString("element");
+      if (nodeElement == null)
+        return false;
+      if (!nodeElement.equals("Organization"))
+        return false;
+      String targetOrgId = node.getAttributes().getString("Organization-id");
+      if (targetOrgId == null)
+        return false;
+      if (targetOrgId.equals(orgId))
+        return true;
+      return false;
+    }, "Organization-id", orgId);
 
-    if (filter(orgId, roleIds))
-      personIdsTreeMap = personIdsSearch(orgId, personIdsTreeMap);
+    if (!orgIdNodeIterator.hasNext())
+      return new NullIterator<String>();
 
-    for (; parentOrgIdIterator.hasNext();) {
-      personIdsTreeMap = personIdsSearch(parentOrgIdIterator.next(), personIdsTreeMap);
-    }
+    TreeNode orgIdNode = orgIdNodeIterator.next();
+    TreeNode orgRoleIdNodes = orgIdNode.getChildren().at(2).b();
+    TreeNode orgRoleIdNode = orgRoleIdNodes.getChildren().at(0).b();
+    String orgRoleId = orgRoleIdNode.getAttributes().getString("text-roleRefId");
+    if (!filter(filterIds, orgRoleId))
+      return new NullIterator<String>();
+
+    InterfaceTraverser traverser = personTree.getTraverser();
 
-    if (personIdsTreeMap.isEmpty())
-      return new NullIterator();
+    return new Iterator<String>() {
+      Iterator<TreeNode> orgIdNodeIterator = traverser.find((TreeNode node) -> {
+        String nodeElement = node.getAttributes().getString("element");
+        if (nodeElement == null)
+          return false;
+        if (!nodeElement.equals("organizationRefId"))
+          return false;
+        String targetOrgId = node.getAttributes().getString("text-organizationRefId");
+        if (targetOrgId == null)
+          return false;
+        if (targetOrgId.equals(orgId))
+          return true;
+        return false;
+      }, "text-organizationRefId", orgId);
 
-    Iterator<P2<String, String>> personIdsIterator = personIdsTreeMap.iterator();
-    return new Iterator<String>() {
+      String targetPersonId;
 
       @Override
       public boolean hasNext() {
-        if (personIdsIterator.hasNext())
+        for (; orgIdNodeIterator.hasNext();) {
+          TreeNode orgIdNode = orgIdNodeIterator.next();
+          ParentIndex parentIndex = traverser.getParentIndex();
+          TreeNode OrganizationMappedByRoleNode = parentIndex.get(orgIdNode);
+          TreeNode parentOrganizations = parentIndex.get(OrganizationMappedByRoleNode);
+          TreeNode targetPersonIdNode = parentIndex.get(parentOrganizations);
+          targetPersonId = targetPersonIdNode.getAttributes().getString("Person-id");
           return true;
-        return false;
-      }
-
-      @Override
-      public String next() {
-        return personIdsIterator.next()._1();
-      }
-
-    };
-  }
-
-  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;
-
-      @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;
+        return targetPersonId;
       }
 
     };
   }
 
-  private TreeMap<String, String> personIdsSearch(String orgId, TreeMap<String, String> orgIdsTreeMap) {
-
-    InterfaceTraverser personTraverser = personTree.getTraverser();
-
-    Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.findAll((TreeNode node) -> {
-      Iterator<String> personIdIterator = node.getAttributes().getString("element");
-      for (; personIdIterator.hasNext();) {
-        if (personIdIterator.next().equals("Person"))
-          return true;
-      }
-      return false;
-    }, "Person-id");
-
-    for (; personIdPairIterator.hasNext();) {
-
-      Pair<TreeNode, NodePath> personIdPair = personIdPairIterator.next();
-
-      Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = personTraverser.findInSubTree((TreeNode node) -> {
-        Iterator<String> personIdIterator = node.getAttributes().getString("text-organizationRefId");
-        for (; personIdIterator.hasNext();) {
-          if (personIdIterator.next().equals(orgId))
-            return true;
-        }
-        return false;
-      }, personIdPair, "text-organizationRefId", orgId);
-
-      if (orgIdPairIterator.hasNext()) {
-        Iterator<String> personIdIterator = personIdPair.left().getAttributes().getString("Person-id");
-        if (personIdIterator.hasNext()) {
-          String personId = personIdIterator.next();
-          orgIdsTreeMap = orgIdsTreeMap.set(personId, personId);
-        }
-      }
-    }
-    return orgIdsTreeMap;
-  }
-
-  public boolean filter(String orgId, LinkedList<String> roleIds) {
-
-    if (roleIds == null)
-      return true;
-
-    if (roleIds.isEmpty())
-      return true;
-
-    InterfaceTraverser orgTraverser = organizationTree.getTraverser();
-
-    Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = orgTraverser.find((TreeNode node) -> {
-      Iterator<String> personIdIterator = node.getAttributes().getString("element");
-      for (; personIdIterator.hasNext();) {
-        if (!personIdIterator.next().equals("Organization"))
-          continue;
-        Iterator<String> compareOrgIdIterator = node.getAttributes().getString("Organization-id");
-        for (; compareOrgIdIterator.hasNext();) {
-          if (compareOrgIdIterator.next().equals(orgId))
-            return true;
-        }
-      }
-      return false;
-    }, "Organization-id", orgId);
-
-    if (!orgIdPairIterator.hasNext())
-      return false;
-
-    Pair<TreeNode, NodePath> orgIdPair = orgIdPairIterator.next();
-
-    for (String id : roleIds) {
-      Pattern personPattern = Pattern.compile("r:");
-      Matcher personMacher = personPattern.matcher(id);
-      if (personMacher.find()) {
-        if (roleFilter(id, orgIdPair))
-          return false;
-      }
-
-      Pattern organizationPattern = Pattern.compile("rde:");
-      Matcher organizationMacher = organizationPattern.matcher(id);
-      if (organizationMacher.find()) {
-        if (!rdeFilter(id, orgIdPair))
-          return false;
-      }
-    }
-    return true;
-  }
-
-  private boolean rdeFilter(String filterRdeId, Pair<TreeNode, NodePath> searchNodePair) {
-
-    InterfaceTraverser orgTraverser = organizationTree.getTraverser();
-
-    Iterator<Pair<TreeNode, NodePath>> orgRoleIdPairIterator = orgTraverser.findInSubTreeAllValue((TreeNode node) -> {
-      Iterator<String> element = node.getAttributes().getString("element");
-      if (!element.hasNext())
-        return false;
-      if (!element.next().equals("roleRefId"))
-        return false;
-      Iterator<String> roleId = node.getAttributes().getString("text-roleRefId");
-      if (roleId.hasNext())
-        return true;
-      return false;
-    }, searchNodePair, "text-roleRefId");
-
-    TreeMap<String, String> orgRoleIdMap = TreeMap.empty(Ord.stringOrd);
-
-    for (; orgRoleIdPairIterator.hasNext();) {
-      Iterator<String> roleIdIterator = orgRoleIdPairIterator.next().left().getAttributes().getString("text-roleRefId");
-      for (; roleIdIterator.hasNext();) {
-        String roleId = roleIdIterator.next();
-        orgRoleIdMap = orgRoleIdMap.set(roleId, roleId);
-      }
-    }
-
-    Iterator<P2<String, String>> orgRoleIdP2Iterator = orgRoleIdMap.iterator();
-    InterfaceTraverser roleTraverser = roleTree.getTraverser();
-
-    for (; orgRoleIdP2Iterator.hasNext();) {
-      String orgRoleId = orgRoleIdP2Iterator.next()._1();
-
-      Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = roleTraverser.find((TreeNode node) -> {
-        Iterator<String> element = node.getAttributes().getString("element");
-        if (!element.hasNext())
-          return false;
-        if (!element.next().equals("Role"))
-          return false;
-        Iterator<String> compareRoleIdIterator = node.getAttributes().getString("Role-id");
-        for (; compareRoleIdIterator.hasNext();) {
-          if (compareRoleIdIterator.next().equals(orgRoleId))
-            return true;
-        }
-        return false;
-      }, "Role-id", orgRoleId);
-
-      for (; roleIdPairIterator.hasNext();) {
-
-        Pair<TreeNode, NodePath> rolePair = roleIdPairIterator.next();
-        Iterator<Pair<TreeNode, NodePath>> rdeIdPairIterator = roleTraverser.findInSubTree((TreeNode node) -> {
-          Iterator<String> element = node.getAttributes().getString("element");
-          if (!element.hasNext())
-            return false;
-          if (!element.next().equals("roleDescriptionElementRefIds"))
-            return false;
-          Iterator<String> rdeIdIterator = node.getAttributes().getString("text-roleDescriptionElementRefIds");
-          for (; rdeIdIterator.hasNext();) {
-            if (rdeIdIterator.next().equals(filterRdeId))
-              return true;
-          }
-          return false;
-        }, rolePair, "text-roleDescriptionElementRefIds", filterRdeId);
-
-        if (!rdeIdPairIterator.hasNext())
-          return false;
-      }
-
-    }
-    return true;
-  }
-
-  public boolean roleFilter(String id, Pair<TreeNode, NodePath> searchNodePair) {
-    // System.out.println(searchNodePair.getAttributes().getString("id"));
-    InterfaceTraverser orgTraverser = organizationTree.getTraverser();
-
-    Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = orgTraverser.findInSubTree((TreeNode node) -> {
-      Iterator<String> elementName = node.getAttributes().getString("element");
-      if (!elementName.hasNext())
-        return false;
-      if (!elementName.next().equals("roleRefIds"))
-        return false;
-      Iterator<String> roleId = node.getAttributes().getString("text-roleRefIds");
-      for (; roleId.hasNext();) {
-        if (roleId.next().equals(id))
-          return true;
-      }
-      return false;
-    }, searchNodePair, "text-roleRefIds", id);
-
-    if (roleIdPairIterator.hasNext()) {
-      return false;
-    }
-    return true;
-  }
-
-  public Iterator<String> roleIds(String id) {
+  public Iterator<String> roleIds(String id, LinkedList<String> filterIds) {
     Pattern personPattern = Pattern.compile("p:");
     Matcher personMacher = personPattern.matcher(id);
     if (personMacher.find()) {
-      return searchRoleIds(personTree, id, "Person");
+      return searchPersonRoleIds(personTree, id, "Person", filterIds);
     }
 
     Pattern organizationPattern = Pattern.compile("o:");
     Matcher organizationMacher = organizationPattern.matcher(id);
     if (organizationMacher.find()) {
-      return searchRoleIds(organizationTree, id, "Organization");
+      return searchOrgRoleIds(organizationTree, id, "Organization", filterIds);
     }
 
-    return new NullIterator();
+    return new NullIterator<String>();
   }
 
-  public Iterator<String> searchRoleIds(JungleTree tree, String id, String element) {
+  public Iterator<String> searchPersonRoleIds(JungleTree tree, String id, String element, LinkedList<String> filterIds) {
 
     InterfaceTraverser traverser = tree.getTraverser();
 
-    Iterator<Pair<TreeNode, NodePath>> idPairIterator = traverser.find((TreeNode node) -> {
-      Iterator<String> nodeElement = node.getAttributes().getString("element");
-      if (!nodeElement.hasNext())
-        return false;
-      if (!nodeElement.next().equals(element))
-        return false;
-      Iterator<String> nodeIdIterator = node.getAttributes().getString(element + "-id");
-      for (; nodeIdIterator.hasNext();) {
-        if (nodeIdIterator.next().equals(id))
-          return true;
-      }
-      return false;
-    }, element + "-id", id);
+    return new Iterator<String>() {
 
-    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) -> {
-        Iterator<String> nodeElement = node.getAttributes().getString("element");
-        if (!nodeElement.hasNext())
+      String roleRefId = "";
+      Iterator<TreeNode> idNodeIterator = traverser.find((TreeNode node) -> {
+        String nodeElement = node.getAttributes().getString("element");
+        if (nodeElement == null)
           return false;
-        if (!nodeElement.next().equals("roleRefId"))
+        if (!nodeElement.equals(element))
           return false;
-        Iterator<String> nodeIdIterator = node.getAttributes().getString("text-roleRefId");
-        if (nodeIdIterator.hasNext())
+        String nodeId = node.getAttributes().getString(element + "-id");
+        if (nodeId == null)
+          return false;
+        if (nodeId.equals(id))
           return true;
         return false;
-      }, targetPair, "text-roleRefId");
+      }, element + "-id", id);
 
-      for (; roleIdPairIterator.hasNext();) {
-        Pair<TreeNode, NodePath> roleIdPair = roleIdPairIterator.next();
-        Iterator<String> roleIdIterator = roleIdPair.left().getAttributes().getString("text-roleRefId");
-        for (; roleIdIterator.hasNext();) {
-          String roleId = roleIdIterator.next();
-          idsTreeMap = idsTreeMap.set(roleId, roleId);
-        }
-      }
-    }
-
-    if (idsTreeMap.isEmpty())
-      return new NullIterator();
-
-    Iterator<P2<String, String>> ids = idsTreeMap.iterator();
-    return new Iterator<String>() {
+      Iterator<TreeNode> OrganizationMappedByRoleIterator = getParentOrgs();
 
       @Override
       public boolean hasNext() {
-        if (ids.hasNext())
+
+        if (OrganizationMappedByRoleIterator == null)
+          return false;
+
+        if (OrganizationMappedByRoleIterator.hasNext())
+          roleRefId = search();
+        else
+          roleRefId = null;
+
+        if (roleRefId != null)
+          return true;
+
+        OrganizationMappedByRoleIterator = getParentOrgs();
+        if (OrganizationMappedByRoleIterator != null)
+          roleRefId = search();
+
+        if (roleRefId != null)
           return true;
-        return false;
+
+        return this.hasNext();
+      }
+
+      private String search() {
+        for (; OrganizationMappedByRoleIterator.hasNext();) {
+          TreeNode OrganizationMappedByRole = OrganizationMappedByRoleIterator.next();
+          TreeNode organizationRefIdNode = OrganizationMappedByRole.getChildren().at(0).b();
+          System.out.println(organizationRefIdNode.getAttributes().getString("element"));
+          String organizationRefId = organizationRefIdNode.getAttributes().getString("text-organizationRefId");
+          if (!filterIds.contains(organizationRefId))
+            continue;
+
+          TreeNode roleRefIdNode = OrganizationMappedByRole.getChildren().at(1).b();
+          return roleRefIdNode.getAttributes().getString("text-roleRefId");
+        }
+        OrganizationMappedByRoleIterator = getParentOrgs();
+
+        return null;
+      }
+
+      private Iterator<TreeNode> getParentOrgs() {
+        for (; idNodeIterator.hasNext();) {
+          TreeNode targetPersonNode = idNodeIterator.next();
+          TreeNode parentOrganizations = targetPersonNode.getChildren().at(5).b();
+          return parentOrganizations.getChildren().iterator();
+        }
+        return null;
       }
 
       @Override
       public String next() {
-        return ids.next()._1();
+        return roleRefId;
+      }
+
+    };
+  }
+
+  public Iterator<String> searchOrgRoleIds(JungleTree tree, String id, String element, LinkedList<String> filterIds) {
+
+    InterfaceTraverser traverser = tree.getTraverser();
+
+    return new Iterator<String>() {
+
+      String roleRefId = "";
+      Iterator<TreeNode> idNodeIterator = 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);
+      Iterator<TreeNode> OrganizationMappedByRoleIterator = getParentOrgs();
+
+      @Override
+      public boolean hasNext() {
+
+        if (OrganizationMappedByRoleIterator == null)
+          return false;
+        if (OrganizationMappedByRoleIterator.hasNext())
+          roleRefId = search();
+        else
+          roleRefId = null;
+        if (roleRefId != null)
+          return true;
+
+        OrganizationMappedByRoleIterator = getParentOrgs();
+        if (OrganizationMappedByRoleIterator != null)
+          roleRefId = search();
+
+        if (roleRefId != null)
+          return true;
+
+        return false;
+      }
+
+      private String search() {
+        for (; OrganizationMappedByRoleIterator.hasNext();) {
+          TreeNode OrganizationMappedByRole = OrganizationMappedByRoleIterator.next();
+          TreeNode organizationRefIdNode = OrganizationMappedByRole.getChildren().at(0).b();
+          String organizationRefId = organizationRefIdNode.getAttributes().getString("text-organizationRefId");
+          if (!filterIds.contains(organizationRefId))
+            continue;
+
+          TreeNode roleRefIdNode = OrganizationMappedByRole.getChildren().at(1).b();
+          return roleRefIdNode.getAttributes().getString("text-roleRefId");
+        }
+        OrganizationMappedByRoleIterator = getParentOrgs();
+
+        return null;
+      }
+
+      private Iterator<TreeNode> getParentOrgs() {
+        for (; idNodeIterator.hasNext();) {
+          TreeNode targetPersonNode = idNodeIterator.next();
+          TreeNode parentOrganizations = targetPersonNode.getChildren().at(4).b();
+          return parentOrganizations.getChildren().iterator();
+        }
+        return null;
+      }
+
+      @Override
+      public String next() {
+        return roleRefId;
       }
 
     };
@@ -397,67 +302,60 @@
   public Iterator<String> competentRoleId(String personId) {
 
     InterfaceTraverser personTraverser = personTree.getTraverser();
-    Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.find((TreeNode node) -> {
-      Iterator<String> nodeElement = node.getAttributes().getString("element");
-      if (!nodeElement.hasNext())
-        return false;
-      if (!nodeElement.next().equals("Person"))
-        return false;
-      Iterator<String> nodeIdIterator = node.getAttributes().getString("Person-id");
-      if (!nodeIdIterator.hasNext())
-        return false;
-      if (nodeIdIterator.next().equals(personId))
-        return true;
-      return false;
-    }, "Person-id", personId);
+
+    return new Iterator<String>() {
 
-    if (!personIdPairIterator.hasNext())
-      return new NullIterator();
-
-    Pair<TreeNode, NodePath> personIdPair = personIdPairIterator.next();
-
-    Iterator<Pair<TreeNode, NodePath>> priorityPairIterator = personTraverser.findInSubTree((TreeNode node) -> {
-      Iterator<String> nodeElement = node.getAttributes().getString("element");
-      if (!nodeElement.hasNext())
-        return false;
-      if (!nodeElement.next().equals("priority"))
+      String roleId = "";
+      Iterator<TreeNode> personNodeIterator = personTraverser.find((TreeNode node) -> {
+        String nodeElement = node.getAttributes().getString("element");
+        if (nodeElement == null)
+          return false;
+        if (!nodeElement.equals("Person"))
+          return false;
+        String targetPersonId = node.getAttributes().getString("Person-id");
+        if (targetPersonId == null)
+          return false;
+        if (targetPersonId.equals(personId))
+          return true;
         return false;
-      Iterator<String> priorityIterator = node.getAttributes().getString("text-priority");
-      for (; priorityIterator.hasNext();) {
-        if (priorityIterator.next().equals("0"))
-          return true;
-      }
-      return false;
-    }, personIdPair, "text-priority", "0");
-
-    TreeMap<String, String> roleIdTreeMap = TreeMap.empty(Ord.stringOrd);
-
-    for (; priorityPairIterator.hasNext();) {
-
-      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);
-      Iterator<String> roleIdIterator = roleIdNode.getAttributes().getString("text-roleRefId");
-      for (; roleIdIterator.hasNext();) {
-        String roleId = roleIdIterator.next();
-        roleIdTreeMap = roleIdTreeMap.set(roleId, roleId);
-      }
-    }
-    Iterator<P2<String, String>> roleIdP2Iterator = roleIdTreeMap.iterator();
-    return new Iterator<String>() {
+      }, "PersonId", personId);
+      Iterator<TreeNode> PriorityMappedByRoleIterator = new NullIterator<TreeNode>();
 
       @Override
       public boolean hasNext() {
-        if (roleIdP2Iterator.hasNext())
+
+        for (; PriorityMappedByRoleIterator.hasNext();) {
+          if (search())
+            return true;
+        }
+
+        for (; personNodeIterator.hasNext();) {
+          TreeNode personNode = personNodeIterator.next();
+          TreeNode prioritiesNode = personNode.getChildren().at(6).b();
+          PriorityMappedByRoleIterator = prioritiesNode.getChildren().iterator();
+          for (; PriorityMappedByRoleIterator.hasNext();) {
+            if (search())
+              return true;
+          }
+        }
+        return false;
+      }
+
+      private boolean search() {
+        TreeNode priorityMappedByRole = PriorityMappedByRoleIterator.next();
+        TreeNode priorityNode = priorityMappedByRole.getChildren().at(0).b();
+        String priority = priorityNode.getAttributes().getString("text-priority");
+        if (priority.equals("0")) {
+          TreeNode roleIdNode = priorityMappedByRole.getChildren().at(1).b();
+          roleId = roleIdNode.getAttributes().getString("text-roleRefId");
           return true;
+        }
         return false;
       }
 
       @Override
       public String next() {
-        return roleIdP2Iterator.next()._1();
+        return roleId;
       }
     };
   }
@@ -465,168 +363,163 @@
   public Iterator<String> concurrentRoleIds(String personId) {
 
     InterfaceTraverser personTraverser = personTree.getTraverser();
-    Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.find((TreeNode node) -> {
-      Iterator<String> nodeElement = node.getAttributes().getString("element");
-      if (!nodeElement.hasNext())
-        return false;
-      if (!nodeElement.next().equals("Person"))
-        return false;
-      Iterator<String> nodeId = node.getAttributes().getString("Person-id");
-      for (; nodeId.hasNext();) {
-        if (nodeId.next().equals(personId))
-          return true;
-      }
-      return false;
-    }, "Person-id", personId);
 
-    if (!personIdPairIterator.hasNext())
-      return new NullIterator();
-
-    Pair<TreeNode, NodePath> personidPair = personIdPairIterator.next();
+    return new Iterator<String>() {
 
-    Iterator<Pair<TreeNode, NodePath>> priorityPairIterator = personTraverser.findInSubTreeAllValue(
-        (TreeNode node) -> {
-          Iterator<String> nodeElement = node.getAttributes().getString("element");
-          if (!nodeElement.hasNext())
-            return false;
-          if (!nodeElement.next().equals("priority"))
-            return false;
-          Iterator<String> priorityIterator = node.getAttributes().getString("text-priority");
-          if (priorityIterator.hasNext())
-            return true;
+      String roleId = "";
+      Iterator<TreeNode> personNodeIterator = personTraverser.find((TreeNode node) -> {
+        String nodeElement = node.getAttributes().getString("element");
+        if (nodeElement == null)
+          return false;
+        if (!nodeElement.equals("Person"))
           return false;
-        }, personidPair, "text-priority");
-
-    TreeMap<String, String> roleIdTreeMap = TreeMap.empty(Ord.stringOrd);
-
-    for (; priorityPairIterator.hasNext();) {
-
-      Pair<TreeNode, NodePath> priorityPair = priorityPairIterator.next();
-      TreeNode priorityNode = priorityPair.left();
-      Iterator<String> priorityIterator = priorityNode.getAttributes().getString("text-priority");
-      for (; priorityIterator.hasNext();) {
-        int priority = Integer.parseInt(priorityIterator.next());
-        if (priority > 0) {
-          NodePath priorityPath = priorityPair.right();
-          Pair<Integer, NodePath> removeLastPair = priorityPath.last();
-          NodePath roleIdNodePath = removeLastPair.right().add(removeLastPair.left() + 1);
-          TreeNode roleIdNode = getTarget(personTree.getRootNode(), roleIdNodePath);
-          Iterator<String> roleIdIterator = roleIdNode.getAttributes().getString("text-roleRefId");
-          for (; roleIdIterator.hasNext();) {
-            String roleId = roleIdIterator.next();
-            roleIdTreeMap = roleIdTreeMap.set(roleId, roleId);
-          }
-        }
-      }
-    }
-
-    Iterator<P2<String, String>> roleIdP2Iterator = roleIdTreeMap.iterator();
-    return new Iterator<String>() {
+        String targetPersonId = node.getAttributes().getString("Person-id");
+        if (targetPersonId == null)
+          return false;
+        if (targetPersonId.equals(personId))
+          return true;
+        return false;
+      }, "PersonId", personId);
+      Iterator<TreeNode> PriorityMappedByRoleIterator = new NullIterator<TreeNode>();
 
       @Override
       public boolean hasNext() {
-        if (roleIdP2Iterator.hasNext())
+
+        for (; PriorityMappedByRoleIterator.hasNext();) {
+          if (search())
+            return true;
+        }
+
+        for (; personNodeIterator.hasNext();) {
+          TreeNode personNode = personNodeIterator.next();
+          TreeNode prioritiesNode = personNode.getChildren().at(6).b();
+          PriorityMappedByRoleIterator = prioritiesNode.getChildren().iterator();
+          for (; PriorityMappedByRoleIterator.hasNext();) {
+            if (search())
+              return true;
+          }
+        }
+        return false;
+      }
+
+      private boolean search() {
+        TreeNode priorityMappedByRole = PriorityMappedByRoleIterator.next();
+        TreeNode priorityNode = priorityMappedByRole.getChildren().at(0).b();
+        int priority = Integer.parseInt(priorityNode.getAttributes().getString("text-priority"));
+
+        if (priority > 0) {
+          TreeNode roleIdNode = priorityMappedByRole.getChildren().at(1).b();
+          roleId = roleIdNode.getAttributes().getString("text-roleRefId");
           return true;
+        }
         return false;
+
       }
 
       @Override
       public String next() {
-        return roleIdP2Iterator.next()._1();
+        return roleId;
       }
     };
   }
 
   public Iterator<String> deepPersonIds(String orgId, LinkedList<String> filterIds) {
 
-    TreeMap<String, String> personIdsTreeMap = TreeMap.empty(Ord.stringOrd);
-    Iterator<String> childrensIterator = deepChildOrganizationIdsPlus(orgId, filterIds);
-
-    if (!childrensIterator.hasNext())
-      return new NullIterator();
-
-    for (; childrensIterator.hasNext();) {
-      String id = childrensIterator.next();
-      personIdsTreeMap = personIdsSearch(id, personIdsTreeMap);
-    }
-
-    if (personIdsTreeMap.isEmpty())
-      return new NullIterator();
-
-    Iterator<P2<String, String>> personIds = personIdsTreeMap.iterator();
     return new Iterator<String>() {
+      Iterator<String> orgIdIterator = deepParentOrganizationIdsPlus(orgId, filterIds);
+      private Iterator<String> personIterator = new NullIterator<String>();
+      String personId = "";
 
       @Override
       public boolean hasNext() {
-        if (personIds.hasNext())
-          return true;
-        return false;
-      }
-
-      @Override
-      public String next() {
-        return personIds.next()._1();
-      }
-    };
-  }
-
-  public Iterator<String> deepChildOrganizationIdsPlus(String orgId, LinkedList<String> filterIds) {
-    TreeMap<String, String> orgIdsTreeMap = TreeMap.empty(Ord.stringOrd);
+        for (; orgIdIterator.hasNext();) {
+          if (personIterator.hasNext()) {
+            personId = personIterator.next();
+            return true;
+          }
 
-    orgIdsTreeMap = orgIdsTreeMap.set(orgId, orgId);
-    orgIdsTreeMap = _deepChildOrganizationIds(orgId, orgIdsTreeMap);
-
-    if (orgIdsTreeMap.isEmpty())
-      return new NullIterator();
-
-    Iterator<P2<String, String>> orgIdsP2Iterator = orgIdsTreeMap.iterator();
-    return new Iterator<String>() {
-
-      String childOrgId;
-
-      @Override
-      public boolean hasNext() {
-        for (; orgIdsP2Iterator.hasNext();) {
-          childOrgId = orgIdsP2Iterator.next()._1();
-          if (filter(childOrgId, filterIds))
+          String targetOrgId = orgIdIterator.next();
+          personIterator = personIds(targetOrgId, new LinkedList<>());
+          if (personIterator.hasNext()) {
+            personId = personIterator.next();
             return true;
+          }
         }
         return false;
       }
 
       @Override
       public String next() {
-        return childOrgId;
+        // TODO Auto-generated method stub
+        return personId;
+      }
+
+    };
+  }
+
+  public Iterator<String> deepChildOrganizationIdsPlus(String orgId, LinkedList<String> filterIds) {
+
+    return new Iterator<String>() {
+      Iterator<String> childOrgIdIterator = deepChildOrganizationIds(orgId, filterIds);
+      String childOrgId = initOrgId();
+
+      @Override
+      public boolean hasNext() {
+        return childOrgId != null;
       }
+
+      private String initOrgId() {
+        if (filter(filterIds, orgId))
+          return orgId;
+        if (childOrgIdIterator.hasNext())
+          return childOrgIdIterator.next();
+        return null;
+      }
+
+      @Override
+      public String next() {
+        String str = childOrgId;
+        if (childOrgIdIterator.hasNext())
+          childOrgId = childOrgIdIterator.next();
+        else
+          childOrgId = null;
+        return str;
+      }
+
     };
   }
 
   public Iterator<String> deepChildOrganizationIds(String orgId, LinkedList<String> filterIds) {
 
-    TreeMap<String, String> orgIdsTreeMap = TreeMap.empty(Ord.stringOrd);
-    TreeMap<String, String> newOrgIdsTreeMap = _deepChildOrganizationIds(orgId, orgIdsTreeMap);
-    if (newOrgIdsTreeMap.isEmpty())
-      return new NullIterator();
+    return new Iterator<String>() {
+
+      Iterator<TreeNode> childOrgnizationIdsIterator = childOrganizationIdsNode(orgId);
+      Stack<String> orgIdStack = new Stack<String>();
+
+      String childOrgId;
+
+      @Override
+      public boolean hasNext() {
 
-    Iterator<P2<String, String>> orgIdP2Iterator = newOrgIdsTreeMap.iterator();
+        for (; childOrgnizationIdsIterator.hasNext();) {
+          TreeNode parentOrgIdNode = childOrgnizationIdsIterator.next();
+          childOrgId = parentOrgIdNode.getAttributes().getString("text-organizationRefId");
+          orgIdStack.push(childOrgId);
+          if (orgNodefilter(filterIds, parentOrgIdNode))
+            return true;
+        }
+        if (orgIdStack.isEmpty())
+          return false;
 
-    return new Iterator<String>() {
-      String childOrgId;
+        childOrgnizationIdsIterator = childOrganizationIdsNode(orgIdStack.pop());
+        return this.hasNext();
+      }
 
       @Override
       public String next() {
         return childOrgId;
       }
 
-      @Override
-      public boolean hasNext() {
-        for (; orgIdP2Iterator.hasNext();) {
-          childOrgId = orgIdP2Iterator.next()._1();
-          if (filter(childOrgId, filterIds))
-            return true;
-        }
-        return false;
-      }
     };
   }
 
@@ -649,99 +542,255 @@
   }
 
   public Iterator<String> childOrganizationIds(String orgId, LinkedList<String> filterIds) {
-    TreeMap<String, String> childrenOrgIdTreeMap = TreeMap.empty(Ord.stringOrd);
-    TreeMap<String, String> newChildrenOrgIdTreeMap = _childOrganizationIds(orgId, childrenOrgIdTreeMap);
-
-    if (newChildrenOrgIdTreeMap.isEmpty())
-      return new NullIterator();
-
-    Iterator<P2<String, String>> childrenOrgIdIterator = newChildrenOrgIdTreeMap.iterator();
 
     return new Iterator<String>() {
-      String childOrgId;
+      Iterator<TreeNode> orgNodeIterator = childOrganizationIdsNode(orgId);
+      String organizationRefId;
 
       @Override
       public boolean hasNext() {
-
-        if (childrenOrgIdIterator.hasNext()) {
-          childOrgId = childrenOrgIdIterator.next()._1();
-          if (filter(childOrgId, filterIds))
-            return true;
+        for (; orgNodeIterator.hasNext();) {
+          TreeNode organizationRefIdNode = orgNodeIterator.next();
+          organizationRefId = organizationRefIdNode.getAttributes().getString("text-organizationRefId");
+          return true;
         }
         return false;
       }
 
       @Override
       public String next() {
-        return childOrgId;
+        return organizationRefId;
+      }
+
+    };
+  }
+
+  public Iterator<TreeNode> childOrganizationIdsNode(String orgId) {
+
+    InterfaceTraverser orgTraverser = organizationTree.getTraverser();
+
+    return new Iterator<TreeNode>() {
+      TreeNode childOrgNode;
+
+      Iterator<TreeNode> orgIdNodeIterator = 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("Organization-id");
+        if (nodeId == null)
+          return false;
+        if (nodeId.equals(orgId))
+          return true;
+        return false;
+      }, "Organization-id", orgId);
+
+      Iterator<TreeNode> childOrganizations = getParentOrgs();
+
+      @Override
+      public boolean hasNext() {
+
+        if (childOrganizations == null)
+          return false;
+        if (childOrganizations.hasNext())
+          childOrgNode = search();
+        else
+          childOrgNode = null;
+        if (childOrgNode != null)
+          return true;
+
+        childOrganizations = getParentOrgs();
+        if (childOrganizations != null)
+          childOrgNode = search();
+
+        if (childOrgNode != null)
+          return true;
+
+        return this.hasNext();
+      }
+
+      @Override
+      public TreeNode next() {
+        return childOrgNode;
+      }
+
+      private TreeNode search() {
+        for (; childOrganizations.hasNext();) {
+          TreeNode OrganizationMappedByRole = childOrganizations.next();
+          TreeNode organizationRefIdsNode = OrganizationMappedByRole.getChildren().at(0).b();
+          TreeNode organizationRefIdNode = organizationRefIdsNode.getChildren().at(0).b();
+          return organizationRefIdNode;
+
+        }
+        childOrganizations = getParentOrgs();
+
+        return null;
+      }
+
+      private Iterator<TreeNode> getParentOrgs() {
+        for (; orgIdNodeIterator.hasNext();) {
+          TreeNode targetPersonNode = orgIdNodeIterator.next();
+          TreeNode parentOrganizations = targetPersonNode.getChildren().at(3).b();
+          return parentOrganizations.getChildren().iterator();
+        }
+        return null;
       }
     };
 
   }
 
+  private boolean orgNodefilter(LinkedList<String> filterIds, TreeNode orgNode) {
+    System.out.println(orgNode.getAttributes().getString("element"));
+    String orgId = orgNode.getAttributes().getString("text-organizationRefId");
+
+    return filter(filterIds, orgId);
+  }
+
+  private boolean filter(LinkedList<String> filterIds, String id) {
+
+    Pattern orgPattern = Pattern.compile("o:");
+    Matcher orgMacher = orgPattern.matcher(id);
+    if (orgMacher.find()) {
+      id = getRole(id);
+    }
+
+    for (String filterId : filterIds) {
+      Pattern rolePattern = Pattern.compile("r:");
+      Matcher roleMacher = rolePattern.matcher(filterId);
+      if (roleMacher.find()) {
+        if (!filterId.equals(id)) {
+          return false;
+        }
+      } else {
+        Pattern rdePattern = Pattern.compile("rde:");
+        Matcher rdeMacher = rdePattern.matcher(filterId);
+        if (rdeMacher.find()) {
+          if (!getRde(id, filterId))
+            return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  private String getRole(String orgId) {
+    InterfaceTraverser orgTraverser = organizationTree.getTraverser();
+    Iterator<TreeNode> orgNodeIterator = 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("Organization");
+      if (nodeId == null)
+        return false;
+      if (nodeId.equals(orgId))
+        return true;
+      return false;
+    }, "Organization-id", orgId);
+
+    if (!orgNodeIterator.hasNext())
+      return "";
+
+    TreeNode orgNode = orgNodeIterator.next();
+    TreeNode roleRefIds = orgNode.getChildren().at(2).b();
+    TreeNode roleRefId = roleRefIds.getChildren().at(0).b();
+    String roleId = roleRefId.getAttributes().getString("text-roleRefId");
+    return roleId;
+  }
+
+  private boolean getRde(String roleId, String filterId) {
+
+    InterfaceTraverser roleTraverser = roleTree.getTraverser();
+    Iterator<TreeNode> rdeIdNodeIterator = roleTraverser.find((TreeNode node) -> {
+      String nodeElement = node.getAttributes().getString("element");
+      if (nodeElement == null)
+        return false;
+      if (!nodeElement.equals("Role"))
+        return false;
+      String nodeId = node.getAttributes().getString("Role-id");
+      if (nodeId == null)
+        return false;
+      if (nodeId.equals(roleId))
+        return true;
+      return false;
+    }, "Role-id", roleId);
+
+    for (; rdeIdNodeIterator.hasNext();) {
+      TreeNode rdeIdNode = rdeIdNodeIterator.next();
+      TreeNode roleDescriptionElementRefIds = rdeIdNode.getChildren().at(6).b();
+      Iterator<TreeNode> roleDescriptionElementRefIdIterator = roleDescriptionElementRefIds.getChildren().iterator();
+      for (; roleDescriptionElementRefIdIterator.hasNext();) {
+        String roleDescriptionElementRefId = roleDescriptionElementRefIdIterator.next().getAttributes()
+            .getString("text-roleDescriptionElementRefId");
+        System.out.println(roleDescriptionElementRefId);
+        if (roleDescriptionElementRefId.equals(filterId))
+          return true;
+      }
+    }
+    return false;
+  }
+
   public TreeMap<String, String> _childOrganizationIds(String orgId, TreeMap<String, String> childOrgIdsTreeMap) {
 
     InterfaceTraverser orgTraverser = organizationTree.getTraverser();
 
-    Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = orgTraverser.find((TreeNode node) -> {
-      Iterator<String> nodeElement = node.getAttributes().getString("element");
-      if (!nodeElement.hasNext())
+    Iterator<TreeNode> orgIdNodeIterator = orgTraverser.find((TreeNode node) -> {
+      String nodeElement = node.getAttributes().getString("element");
+      if (nodeElement == null)
         return false;
-      if (!nodeElement.next().equals("Organization"))
+      if (!nodeElement.equals("Organization"))
         return false;
-      Iterator<String> nodeIdIterator = node.getAttributes().getString("Organization-id");
-      for (; nodeIdIterator.hasNext();) {
-        if (nodeIdIterator.next().equals(orgId))
-          return true;
-      }
+      String nodeId = node.getAttributes().getString("Organization-id");
+      if (nodeId == null)
+        return false;
+      if (nodeId.equals(orgId))
+        return true;
       return false;
     }, "Organization-id", orgId);
 
-    if (!orgIdPairIterator.hasNext())
+    if (!orgIdNodeIterator.hasNext())
       return childOrgIdsTreeMap;
 
-    Pair<TreeNode, NodePath> orgIdPair = orgIdPairIterator.next();
+    TreeNode orgIdNode = orgIdNodeIterator.next();
 
-    Iterator<Pair<TreeNode, NodePath>> chilrenOrgPairIterator = orgTraverser.findInSubTree((TreeNode node) -> {
-      Iterator<String> nodeElement = node.getAttributes().getString("element");
-      if (!nodeElement.hasNext())
+    Iterator<TreeNode> chilrenOrgNodeIterator = orgTraverser.findInSubTree((TreeNode node) -> {
+      String nodeElement = node.getAttributes().getString("element");
+      if (nodeElement == null)
         return false;
-      if (nodeElement.next().equals("childOrganizations"))
+      if (nodeElement.equals("childOrganizations"))
         return true;
       return false;
-    }, orgIdPair, "element", "childOrganizations");
+    }, orgIdNode, "element", "childOrganizations");
 
-    if (!chilrenOrgPairIterator.hasNext())
+    if (!chilrenOrgNodeIterator.hasNext())
       return childOrgIdsTreeMap;
 
-    Pair<TreeNode, NodePath> chilerenOrg = chilrenOrgPairIterator.next();
+    TreeNode chilerenOrg = chilrenOrgNodeIterator.next();
 
-    Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdPairIterator = orgTraverser.findInSubTreeAllValue(
-        (TreeNode node) -> {
-          Iterator<String> nodeElement = node.getAttributes().getString("element");
-          if (!nodeElement.hasNext())
-            return false;
-          if (!nodeElement.next().equals("organizationRefIds"))
-            return false;
-          Iterator<String> nodeText = node.getAttributes().getString("text-organizationRefIds");
-          if (nodeText.hasNext())
-            return true;
-          return false;
-        }, chilerenOrg, "text-organizationRefIds");
+    Iterator<TreeNode> chilrenOrgIdNodeIterator = 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();) {
-      Iterator<String> childrenOrgIdIterator = chilrenOrgIdPairIterator.next().left().getAttributes()
-          .getString("text-organizationRefIds");
-      for (; childrenOrgIdIterator.hasNext();) {
-        String childrenOrgId = childrenOrgIdIterator.next();
-        childOrgIdsTreeMap = childOrgIdsTreeMap.set(childrenOrgId, childrenOrgId);
-      }
+    for (; chilrenOrgIdNodeIterator.hasNext();) {
+      String childrenOrgId = chilrenOrgIdNodeIterator.next().getAttributes().getString("text-organizationRefIds");
+      childOrgIdsTreeMap = childOrgIdsTreeMap.set(childrenOrgId, childrenOrgId);
+
     }
 
     return childOrgIdsTreeMap;
   }
 
-  class NullIterator implements Iterator<String> {
+  class NullIterator<T> implements Iterator<T> {
 
     @Override
     public boolean hasNext() {
@@ -749,7 +798,7 @@
     }
 
     @Override
-    public String next() {
+    public T next() {
       return null;
     }
 
@@ -759,169 +808,179 @@
 
     InterfaceTraverser personTraverser = personTree.getTraverser();
 
-    Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.find((TreeNode node) -> {
-      Iterator<String> element = node.getAttributes().getString("element");
-      if (!element.hasNext())
-        return false;
-      if (!element.next().equals("Person"))
+    Iterator<TreeNode> roleIdNodeIterator = personTraverser.find((TreeNode node) -> {
+      String element = node.getAttributes().getString("element");
+      if (element == null)
         return false;
-      Iterator<String> nodePersonId = node.getAttributes().getString("Person-id");
-      for (; nodePersonId.hasNext();) {
-        if (nodePersonId.next().equals(personId))
-          return true;
-      }
-      return false;
-    }, "Person-id", personId);
-
-    if (!personIdPairIterator.hasNext())
-      return "";
-
-    Pair<TreeNode, NodePath> targetPersonIdPair = personIdPairIterator.next();
-
-    Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = personTraverser.findInSubTree((TreeNode node) -> {
-      Iterator<String> element = node.getAttributes().getString("element");
-      if (!element.hasNext())
+      if (!element.equals("roleRefId"))
+        return false;
+      String compareRoleId = node.getAttributes().getString("text-roleRefId");
+      if (compareRoleId == null)
         return false;
-      if (!element.next().equals("roleRefId"))
-        return false;
-      Iterator<String> compareRoleId = node.getAttributes().getString("text-roleRefId");
-      for (; compareRoleId.hasNext();) {
-        if (compareRoleId.next().equals(roleId))
-          return true;
-      }
+      if (compareRoleId.equals(roleId))
+        return true;
       return false;
-    }, targetPersonIdPair, "text-roleRefId", roleId);
+    }, "text-roleRefId", roleId);
 
-    for (; roleIdPairIterator.hasNext();) {
-      Pair<TreeNode, NodePath> roleIdPair = roleIdPairIterator.next();
-      NodePath roleIdNodePath = roleIdPair.right();
-      Pair<Integer, NodePath> removeLastPath = roleIdNodePath.last();
-      NodePath priorityNodePath = removeLastPath.right().add(removeLastPath.left() - 1);
-      TreeNode priorityNode = getTarget(personTree.getRootNode(), priorityNodePath);
-      Iterator<String> element = priorityNode.getAttributes().getString("element");
-      if (element.hasNext()) {
-        if (element.next().equals("priority")) {
-          Iterator<String> priority = priorityNode.getAttributes().getString("text-priority");
-          if (priority.hasNext())
-            return priority.next();
-        }
-      }
+    for (; roleIdNodeIterator.hasNext();) {
+      TreeNode roleIdNode = roleIdNodeIterator.next();
+      ParentIndex parentIndex = personTraverser.getParentIndex();
+      TreeNode roleIdParentNode = parentIndex.get(roleIdNode);
+      TreeNode parent = parentIndex.get(roleIdParentNode);
+      parent = parentIndex.get(parent);
+      String nodePersonId = parent.getAttributes().getString("Person-Id");
+      if (nodePersonId != null && !nodePersonId.equals(personId))
+        continue;
+      TreeNode priorityNode = roleIdParentNode.getChildren().at(0).b();
+      if (priorityNode.getAttributes().getString("element").equals("priority"))
+        return priorityNode.getAttributes().getString("text-priority");
     }
     return "";
   }
 
-  public Iterator<String> parentOrganizationIds(String orgId, LinkedList<String> filterIds) {
+  public Iterator<String> parentOrganizationIds(String id, LinkedList<String> 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;
+      Iterator<TreeNode> orgNodeIterator = parentOrganizationIdsNode(id);
+      String organizationRefId;
 
       @Override
       public boolean hasNext() {
-        for (; parentIdP2Iterator.hasNext();) {
-          parentId = parentIdP2Iterator.next()._1();
-          if (filter(parentId, filterIds))
-            return true;
+        for (; orgNodeIterator.hasNext();) {
+          TreeNode organizationRefIdNode = orgNodeIterator.next();
+          String orgId = organizationRefIdNode.getAttributes().getString("text-organizationRefId");
+          if (!filter(filterIds, orgId))
+            continue;
+          organizationRefId = orgId;
+          return true;
         }
         return false;
       }
 
       @Override
       public String next() {
-        return parentId;
+        return organizationRefId;
       }
 
     };
   }
 
-  public TreeMap<String, String> _parentOrganizationIds(String orgId) {
+  public Iterator<TreeNode> parentOrganizationIdsNode(String id) {
+
+    return new Iterator<TreeNode>() {
+      InterfaceTraverser traverser = getTraverser(id);
+      String element;
+      int pos;
 
-    InterfaceTraverser orgTraverser = organizationTree.getTraverser();
-    Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = orgTraverser.find((TreeNode node) -> {
-      Iterator<String> element = node.getAttributes().getString("element");
-      if (!element.hasNext())
-        return false;
-      if (!element.next().equals("Organization"))
-        return false;
-      Iterator<String> nodeIdIterator = node.getAttributes().getString("Organization-id");
-      for (; nodeIdIterator.hasNext();) {
-        if (nodeIdIterator.next().equals(orgId))
+      Iterator<TreeNode> idNodeIterator = 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;
-    }, "Organization-id", orgId);
-
-    if (!orgIdPairIterator.hasNext())
-      return TreeMap.empty(Ord.stringOrd);
-
-    Pair<TreeNode, NodePath> orgNode = orgIdPairIterator.next();
-
-    Iterator<Pair<TreeNode, NodePath>> parentOrgPairIterator = orgTraverser.findInSubTree((TreeNode node) -> {
-      Iterator<String> element = node.getAttributes().getString("element");
-      if (!element.hasNext())
         return false;
-      if (element.next().equals("parentOrganizations"))
-        return true;
-      return false;
-    }, orgNode, "element", "parentOrganizations");
+      }, element + "-id", id);
 
-    TreeMap<String, String> parentIdsTreeMap = TreeMap.empty(Ord.stringOrd);
-
-    for (; parentOrgPairIterator.hasNext();) {
-      Pair<TreeNode, NodePath> parentOrgNode = parentOrgPairIterator.next();
+      TreeNode orgId;
+      Iterator<TreeNode> parentOrganizationsIterator = getparentOrganizations();
 
-      Iterator<Pair<TreeNode, NodePath>> parentOrgIdPairIterator = orgTraverser.findInSubTreeAllValue(
-          (TreeNode node) -> {
-            Iterator<String> element = node.getAttributes().getString("element");
-            if (!element.hasNext())
-              return false;
-            if (!element.next().equals("organizationRefId"))
-              return false;
-            Iterator<String> parentIdIterator = node.getAttributes().getString("text-organizationRefId");
-            if (parentIdIterator.hasNext())
-              return true;
-            return false;
-          }, parentOrgNode, "text-organizationRefId");
-
-      for (; parentOrgIdPairIterator.hasNext();) {
-        Iterator<String> parentIdIterator = parentOrgIdPairIterator.next().left().getAttributes()
-            .getString("text-organizationRefId");
-        for (; parentIdIterator.hasNext();) {
-          String parentId = parentIdIterator.next();
-          parentIdsTreeMap = parentIdsTreeMap.set(parentId, parentId);
+      private Iterator<TreeNode> getparentOrganizations() {
+        for (; idNodeIterator.hasNext();) {
+          TreeNode targetPersonNode = idNodeIterator.next();
+          TreeNode parentOrganizations = targetPersonNode.getChildren().at(pos).b();
+          return parentOrganizations.getChildren().iterator();
         }
+        return null;
       }
 
-    }
+      @Override
+      public boolean hasNext() {
+        if (parentOrganizationsIterator == null)
+          return false;
+        if (parentOrganizationsIterator.hasNext())
+          orgId = search();
+        else
+          orgId = null;
+        if (orgId != null)
+          return true;
+
+        for (; parentOrganizationsIterator != null;) {
+          parentOrganizationsIterator = getparentOrganizations();
+          if (parentOrganizationsIterator != null)
+            orgId = search();
+
+          if (orgId != null)
+            return true;
+        }
+        return false;
+      }
+
+      @Override
+      public TreeNode next() {
+        return orgId;
+      }
 
-    return parentIdsTreeMap;
+      private TreeNode search() {
+        for (; parentOrganizationsIterator.hasNext();) {
+          TreeNode OrganizationMappedByRole = parentOrganizationsIterator.next();
+          TreeNode organizationRefIdNode = OrganizationMappedByRole.getChildren().at(0).b();
+          return organizationRefIdNode;
+        }
+        parentOrganizationsIterator = getparentOrganizations();
+
+        return null;
+      }
 
+      private InterfaceTraverser getTraverser(String id) {
+        Pattern rolePattern = Pattern.compile("p:");
+        Matcher roleMacher = rolePattern.matcher(id);
+        if (roleMacher.find()) {
+          element = "Person";
+          pos = 5;
+          return personTree.getTraverser();
+        }
+
+        Pattern rdePattern = Pattern.compile("o:");
+        Matcher rdeMacher = rdePattern.matcher(id);
+        if (rdeMacher.find()) {
+          element = "Organization";
+          pos = 4;
+          return organizationTree.getTraverser();
+        }
+        return null;
+      }
+
+    };
   }
 
   public Iterator<String> deepParentOrganizationIds(String orgId, LinkedList<String> filterIds) {
-    TreeMap<String, String> parentIdsTreeMap = TreeMap.empty(Ord.stringOrd);
-    TreeMap<String, String> newParentIdsTreeMap = _deepParentOrganizationIds(orgId, parentIdsTreeMap);
-
-    if (newParentIdsTreeMap.isEmpty())
-      return new NullIterator();
-
-    Iterator<P2<String, String>> parentIds = newParentIdsTreeMap.iterator();
 
     return new Iterator<String>() {
+      Iterator<TreeNode> parentOrgnizationIdsIterator = parentOrganizationIdsNode(orgId);
+      Stack<String> orgIdStack = new Stack<String>();
+
       String parentOrgId;
 
       @Override
       public boolean hasNext() {
-        for (; parentIds.hasNext();) {
-          parentOrgId = parentIds.next()._1();
-          if (filter(parentOrgId, filterIds))
+
+        for (; parentOrgnizationIdsIterator.hasNext();) {
+          TreeNode parentOrgIdNode = parentOrgnizationIdsIterator.next();
+          parentOrgId = parentOrgIdNode.getAttributes().getString("text-organizationRefId");
+          orgIdStack.push(parentOrgId);
+          if (orgNodefilter(filterIds, parentOrgIdNode))
             return true;
         }
-        return false;
+        if (orgIdStack.isEmpty())
+          return false;
+
+        parentOrgnizationIdsIterator = parentOrganizationIdsNode(orgIdStack.pop());
+        return this.hasNext();
       }
 
       @Override
@@ -932,49 +991,33 @@
     };
   }
 
-  public TreeMap<String, String> _deepParentOrganizationIds(String orgId, TreeMap<String, String> orgIds) {
-
-    TreeMap<String, String> parentIdsTreeMap = _parentOrganizationIds(orgId);
-
-    if (parentIdsTreeMap.isEmpty())
-      return 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);
-
-    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;
+      String parentOrgId = initOrgId();
+      Iterator<String> parentOrgIdIterator = deepParentOrganizationIds(id, filterIds);
 
       @Override
       public boolean hasNext() {
-        for (; personIds.hasNext();) {
-          parentOrgId = personIds.next()._1();
-          if (filter(parentOrgId, filterIds))
-            return true;
-        }
-        return false;
+        return parentOrgId != null;
+      }
+
+      private String initOrgId() {
+        if (filter(filterIds, id))
+          return id;
+
+        if (parentOrgIdIterator.hasNext())
+          return parentOrgIdIterator.next();
+        return null;
       }
 
       @Override
       public String next() {
-        return parentOrgId;
+        String str = parentOrgId;
+        parentOrgId = null;
+        if (parentOrgIdIterator.hasNext())
+          parentOrgId = parentOrgIdIterator.next();
+        return str;
       }
 
     };
@@ -991,81 +1034,66 @@
     final String StrPath = str;
 
     InterfaceTraverser traverser = null;
-    TreeNode root = null;
     String elementName = null;
     if (splitPath[0].equals("r")) {
       traverser = roleTree.getTraverser();
-      root = roleTree.getRootNode();
       elementName = "Role";
     }
     if (splitPath[0].equals("rde")) {
       traverser = rdeTree.getTraverser();
-      root = rdeTree.getRootNode();
       elementName = "RoleDescriptionElement";
     }
 
-    Iterator<Pair<TreeNode, NodePath>> PathNameIterator = traverser.find((TreeNode node) -> {
-      Iterator<String> element = node.getAttributes().getString("element");
-      if (!element.hasNext())
+    Iterator<TreeNode> PathNameIterator = traverser.find((TreeNode node) -> {
+      String element = node.getAttributes().getString("element");
+      if (element == null)
         return false;
-      if (!element.next().equals("path"))
+      if (!element.equals("path"))
         return false;
-      Iterator<String> pathStringIterator = node.getAttributes().getString("text-path");
-      for (; pathStringIterator.hasNext();) {
-        if (pathStringIterator.next().equals(StrPath))
-          return true;
-      }
+      String pathString = node.getAttributes().getString("text-path");
+      if (pathString == null)
+        return false;
+      if (pathString.equals(StrPath))
+        return true;
       return false;
     }, "text-path", StrPath);
 
     if (!PathNameIterator.hasNext())
       return "";
 
-    Pair<TreeNode, NodePath> pathNamePair = PathNameIterator.next();
-    NodePath pathNamePath = pathNamePair.right();
-    NodePath pathNameIdPath = pathNamePath.last().right();
-
-    TreeNode pathNameIdNode = getTarget(root, pathNameIdPath);
-    Iterator<String> pathNameIdIterator = pathNameIdNode.getAttributes().getString(elementName + "-id");
-    if (pathNameIdIterator.hasNext())
-      return pathNameIdIterator.next();
-    return "";
+    TreeNode pathNameNode = PathNameIterator.next();
+    ParentIndex parentIndex = traverser.getParentIndex();
+    TreeNode pathNameIdNode = parentIndex.get(pathNameNode);
+    String pathNameId = pathNameIdNode.getAttributes().getString(elementName + "-id");
+    return pathNameId;
   }
 
   public Iterator<String> roleDescriptionElementIds(String id, LinkedList<String> filterIds) {
 
-    Iterator<String> orgIdsIterator = deepParentOrganizationIdsPlus(id, filterIds);
-
-    TreeMap<String, String> rdeIdsTreeMap = TreeMap.empty(Ord.stringOrd);
-
-    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>() {
+      Iterator<String> parentOrgIdIterator = deepParentOrganizationIdsPlus(id, filterIds);
+      Iterator<String> rdeIdIterator = new NullIterator<String>();
 
       @Override
       public boolean hasNext() {
-        if (rdeIds.hasNext())
+
+        if (rdeIdIterator.hasNext())
           return true;
-        return false;
+
+        if (parentOrgIdIterator.hasNext()) {
+          String orgId = parentOrgIdIterator.next();
+          String roleId = getRole(orgId);
+          rdeIdIterator = getRde(roleId);
+        } else {
+          return false;
+        }
+
+        return this.hasNext();
       }
 
       @Override
       public String next() {
-        return rdeIds.next()._1();
+        return rdeIdIterator.next();
       }
     };
   }
@@ -1074,50 +1102,43 @@
 
     InterfaceTraverser traverser = roleTree.getTraverser();
 
-    Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = traverser.find((TreeNode node) -> {
-      Iterator<String> element = node.getAttributes().getString("element");
-      if (!element.hasNext())
-        return false;
-      if (!element.next().equals("Role"))
-        return false;
-      Iterator<String> idIterator = node.getAttributes().getString("Role-id");
-      for (; idIterator.hasNext();) {
-        if (idIterator.next().equals(roleId))
-          return true;
-      }
-      return false;
-    }, "Role-id", roleId);
-
-    if (!roleIdPairIterator.hasNext())
-      return new NullIterator();
-
-    Pair<TreeNode, NodePath> roleIdPair = roleIdPairIterator.next();
+    return new Iterator<String>() {
 
-    Iterator<Pair<TreeNode, NodePath>> rdeIdPairIterator = traverser.findInSubTreeAllValue((TreeNode node) -> {
-      Iterator<String> element = node.getAttributes().getString("element");
-      if (!element.hasNext())
-        return false;
-      if (!element.next().equals("roleDescriptionElementRefIds"))
+      Iterator<TreeNode> roleIdNodeIterator = 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("Role-id");
+        if (id == null)
+          return false;
+        if (id.equals(roleId))
+          return true;
         return false;
-      Iterator<String> rdeIterator = node.getAttributes().getString("text-roleDescriptionElementRefIds");
-      if (rdeIterator.hasNext())
-        return true;
-      return false;
-    }, roleIdPair, "text-roleDescriptionElementRefIds");
-
-    if (!rdeIdPairIterator.hasNext())
-      return new NullIterator();
-
-    Iterator<String> rdeIdIterator = rdeIdPairIterator.next().left().getAttributes().getString("text-roleDescriptionElementRefIds");
- 
-    return new Iterator<String>() {
-      String rdeId = "";
+      }, "Role-id", roleId);
+      String rdeId;
+      Iterator<TreeNode> roleDescriptionElementRefIdIterator = new NullIterator<TreeNode>();
 
       @Override
       public boolean hasNext() {
-        if (rdeIdIterator.hasNext()) {
-          rdeId = rdeIdIterator.next();
-          return true;
+        for (; roleIdNodeIterator.hasNext();) {
+
+          if (roleDescriptionElementRefIdIterator.hasNext()) {
+            rdeId = roleDescriptionElementRefIdIterator.next().getAttributes()
+                .getString("text-roleDescriptionElementRefId");
+            return true;
+          }
+
+          TreeNode roleId = roleIdNodeIterator.next();
+          TreeNode roleDescriptionElementRefIds = roleId.getChildren().at(6).b();
+          roleDescriptionElementRefIdIterator = roleDescriptionElementRefIds.getChildren().iterator();
+          if (roleDescriptionElementRefIdIterator.hasNext()) {
+            rdeId = roleDescriptionElementRefIdIterator.next().getAttributes()
+                .getString("text-roleDescriptionElementRefId");
+            return true;
+          }
+
         }
         return false;
       }
@@ -1130,24 +1151,4 @@
 
   }
 
-  public TreeNode getTarget(TreeNode node, NodePath path) {
-    TreeNode target;
-    Pair<Integer, NodePath> popPath = path.pop();
-    int num = popPath.left();
-    NodePath newPath = popPath.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 (popPath.right().size() == 0)
-      return child;
-
-    target = getTarget(child, popPath.right());
-    return target;
-  }
-
 }
--- a/src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/JungleBulletinBoard.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/main/java/jp/ac/u_ryukyu/cr/ie/tatsuki/bbs/JungleBulletinBoard.java	Tue Nov 25 12:12:17 2014 +0900
@@ -2,13 +2,11 @@
 
 import java.io.FileInputStream;
 import java.nio.ByteBuffer;
-import java.util.Iterator;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import javax.xml.parsers.SAXParser;
 import javax.xml.parsers.SAXParserFactory;
 
-import fj.data.List;
 import ac.jp.u_ryukyu.cr.ie.tatsuki.xmlReader.ReadXmlHandler;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
@@ -34,552 +32,564 @@
 
 public class JungleBulletinBoard implements XmlBulletinBoard {
 
-  private final Jungle jungle;
+	private final Jungle jungle;
+
 
-  public JungleBulletinBoard() {
-    jungle = new DefaultJungle(null, "hoge", new DefaultTreeEditor(new DefaultTraverser()));
-    jungle.createNewTree("boards");
-  }
+	public JungleBulletinBoard() {
+		jungle = new DefaultJungle(null, "hoge", new DefaultTreeEditor(new DefaultTraverser()));
+		jungle.createNewTree("boards");
+	}
 
-  public IterableConverter<String, TreeNode> getBoards() {
-    JungleTree tree = jungle.getTreeByName("boards");
-    TreeNode node = tree.getRootNode();
-    Children chs = node.getChildren();
+
 
-    IterableConverter.Converter<String, TreeNode> converter = new IterableConverter.Converter<String, TreeNode>() {
+	public IterableConverter<String, TreeNode> getBoards() {
+		JungleTree tree = jungle.getTreeByName("boards");
+		TreeNode node = tree.getRootNode();
+		Children chs = node.getChildren();
 
-      public String conv(TreeNode _b) {
-        List<ByteBuffer> byteBufferList = _b.getAttributes().get("name");
-        if (byteBufferList.isNotEmpty())
-          return byteBufferList.head().toString();
-        return "";
-      }
-    };
+		IterableConverter.Converter<String, TreeNode> converter = new IterableConverter.Converter<String, TreeNode>() {
+			public String conv(TreeNode _b) {
+				ByteBuffer e = _b.getAttributes().get("name");
+				System.out.println(new String(e.array()));
+				return new String(e.array());
+			}
+		};
 
-    return new IterableConverter<String, TreeNode>(chs, converter);
-  }
+		return new IterableConverter<String, TreeNode>(chs, converter);
+	}
+
 
-  public void createBoards(final String _name) {
-    if (null == jungle.createNewTree(_name)) {
-      throw new IllegalStateException();
-    }
+	public void createBoards(final String _name) {
+		if (null == jungle.createNewTree(_name)) {
+			throw new IllegalStateException();
+		}
 
-    JungleTree tree = jungle.getTreeByName("boards");
-    JungleTreeEditor editor = tree.getTreeEditor();
-    DefaultNodePath root = new DefaultNodePath();
-    Either<Error, JungleTreeEditor> either = editor.addNewChildAt(root, 0);
-    if (either.isA()) {
-      throw new IllegalStateException();
-    }
-    editor = either.b();
+		JungleTree tree = jungle.getTreeByName("boards");
+		JungleTreeEditor editor = tree.getTreeEditor();
+		DefaultNodePath root = new DefaultNodePath();
+		Either<Error, JungleTreeEditor> either = editor.addNewChildAt(root, 0);
+		if (either.isA()) {
+			throw new IllegalStateException();
+		}
+		editor = either.b();
 
-    either = editor.putAttribute(root.add(0), "name", ByteBuffer.wrap(_name.getBytes()));
-    if (either.isA()) {
-      throw new IllegalStateException();
-    }
-    editor = either.b();
-    either = either.b().success();
-    if (either.isA()) {
-      throw new IllegalStateException();
-    }
+		either = editor.putAttribute(root.add(0), "name",ByteBuffer.wrap(_name.getBytes()));
+		if (either.isA()) {
+			throw new IllegalStateException();
+		}
+		editor = either.b();
+		either = either.b().success();
+		if (either.isA()) {
+			throw new IllegalStateException();
+		}
 
-  }
+	}
 
-  public void createFolder(final String _board, final String _author, final String _message, final String _editKey,
-      String _nodeNum) {
-    JungleTree tree = jungle.getTreeByName(_board);
-    if (tree == null) {
-      throw new IllegalStateException();
-    }
+	public void createFolder(final String _board, final String _author, final String _message, final String _editKey, String _nodeNum) {
+		JungleTree tree = jungle.getTreeByName(_board);
+		if (tree == null) {
+			throw new IllegalStateException();
+		}
 
-    DefaultNodePath path = new DefaultNodePath();
-    try {
-      for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) {
-        if (!_nodeNum.substring(count, count + 1).equals("/"))
-          path = path.add(Integer.parseInt(_nodeNum.substring(count, count + 1)));
-      }
-    } catch (Exception _e) {
-    }
-    Either<Error, JungleTreeEditor> either;
-    final long timestamp = System.currentTimeMillis();
-    final ByteBuffer tBuffer = ByteBuffer.allocate(16);
-    tBuffer.putLong(timestamp);
+		DefaultNodePath path = new DefaultNodePath();
+		try {
+			for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) {
+				if (!_nodeNum.substring(count, count + 1).equals("/"))
+					path = path.add(Integer.parseInt(_nodeNum.substring(count,
+							count + 1)));
+			}
+		} catch (Exception _e) {
+		}
+		Either<Error, JungleTreeEditor> either;
+		final long timestamp = System.currentTimeMillis();
+		final ByteBuffer tBuffer = ByteBuffer.allocate(16);
+		tBuffer.putLong(timestamp);
 
-    do {
-      TreeNode node = tree.getRootNode();
-      DefaultTraverser traverser = new DefaultTraverser();
-      // TraversableNodeWrapper<Node> traversable = new
-      // TraversableNodeWrapper<Node>(node);
-      DefaultEvaluator evaluator = new DefaultEvaluator(path);
-      Either<Error, Traversal> ret = traverser.traverse(node, evaluator);
-      if (ret.isA()) {
-        Assert.fail();
-      }
+		do {
+			TreeNode node = tree.getRootNode();
+			DefaultTraverser traverser = new DefaultTraverser();
+			// TraversableNodeWrapper<Node> traversable = new
+			// TraversableNodeWrapper<Node>(node);
+			DefaultEvaluator evaluator = new DefaultEvaluator(path);
+			Either<Error, Traversal> ret = traverser.traverse(node,
+					evaluator);
+			if (ret.isA()) {
+				Assert.fail();
+			}
 
-      Traversal traversal = ret.b();
-      TreeNode target = traversal.destination();
-      int size = target.getChildren().size();
-      JungleTreeEditor editor = tree.getTreeEditor();
-      either = editor.addNewChildAt(path, size);
-      if (either.isA()) {
-        throw new IllegalStateException();
-      }
-      editor = either.b();
+			Traversal traversal = ret.b();
+			TreeNode target = traversal.destination();
+			int size = target.getChildren().size();
+			JungleTreeEditor editor = tree.getTreeEditor();
+			either = editor.addNewChildAt(path, size);
+			if (either.isA()) {
+				throw new IllegalStateException();
+			}
+			editor = either.b();
 
-      NodeEditor e = new NodeEditor() {
+			NodeEditor e = new NodeEditor() {
 
-        public Either<Error, LoggingNode> edit(TreeNode node) {
-          LoggingNode logNode = wrap(node, new DefaultOperationLog());
-          logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
-          logNode = logNode.getAttributes().put("timestamp", tBuffer).b();
-          return DefaultEither.newB(logNode);
-        }
+				public Either<Error,LoggingNode> edit(TreeNode node) {
+					LoggingNode logNode = wrap(node , new DefaultOperationLog());
+					logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
+					logNode = logNode.getAttributes().put("timestamp", tBuffer).b();
+					return DefaultEither.newB(logNode);
+				}
 
-        @Override
-        public LoggingNode wrap(TreeNode node, OperationLog op) {
-          return new LoggingNode(node, op);
-        }
-      };
-      path = path.add(size);
-      either = editor.edit(path, e);
-      if (either.isA()) {
-        throw new IllegalStateException();
-      }
-      editor = either.b();
-      either = editor.success();
-    } while (either.isA());
+				@Override
+				public LoggingNode wrap(TreeNode node, OperationLog op) {
+					return new LoggingNode(node, op);
+				}
+			};
+			path = path.add(size);
+			either = editor.edit(path, e);
+			if (either.isA()) {
+				throw new IllegalStateException();
+			}
+			editor = either.b();
+			either = editor.success();
+		} while (either.isA());
 
-  }
+	}
 
-  public void createBoardMessage(final String _board, final String _author, final String _message, final String _editKey) {
-    JungleTree tree = jungle.getTreeByName(_board);
-    if (tree == null) {
-      throw new IllegalStateException();
-    }
+	public void createBoardMessage(final String _board, final String _author, final String _message, final String _editKey) {
+		JungleTree tree = jungle.getTreeByName(_board);
+		if (tree == null) {
+			throw new IllegalStateException();
+		}
 
-    Either<Error, JungleTreeEditor> either;
-    final long timestamp = System.currentTimeMillis();
-    final ByteBuffer tBuffer = ByteBuffer.allocate(16);
-    tBuffer.putLong(timestamp);
-    do {
+		Either<Error, JungleTreeEditor> either;
+		final long timestamp = System.currentTimeMillis();
+		final ByteBuffer tBuffer = ByteBuffer.allocate(16);
+		tBuffer.putLong(timestamp);
+		do {
 
-      TreeNode node = tree.getRootNode();
-      int size = node.getChildren().size();
-      DefaultNodePath path = new DefaultNodePath();
+			TreeNode node = tree.getRootNode();
+			int size = node.getChildren().size();
+			DefaultNodePath path = new DefaultNodePath();
 
-      JungleTreeEditor editor = tree.getTreeEditor();
-      either = editor.addNewChildAt(path, size);
-      if (either.isA()) {
-        throw new IllegalStateException();
-      }
-      editor = either.b();
+			JungleTreeEditor editor = tree.getTreeEditor();
+			either = editor.addNewChildAt(path, size);
+			if (either.isA()) {
+				throw new IllegalStateException();
+			}
+			editor = either.b();
+
+			NodeEditor e = new NodeEditor() {
+				public Either<Error,LoggingNode> edit(TreeNode node) {
+					LoggingNode logNode = wrap(node , new DefaultOperationLog());
+					logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
+					logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
+					logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
+					logNode = logNode.getAttributes().put("timestamp", tBuffer).b();
+					return DefaultEither.newB(logNode);
+				}
 
-      NodeEditor e = new NodeEditor() {
-        public Either<Error, LoggingNode> edit(TreeNode node) {
-          LoggingNode logNode = wrap(node, new DefaultOperationLog());
-          logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
-          logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
-          logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
-          logNode = logNode.getAttributes().put("timestamp", tBuffer).b();
-          return DefaultEither.newB(logNode);
-        }
+				@Override
+				public LoggingNode wrap(TreeNode node, OperationLog op) {
+					return new LoggingNode(node, op);
+				}
 
-        @Override
-        public LoggingNode wrap(TreeNode node, OperationLog op) {
-          return new LoggingNode(node, op);
-        }
+			};
+			path = path.add(size);
+			either = editor.edit(path, e);
+			if (either.isA()) {
+				throw new IllegalStateException();
+			}
+			editor = either.b();
+			either = editor.success();
+		} while (either.isA());
 
-      };
-      path = path.add(size);
-      either = editor.edit(path, e);
-      if (either.isA()) {
-        throw new IllegalStateException();
-      }
-      editor = either.b();
-      either = editor.success();
-    } while (either.isA());
+	}
 
-  }
-
-  public void editMessage(String _board, String _nodeNum, final String _author, final String _message,
-      final String _editKey) {
-    final long timestamp = System.currentTimeMillis();
-    final ByteBuffer tBuffer = ByteBuffer.allocate(16);
-    tBuffer.putLong(timestamp);
-    JungleTree tree = jungle.getTreeByName(_board);
-    Either<Error, JungleTreeEditor> either = null;
+	public void editMessage(String _board, String _nodeNum,final String _author, final String _message, final String _editKey) {
+		final long timestamp = System.currentTimeMillis();
+		final ByteBuffer tBuffer = ByteBuffer.allocate(16);
+		tBuffer.putLong(timestamp);
+		JungleTree tree = jungle.getTreeByName(_board);
+		Either<Error, JungleTreeEditor> either = null;
 
-    do {
-      DefaultNodePath path = new DefaultNodePath();
-      try {
-        for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) {
-          if (!_nodeNum.substring(count, count + 1).equals("/"))
-            path = path.add(Integer.parseInt(_nodeNum.substring(count, count + 1)));
-        }
-      } catch (Exception _e) {
-      }
-      JungleTreeEditor editor = tree.getTreeEditor();
-      NodeEditor e = new NodeEditor() {
-        public Either<Error, LoggingNode> edit(TreeNode node) {
-          LoggingNode logNode = wrap(node, new DefaultOperationLog());
-          logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
-          logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
-          logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
-          logNode = logNode.getAttributes().put("timestamp", tBuffer).b();
-          return DefaultEither.newB(logNode);
-        }
+		do {
+			DefaultNodePath path = new DefaultNodePath();
+			try {
+				for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) {
+					if (!_nodeNum.substring(count, count + 1).equals("/"))
+						path = path.add(Integer.parseInt(_nodeNum.substring(count, count + 1)));
+				}
+			} catch (Exception _e) {
+			}
+			JungleTreeEditor editor = tree.getTreeEditor();
+			NodeEditor e = new NodeEditor() {
+				public Either<Error,LoggingNode> edit(TreeNode node) {
+					LoggingNode logNode = wrap(node , new DefaultOperationLog());
+					System.out.println(new String(node.getAttributes().get("mes").array()));
+					logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
+					logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
+					logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
+					logNode = logNode.getAttributes().put("timestamp", tBuffer).b();
+					System.out.println(new String(node.getAttributes().get("mes").array()));
+					return DefaultEither.newB(logNode);
+				}
 
-        @Override
-        public LoggingNode wrap(TreeNode node, OperationLog op) {
-          return new LoggingNode(node, op);
-        }
+				@Override
+				public LoggingNode wrap(TreeNode node, OperationLog op) {
+					return new LoggingNode(node, op);
+				}
 
-      };
-      either = editor.edit(path, e);
-      if (either.isA()) {
-        throw new IllegalStateException();
-      }
-      editor = either.b();
-      either = editor.success();
-    } while (either.isA());
-  }
+			};
+			either = editor.edit(path, e);
+			if (either.isA()) {
+				throw new IllegalStateException();
+			}
+			editor = either.b();
+			either = editor.success();
+		} while (either.isA());
+	}
 
-  public void createAttribute(String _board, String _uuid, final String _author, final String _message,
-      final String _editKey) {
-    final long timestamp = System.currentTimeMillis();
-    final ByteBuffer tBuffer = ByteBuffer.allocate(16);
-    tBuffer.putLong(timestamp);
-    JungleTree tree = jungle.getTreeByName(_board);
-    Either<Error, JungleTreeEditor> either = null;
-    DefaultNodePath path = new DefaultNodePath();
-    do {
-      try {
-        for (int count = 0; _uuid.substring(count, count + 1) != null; count++) {
-          if (!_uuid.substring(count, count + 1).equals("/"))
-            path = path.add(Integer.parseInt(_uuid.substring(count, count + 1)));
-        }
-      } catch (Exception _e) {
-      }
+	public void createAttribute(String _board, String _uuid, final String _author, final String _message, final String _editKey) {
+		final long timestamp = System.currentTimeMillis();
+		final ByteBuffer tBuffer = ByteBuffer.allocate(16);
+		tBuffer.putLong(timestamp);
+		JungleTree tree = jungle.getTreeByName(_board);
+		Either<Error, JungleTreeEditor> either = null;
+		DefaultNodePath path = new DefaultNodePath();
+		do {
+			try {
+				for (int count = 0; _uuid.substring(count, count + 1) != null; count++) {
+					if (!_uuid.substring(count, count + 1).equals("/"))
+						path = path.add(Integer.parseInt(_uuid.substring(count,
+								count + 1)));
+				}
+			} catch (Exception _e) {
+			}
 
-      JungleTreeEditor editor = tree.getTreeEditor();
-      NodeEditor e = new NodeEditor() {
-        String str;
+			JungleTreeEditor editor = tree.getTreeEditor();
+			NodeEditor e = new NodeEditor() {
+				String str;
 
-        public Either<Error, LoggingNode> edit(TreeNode node) {
-          LoggingNode logNode = wrap(node, new DefaultOperationLog());
-          str = "0";
-          int count = 0;
-          for (; logNode.getAttributes().get("mes" + String.valueOf(count)) != null; count++) {
-          }
-          str = String.valueOf(count);
-          logNode = logNode.getAttributes().put("mes" + str, ByteBuffer.wrap(_message.getBytes())).b();
-          logNode = logNode.getAttributes().put("timestamp" + str, tBuffer).b();
-          return DefaultEither.newB(logNode);
-        }
+				public Either<Error,LoggingNode> edit(TreeNode node) {
+					LoggingNode logNode = wrap(node , new DefaultOperationLog());
+					str = "0";
+					int count = 0;
+					for (; logNode.getAttributes().get("mes" + String.valueOf(count)) != null; count++) {
+					}
+					str = String.valueOf(count);
+					logNode = logNode.getAttributes().put("mes" + str,ByteBuffer.wrap(_message.getBytes())).b();
+					logNode = logNode.getAttributes().put("timestamp" + str, tBuffer).b();
+					return DefaultEither.newB(logNode);
+				}
 
-        @Override
-        public LoggingNode wrap(TreeNode node, OperationLog op) {
-          return new LoggingNode(node, op);
-        }
-      };
-      either = editor.edit(path, e);
-      if (either.isA()) {
-        throw new IllegalStateException();
-      }
-      editor = either.b();
-      either = editor.success();
-    } while (either.isA());
-  }
+				@Override
+				public LoggingNode wrap(TreeNode node, OperationLog op) {
+					return new LoggingNode(node, op);
+				}
+			};
+			either = editor.edit(path, e);
+			if (either.isA()) {
+				throw new IllegalStateException();
+			}
+			editor = either.b();
+			either = editor.success();
+		} while (either.isA());
+	}
 
-  public void editAttribute(String boardName, String _path, final String id, final String _message) {
-    final long timestamp = System.currentTimeMillis();
-    final ByteBuffer tBuffer = ByteBuffer.allocate(16);
-    tBuffer.putLong(timestamp);
-    JungleTree tree = jungle.getTreeByName(boardName);
-    Either<Error, JungleTreeEditor> either = null;
-    DefaultNodePath path = new DefaultNodePath();
-    do {
-      try {
-        for (int count = 0; _path.substring(count, count + 1) != null; count++) {
-          if (!_path.substring(count, count + 1).equals("/"))
-            path = path.add(Integer.parseInt(_path.substring(count, count + 1)));
-        }
-      } catch (Exception _e) {
-      }
+	public void editAttribute(String boardName, String _path, final String id, final String _message) {
+		final long timestamp = System.currentTimeMillis();
+		final ByteBuffer tBuffer = ByteBuffer.allocate(16);
+		tBuffer.putLong(timestamp);
+		JungleTree tree = jungle.getTreeByName(boardName);
+		Either<Error, JungleTreeEditor> either = null;
+		DefaultNodePath path = new DefaultNodePath();
+		do {
+			try {
+				for (int count = 0; _path.substring(count, count + 1) != null; count++) {
+					if (!_path.substring(count, count + 1).equals("/"))
+						path = path.add(Integer.parseInt(_path.substring(count,
+								count + 1)));
+				}
+			} catch (Exception _e) {
+			}
 
-      JungleTreeEditor editor = tree.getTreeEditor();
-      NodeEditor e = new NodeEditor() {
-        public Either<Error, LoggingNode> edit(TreeNode node) {
-          LoggingNode logNode = wrap(node, new DefaultOperationLog());
-          // EnableNodeWrapper<T> node = _e.getWrap();
-          logNode = logNode.getAttributes().put("mes" + id, ByteBuffer.wrap(_message.getBytes())).b();
-          logNode = logNode.getAttributes().put("timestamp" + id, tBuffer).b();
-          return DefaultEither.newB(logNode);
-        }
+			JungleTreeEditor editor = tree.getTreeEditor();
+			NodeEditor e = new NodeEditor() {
+				public Either<Error,LoggingNode> edit(TreeNode node) {
+					LoggingNode logNode = wrap(node , new DefaultOperationLog());
+					// EnableNodeWrapper<T> node = _e.getWrap();
+					logNode = logNode.getAttributes().put("mes" + id,ByteBuffer.wrap(_message.getBytes())).b();
+					logNode = logNode.getAttributes().put("timestamp" + id, tBuffer).b();
+					return DefaultEither.newB(logNode);
+				}
 
-        @Override
-        public LoggingNode wrap(TreeNode node, OperationLog op) {
-          return new LoggingNode(node, op);
-        }
+				@Override
+				public LoggingNode wrap(TreeNode node, OperationLog op) {
+					return new LoggingNode(node, op);
+				}
 
-      };
-      either = editor.edit(path, e);
-      if (either.isA()) {
-        throw new IllegalStateException();
-      }
-      editor = either.b();
-      either = editor.success();
-    } while (either.isA());
-  }
+			};
+			either = editor.edit(path, e);
+			if (either.isA()) {
+				throw new IllegalStateException();
+			}
+			editor = either.b();
+			either = editor.success();
+		} while (either.isA());
+	}
 
-  public void deleteNode(String _board, String _path, String _id) {
-    int id = Integer.parseInt(_id);
-    final long timestamp = System.currentTimeMillis();
-    final ByteBuffer tBuffer = ByteBuffer.allocate(16);
-    tBuffer.putLong(timestamp);
-    JungleTree tree = jungle.getTreeByName(_board);
-    Either<Error, JungleTreeEditor> either = null;
-    DefaultNodePath path = new DefaultNodePath();
-    do {
-      try {
-        for (int count = 0; _path.substring(count, count + 1) != null; count++) {
-          if (!_path.substring(count, count + 1).equals("/"))
-            path = path.add(Integer.parseInt(_path.substring(count, count + 1)));
-        }
-      } catch (Exception _e) {
-      }
+	public void deleteNode(String _board, String _path, String _id) {
+		int id = Integer.parseInt(_id);
+		final long timestamp = System.currentTimeMillis();
+		final ByteBuffer tBuffer = ByteBuffer.allocate(16);
+		tBuffer.putLong(timestamp);
+		JungleTree tree = jungle.getTreeByName(_board);
+		Either<Error, JungleTreeEditor> either = null;
+		DefaultNodePath path = new DefaultNodePath();
+		do {
+			try {
+				for (int count = 0; _path.substring(count, count + 1) != null; count++) {
+					if (!_path.substring(count, count + 1).equals("/"))
+						path = path.add(Integer.parseInt(_path.substring(count,count + 1)));
+				}
+			} catch (Exception _e) {
+			}
 
-      JungleTreeEditor editor = tree.getTreeEditor();
+			JungleTreeEditor editor = tree.getTreeEditor();
 
-      either = editor.deleteChildAt(path, id);
-      if (either.isA()) {
-        throw new IllegalStateException();
-      }
-      editor = either.b();
-      either = editor.success();
-    } while (either.isA());
+			either = editor.deleteChildAt(path, id);
+			if (either.isA()) {
+				throw new IllegalStateException();
+			}
+			editor = either.b();
+			either = editor.success();
+		} while (either.isA());
 
-  }
+	}
 
-  public void deleteAttribute(String _board, String _path, final String id) {
-    final long timestamp = System.currentTimeMillis();
-    final ByteBuffer tBuffer = ByteBuffer.allocate(16);
-    tBuffer.putLong(timestamp);
-    JungleTree tree = jungle.getTreeByName(_board);
-    Either<Error, JungleTreeEditor> either = null;
-    DefaultNodePath path = new DefaultNodePath();
-    do {
-      try {
-        for (int count = 0; _path.substring(count, count + 1) != null; count++) {
-          if (!_path.substring(count, count + 1).equals("/"))
-            path = path.add(Integer.parseInt(_path.substring(count, count + 1)));
-        }
-      } catch (Exception _e) {
-        System.out.println("屑");
-      }
+	public void deleteAttribute(String _board, String _path, final String id) {
+		final long timestamp = System.currentTimeMillis();
+		final ByteBuffer tBuffer = ByteBuffer.allocate(16);
+		tBuffer.putLong(timestamp);
+		JungleTree tree = jungle.getTreeByName(_board);
+		Either<Error, JungleTreeEditor> either = null;
+		DefaultNodePath path = new DefaultNodePath();
+		do {
+			try {
+				for (int count = 0; _path.substring(count, count + 1) != null; count++) {
+					if (!_path.substring(count, count + 1).equals("/"))
+						path = path.add(Integer.parseInt(_path.substring(count,
+								count + 1)));
+				}
+			} catch (Exception _e) {
+				System.out.println("屑");
+			}
 
-      JungleTreeEditor editor = tree.getTreeEditor();
-      NodeEditor e = new NodeEditor() {
-        public Either<Error, LoggingNode> edit(TreeNode node) {
-          LoggingNode logNode = wrap(node, new DefaultOperationLog());
-          logNode = logNode.getAttributes().delete("mes" + id).b();
-          logNode = logNode.getAttributes().delete("timestamp" + id).b();
-          int count = Integer.parseInt(id);
-          for (; logNode.getAttributes().get("mes" + String.valueOf(count + 1)) != null;) {
-            logNode = logNode.getAttributes()
-                .put("mes" + count, node.getAttributes().get("mes" + String.valueOf(count + 1)).head()).b();
-            logNode = logNode.getAttributes().put("timestamp" + count, tBuffer).b();
-            count++;
-          }
-          if (count != Integer.parseInt(id)) {
-            logNode = logNode.getAttributes().delete("timestamp" + count).b();
-            logNode = logNode.getAttributes().delete("mes" + count).b();
-          }
+			JungleTreeEditor editor = tree.getTreeEditor();
+			NodeEditor e = new NodeEditor() {
+				public Either<Error,LoggingNode> edit(TreeNode node) {
+					LoggingNode logNode = wrap(node , new DefaultOperationLog());
+					logNode = logNode.getAttributes().delete("mes" + id).b();
+					logNode = logNode.getAttributes().delete("timestamp" + id).b();
+					int count = Integer.parseInt(id);
+					for (; logNode.getAttributes().get("mes" + String.valueOf(count + 1)) != null;) {
+						logNode = logNode.getAttributes().put("mes" + count,node.getAttributes().get("mes"+ String.valueOf(count + 1))).b();
+						logNode = logNode.getAttributes().put("timestamp" + count, tBuffer).b();
+						count++;
+					}
+					if (count != Integer.parseInt(id)) {
+						logNode = logNode.getAttributes().delete("timestamp" + count).b();
+						logNode = logNode.getAttributes().delete("mes" + count).b();
+					}
 
-          return DefaultEither.newB(logNode);
-        }
+					return DefaultEither.newB(logNode);
+				}
 
-        @Override
-        public LoggingNode wrap(TreeNode node, OperationLog op) {
-          return new LoggingNode(node, op);
-        }
-      };
-      either = editor.edit(path, e);
-      if (either.isA()) {
-        throw new IllegalStateException();
-      }
-      editor = either.b();
-      either = editor.success();
-    } while (either.isA());
-  }
+				@Override
+				public LoggingNode wrap(TreeNode node, OperationLog op) {
+					return new LoggingNode(node, op);
+				}
+			};
+			either = editor.edit(path, e);
+			if (either.isA()) {
+				throw new IllegalStateException();
+			}
+			editor = either.b();
+			either = editor.success();
+		} while (either.isA());
+	}
 
-  public void editMatrixMessage(String _board, String _uuid, final String _author, final String _message,
-      final String _editKey) {
-    final long timestamp = System.currentTimeMillis();
-    final ByteBuffer tBuffer = ByteBuffer.allocate(16);
-    tBuffer.putLong(timestamp);
-    JungleTree tree = jungle.getTreeByName(_board);
-    Either<Error, JungleTreeEditor> either = null;
-    do {
-      DefaultNodePath path = new DefaultNodePath();
-      path = path.add(Integer.parseInt(_uuid));
+	public void editMatrixMessage(String _board, String _uuid,
+			final String _author, final String _message, final String _editKey) {
+		final long timestamp = System.currentTimeMillis();
+		final ByteBuffer tBuffer = ByteBuffer.allocate(16);
+		tBuffer.putLong(timestamp);
+		JungleTree tree = jungle.getTreeByName(_board);
+		Either<Error, JungleTreeEditor> either = null;
+		do {
+			DefaultNodePath path = new DefaultNodePath();
+			path = path.add(Integer.parseInt(_uuid));
 
-      JungleTreeEditor editor = tree.getTreeEditor();
-      NodeEditor e = new NodeEditor() {
-        public Either<Error, LoggingNode> edit(TreeNode node) {
-          LoggingNode logNode = wrap(node, new DefaultOperationLog());
-          logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
-          logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
-          logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
-          logNode = logNode.getAttributes().put("timestamp", tBuffer).b();
-          return DefaultEither.newB(logNode);
-        }
+			JungleTreeEditor editor = tree.getTreeEditor();
+			NodeEditor e = new NodeEditor() {
+				public Either<Error,LoggingNode> edit(TreeNode node) {
+					LoggingNode logNode = wrap(node , new DefaultOperationLog());
+					logNode = logNode.getAttributes().put("author", ByteBuffer.wrap(_author.getBytes())).b();
+					logNode = logNode.getAttributes().put("mes", ByteBuffer.wrap(_message.getBytes())).b();
+					logNode = logNode.getAttributes().put("key", ByteBuffer.wrap(_editKey.getBytes())).b();
+					logNode = logNode.getAttributes().put("timestamp", tBuffer).b();
+					return DefaultEither.newB(logNode);
+				}
 
-        @Override
-        public LoggingNode wrap(TreeNode node, OperationLog op) {
-          return new LoggingNode(node, op);
-        }
+				@Override
+				public LoggingNode wrap(TreeNode node, OperationLog op) {
+					return new LoggingNode(node, op);
+				}
+
 
-      };
-      either = editor.edit(path, e);
-      if (either.isA()) {
-        throw new IllegalStateException();
-      }
-      editor = either.b();
-      either = editor.success();
-    } while (either.isA());
-  }
+			};
+			either = editor.edit(path, e);
+			if (either.isA()) {
+				throw new IllegalStateException();
+			}
+			editor = either.b();
+			either = editor.success();
+		} while (either.isA());
+	}
 
-  public Iterable<BoardMessage> getMessages(String _boardName) {
-    JungleTree tree = jungle.getTreeByName(_boardName);
-    TreeNode node = tree.getRootNode();
-    Children chs = node.getChildren();
-    final AtomicInteger counter = new AtomicInteger(0);
-    IterableConverter.Converter<BoardMessage, TreeNode> converter = new IterableConverter.Converter<BoardMessage, TreeNode>() {
-      public BoardMessage conv(TreeNode _b) {
-        String uuid = Integer.toString(counter.get());
-        String author = new String(_b.getAttributes().get("author").head().array());
-        String message = new String(_b.getAttributes().get("mes").head().array());
-        counter.incrementAndGet();
-        return new BoardMessageImpl(author, message, uuid);
-      }
-    };
-    return new IterableConverter<BoardMessage, TreeNode>(chs, converter);
-  }
+	public Iterable<BoardMessage> getMessages(String _boardName) {
+		JungleTree tree = jungle.getTreeByName(_boardName);
+		TreeNode node = tree.getRootNode();
+		Children chs = node.getChildren();
+		final AtomicInteger counter = new AtomicInteger(0);
+		IterableConverter.Converter<BoardMessage, TreeNode> converter = new IterableConverter.Converter<BoardMessage, TreeNode>() {
+			public BoardMessage conv(TreeNode _b) {
+				String uuid = Integer.toString(counter.get());
+				String author = new String(_b.getAttributes().get("author").array());
+				String message = new String(_b.getAttributes().get("mes").array());
+				counter.incrementAndGet();
+				return new BoardMessageImpl(author, message, uuid);
+			}
+		};
+		return new IterableConverter<BoardMessage, TreeNode>(chs, converter);
+	}
 
-  public Iterable<BoardMessage> getFolder(String _boardName, String _nodeNum) {
+	public Iterable<BoardMessage> getFolder(String _boardName, String _nodeNum) {
 
-    DefaultNodePath path = new DefaultNodePath();
-    try {
-      for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) {
-        if (!_nodeNum.substring(count, count + 1).equals("/"))
-          path = path.add(Integer.parseInt(_nodeNum.substring(count, count + 1)));
-      }
-    } catch (Exception _e) {
-    }
-    JungleTree tree = jungle.getTreeByName(_boardName);
-    TreeNode node = tree.getRootNode();
+		DefaultNodePath path = new DefaultNodePath();
+		try {
+			for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) {
+				if (!_nodeNum.substring(count, count + 1).equals("/"))
+					path = path.add(Integer.parseInt(_nodeNum.substring(count,count + 1)));
+			}
+		} catch (Exception _e) {
+		}
+		JungleTree tree = jungle.getTreeByName(_boardName);
+		TreeNode node = tree.getRootNode();
 
-    DefaultTraverser traverser = new DefaultTraverser();
-    DefaultEvaluator evaluator = new DefaultEvaluator(path);
-    Either<Error, Traversal> ret = traverser.traverse(node, evaluator);
-    if (ret.isA()) {
-      Assert.fail();
-    }
+		DefaultTraverser traverser = new DefaultTraverser();
+		DefaultEvaluator evaluator = new DefaultEvaluator(path);
+		Either<Error, Traversal> ret = traverser.traverse(node,evaluator);
+		if (ret.isA()) {
+			Assert.fail();
+		}
 
-    Traversal traversal = ret.b();
-    TreeNode target = traversal.destination();
-    Children chs = target.getChildren();
+		Traversal traversal = ret.b();
+		TreeNode target = traversal.destination();
+		Children chs = target.getChildren();
 
-    final AtomicInteger counter = new AtomicInteger(0);
-    IterableConverter.Converter<BoardMessage, TreeNode> converter = new IterableConverter.Converter<BoardMessage, TreeNode>() {
-      public BoardMessage conv(TreeNode _b) {
-        String uuid = Integer.toString(counter.get());
-        String message = new String(_b.getAttributes().get("element").head().array());
-        counter.incrementAndGet();
-        return new BoardMessageImpl(null, message, uuid);
-      }
-    };
-    return new IterableConverter<BoardMessage, TreeNode>(chs, converter);
-  }
+		final AtomicInteger counter = new AtomicInteger(0);
+		IterableConverter.Converter<BoardMessage, TreeNode> converter = new IterableConverter.Converter<BoardMessage, TreeNode>() {
+			public BoardMessage conv(TreeNode _b) {
+				String uuid = Integer.toString(counter.get());
+				String message = new String(_b.getAttributes().get("element").array());
+				counter.incrementAndGet();
+				return new BoardMessageImpl(null, message, uuid);
+			}
+		};
+		return new IterableConverter<BoardMessage, TreeNode>(chs, converter);
+	}
 
-  public GetAttributeImp getAttribute(String _boardName, String _nodeNum) {
+	public GetAttributeImp getAttribute(String _boardName, String _nodeNum) {
 
-    DefaultNodePath path = new DefaultNodePath();
-    try {
-      for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) {
-        if (!_nodeNum.substring(count, count + 1).equals("/"))
-          path = path.add(Integer.parseInt(_nodeNum.substring(count, count + 1)));
-      }
-    } catch (Exception _e) {
-    }
-    JungleTree tree = jungle.getTreeByName(_boardName);
-    TreeNode node = tree.getRootNode();
+		DefaultNodePath path = new DefaultNodePath();
+		try {
+			for (int count = 0; _nodeNum.substring(count, count + 1) != null; count++) {
+				if (!_nodeNum.substring(count, count + 1).equals("/"))
+					path = path.add(Integer.parseInt(_nodeNum.substring(count,
+							count + 1)));
+			}
+		} catch (Exception _e) {
+		}
+		JungleTree tree = jungle.getTreeByName(_boardName);
+		TreeNode node = tree.getRootNode();
 
-    DefaultTraverser traverser = new DefaultTraverser();
-    DefaultEvaluator evaluator = new DefaultEvaluator(path);
-    Either<Error, Traversal> ret = traverser.traverse(node, evaluator);
-    if (ret.isA()) {
-      Assert.fail();
-    }
+		DefaultTraverser traverser = new DefaultTraverser();
+		DefaultEvaluator evaluator = new DefaultEvaluator(path);
+		Either<Error, Traversal> ret = traverser.traverse(node,evaluator);
+		if (ret.isA()) {
+			Assert.fail();
+		}
 
-    Traversal traversal = ret.b();
-    TreeNode target = traversal.destination();
-    return new GetAttributeImp(target);
-  }
+		Traversal traversal = ret.b();
+		TreeNode target = traversal.destination();
+		return new GetAttributeImp(target);
+	}
 
-  private static class BoardMessageImpl implements BoardMessage {
-    private final String author;
-    private final String message;
-    private final String uuid;
+	
 
-    public BoardMessageImpl(String _author, String _message, String _uuid) {
-      author = _author;
-      message = _message;
-      uuid = _uuid;
-    }
+	private static class BoardMessageImpl implements BoardMessage {
+		private final String author;
+		private final String message;
+		private final String uuid;
 
-    public String getAuthor() {
-      return author;
-    }
+		public BoardMessageImpl(String _author, String _message, String _uuid) {
+			author = _author;
+			message = _message;
+			uuid = _uuid;
+		}
+
+		public String getAuthor() {
+			return author;
+		}
 
-    public String getMessage() {
-      return message;
-    }
+		public String getMessage() {
+			return message;
+		}
 
-    public String getUUID() {
-      return uuid;
-    }
-
-  }
+		public String getUUID() {
+			return uuid;
+		}
 
-  public void readXml(String xmlPath) {
-    try {
-      SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
-      SAXParser saxParser = saxParserFactory.newSAXParser();
-      createBoards(xmlPath);
-      JungleTree tree = jungle.getTreeByName(xmlPath);
-      ReadXmlHandler readXmlHandler = new ReadXmlHandler(tree);
-      saxParser.parse(new FileInputStream("xml/" + xmlPath), readXmlHandler);
-    } catch (Exception e) {
-      e.printStackTrace();
-    }
-  }
+	}
+	
+	public void readXml(String xmlPath){
+		try {
+			SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
+			SAXParser saxParser = saxParserFactory.newSAXParser();
+			createBoards(xmlPath);
+			JungleTree tree = jungle.getTreeByName(xmlPath);
+			ReadXmlHandler readXmlHandler = new ReadXmlHandler(tree);
+			saxParser.parse(new FileInputStream("xml/" + xmlPath), readXmlHandler);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
 
-  public String sanitize(String str) {
-    if (str == null) {
-      return str;
-    }
-    str = str.replaceAll("&", "&amp;");
-    str = str.replaceAll("<", "&lt;");
-    str = str.replaceAll(">", "&gt;");
-    str = str.replaceAll("\"", "&quot;");
-    str = str.replaceAll("'", "&#39;");
-    return str;
-  }
+	public String sanitize(String str) {
+		if (str == null) {
+			return str;
+		}
+		str = str.replaceAll("&", "&amp;");
+		str = str.replaceAll("<", "&lt;");
+		str = str.replaceAll(">", "&gt;");
+		str = str.replaceAll("\"", "&quot;");
+		str = str.replaceAll("'", "&#39;");
+		return str;
+	}
 
-  @Override
-  public void createBoards(String _name, String _author, String _initMessage, String _editKey) {
-  }
+
+
+	@Override
+	public void createBoards(String _name, String _author, String _initMessage,
+			String _editKey) {
+	}
 
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/ChildOrganizationIdsTest.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/ChildOrganizationIdsTest.java	Tue Nov 25 12:12:17 2014 +0900
@@ -10,24 +10,22 @@
 
 public class ChildOrganizationIdsTest {
 
-	@Test
-	public void childOrganizationIdsTest(){
-		JuGrix jugrix = new JuGrix(false);
-		LinkedList<String> list = new LinkedList<String>();
-		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);
-    
+  @Test
+  public void childOrganizationIdsTest() {
+    JuGrix jugrix = new JuGrix();
+    LinkedList<String> list = new LinkedList<String>();
+    list.add("r:11");
+    Iterator<String> ids = jugrix.childOrganizationIds("o:2", list);
 
     Assert.assertTrue(ids.hasNext());
-    Assert.assertEquals(ids.next(),"o:9");
+    Assert.assertEquals(ids.next(), "o:3");
+
+    list = new LinkedList<String>();
+    list.add("rde:4");
+    ids = jugrix.childOrganizationIds("o:2", list);
+
     Assert.assertTrue(ids.hasNext());
-    Assert.assertEquals(ids.next(),"o:3");
-	}
+    Assert.assertEquals(ids.next(), "o:3");
+  }
+
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/CompetentRoleIdTest.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/CompetentRoleIdTest.java	Tue Nov 25 12:12:17 2014 +0900
@@ -11,14 +11,11 @@
 
 	@Test
 	public void testCompetentRoleIdTest(){
-		JuGrix jugrix = new JuGrix(false);
+		
+	  JuGrix jugrix = new JuGrix();
 		Iterator<String> roleIds = jugrix.competentRoleId("p:1");
 		Assert.assertTrue(roleIds.hasNext());
 		Assert.assertEquals(roleIds.next(), "r:10");
 		
-    jugrix = new JuGrix(true);
-    roleIds = jugrix.competentRoleId("p:1");
-    Assert.assertTrue(roleIds.hasNext());
-    Assert.assertEquals(roleIds.next(), "r:10");
 	}
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/ConcurrentRoleIdsTest.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/ConcurrentRoleIdsTest.java	Tue Nov 25 12:12:17 2014 +0900
@@ -8,20 +8,12 @@
 import junit.framework.Assert;
 
 public class ConcurrentRoleIdsTest {
-	
-	@Test
-	public void testConcurrentRoleId(){
-		JuGrix jugrix = new JuGrix(false);
-		Iterator<String> roleIds = jugrix.concurrentRoleIds("p:1");
-		Assert.assertTrue(roleIds.hasNext());
-		Assert.assertEquals(roleIds.next(), "r:34");
-		
-    jugrix = new JuGrix(true);
-    roleIds = jugrix.concurrentRoleIds("p:1");
+
+  @Test
+  public void testConcurrentRoleId() {
+    JuGrix jugrix = new JuGrix();
+    Iterator<String> roleIds = jugrix.concurrentRoleIds("p:1");
     Assert.assertTrue(roleIds.hasNext());
     Assert.assertEquals(roleIds.next(), "r:34");
-    
-		roleIds = jugrix.concurrentRoleIds("p:48");
-		Assert.assertFalse(roleIds.hasNext());
-	}
+  }
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/DeepChildOrganizationIdsPlusTest.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/DeepChildOrganizationIdsPlusTest.java	Tue Nov 25 12:12:17 2014 +0900
@@ -11,31 +11,30 @@
 public class DeepChildOrganizationIdsPlusTest {
 
   @Test
-  public void TestDeepChildOrganizationIdsPlus(){
-    JuGrix jugrix = new JuGrix(false);
-    LinkedList<String> filterIds = new LinkedList<String>();
-    filterIds.add("r:9");
-    Iterator<String> childrenIds = jugrix.deepChildOrganizationIdsPlus("o:2", filterIds);
-    Assert.assertTrue(childrenIds.hasNext());
-    Assert.assertEquals(childrenIds.next(),"o:2");
-    
-    filterIds = new LinkedList<String>();
-    filterIds.add("r:5");
-    childrenIds = jugrix.deepChildOrganizationIdsPlus("o:2", filterIds);
-    Assert.assertTrue(childrenIds.hasNext());
-    Assert.assertEquals(childrenIds.next(),"o:4");
-    
-    jugrix = new JuGrix(true);
-    filterIds = new LinkedList<String>();
-    filterIds.add("r:9");
-    childrenIds = jugrix.deepChildOrganizationIdsPlus("o:2", filterIds);
-    Assert.assertTrue(childrenIds.hasNext());
-    Assert.assertEquals(childrenIds.next(),"o:2");
-    
-    filterIds = new LinkedList<String>();
-    filterIds.add("r:5");
-    childrenIds = jugrix.deepChildOrganizationIdsPlus("o:2", filterIds);
-    Assert.assertTrue(childrenIds.hasNext());
-    Assert.assertEquals(childrenIds.next(),"o:4");
+  public void TestDeepChildOrganizationIdsPlus() {
+
+    JuGrix jugrix = new JuGrix();
+      LinkedList<String> filterIds = new LinkedList<String>();
+      Iterator<String> childrenIds = jugrix.deepChildOrganizationIdsPlus("o:2", filterIds);
+      Assert.assertTrue(childrenIds.hasNext());
+      String orgId = childrenIds.next();
+      Assert.assertEquals(orgId, "o:2");
+      Assert.assertTrue(childrenIds.hasNext());
+      orgId = childrenIds.next();
+      Assert.assertEquals(orgId, "o:3");
+
+      filterIds.add("r:9");
+      childrenIds = jugrix.deepChildOrganizationIdsPlus("o:2", filterIds);
+      Assert.assertTrue(childrenIds.hasNext());
+      orgId = childrenIds.next();
+      Assert.assertEquals(orgId, "o:2");
+      
+      filterIds.add("rde:3");
+      childrenIds = jugrix.deepChildOrganizationIdsPlus("o:2", filterIds);
+      Assert.assertTrue(childrenIds.hasNext());
+      orgId = childrenIds.next();
+      Assert.assertEquals(orgId, "o:2");
+
+
   }
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/DeepChildOrganizationIdsTest.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/DeepChildOrganizationIdsTest.java	Tue Nov 25 12:12:17 2014 +0900
@@ -12,37 +12,23 @@
 
   @Test
   public void TestDeepChildOrganizationIds() {
-    JuGrix jugrix = new JuGrix(false);
+    
+    JuGrix jugrix = new JuGrix();
     LinkedList<String> filterIds = new LinkedList<String>();
-    filterIds.add("r:5");
+    filterIds.add("r:11");
     Iterator<String> childrenIds = jugrix.deepChildOrganizationIds("o:2", filterIds);
 
     Assert.assertTrue(childrenIds.hasNext());
     String childrenId = childrenIds.next();
-    Assert.assertEquals(childrenId, "o:4");
+    Assert.assertEquals(childrenId, "o:3");
 
     filterIds.add("rde:4");
     childrenIds = jugrix.deepChildOrganizationIds("o:2", filterIds);
 
     Assert.assertTrue(childrenIds.hasNext());
     childrenId = childrenIds.next();
-    Assert.assertEquals(childrenId, "o:4");
+    Assert.assertEquals(childrenId, "o:3");
     Assert.assertFalse(childrenIds.hasNext());
     
-    jugrix = new JuGrix(true);
-    filterIds = new LinkedList<String>();
-    filterIds.add("r:5");
-    childrenIds = jugrix.deepChildOrganizationIds("o:2", filterIds);
-
-    Assert.assertTrue(childrenIds.hasNext());
-    childrenId = childrenIds.next();
-    Assert.assertEquals(childrenId, "o:4");
-
-    filterIds.add("rde:4");
-    childrenIds = jugrix.deepChildOrganizationIds("o:2", filterIds);
-
-    Assert.assertTrue(childrenIds.hasNext());
-    childrenId = childrenIds.next();
-    Assert.assertEquals(childrenId, "o:4");
   }
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/DeepParentOrganizationIdsPlusTest.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/DeepParentOrganizationIdsPlusTest.java	Tue Nov 25 12:12:17 2014 +0900
@@ -11,37 +11,20 @@
 public class DeepParentOrganizationIdsPlusTest {
 	@Test
 	public void deepParentOrganizationIdsPlus(){
-		JuGrix jugrix = new JuGrix(false);
+		JuGrix jugrix = new JuGrix();
 		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:2");
 		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");
 
-		
-		jugrix = new JuGrix(true);
-    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	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/DeepParentOrganizationIdsTest.java	Tue Nov 25 12:12:17 2014 +0900
@@ -9,34 +9,26 @@
 import org.junit.Test;
 
 public class DeepParentOrganizationIdsTest {
-	
-	@Test
-	public void deepParentOrganizationIds(){
-		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");
+
+  @Test
+  public void deepParentOrganizationIds() {
+    JuGrix jugrix = new JuGrix();
+    LinkedList<String> filterIds = new LinkedList<String>();
+    Iterator<String> childrenIds = jugrix.deepParentOrganizationIds("o:2", filterIds);
     Assert.assertTrue(childrenIds.hasNext());
-		Assert.assertEquals(childrenIds.next(),"o:22");
-		
-		filterIds.add("r:2");
-		childrenIds = jugrix.deepParentOrganizationIds("o:2", filterIds);
+    Assert.assertEquals(childrenIds.next(), "o:23");
     Assert.assertTrue(childrenIds.hasNext());
-		Assert.assertEquals(childrenIds.next(),"o:23");
+    Assert.assertEquals(childrenIds.next(), "o:22");
 
-		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");
-	}
+    Assert.assertEquals(childrenIds.next(), "o:23");
+
+    filterIds.add("rde: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	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/DeepPersonIdsTest.java	Tue Nov 25 12:12:17 2014 +0900
@@ -10,7 +10,7 @@
 public class DeepPersonIdsTest {
 	@Test
 	public void TestDeepPersonIds(){
-		JuGrix jugrix = new JuGrix(false);
+		JuGrix jugrix = new JuGrix();
 		LinkedList<String> filterIds = new LinkedList<String>();
 		//filterIds.add("r:9");
 		Iterator<String> ids = jugrix.deepPersonIds("o:2",filterIds);
@@ -18,17 +18,5 @@
 		for (;ids.hasNext();) {
 			System.out.println(ids.next());
 		}
-		
-		
-	  jugrix = new JuGrix(true);
-	  filterIds = new LinkedList<String>();
-	  //filterIds.add("r:9");
-	  ids = jugrix.deepPersonIds("o:3",filterIds);
-	  System.out.println("------------------------------------------------");
-	  for (;ids.hasNext();) {
-	    System.out.println(ids.next());
-	  }
 	}
-	
-
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/IsActiveTest.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/IsActiveTest.java	Tue Nov 25 12:12:17 2014 +0900
@@ -11,7 +11,7 @@
     @Test
     public void TestIsActive(){
 
-            JuGrix jugrix = new JuGrix(false); 
+            JuGrix jugrix = new JuGrix(); 
             String personId = "p:1";
             
             Assert.assertTrue(jugrix.isActive(personId));
@@ -19,12 +19,6 @@
             personId = "p:100";
             Assert.assertFalse(jugrix.isActive(personId));
             
-            jugrix = new JuGrix(true); 
-            personId = "p:1";
-            Assert.assertTrue(jugrix.isActive(personId));
-            
-            personId = "p:100";
-            Assert.assertFalse(jugrix.isActive(personId));
     }
 
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/ParentOrganizationIdsTest.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/ParentOrganizationIdsTest.java	Tue Nov 25 12:12:17 2014 +0900
@@ -11,7 +11,7 @@
 public class ParentOrganizationIdsTest {
 	@Test
 	public void testParentOrganizationIds() {
-		JuGrix jugrix = new JuGrix(false);
+		JuGrix jugrix = new JuGrix();
 		LinkedList<String> filterIds = new LinkedList<String>();
 		filterIds.add("r:2");
 		Iterator<String> childrenIds = jugrix.parentOrganizationIds("o:2", filterIds);
@@ -22,15 +22,11 @@
 		childrenIds = jugrix.parentOrganizationIds("o:2", filterIds);
 		Assert.assertFalse(childrenIds.hasNext());
 		
-		jugrix = new JuGrix(true);
-    filterIds = new LinkedList<String>();
-    filterIds.add("r:2");
+		filterIds = new LinkedList<String>();
+    filterIds.add("rde:2");
     childrenIds = jugrix.parentOrganizationIds("o:2", filterIds);
     Assert.assertTrue(childrenIds.hasNext());
     Assert.assertEquals(childrenIds.next(), "o:23");
-    
-    filterIds.add("r:2a");
-    childrenIds = jugrix.parentOrganizationIds("o:2", filterIds);
-    Assert.assertFalse(childrenIds.hasNext());
+		
 	}
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/PersonIdsTest.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/PersonIdsTest.java	Tue Nov 25 12:12:17 2014 +0900
@@ -14,16 +14,16 @@
   @Test
   public void testPersonIds() {
 
-    JuGrix jugrix = new JuGrix(false);
+    JuGrix jugrix = new JuGrix();
     LinkedList<String> filterIds = new LinkedList<String>();
-    filterIds.add("r:9");
+    
     Iterator<String> ids = jugrix.personIds("o:2", filterIds);
-
+    Assert.assertTrue(ids.hasNext());
+    Assert.assertEquals(ids.next(), "p:1");
     Assert.assertTrue(ids.hasNext());
     Assert.assertEquals(ids.next(), "p:45");
-    Assert.assertEquals(ids.next(), "p:1");
-
-    filterIds.add("rde:3");
+    
+    filterIds.add("r:9");
     ids = jugrix.personIds("o:2", filterIds);
 
     Assert.assertTrue(ids.hasNext());
@@ -31,28 +31,20 @@
     Assert.assertTrue(ids.hasNext());
     Assert.assertEquals(ids.next(), "p:1");
 
-    filterIds.add("rde:322");
-    ids = jugrix.personIds("o:2", filterIds);
-    Assert.assertFalse(ids.hasNext());
-    
-    jugrix = new JuGrix(true);
-    filterIds = new LinkedList<String>();
-    filterIds.add("r:9");
-    ids = jugrix.personIds("o:2", filterIds);
-
-    ids.hasNext();
-    Assert.assertEquals(ids.next(), "p:45");
-    Assert.assertEquals(ids.next(), "p:1");
 
     filterIds.add("rde:3");
     ids = jugrix.personIds("o:2", filterIds);
 
     ids.hasNext();
     Assert.assertEquals(ids.next(), "p:45");
+    ids.hasNext();
     Assert.assertEquals(ids.next(), "p:1");
 
+
+
     filterIds.add("rde:322");
     ids = jugrix.personIds("o:2", filterIds);
     Assert.assertFalse(ids.hasNext());
-  }
+    
+   }
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/RoleDescriptionElementIdsTest.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/RoleDescriptionElementIdsTest.java	Tue Nov 25 12:12:17 2014 +0900
@@ -12,25 +12,22 @@
 
 	@Test
 	public void testRoleDescriptionElementIds(){
-		JuGrix jugrix = new JuGrix(true);
+		JuGrix jugrix = new JuGrix();
 		LinkedList<String> ids = new LinkedList<String>();
 		//ids.add("o:34");
 		Iterator<String> rdeIds = jugrix.roleDescriptionElementIds("o:2",ids);
-
+    Assert.assertTrue(rdeIds.hasNext());
+		String rdeId = rdeIds.next();
+		Assert.assertEquals(rdeId,"rde:3");
+    Assert.assertTrue(rdeIds.hasNext());
+    rdeId = rdeIds.next();
+    Assert.assertEquals(rdeId,"rde:2");
     
-		Assert.assertEquals(rdeIds.next(),"rde:3");
-		Assert.assertEquals(rdeIds.next(),"rde:2");
-    Assert.assertEquals(rdeIds.next(),"rde:10");
-    Assert.assertEquals(rdeIds.next(),"rde:1");
-	  
-	  jugrix = new JuGrix(true);
-    ids = new LinkedList<String>();
-    //ids.add("o:34");
+    ids.add("r:9");
     rdeIds = jugrix.roleDescriptionElementIds("o:2",ids);
-
-    Assert.assertEquals(rdeIds.next(),"rde:3");
-    Assert.assertEquals(rdeIds.next(),"rde:2");
-    Assert.assertEquals(rdeIds.next(),"rde:10");
-    Assert.assertEquals(rdeIds.next(),"rde:1");
+    Assert.assertTrue(rdeIds.hasNext());
+    rdeId = rdeIds.next();
+    Assert.assertEquals(rdeId,"rde:3");
+    Assert.assertFalse(rdeIds.hasNext());
 	}
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/RoleIdsTest.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/RoleIdsTest.java	Tue Nov 25 12:12:17 2014 +0900
@@ -1,6 +1,7 @@
 package jp.ac.u_ryukyu.cr.ie.tatsuki.functionTest;
 
 import java.util.Iterator;
+import java.util.LinkedList;
 
 import jp.ac.u_ryukyu.cr.ie.tatsuki.bbs.JuGrix;
 import junit.framework.Assert;
@@ -11,29 +12,23 @@
 
   @Test
   public void testRoleIds() {
-    JuGrix jugrix = new JuGrix(false);
-    Iterator<String> orgIds = jugrix.roleIds("o:6");
+    JuGrix jugrix = new JuGrix();
+    LinkedList<String> filterIds = new LinkedList<String>();
+    filterIds.add("o:5");
+    Iterator<String> orgIds = jugrix.roleIds("o:6",filterIds);
     orgIds.hasNext();
     Assert.assertEquals(orgIds.next(), "r:18");
     Assert.assertFalse(orgIds.hasNext());
 
-    Iterator<String> personIds = jugrix.roleIds("p:1");
-    personIds.hasNext();
-    Assert.assertEquals(personIds.next(), "r:34");
-    personIds.hasNext();
-    Assert.assertEquals(personIds.next(), "r:10");
     
-    jugrix = new JuGrix(true);
-    orgIds = jugrix.roleIds("o:6");
-    orgIds.hasNext();
-    Assert.assertEquals(orgIds.next(), "r:18");
-    Assert.assertFalse(orgIds.hasNext());
-
-    personIds = jugrix.roleIds("p:1");
-    personIds.hasNext();
-    Assert.assertEquals(personIds.next(), "r:34");
+    filterIds = new LinkedList<String>();
+    filterIds.add("o:2");
+    
+    Iterator<String> personIds = jugrix.roleIds("p:1",filterIds);
     personIds.hasNext();
     Assert.assertEquals(personIds.next(), "r:10");
 
+    
+
   }
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/RolePriorityTest.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/RolePriorityTest.java	Tue Nov 25 12:12:17 2014 +0900
@@ -9,12 +9,8 @@
 
 	@Test
 	public void testRolePriority(){
-		JuGrix jugrix = new JuGrix(false);
+		JuGrix jugrix = new JuGrix();
 		String priority = jugrix.rolePriority("p:1", "r:34");
 		Assert.assertEquals(priority,"1");
-		
-		jugrix = new JuGrix(true);
-    priority = jugrix.rolePriority("p:1", "r:34");
-    Assert.assertEquals(priority,"1");
 	}
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/StringPathToIdTest.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/functionTest/StringPathToIdTest.java	Tue Nov 25 12:12:17 2014 +0900
@@ -8,16 +8,10 @@
 public class StringPathToIdTest {
   @Test
   public void testStringPathToId() {
-    JuGrix jugrix = new JuGrix(false);
+    JuGrix jugrix = new JuGrix();
     String id = jugrix.stringPathToId("r:path:エスアールエルテクノシステム/臨検システム部/業務システムグループ");
     Assert.assertEquals(id, "r:43");
     id = jugrix.stringPathToId("rde:path:システム開発申請書/組織的役割/起票部署");
     Assert.assertEquals(id, "rde:10");
-
-    jugrix = new JuGrix(true);
-    id = jugrix.stringPathToId("r:path:エスアールエルテクノシステム/臨検システム部/業務システムグループ");
-    Assert.assertEquals(id, "r:43");
-    id = jugrix.stringPathToId("rde:path:システム開発申請書/組織的役割/起票部署");
-    Assert.assertEquals(id, "rde:10");
   }
 }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/xmlReadTest/ReadXmlTest.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/xmlReadTest/ReadXmlTest.java	Tue Nov 25 12:12:17 2014 +0900
@@ -11,7 +11,7 @@
     @Test
     public void Readml(){
         long t1 = System.currentTimeMillis();
-        new JuGrix(true);
+        new JuGrix();
         long t2 = System.currentTimeMillis();
         System.out.println(t2 - t1 + "s");
     }
--- a/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/xmlReadTest/SaxTest.java	Mon Nov 17 18:47:10 2014 +0900
+++ b/src/test/java/jp/ac/u_ryukyu/cr/ie/tatsuki/xmlReadTest/SaxTest.java	Tue Nov 25 12:12:17 2014 +0900
@@ -6,7 +6,6 @@
 
 import javax.xml.parsers.*;
 
-import fj.data.List;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
@@ -19,86 +18,76 @@
 import junit.framework.Assert;
 
 class SaxTest {
-  public static void main(String args[]) {
-    try {
-      SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
-      SAXParser saxParser = saxParserFactory.newSAXParser();
-      Jungle jungle = new DefaultJungle(null, "hoge", new DefaultTreeEditor(new DefaultTraverser()));
-      JungleTree tree = jungle.createNewTree("XMLTEST");
-      TestHandler testHandler = new TestHandler(tree);
-      saxParser.parse(new FileInputStream("xml/sample.xml"), testHandler);
-      JungleTree newTree = testHandler.getTree();
-      InterfaceTraverser ifTraverser = newTree.getTraverser();
+	public static void main(String args[]) {
+		try {
+			SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
+			SAXParser saxParser = saxParserFactory.newSAXParser();
+			Jungle jungle = new DefaultJungle(null, "hoge",new DefaultTreeEditor(new DefaultTraverser()));
+			JungleTree tree = jungle.createNewTree("XMLTEST");
+			TestHandler testHandler = new TestHandler(tree);
+			saxParser.parse(new FileInputStream("xml/sample.xml"), testHandler);
+			JungleTree newTree = testHandler.getTree();
+			InterfaceTraverser ifTraverser = newTree.getTraverser();
 
-      Iterator<Pair<TreeNode, NodePath>> searchNode = ifTraverser.find((TreeNode node) -> {
-        List<ByteBuffer> attribute = node.getAttributes().get("element");
-        if (attribute.isNotEmpty()) {
-          byte[] byteAttribute = attribute.head().array();
-          String str = new String(byteAttribute);
-          System.out.println("attribute = " + str);
-          return str.equals("Person");
-        }
-        return false;
-      }, "element", "Person");
-      Pair<TreeNode, NodePath> nodePair = searchNode.next();
-      Iterator<String> element = nodePair.left().getAttributes().getString("element");
-      Assert.assertTrue(element.hasNext());
-      Assert.assertEquals(element.next(), "Person");
-      Assert.assertEquals(nodePair.right().toString(), "<-1,0>");
+			Iterator<TreeNode> searchNodeIterator = ifTraverser.find((
+					TreeNode node) -> {
+				ByteBuffer attribute = node.getAttributes().get("element");
+				if (attribute != null) {
+					byte[] byteAttribute = attribute.array();
+					String str = new String(byteAttribute);
+					System.out.println("attribute = " + str);
+					return str.equals("Person");
+				}
+				return false;
+			}, "element", "Person");
+			TreeNode searchNode = searchNodeIterator.next();
+			Assert.assertEquals(searchNode.getAttributes().getString("element"),"Person");
 
-      searchNode = ifTraverser.find((TreeNode node) -> {
-        List<ByteBuffer> attribute = node.getAttributes().get("element");
-        if (attribute.isNotEmpty()) {
-          byte[] byteAttribute = attribute.head().array();
-          String str = new String(byteAttribute);
-          System.out.println("attribute = " + str);
-          return str.equals("name");
-        }
-        return false;
-      }, "element", "name");
-      searchNode.hasNext();
-      nodePair = searchNode.next();
-      Iterator<String> textIterator = nodePair.left().getAttributes().getString("text");
-      Assert.assertTrue(textIterator.hasNext());
-      Assert.assertEquals(textIterator.next(), "tatsuki");
-      Assert.assertEquals(nodePair.right().toString(), "<-1,0,0>");
-
-      searchNode = ifTraverser.find((TreeNode node) -> {
-        List<ByteBuffer> attribute = node.getAttributes().get("text");
-        if (attribute.isNotEmpty()) {
-          byte[] byteAttribute = attribute.head().array();
-          String str = new String(byteAttribute);
-          System.out.println("attribute = " + str);
-          return str.equals("tatsuki");
-        }
-        return false;
-      }, "text", "tatsuki");
+			
+			searchNodeIterator = ifTraverser.find((TreeNode node) -> {
+				ByteBuffer attribute = node.getAttributes().get("element");
+				if (attribute != null) {
+					byte[] byteAttribute = attribute.array();
+					String str = new String(byteAttribute);
+					System.out.println("attribute = " + str);
+					return str.equals("name");
+				}
+				return false;
+			}, "element", "name");
+			
+			searchNode = searchNodeIterator.next();
+			Assert.assertEquals(searchNode.getAttributes().getString("text"),"tatsuki");
+			
+			searchNodeIterator = ifTraverser.find((TreeNode node) -> {
+				ByteBuffer attribute = node.getAttributes().get("text");
+				if (attribute != null) {
+					byte[] byteAttribute = attribute.array();
+					String str = new String(byteAttribute);
+					System.out.println("attribute = " + str);
+					return str.equals("tatsuki");
+				}
+				return false;
+			}, "text", "tatsuki");
+			
+			searchNode = searchNodeIterator.next();
+			Assert.assertEquals(searchNode.getAttributes().getString("id"),"10");
 
-      nodePair = searchNode.next();
-      Iterator<String> idIterator = nodePair.left().getAttributes().getString("id");
-      Assert.assertTrue(idIterator.hasNext());
-      Assert.assertEquals(idIterator.next(), "10");
-      Assert.assertEquals(nodePair.right().toString(), "<-1,0,0>");
-
-      searchNode = ifTraverser.find((TreeNode node) -> {
-         List<ByteBuffer> attribute = node.getAttributes().get("id");
-        if (attribute.isNotEmpty()) {
-          byte[] byteAttribute = attribute.head().array();
-          String str = new String(byteAttribute);
-          System.out.println("attribute = " + str);
-          return str.equals("10");
-        }
-        return false;
-      }, "id", "10");
-
-      nodePair = searchNode.next();
-      idIterator = nodePair.left().getAttributes().getString("id");
-      Assert.assertTrue(idIterator.hasNext());
-      Assert.assertEquals(idIterator.next(), "10");
-      Assert.assertEquals(nodePair.right().toString(), "<-1,0,0>");
-
-    } catch (Exception e) {
-      e.printStackTrace();
-    }
-  }
+			searchNodeIterator = ifTraverser.find((TreeNode node) -> {
+				ByteBuffer attribute = node.getAttributes().get("id");
+				if (attribute != null) {
+					byte[] byteAttribute = attribute.array();
+					String str = new String(byteAttribute);
+					System.out.println("attribute = " + str);
+					return str.equals("10");
+				}
+				return false;
+			}, "id", "10");
+			
+			searchNode = searchNodeIterator.next();
+			Assert.assertEquals(searchNode.getAttributes().getString("id"),"10");
+			
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
 }
\ No newline at end of file