AlternativeFragment.java

Go to the documentation of this file.

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

/**
 * @file AlternativeFragment.java
 *
 * @brief Class representing fragment for suggestion alternative
 */

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

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.SuggestionFragment;
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 fragment for suggestion alternative
 *
 * @brief Class representing fragment for suggestion alternative
 *
 * @author Marek Kopecky
 */
@Entity
@Table(name = "alternativeFragment")
@XmlRootElement
@NamedQueries({
  @NamedQuery(name = "AlternativeFragment.findAll", query = "SELECT a FROM AlternativeFragment a"),
  @NamedQuery(name = "AlternativeFragment.findById", query = "SELECT a FROM AlternativeFragment a WHERE a.id = :id"),
  @NamedQuery(name = "AlternativeFragment.findByAlternative", query = "SELECT a FROM AlternativeFragment a WHERE a.alternative = :alternative"),
  @NamedQuery(name = "AlternativeFragment.findByOffset", query = "SELECT a FROM AlternativeFragment a WHERE a.offset = :frOffset"),
  @NamedQuery(name = "AlternativeFragment.findByLength", query = "SELECT a FROM AlternativeFragment a WHERE a.length = :frLength"),
  @NamedQuery(name = "AlternativeFragment.findByIsGood", query = "SELECT a FROM AlternativeFragment a WHERE a.isGood = :isGood"),
  @NamedQuery(name = "AlternativeFragment.deleteByAltId", query = "DELETE FROM AlternativeFragment a WHERE a.alternative  = :altId")
})
public class AlternativeFragment 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 alternative to which this fragment belongs */
  @Basic(optional = false)
  @NotNull
  @Column(name = "alternative", nullable = false, insertable = false, updatable = false)
  private int alternative;
  
  /** XPath of element with alternative fragment */
  @Lob
  @Size(max = 2147483647)
  @Column(name = "path")
  private String path;
  
  /** Offset of alternative fragment in given element */
  @Column(name = "offset")
  private Integer offset;
  
  /** Length of alternative fragment */
  @Column(name = "fLength")
  private Integer length;
  
  /** Textual content of alternative 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;
  
  /**
   * Alternative to which this fragment belongs
   */
  @ManyToOne(optional = false)
  @JoinColumn(name = "alternative", referencedColumnName = "id")
  private Alternative refAlternative;

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

  /**
   * Constructor
   *
   * @param path XPath of element with alternative fragment
   * @param offset Offset of alternative fragment in given element
   * @param length Length of alternative fragment
   * @param annotatedText Textual content of alternative fragment
   * @param refAlternative Alternative to which this fragment belongs
   */
  public AlternativeFragment(String path, Integer offset, Integer length, String annotatedText, Alternative refAlternative) {
    this.path = path;
    this.offset = offset;
    this.length = length;
    this.annotatedText = annotatedText;
    this.refAlternative = refAlternative;
    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 refAlternative Alternative to which this fragment belongs
   * @param isGood Indicator, whether fragment is good (not orphaned)
   */
  public AlternativeFragment(String path, Integer offset, Integer length, String annotatedText, Alternative refAlternative, Boolean isGood) {
    this.path = path;
    this.offset = offset;
    this.length = length;
    this.annotatedText = annotatedText;
    this.refAlternative = refAlternative;
    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 AlternativeFragment(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 alternative
   * 
   * @return ID
   */
  public int getAlternative() {
    return alternative;
  }

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

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

  /**
   * Sets XPath
   * @param path new XPath
   */
  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 alternative to which this fragment belongs
   *
   * @return Returns alternative to which this fragment belongs
   */
  public Alternative getRefAlternative() {
    return refAlternative;
  }

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

  /**
   * Sets alternative to which this fragment belongs
   *
   * @param refAlternative Alternative to which this fragment belongs
   */
  public void setRefAlternative(Alternative refAlternative) {
    this.refAlternative = refAlternative;
  }

  /**
   * Sets alternative to which this fragment belongs
   *
   * @param value Alternative to which this fragment belongs
   */
  @Override
  public void setRefSecSuggestion(SecSuggestion value) {
    if (value instanceof Alternative) {
      this.refAlternative = (Alternative) 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();
  }
  
  /**
   * 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 AlternativeFragment)) {
      return false;
    }
    AlternativeFragment other = (AlternativeFragment) 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 other Object to compare with
   * @return If object is same type and have same content, returns true, false
   * otherwise
   */
  public boolean contentEqualsForSec(SuggestionFragment other) {
    if (other == null) {
      return false;
    }
    if ((this.path == null) ? (other.getPath() != null) : !this.path.equals(other.getPath())) {
      if ((this.path == null) ? (other.getPath() != null) : !this.path.equals(other.getPath().concat("/text()"))) {
        return false;
      }
    }
    if (this.offset != other.getOffset() && (this.offset == null || !this.offset.equals(other.getOffset()))) {
      return false;
    }
    if (this.length != other.getLength() && (this.length == null || !this.length.equals(other.getLength()))) {
      return false;
    }
    if ((this.annotatedText == null) ? (other.getAnnotatedText() != null) : !this.annotatedText.equals(other.getAnnotatedText())) {
      return false;
    }
    return true;
  }  // contentEqualsWithSuggestion()
        
  /**
   * 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 AlternativeFragment other = (AlternativeFragment) 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 fragment in XML
   *
   * @return Returns serialized informations about 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>";
  }

  @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 AlternativeFragment)) {
      throw new UnsupportedOperationException("Not supported yet.");
    }
    AlternativeFragment other = (AlternativeFragment) object;
    int compareResult = offset.compareTo(other.getOffset());
    if (compareResult == 0) {
      compareResult = length.compareTo(other.getLength());
    }

    return compareResult;
  }
}  // public class AlternativeFragment