Fragment.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: Fragment.java
 * Description: Class representing annotated fragment
 */

/**
 * @file Fragment.java
 *
 * @brief Class representing annotated fragment
 */

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

import cz.vutbr.fit.knot.annotations.comet.Util;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.UpdatableFragment;
import java.io.Serializable;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.Lob;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import javax.xml.xpath.XPathExpressionException;

/**
 * Class representing annotated fragment
 *
 * @brief Class representing annotated fragment
 *
 * @author idytrych
 */
@Entity
@Table(name = "fragment")
@NamedQueries({
  @NamedQuery(name = "Fragment.findAll", query = "SELECT f FROM Fragment f"),
  @NamedQuery(name = "Fragment.findById", query = "SELECT f FROM Fragment f WHERE f.id = :id"),
  @NamedQuery(name = "Fragment.findByAnnotation", query = "SELECT f FROM Fragment f WHERE f.annotation = :annotation"),
  @NamedQuery(name = "Fragment.findByOffset", query = "SELECT f FROM Fragment f WHERE f.offset = :offset"),
  @NamedQuery(name = "Fragment.findByLength", query = "SELECT f FROM Fragment f WHERE f.length = :length")})
public class Fragment implements Serializable, Comparable<Object> {

  private static final long serialVersionUID = 1L;
  /**
   * Id of fragment
   */
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Basic(optional = false)
  @Column(name = "id")
  private Integer id;
  /**
   * Id of annotation to which this fragment belongs
   */
  @Basic(optional = false)
  @Column(name = "annotation", nullable = false, insertable = false, updatable = false)
  private int annotation;
  /**
   * XPath of element with annotated fragment
   */
  @Lob
  @Column(name = "frPath")
  private String path;
  /**
   * Offset of annotated fragment in given element
   */
  @Column(name = "frOffset")
  private Integer offset;
  /**
   * Length of annotated fragment
   */
  @Column(name = "frLength")
  private Integer length;
  /**
   * Textual content of annotated fragment
   */
  @Basic(optional = false)
  @Lob
  @Column(name = "annotatedText")
  private String annotatedText;
  /**
   * Indicator, whether fragment is good (not orphaned)
   */
  @Basic(optional = false)
  @Column(name = "isGood")
  private boolean isGood;
  /**
   * Annotation to which this fragment belongs
   */
  @ManyToOne(optional = false)
  @JoinColumn(name = "annotation", referencedColumnName = "id")
  private Annotation refAnnotation;

  /**
   * Constructor
   */
  public Fragment() {
  }

  /**
   * Constructor
   * 
   * @param id sets id of the object
   */
  public Fragment(Integer id) {
    this.id = id;
  }

  
  /**
   * Constructor
   *
   * @param path XPath of element with annotated fragment
   * @param offset Offset of annotated fragment in given element
   * @param length Length of annotated fragment
   * @param annotatedText Textual content of annotated fragment
   * @param refAnnotation Annotation to which this fragment belongs
   */
  public Fragment(String path, Integer offset, Integer length, String annotatedText, Annotation refAnnotation) {
    this.path = path;
    this.offset = offset;
    this.length = length;
    this.annotatedText = annotatedText;
    this.refAnnotation = refAnnotation;
    this.isGood = true;
  }

  /**
   * Constructor
   *
   * @param path XPath of element with annotated fragment
   * @param offset Offset of annotated fragment in given element
   * @param length Length of annotated fragment
   * @param annotatedText Textual content of annotated fragment
   * @param refAnnotation Annotation to which this fragment belongs
   * @param isGood Indicator, whether fragment is good (not orphaned)
   */
  public Fragment(String path, Integer offset, Integer length, String annotatedText, Annotation refAnnotation, Boolean isGood) {
    this.path = path;
    this.offset = offset;
    this.length = length;
    this.annotatedText = annotatedText;
    this.refAnnotation = refAnnotation;
    this.isGood = isGood;
  }

  /**
   * Constructor
   *
   * @param path XPath of element with annotated fragment
   * @param offset Offset of annotated fragment in given element
   * @param length Length of annotated fragment
   */
  public Fragment(String path, Integer offset, Integer length) {
    this.path = path;
    this.offset = offset;
    this.length = length;
    this.isGood = true;
  }

  /**
   * Gets id of fragment
   *
   * @return Returns id of fragment
   */
  public Integer getId() {
    return id;
  }

  /**
   * Sets id of fragment
   *
   * @param id Id of fragment
   */
  public void setId(Integer id) {
    this.id = id;
  }

  /**
   * Gets annotation to which this fragment belongs
   *
   * @return Returns annotation to which this fragment belongs
   */
  public int getAnnotation() {
    return annotation;
  }

