BidirectionallyUnNestNodeIterator.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Subproject: Position of fragment of text in XML document
 * Author: Bc. Lukas Kubik xkubik22@stud.fit.vutbr.cz
 * File: BidirectionallyUnNestNodeIterator.java
 * Description: Node iterator which is gradually unnesting
 */

/**
 * @file BidirectionallyUnNestNodeIterator.java
 *
 * @brief Node iterator which is gradually unnesting
 */

package cz.vutbr.fit.knot.annotations.fragmentUpdater.nodeIterators;

import cz.vutbr.fit.knot.annotations.fragmentUpdater.XPathHelper;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathExpressionException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;

/**
 * Node iterator which is gradually unnesting
 *
 * @brief Node iterator which is gradually unnesting
 * @author Bc. Lukas Kubik
 */
public class BidirectionallyUnNestNodeIterator extends RecursiveNodeIterator{
  
  /** 
   * Next node sides
   * 
   * @brief Next node sides
   */
  protected enum flow {
    LEFT, RIGHT
  };
 
  /** Next node side. */
  protected flow currentFlow;
  protected Node nextNodeL, nextNodeR;
  /** 
   * Loop end condition. It is activated when one of the loops steps out of
   * the root node.
   */
  protected boolean leftEnd, rightEnd;
  protected String sessionL;
  protected String sessionR;

  /**
   * Overriden initialization method.
   *
   * @param document document whose nodes will be iterated through
   * @param expr expression according to which iterating will be provided
   */
  @Override
  public void init(Document document, XPathExpression expr) throws XPathExpressionException {
    this.timestamp = System.currentTimeMillis();
    this.sessionL = "L" + this.timestamp;
    this.sessionR = "R" + this.timestamp;
    this.document = document;
    this.nodeList = XPathHelper.evaluateXPath(document, expr);
    this.currentNodeIndex = 0;
    this.firstNode = true;
    this.currentFlow = flow.RIGHT;
    this.leftEnd = this.rightEnd = false;
    
    if (nodeList.getLength() == 0) {
      nextNodeL = nextNodeR = null;
    } else {
      // First node which will be parsed
      nextNodeL = nextNodeR = nodeList.item(currentNodeIndex);
    }
  }

  /**
   * Overriden method for iterator's next node
   *
   * @return iterator's next node
   */
  @Override
  public Node nextNode() {
    
    Node resultNode = null;
        
    if(firstNode){
      firstNode = false;
      setVisited(nextNodeL, flow.LEFT);
      setVisited(nextNodeR, flow.RIGHT);
      // We can return both nodes because nextNodeL == nextNodeR
      return nextNodeL;
    }
   
    // Flow of right terminal nodes
    if(currentFlow == flow.RIGHT && !rightEnd){
      if (nextNodeR == null) {
        rightEnd = true;
        changeFlow();
        return nextNode();
      }
      
      // If the node is visited then we go to the right node or to parent's next node.
      if(isVisited(nextNodeR, currentFlow)){
        if(nextNodeR.getNextSibling() != null){
          nextNodeR = nextNodeR.getNextSibling();
          return nextNode();
        }
        else{
          setVisited(nextNodeR.getParentNode(), currentFlow);
          nextNodeR = nextNodeR.getParentNode();
          return nextNode();
        }
      }
      else{
        if(nextNodeR.hasChildNodes()){
          nextNodeR = nextNodeR.getFirstChild();
          return nextNode();
        }
        else{
          resultNode = nextNodeR;
          setVisited(nextNodeR, currentFlow);
        }
      }
    }
    // Flow of left terminal nodes
    else if(!leftEnd){
      if (nextNodeL == null) {
        leftEnd = true;
        changeFlow();
        return nextNode();
      }
      
      // If the node is visited then we go to the left node or to parent's previous node.
      if(isVisited(nextNodeL, currentFlow)){
        if(nextNodeL.getPreviousSibling() != null){
          nextNodeL = nextNodeL.getPreviousSibling();
          return nextNode();
        }
        else{
          setVisited(nextNodeL.getParentNode(), currentFlow);
          nextNodeL = nextNodeL.getParentNode();
          return nextNode();
        }
      }
      else{
        if(nextNodeL.hasChildNodes()){
          nextNodeL = nextNodeL.getLastChild();
          return nextNode();
        }
        else{
          resultNode = nextNodeL;
          setVisited(nextNodeL, currentFlow);
        }
      }
    }
    // No more nodes available
    else{
      return null;
    }
    
    // If node is not empty or non text.
    //if (resultNode.getNodeName().equals("#text") && !isWhitespaced(resultNode.getTextContent())) 
    if((resultNode.getNodeType() == Node.TEXT_NODE || resultNode.getNodeType() == Node.CDATA_SECTION_NODE)
            && !isWhitespaced(resultNode.getNodeValue())){
      if(!leftEnd && !rightEnd){
        changeFlow();
      }
      return resultNode;
    }

    return nextNode();

  }
  
  /**
   * Is there any more node for comparing?
   * @return True if yes, false if not
   */
  public boolean hasNext() {
    if(leftEnd && rightEnd){
      return false;
    }
    return true;
  }
  

  /**
   * Changes current flow of the nodes.
   */
  protected void changeFlow() {
    if(currentFlow == flow.RIGHT){
      currentFlow = flow.LEFT;
    }
    else{
      currentFlow = flow.RIGHT;
    }
  }
  
  /**
   * Sets node's "visited" flag
   *
   * @param node node which flag is to be set
   * @param currentFlow next node side
   */
  private void setVisited(Node node, flow currentFlow) {
    if (node == null) {
      return;
    }
    
    if(currentFlow == flow.RIGHT){
      node.setUserData(this.sessionR, timestamp, null);
    }
    else{
      node.setUserData(this.sessionL, timestamp, null);
    }
  }

  /**
   * Getter of node's "visited" flag
   *
   * @param node node which flag is to be returned
   * @param currentFlow next node side
   * @return true if "visited" flag is set, false if isn't
   */
  private boolean isVisited(Node node, flow currentFlow) {
    if (node == null) {
      return true;
    }

    Long visited = null;
    
    if(currentFlow == flow.RIGHT){
      visited = (Long) node.getUserData(this.sessionR);
    }
    else{
      visited = (Long) node.getUserData(this.sessionL);
    }

    if (visited == null) {
      return false;
    }

    return (visited == timestamp);
  }
  
  /**
   * Overriden toString() method
   *
   * @return string representation of class
   */
  @Override
  public String toString() {
    return "BidirectionallyUnNest";
  }
}  // class BidirectionallyUnNestNodeIterator