SuggestionFragment.java

Go to the documentation of this file.

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

/**
 * @file SuggestionFragment.java
 *
 * @brief Class representing suggested annotation fragment
 */

package cz.vutbr.fit.knot.annotations.modules.suggestionManager;

import cz.vutbr.fit.knot.annotations.comet.Util;
import cz.vutbr.fit.knot.annotations.entity.Fragment;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.UpdatableFragment;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.alternative.AlternativeFragment;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.alternative.SecFragment;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.alternative.SecSuggestion;
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.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.xpath.XPathExpressionException;

/**
 * Class representing suggested annotation fragment
 *
 * @brief Class representing suggested annotation fragment
 *
 * @author Martin Petr (xpetrm05)
 */
@Entity
@Table(name = "suggestionFragment")
@XmlRootElement
@NamedQueries({
  @NamedQuery(name = "SuggestionFragment.findAll", query = "SELECT s FROM SuggestionFragment s"),
  @NamedQuery(name = "SuggestionFragment.findById", query = "SELECT s FROM SuggestionFragment s WHERE s.id = :id"),
  @NamedQuery(name = "SuggestionFragment.findBySuggestion", query = "SELECT s FROM SuggestionFragment s WHERE s.suggestion = :suggestion"),
  @NamedQuery(name = "SuggestionFragment.findByOffset", query = "SELECT s FROM SuggestionFragment s WHERE s.offset = :frOffset"),
  @NamedQuery(name = "SuggestionFragment.findByLength", query = "SELECT s FROM SuggestionFragment s WHERE s.length = :frLength"),
  @NamedQuery(name = "SuggestionFragment.findByIsGood", query = "SELECT s FROM SuggestionFragment s WHERE s.isGood = :isGood")})
public class SuggestionFragment implements Serializable, Comparable<Object>, SecFragment {
  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 suggested annotation to which this fragment belongs */
  @Basic(optional = false)
  @NotNull
  @Column(name = "suggestion", nullable = false, insertable = false, updatable = false)
  private int suggestion;
  
  /** XPath of element with suggested annotation fragment */
  @Lob
  @Size(max = 2147483647)
  @Column(name = "path")
  private String path;
  
  /** Offset of suggested annotation fragment in given element */
  @Column(name = "offset")
  private Integer offset;
  
  /** Length of suggested annotation fragment */
  @Column(name = "fLength")
  private Integer length;
  
  /** Textual content of suggested annotation fragment */
  @Basic(optional = false)
  @NotNull
  @Lob
  @Size(min = 0, max = 16777215)
  @Column(name = "annotatedText")
  private String annotatedText;
  
  /**
   * Indicator, whether fragment is good (not orphaned)
   */
  @Basic(optional = false)
  @NotNull
  @Column(name = "isGood")
  private boolean isGood;
  
  /**
   * Suggestion to which this fragment belongs
   */
  @ManyToOne(optional = false)
  @JoinColumn(name = "suggestion", referencedColumnName = "id")
  private Suggestion refSuggestion;

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

