MatcherProvider.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: MatcherProvider.java
 * Description: Class providing access to available matchers
 */

/**
 * @file MatcherProvider.java
 *
 * @brief Class providing access to available matchers
 */

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

import cz.vutbr.fit.knot.annotations.comet.Util;
import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPathExpressionException;
import org.apache.html.dom.HTMLDocumentImpl;
import org.cyberneko.html.parsers.DOMFragmentParser;
import org.cyberneko.html.parsers.DOMParser;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentFragment;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.html.HTMLDocument;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

/**
 * Class providing access to available matchers
 *
 * @brief Class providing access to available matchers
 * @author Peter Bartoš, Michael Angelov
 */
public class MatcherProvider {

  public ArrayList<MatcherWrapper> matcherWrappers;
  protected static final String _SET_NAMESPACES = "http://xml.org/sax/features/namespaces";
  protected static final String _REPORT_ERRORS = "http://cyberneko.org/html/features/report-errors";

  /**
   * Constructor
   *
   */
  public MatcherProvider() {
    matcherWrappers = new ArrayList<MatcherWrapper>();
  }

  /**
   * Method for adding matcher to list of provided matchers
   *
   * @param matcher matcher to be added
   * @param priority priority of matcher
   */
  public void add(Matcher matcher, int priority) {
    matcherWrappers.add(new MatcherWrapper(matcher, priority));
    sortMatchers();
  }

  /**
   * Method for adding matcher wrapper
   *
   * @param mw matcher wrapper to be added
   */
  public void add(MatcherWrapper mw) {
    matcherWrappers.add(mw);
    sortMatchers();
  }

  /**
   * Method for removing matcher wrapper from list
   *
   * @param mw matcher to be removed
   */
  public void remove(MatcherWrapper mw) {
    matcherWrappers.remove(mw);
    sortMatchers();
  }

  /**
   * Method for removing matcher from provided matcher list
   *
   * @param matcher matcher to be removed
   */
  public void removeMatcher(Matcher matcher) {
    for (MatcherWrapper mw : matcherWrappers) {
      if (mw.matcher == matcher) {
        matcherWrappers.remove(mw);
        break;
      }
    }

    // sort matcher in the end
    sortMatchers();
  }

  /**
   * Getter for list of provided matchers
   *
   * @return list of provided matchers
   */
  public ArrayList<MatcherWrapper> getMatcherWrappers() {
    return matcherWrappers;
  }

  /**
   * Method for matching query fragment in document
   *
   * @param text text in which fragment should be matched
   * @param queryFragment fragment to be matched
   * @return result fragment that was matched in document
   */
  public UpdatableFragment match(String text, UpdatableFragment queryFragment) throws ParserConfigurationException, SAXException, IOException, XPathExpressionException {
    Document document = getDocumentFromString(text, false, true);
    for (MatcherWrapper mw : matcherWrappers) {
      UpdatableFragment resultFragment = mw.matcher.match(document, queryFragment);
      if (resultFragment != null) {
        return resultFragment;
      }
    }

    return null;
  }

  /**
   * Method for matching query fragment in document
   *
   * @param document Document in which fragment should be matched
   * @param queryFragment fragment to be matched
   * @return result fragment that was matched in document
   */
  public UpdatableFragment match(Document document, UpdatableFragment queryFragment) throws XPathExpressionException {
    for (MatcherWrapper mw : matcherWrappers) {
      UpdatableFragment resultFragment = mw.matcher.match(document, queryFragment);
      if (resultFragment != null) {
        return resultFragment;
      }
    }

    return null;
  }

  /**
   * Method for matching query fragment in document
   *
   * @param document Document in which fragment should be matched
   * @param queryFragment fragment to be matched
   * @return result fragments that was matched in document
   */
  public ArrayList<UpdatableFragment> matchAll(Document document, UpdatableFragment queryFragment) throws XPathExpressionException {
    ArrayList<UpdatableFragment> allResultFragments = new ArrayList<UpdatableFragment>();
    for (MatcherWrapper mw : matcherWrappers) {  // for all wrappers
      ArrayList<UpdatableFragment> resultFragments = mw.matcher.matchAll(document, queryFragment);
      // Add all fragments which are not included
      for (Iterator<UpdatableFragment> rFIt = resultFragments.iterator(); rFIt.hasNext();) {
        UpdatableFragment rF = rFIt.next();
        if (!allResultFragments.contains(rF)) {
          allResultFragments.add(rF);
        }
      }
    }  // for all wrappers

    return allResultFragments;
  }  // matchAll()
  
