Matcher.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Subproject: Position of fragment of text in XML document
 * Authors: Peter Bartoš, Michael Angelov
 * Edited by: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz,
 *            Bc. Lukas Kubik xkubik22@stud.fit.vutbr.cz
 * File: Matcher.java
 * Description: Class for matcher consisting of comparator and node iterator
 */

/**
 * @file Matcher.java
 *
 * @brief Class for matcher consisting of comparator and node iterator
 */

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

import cz.vutbr.fit.knot.annotations.fragmentUpdater.nodeIterators.BidirectionallyUnNestNodeIterator;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.nodeIterators.NodeIterator;
import java.util.ArrayList;
import javax.xml.xpath.XPathExpressionException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;

/**
 * Class for matcher consisting of comparator and node iterator
 *
 * @brief Class for matcher consisting of comparator and node iterator
 * @author Peter Bartoš, Michael Angelov
 */
public class Matcher {

  public NodeIterator nodeIterator;
  public Comparator comparator;
  protected boolean iteratorInitialized = false;

  /**
   * Getter for node iterator used in matcher
   *
   * @return node iterator used in matcher
   */
  public NodeIterator getNodeIterator() {
    return nodeIterator;
  }

  /**
   * Getter for comparator used in matcher
   *
   * @return comparator used in matcher
   */
  public Comparator getComparator() {
    return comparator;
  }

  /**
   * Setter for node iterator used in matcher
   *
   * @param nodeIterator node iterator used in matcher
   */
  public void setNodeIterator(NodeIterator nodeIterator) {
    this.nodeIterator = nodeIterator;
  }

  /**
   * Setter for comparator used in matcher
   *
   * @param comparator comparator used in matcher
   */
  public void setComparator(Comparator comparator) {
    this.comparator = comparator;
  }

  /**
   * Constructor
   *
   * @param nodeIterator node iterator to be used
   * @param comparator string comparator to be used
   */
  public Matcher(NodeIterator nodeIterator, Comparator comparator) {
    this.nodeIterator = nodeIterator;
    this.comparator = comparator;
  }

  /**
   * Method for matching fragment in document
   *
   * @param document Document in which given fragment should be matched
   * @param queryFragment fragment to be matched
   * @return result fragment that was matched
   */
  public UpdatableFragment match(Document document, UpdatableFragment queryFragment) throws XPathExpressionException {

    Node node;

    UpdatableFragment resultFragment = null;

    nodeIterator.init(document, queryFragment.getXPathExpression());

    do {
      node = nodeIterator.nextNode();
      // no more nodes
      if (node == null) {
        return null;
      }

      resultFragment = comparator.compare(queryFragment, node);

    } while (resultFragment == null);

    return resultFragment;
  }
    
  /**
   * Method for matching fragments in document
   *
   * @param document Document in which given fragment should be matched
   * @param queryFragment fragment to be matched
   * @return result fragments that was matched
   */
  public ArrayList<UpdatableFragment> matchAll(Document document, UpdatableFragment queryFragment) throws XPathExpressionException {

    Node node;

    UpdatableFragment resultFragment = null;
    ArrayList<UpdatableFragment> resultFragments = new ArrayList<UpdatableFragment>();

    nodeIterator.init(document, queryFragment.getXPathExpression());
    
    node = nodeIterator.nextNode();
    while (node != null) {  // while there are more nodes
      resultFragment = comparator.compare(queryFragment, node);
      if (resultFragment != null) {
        if (!resultFragments.contains(resultFragment)) {
          resultFragments.add(resultFragment);
        }
        resultFragment = null;
      }
      
      node = nodeIterator.nextNode();
    }
    return resultFragments;
  }
  
  /**
   * Inits the Iterator for incremental node matching
   * 
   * @param document Document in which given fragment should be matched
   * @param queryFragment fragment to be matched
   * @throws XPathExpressionException 
   */
  public void InitIterator(Document document, UpdatableFragment queryFragment) throws XPathExpressionException {
    nodeIterator.init(document, queryFragment.getXPathExpression());
    iteratorInitialized = true;
  }
  
  /**
   * Method for matching fragment in next node of the document
   *
   * @param queryFragment fragment to be matched
   * @return result fragment that was matched
   */
  public UpdatableFragment matchInNextNode(UpdatableFragment queryFragment) throws XPathExpressionException {

    if(!iteratorInitialized){
      return null;
    }
    
    Node node;

    UpdatableFragment resultFragment = null;

    node = nodeIterator.nextNode();
    // no more nodes
    if (node == null) {
      return null;
    }

    resultFragment = comparator.compare(queryFragment, node);

    return resultFragment;
  }
  
  /**
   * Is there bidirectional iterator initialized?
   * @return True if yes, False if not.
   */
  public boolean hasBidirectionalIterator(){
    if(nodeIterator.toString().contentEquals("BidirectionallyUnNest")){
      return true;
    }
    return false;
  }
  
  /**
   * Can we match things in another node?
   * Can be used only with the bidirectional node iterator!!!
   * Otherwise it always returns false...
   * @return True if yes, False if not.
   */
  public boolean canMatchNext(){
    if(hasBidirectionalIterator()){
      return ((BidirectionallyUnNestNodeIterator)nodeIterator).hasNext();
    }
    return false;
  }
    

  /**
   * Overriden toString() method
   *
   * @return string representation of class
   */
  @Override
  public String toString() {
    return "(" + nodeIterator + ", " + comparator + ")";
  }

}  // class Matcher