  /**
   * Sets annotation to which this fragment belongs
   *
   * @param annotation Annotation to which this fragment belongs
   */
  public void setAnnotation(int annotation) {
    this.annotation = annotation;
  }

  /**
   * Gets XPath of element with this annotated fragment
   *
   * @return Returns XPath of element with this annotated fragment
   */
  public String getPath() {
    return path;
  }

  /**
   * Sets XPath of element with this annotated fragment
   *
   * @param path XPath of element with this annotated fragment
   */
  public void setPath(String path) {
    this.path = path;
  }

  /**
   * Gets offset of annotated fragment in given element
   *
   * @return Returns offset of annotated fragment in given element
   */
  public Integer getOffset() {
    return offset;
  }

  /**
   * Sets offset of annotated fragment in given element
   *
   * @param offset Offset of annotated fragment in given element
   */
  public void setOffset(Integer offset) {
    this.offset = offset;
  }

  /**
   * Gets length of annotated fragment
   *
   * @return Returns length of annotated fragment
   */
  public Integer getLength() {
    return length;
  }

  /**
   * Sets length of annotated fragment
   *
   * @param length Length of annotated fragment
   */
  public void setLength(Integer length) {
    this.length = length;
  }

  /**
   * Gets textual content of annotated fragment
   *
   * @return Returns textual content of annotated fragment
   */
  public String getAnnotatedText() {
    return annotatedText;
  }

  /**
   * Sets textual content of annotated fragment
   *
   * @param annotatedText Textual content of annotated fragment
   */
  public void setAnnotatedText(String annotatedText) {
    this.annotatedText = annotatedText;
  }

  /**
   * Gets annotation to which this fragment belongs
   *
   * @return Returns annotation to which this fragment belongs
   */
  public Annotation getRefAnnotation() {
    return refAnnotation;
  }

  /**
   * Sets annotation to which this fragment belongs
   *
   * @param refAnnotation Annotation to which this fragment belongs
   */
  public void setRefAnnotation(Annotation refAnnotation) {
    this.refAnnotation = refAnnotation;
  }

  /**
   * Get information about fragment status (whether fragment is good or
   * orphaned))
   *
   * @return If fragment is good, returns true, if it's orphaned, returns false
   */
  public boolean getIsGood() {
    return isGood;
  }

  /**
   * Sets fragment status
   *
   * @param isGood If fragment is good then true, if it's orphaned then false
   */
  public void setIsGood(boolean isGood) {
    this.isGood = isGood;
  }

  @Override
  public int hashCode() {
    int hash = 0;
    hash += (id != null ? id.hashCode() : 0);
    hash += (offset != null ? offset.hashCode() : 0);
    hash += (length != null ? length.hashCode() : 0);
    hash += (annotatedText != null ? annotatedText.hashCode() : 0);
    return hash; 
  }

  /**
   * Compares this with other object and returns, whether objects are same type
   * and have same content (id is irrelevant).
   *
   * @param object Object to compare with
   * @return If object is same type and have same id, returns true, false
   * otherwise
   */
  @Override
  public boolean equals(Object object) {
    if (!(object instanceof Fragment)) {
      return false;
    }
    Fragment other = (Fragment) object;
    
    if (this.path != other.path && (this.path == null || !this.path.equals(other.path))) {
      return false;
    }
    if (this.offset != other.offset && (this.offset == null || !this.offset.equals(other.offset))) {
      return false;
    }
    if (this.length != other.length && (this.length == null || !this.length.equals(other.length))) {
      return false;
    }
    if ((this.annotatedText == null) ? (other.annotatedText != null) : !this.annotatedText.equals(other.annotatedText)) {
      return false;
    }

    return true;
  }