    /**
   * Method for matching query fragment in document
   *
   * @param document Document in which fragment should be matched
   * @param queryFragment fragment to be matched
   * @return result fragments that was matched in document
   */
  public ArrayList<UpdatableFragment> matchAllIncrementally(Document document, UpdatableFragment queryFragment) throws XPathExpressionException {
    ArrayList<UpdatableFragment> allResultFragments = new ArrayList<UpdatableFragment>();
    for (MatcherWrapper mw : matcherWrappers) {  // for all wrappers
      ArrayList<UpdatableFragment> resultFragments = mw.matcher.matchAll(document, queryFragment);
      
      // Are there any matches?
      if(!resultFragments.isEmpty()){
        // Add all fragments within one sensitivity
        for (Iterator<UpdatableFragment> rFIt = resultFragments.iterator(); rFIt.hasNext();) {
          UpdatableFragment rF = rFIt.next();
            allResultFragments.add(rF);
        }
        // return results within one sensitivity
        return allResultFragments;
      } // isEmpty()

    }  // for all wrappers, increasing sensitivity

    return allResultFragments;
  }  // matchAllIncrementally()
  
   /**
   * Method for matching query fragment in document
   * This method should be used only with bidirectional iterator!
   * Bidirectional iterator has a it's own mechanism for traversing the nodes.
   * 
   * @param document Document in which fragment should be matched
   * @param queryFragment fragment to be matched
   * @return result fragments that was matched in document
   */
  public UpdatableFragment matchInClosestNode(Document document, UpdatableFragment queryFragment) throws XPathExpressionException {
    UpdatableFragment resultFragment = null;
    boolean endIteration = false;
    
    for (MatcherWrapper mw : matcherWrappers) { // initialize all wrappers and interators!
      mw.matcher.InitIterator(document, queryFragment);
    }
    
    while(!endIteration){
      endIteration = true;
      
      for (MatcherWrapper mw : matcherWrappers) {  // for all wrappers
        // If there is another node for match
        if(mw.matcher.canMatchNext()){
          // Matching in next node (traversing method is encapsulated withing the iterator)
          resultFragment = mw.matcher.matchInNextNode(queryFragment);

          // Are there any matches?
          if(resultFragment != null){
            // return results within one sensitivity
            return resultFragment;
          }
          endIteration = false;
        }
      }  // for all wrappers
    }

    return resultFragment;
  }  // matchInClosestNode()
  
  /**
   * Method for matching query fragment in document
   * This method should be used only with bidirectional iterator!
   * Bidirectional iterator has a it's own mechanism for traversing the nodes.
   * 
   * @param document Document in which fragment should be matched
   * @param queryFragment fragment to be matched
   * @return result fragments that was matched in document
   */
    public ArrayList<UpdatableFragment> matchIn3ClosestNodes(Document document, UpdatableFragment queryFragment) throws XPathExpressionException {
    ArrayList<UpdatableFragment> resultFragments = new ArrayList<UpdatableFragment>();
    
    for (MatcherWrapper mw : matcherWrappers) { // initialize all wrappers and interators!
      mw.matcher.InitIterator(document, queryFragment);
    }
    
    // If we don't start on the first node then we have to iterate through 3 nodes
    int itrerateNodes = 3;
    
    Node firstNode = document.getDocumentElement();
    firstNode = getFirstTextNode(firstNode);

    NodeList nodeList = XPathHelper.evaluateXPath(document, queryFragment.getXPathExpression());
    
    //If the first node is the same as the original fragment node then we iterate through 2 nodes
    if(nodeList != null && nodeList.getLength() > 0 && nodeList.item(0).isEqualNode(firstNode)){
      itrerateNodes = 2;
    }
    
    // for all wrappers try to find match in original node and it's siblings
    for (MatcherWrapper mw : matcherWrappers) {  
      // Match in closest siblings
      for(int i = 0; i < itrerateNodes; i++){
        if(mw.matcher.canMatchNext()){
          // Matching in next node (traversing method is encapsulated withing the iterator)
          UpdatableFragment uf = mw.matcher.matchInNextNode(queryFragment);
          // Are there any matches?
          if(uf != null){
            resultFragments.add(uf);
          }
        }
        else{
          break;
        }
      }
    }  // for all wrappers

    // If we didn't match in closest siblings on all sensitivities then we will try
    // to continue in next siblings.
    // Code after condition is more or less code of the matchInClosestNode method.
    if(resultFragments.isEmpty()){
      UpdatableFragment resultFragment = null;
      boolean endIteration = false;

      while(!endIteration && resultFragments.isEmpty()){
        endIteration = true;

        for (MatcherWrapper mw : matcherWrappers) {  // for all wrappers
          // If there is another node for match
          if(mw.matcher.canMatchNext()){
            // Matching in next node (traversing method is encapsulated withing the iterator)
            resultFragment = mw.matcher.matchInNextNode(queryFragment);

            // Are there any matches?
            if(resultFragment != null){
              // return results within one sensitivity
              resultFragments.add(resultFragment);
            }
            endIteration = false;
          }
        }  // for all wrappers
      }
    }
    
    if(!resultFragments.isEmpty()){
      UpdatableFragment finalFragment = selectBestSubFragment(queryFragment, resultFragments);
      resultFragments = new ArrayList<UpdatableFragment>();
      resultFragments.add(finalFragment);
    }
    return resultFragments;
  }  // matchIn3ClosestNodes()
  