  /**
   * 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 refSuggestion Suggestion to which this fragment belongs
   */
  public SuggestionFragment(String path, Integer offset, Integer length, String annotatedText, Suggestion refSuggestion) {
    this.path = path;
    this.offset = offset;
    this.length = length;
    this.annotatedText = annotatedText;
    this.refSuggestion = refSuggestion;
    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 refSuggestion Suggestion to which this fragment belongs
   * @param isGood Indicator, whether fragment is good (not orphaned)
   */
  public SuggestionFragment(String path, Integer offset, Integer length, String annotatedText, Suggestion refSuggestion, Boolean isGood) {
    this.path = path;
    this.offset = offset;
    this.length = length;
    this.annotatedText = annotatedText;
    this.refSuggestion = refSuggestion;
    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 SuggestionFragment(String path, Integer offset, Integer length) {
    this.path = path;
    this.offset = offset;
    this.length = length;
    this.isGood = true;
  }

  /**
   * Gets ID of this object
   * 
   * @return id
   */
  public Integer getId() {
    return id;
  }

  /**
   * Sets ID of this object
   * 
   * @param id new ID
   */
  public void setId(Integer id) {
    this.id = id;
  }

  /**
   * Gets ID of suggestion
   * 
   * @return ID
   */
  public int getSuggestion() {
    return suggestion;
  }

  /**
   * Sets ID of suggestion
   * 
   * @param suggestion new id
   */
  public void setSuggestion(int suggestion) {
    this.suggestion = suggestion;
  }

  /**
   * Gets path
   * 
   * @return path
   */
  public String getPath() {
    return path;
  }

  /**
   * Sets path
   * 
   * @param path new path
   */
  public void setPath(String path) {
    this.path = path;
  }

  /**
   * Gets offset
   * 
   * @return offset
   */
  @Override
  public Integer getOffset() {
    return offset;
  }

  /**
   * Sets offset
   * 
   * @param offset new offset
   */
  public void setOffset(Integer offset) {
    this.offset = offset;
  }

  /**
   * Gets length
   * 
   * @return length
   */
  @Override
  public Integer getLength() {
    return length;
  }

  /**
   * Sets length
   * 
   * @param length new length
   */
  public void setLength(Integer length) {
    this.length = length;
  }

  /**
   * Gets annotated text
   * 
   * @return annotated text
   */
  @Override
  public String getAnnotatedText() {
    return annotatedText;
  }
  
  /**
   * Sets annotated text
   * 
   * @param annotatedText  new annotated text
   */
  public void setAnnotatedText(String annotatedText) {
    this.annotatedText = annotatedText;
  }

  /**
   * 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;
  }

  /**
   * Gets suggestion to which this fragment belongs
   *
   * @return Returns suggestion to which this fragment belongs
   */
  public Suggestion getRefSuggestion() {
    return refSuggestion;
  }

  /**
   * Gets sugestion to which this fragment belongs
   *
   * @return Returns suggestion or alternative to which this fragment belongs
   */
  @Override
  public SecSuggestion getRefSecSuggestion() {
    return refSuggestion;
  }

  /**
   * Sets suggestion to which this fragment belongs
   *
   * @param refSuggestion Suggestion to which this fragment belongs
   */
  public void setRefSuggestion(Suggestion refSuggestion) {
    this.refSuggestion = refSuggestion;
  }

  /**
   * Sets suggestion to which this fragment belongs
   *
   * @param value Suggestion to which this fragment belongs
   */
  @Override
  public void setRefSecSuggestion(SecSuggestion value) {
    if (value instanceof Suggestion) {
      this.refSuggestion = (Suggestion) value;
    }
  }
  
  /**
   * 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();
  }
  
  /**
   * Copies all values of the annotation fragment into the suggestion fragment
   * 
   * @param fr fragment of the annotation
   */
  public void updateFromFragment(Fragment fr){
    this.path = fr.getPath();
    this.length = fr.getLength();
    this.offset = fr.getOffset();
    this.annotatedText = fr.getAnnotatedText();
    this.isGood = fr.getIsGood();
  }
  
  /**
   * Copies all values of the alternative fragment into the suggestion fragment
   * 
   * @param fr fragment of the alternative
   */
  public void updateFromAlternativeFragment(AlternativeFragment fr){
    this.path = fr.getPath();
    this.length = fr.getLength();
    this.offset = fr.getOffset();
    this.annotatedText = fr.getAnnotatedText();
    this.isGood = fr.getIsGood();
  }
  
  /**
   * 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 content, returns true, false
   * otherwise
   */
  @Override
  public boolean equals(Object object) {
    if (!(object instanceof SuggestionFragment)) {
      return false;
    }
    SuggestionFragment other = (SuggestionFragment) 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 SuggestionFragment other = (SuggestionFragment) 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()
  
  /**
   * Returns serialized informations about suggested 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 suggested fragment in XML for protocol version 2
   *
   * @return Returns serialized informations about suggested fragment in XML for protocol version 2
   */
  public String toXMLStringV2(){
        String annotUri = this.getRefSuggestion().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 suggested fragment
   *
   * @return Returns Xpointer of annotated fragment
   */
  public String getXpointer(){
        return "xpointer(string-range(" + path + ",\"" + annotatedText + "\", " + offset + ", " + length + "))";
  }

  /**
   * Returns Xpointer of suggested 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);
  }

  @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; 
  }

  @Override
  public String toString() {
    return "cz.vutbr.fit.knot.annotations.modules.suggestionManager.SuggestionFragment[ id=" + id + " ]";
  }
  
  /**
   * 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 SuggestionFragment)) {
      throw new UnsupportedOperationException("Not supported yet.");
    }
    SuggestionFragment other = (SuggestionFragment) object;
    int compareResult = offset.compareTo(other.getOffset());
    if (compareResult == 0) {
      compareResult = length.compareTo(other.getLength());
    }

    return compareResult;
  }
}  // public class SuggestionFragment()