UpdatableFragment.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Subproject: Position of fragment of text in XML document
 * Authors: Michael Angelov
 * Edited by: Ing. Jaroslav Dytrych
 * File: UpdatableFragment.java
 * Description: Class for XML document fragment
 */

/**
 * @file UpdatableFragment.java
 *
 * @brief Class for XML document fragment
 */

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

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathExpressionException;

/**
 * Class for XML document fragment
 *
 * @brief Class for XML document fragment
 * @author Michael Angelov
 */
public class UpdatableFragment {

  private String XPathString;
  private XPathExpression XPathExpression;
  private int offset;
  private int length;
  private String text;
  private int wordCount;

  /**
   * Getter for XPath expression
   *
   * @return fragment's XPath expression
   */
  public XPathExpression getXPathExpression() {
    return XPathExpression;
  }

  /**
   * Setter for XPath expression
   *
   * @param XPathExpression set fragment's XPath expression
   */
  public void setXPathExpression(XPathExpression XPathExpression) {
    this.XPathExpression = XPathExpression;
  }

  /**
   * Getter for string representation of XPath expression
   *
   * @return string representation of XPath expression
   */
  public String getXPathString() {
    return XPathString;
  }

  /**
   * Setter for string representation of XPath expression
   *
   * @param XPathString string representation of XPath expression
   */
  public void setXPathString(String XPathString) {
    this.XPathString = XPathString;
  }

  /**
   * Getter for length of fragment's string
   *
   * @return length of fragment's string
   */
  public int getLength() {
    return length;
  }

  /**
   * Setter for length of fragment's string
   *
   * @param length length of fragment's string
   */
  public void setLength(int length) {
    this.length = length;
  }

  /**
   * Getter for offset of fragment's string
   *
   * @return offset of fragment's string
   */
  public int getOffset() {
    return offset;
  }

  /**
   * Setter for offset of fragment's string
   *
   * @param offset offset of fragment's string
   */
  public void setOffset(int offset) {
    this.offset = offset;
  }

  /**
   * Getter for fragment's string content
   *
   * @return fragment's string content
   */
  public String getText() {
    return text;
  }

  /**
   * Setter for fragment's string content
   *
   * @param text fragment's string content
   */
  public void setText(String text) {
    this.text = text;
  }

  /**
   * Getter for fragment's string word count
   *
   * @return number of words in string with following delimiter:
   * @verbatim
   * \s+
   * @endverbatim
   */
  public int getWordCount() {
    return wordCount;
  }

  /**
   * Constructor
   *
   * @param XPathString string representation of XPath
   * @param offset offset of fragment's string
   * @param length length of fragment's string
   * @param text string content of fragment
   */
  public UpdatableFragment(String XPathString, int offset, int length, String text) throws XPathExpressionException {
    this.XPathString = XPathString;
    this.offset = offset;
    this.length = length;
    this.text = text;

    this.XPathExpression = XPathHelper.XPathStringToExpression(XPathString);
    if (text != null) {
      this.wordCount = text.split("\\s+").length;
    }
    else {
      this.wordCount = 0;
    }
  }

  /**
   * Compares this with other object and returns, whether objects are same type
   * and have same content.
   *
   * @param obj Object to compare with
   * @return If object is same type and have same content, returns true, false otherwise
   */
  @Override
  public boolean equals(Object obj) {
    if (obj == null) {
      return false;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    final UpdatableFragment other = (UpdatableFragment) obj;
    if ((this.XPathString == null) ? (other.XPathString != null) : !this.XPathString.equals(other.XPathString)) {
      return false;
    }
    if (this.offset != other.offset) {
      return false;
    }
    if (this.length != other.length) {
      return false;
    }
    if ((this.text == null) ? (other.text != null) : !this.text.equals(other.text)) {
      return false;
    }
    return true;
  }  // equals()

  /**
   * Gets hash code of this fragment
   *
   * @return Hash code
   */
  @Override
  public int hashCode() {
    int hash = 7;
    hash = 47 * hash + (this.XPathString != null ? this.XPathString.hashCode() : 0);
    hash = 47 * hash + this.offset;
    hash = 47 * hash + this.length;
    hash = 47 * hash + (this.text != null ? this.text.hashCode() : 0);
    return hash;
  }

  /**
   * Overriden toString() method
   *
   * @return string representation of class
   */
  @Override
  public String toString() {
    return "XPath: " + XPathString
         + "\nOffset: " + offset
         + "\nLength: " + length
         + "\nText: " + text;
  }

  /**
   * Uppercase XPath up to /text() (necessary for finding fragment)
   * and complete fragments of path (e.g. "/DIV/" -> "/DIV[1]/")
   *
   * @param path XPath to improve
   * @return Returns modified XPath
   */
  public static String improveXPath(String path) {
    if (path == null) {
      return null;
    }
    if (path.equals("")) {
      return path;
    }

    // uppercase path without "text()" and all following
    String newPath = "";
    int tPos = path.indexOf("text()");
    if (tPos > 0) {
      newPath = path.substring(tPos);
    }
    if (tPos < 0) {
      tPos = path.length();
    }
    newPath = path.toUpperCase().substring(0, tPos) + newPath;

    // add [1]
    String[] splitted = newPath.split("/");
    newPath = "";
    ArrayList<String> sList = new ArrayList<String>(Arrays.asList(splitted));
    Iterator<String> sIt = sList.iterator();
    String pathFragment = sIt.next();  // first fragment, probably empty
    if (!pathFragment.isEmpty()) {  // if path don't starts with "/"
      if (pathFragment.endsWith("]")) {
        newPath = pathFragment;
      } else {
        newPath = pathFragment + "[1]";
      }
    }
    for (; sIt.hasNext();) {  // for second and all other fragments
      pathFragment = sIt.next();
      if (pathFragment.endsWith("]")) {
        newPath = newPath + "/" + pathFragment;
      } else {
        newPath = newPath + "/" + pathFragment + "[1]";
      }
    }

    return newPath;
  }  // improveXPath()
}  // class UpdatableFragment