  /**
   * Method finds the first text node of a document
   * @param firstNode Document first node
   * @return Document first text node
   */
  private Node getFirstTextNode(Node firstNode){
    while (firstNode.hasChildNodes()) {
      firstNode = firstNode.getFirstChild();
    }
    while (firstNode.getNextSibling() != null){
      firstNode = firstNode.getNextSibling();
    }
    while (firstNode.hasChildNodes()) {
      firstNode = firstNode.getFirstChild();
    }
    return firstNode;
  }

  /**
   * Method for sorting matcher according to their priority
   *
   */
  public void sortMatchers() {
    Collections.sort(matcherWrappers, new java.util.Comparator<MatcherWrapper>(){
            @Override
            public int compare(MatcherWrapper o1, MatcherWrapper o2) {
                return o1.getPriority() - o2.getPriority();
            }
    });
    
    for (int i = 0; i < matcherWrappers.size(); i++) {
      matcherWrappers.get(i).setPriority(i);
    }
  }

  /**
   * Method for removing all matchers
   *
   */
  public void removeAll() {
    matcherWrappers.clear();
  }

  /**
   * Converts given string into Document
   *
   * @param text String to convert
   * @param setNamespaces Flag for setting namespaces to parser
   * @param setErrors Flag for setting errors report to parser
   * @return Document
   */
  public Document getDocumentFromString(String text, boolean setNamespaces, boolean setErrors) throws ParserConfigurationException, SAXException, IOException {
    InputSource is = new InputSource();
    is.setCharacterStream(new StringReader(text));

    DOMParser parser = new DOMParser();
    if (setNamespaces) {
      parser.setFeature(_SET_NAMESPACES, false);
    }
    if (setErrors) {
      parser.setFeature(_REPORT_ERRORS, false);
    }
    parser.parse(is);
    Document document = parser.getDocument();

    return document;
  }  // getDocumentFromString()

  /**
   * Converts given string into Document fragment
   *
   * @param text String to convert
   * @return Document fragment
   */
  public DocumentFragment getFragmentFromString(String text) throws ParserConfigurationException, SAXException, IOException {
    InputSource is = new InputSource();
    is.setCharacterStream(new StringReader(text));

    DOMFragmentParser parser = new DOMFragmentParser();
    parser.setFeature("http://xml.org/sax/features/namespaces", false);
    HTMLDocument document = new HTMLDocumentImpl();
    DocumentFragment fragment = document.createDocumentFragment();
    parser.parse(is, fragment);

    return fragment;
  }  // getFragmentFromString()
  
  /**
   * Selects the best fragment from the best substrings
   * 
   * @param origFragment Original fragment
   * @param BestSubParts Best substrings
   * @return New selected fragment
   * @throws XPathExpressionException 
   */
  private UpdatableFragment selectBestSubFragment(UpdatableFragment origFragment,
          ArrayList<UpdatableFragment> BestSubParts)
          throws XPathExpressionException{
    if(BestSubParts.isEmpty()){
      return null;
    }
    else if(BestSubParts.size() == 1){
      return BestSubParts.get(0);
    }
    
    int minBadness = Integer.MAX_VALUE; //treshold
    
    String originalText = origFragment.getText(); // original fragment text
    int orignalOffset = origFragment.getOffset(); // original fragment offset 
    String originalPath = origFragment.getXPathString(); // original fragment XPath 
    
    Iterator<UpdatableFragment> itFrg = BestSubParts.iterator(); // best subfragments iterator
    
    UpdatableFragment comparedfragment; // currently compared fragment
    
    int index = 0; // current index
    int bestIndex = 0; // index of the best fragment text
    
    // finds the best substring
    while(itFrg.hasNext()){
      
      comparedfragment = itFrg.next();
      
      int LD = Util.levenshtein(originalText, comparedfragment.getText());
      double LPerc = (LD / (double)originalText.length()) * 100;
      
      int badness = 355 * Util.levenshtein(originalPath, comparedfragment.getXPathString()) +
              5 * (int)LPerc + 
              Math.abs(orignalOffset - comparedfragment.getOffset());
      if(badness < minBadness){
        minBadness = badness;
        bestIndex = index;
      }
      ++index;
    }
    
    return BestSubParts.get(bestIndex);
  }
  
}  // class MatcherProvider