  /**
   * Compares this with other object and returns, whether objects are same type
   * and have same content (id is irrelevant).
   *
   * @param obj Object to compare with
   * @return If object is same type and have same content, returns true, false
   * otherwise
   */
  public boolean contentEquals(Object obj) {
    if (obj == null) {
      return false;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    final Fragment other = (Fragment) obj;
    if ((this.path == null) ? (other.path != null) : !this.path.equals(other.path)) {
      if ((this.path == null) ? (other.path != null) : !this.path.equals(other.path.concat("/text()"))) {
        return false;
      }
    }
    if (this.offset != other.offset && (this.offset == null || !this.offset.equals(other.offset))) {
      return false;
    }
    if (this.length != other.length && (this.length == null || !this.length.equals(other.length))) {
      return false;
    }
    if ((this.annotatedText == null) ? (other.annotatedText != null) : !this.annotatedText.equals(other.annotatedText)) {
      return false;
    }
    return true;
  }  // contentEquals()

  /**
   * Compares this with instance of UpdatableFragment and returns, whether
   * fragments have same location (XPath, offset and length) and textual
   * content.
   *
   * @param uf Instance of UpdatableFragment to compare with
   * @return If fragments have same location and textual content, returns true,
   * false otherwise
   */
  public boolean fragmentEqualsWUF(UpdatableFragment uf) {
    if (uf == null) {
      return false;
    }
    if ((this.path == null) ? (uf.getXPathString() != null) : !this.path.equals(uf.getXPathString())) {
      return false;
    }
    if (this.offset != uf.getOffset() && (this.offset == null || !this.offset.equals(uf.getOffset()))) {
      return false;
    }
    if (this.length != uf.getLength() && (this.length == null || !this.length.equals(uf.getLength()))) {
      return false;
    }
    if ((this.annotatedText == null) ? (uf.getText() != null) : !this.annotatedText.equals(uf.getText())) {
      return false;
    }
    return true;
  }  // fragmentEqualsWUF()

  /**
   * Creates UpdatableFragment from this fragment and returns it
   *
   * @return UpdatableFragment created from this fragment
   */
  public UpdatableFragment toUpdatableFragment() throws XPathExpressionException {
    UpdatableFragment retUF = new UpdatableFragment(path, offset, length, annotatedText);
    return retUF;
  }

  /**
   * Updates data in this fragment with data from UpdatableFragment
   *
   * @param uf UpdatableFragment with new (updated) data
   */
  public void updateWithUpdatableFragment(UpdatableFragment uf) {
    if (uf.getXPathString().contains("/text()")) {
      this.path = uf.getXPathString();
    } else {
      this.path = uf.getXPathString() + "/text()";
    }
    this.offset = uf.getOffset();
    this.length = uf.getLength();
    this.annotatedText = uf.getText();
  }

  @Override
  public String toString() {
    return "cz.vutbr.fit.knot.annotations.entity.Fragment[id=" + id + "]";
  }

  /**
   * Returns serialized informations about annotated fragment in XML
   *
   * @return Returns serialized informations about annotated fragment in XML
   */
  public String toXMLString() {
    String invalid = "";
    if (!isGood) {
      invalid = " valid=\"false\"";
    }
    return "<a:fragment" + invalid + ">"
            + "<a:path>" + path + "</a:path>"
            + "<a:offset>" + offset + "</a:offset>"
            + "<a:length>" + length + "</a:length>"
            + "<a:annotatedText>" + Util.toHTMLString(annotatedText) + "</a:annotatedText>"
            + "</a:fragment>";
  }

  /**
   * Returns serialized informations about annotated fragment in XML for protocol version 2
   *
   * @return Returns serialized informations about annotated fragment in XML for protocol version 2
   */
  public String toXMLStringV2(){
        String annotUri = this.getRefAnnotation().getSource();
        String fragXpointer = this.getXpointerV2();

        return "<oa:SpecificResource rdf:about=\"" + annotUri + "#" + fragXpointer + "\">"
                + "<oa:hasSelector>"
                + "<oa:FragmentSelector rdf:about=\"" + annotUri + "#" + fragXpointer + "#selector\">"
                + "<dcterms:conformsTo rdf:resource=\"http://tools.ietf.org/rfc/rfc3023\" />"
                + "<rdf:value>" + fragXpointer + "</rdf:value></oa:FragmentSelector></oa:hasSelector>"
                + "<oa:hasSource><dctypes:Text rdf:about=\"" + annotUri + "\"><dc:format>text/xml</dc:format>"
                + "</dctypes:Text></oa:hasSource></oa:SpecificResource>";
  }

  /**
   * Returns Xpointer of annotated fragment
   *
   * @return Returns Xpointer of annotated fragment
   */
  public String getXpointer(){
        return "xpointer(string-range(" + path + ",\"" + annotatedText + "\", " + offset + ", " + length + "))";
  }

  /**
   * Returns Xpointer of annotated fragment for protocol version 2
   *
   * @return Returns Xpointer of annotated fragment
   */
  public String getXpointerV2(){
    String xpointer = "xpointer(string-range(" + path + ",'" + annotatedText + "', " + offset + ", " + length + "))";    
        return Util.toHTMLString(xpointer);
  }

  /**
   * Compares this fragment with another fragment according to offset and length
   * 
   * @param object Fragment to compare
   * @return Returns a negative integer, zero, or a positive integer as this 
   *         object is less than, equal to, or greater than the specified object. 
   */
  @Override
  public int compareTo(Object object) {
    if (!(object instanceof Fragment)) {
      throw new UnsupportedOperationException("Not supported yet.");
    }
    Fragment other = (Fragment) object;
    int compareResult = offset.compareTo(other.getOffset());
    if (compareResult == 0) {
      compareResult = length.compareTo(other.getLength());
    }

    return compareResult;
  }
}  // class Fragment