Alternative.java

Go to the documentation of this file.

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

/**
 * @file Alternative.java
 *
 * @brief Class representing alternative of suggestion.
 */

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

import cz.vutbr.fit.knot.annotations.entity.AnnotDocument;
import cz.vutbr.fit.knot.annotations.entity.AnnotType;
import cz.vutbr.fit.knot.annotations.entity.Annotation;
import cz.vutbr.fit.knot.annotations.entity.User;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.Suggestion;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.SuggestionFragment;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.SuggestionManager;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.attributes.SugBaseAttribute;
import cz.vutbr.fit.knot.annotations.modules.suggestionManager.attributes.SugLinkedAttribute;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import javax.persistence.*;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import javax.xml.bind.annotation.XmlRootElement;

/**
 * Class representing alternative of suggestion.
 * 
 * @brief Class representing alternative of suggestion.
 * @author Marek Kopecky
 */
@Entity
@Table(name = "alternative")
@XmlRootElement
@NamedQueries({
  @NamedQuery(name = "Alternative.findAll", query = "SELECT a FROM Alternative a"),
  @NamedQuery(name = "Alternative.findById", query = "SELECT a FROM Alternative a WHERE a.id = :id"),
  @NamedQuery(name = "Alternative.findByAlternativeOf", query = "SELECT a FROM Alternative a WHERE a.alternativeOf = :alternativeOf AND a.used = 0"),
  @NamedQuery(name = "Alternative.findByType", query = "SELECT a FROM Alternative a WHERE a.type = :type"),
  @NamedQuery(name = "Alternative.findByCreated", query = "SELECT a FROM Alternative a WHERE a.created = :created"),
  @NamedQuery(name = "Alternative.findByAuthorName", query = "SELECT a FROM Alternative a WHERE a.authorName = :authorName"),
  @NamedQuery(name = "Alternative.findByAuthorAddress", query = "SELECT a FROM Alternative a WHERE a.authorAddress = :authorAddress"),
  @NamedQuery(name = "Alternative.findBySource", query = "SELECT a FROM Alternative a WHERE a.source = :source"),
  @NamedQuery(name = "Alternative.findBySourceDocumentID", query = "SELECT a FROM Alternative a WHERE a.sourceDocumentId = :sourceDocumentId"),
  @NamedQuery(name = "Alternative.findBySourceDocumentIDNoNested", query = "SELECT a FROM Alternative a WHERE a.sourceDocumentId = :sourceDocumentId AND a.nestedIn IS NULL"),
  @NamedQuery(name = "Alternative.findByNestedIn", query = "SELECT a FROM Alternative a WHERE a.nestedIn = :nestedIn"),
  @NamedQuery(name = "Alternative.deleteById", query = "DELETE FROM Alternative a WHERE a.id  = :id")
})
public class Alternative implements Serializable, SecSuggestion {
  private static final long serialVersionUID = 1L;
  
  /** Id of alternative */
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Basic(optional = false)
  @Column(name = "id")
  private Integer id;
  
  /** Id of type of alternative */
  @Basic(optional = false)
  @NotNull
  @Column(name = "type", nullable=false, insertable=false, updatable=false)
  private int type;
  
  /** Date of creation */
  @Basic(optional = true)
  @Column(name = "created")
  @Temporal(TemporalType.TIMESTAMP)
  private Date created;
  
  /** URI of alternative author (user) */
  @Basic(optional = true)
  @Size(min = 1, max = 255)
  @Column(name = "authorIdStr")
  private String authorIdStr;
  
  /** Name of alternative author (user) */
  @Size(max = 40)
  @Column(name = "authorName")
  private String authorName;
  
  /** E-mail of alternative author (user) */
  @Size(max = 255)
  @Column(name = "authorAddress")
  private String authorAddress;
  
  /** URI of annotated copy of document to which this alternative belongs */
  @Basic(optional = false)
  @NotNull
  @Size(min = 1, max = 255)
  @Column(name = "source")
  private String source;
  
  /** Id of annotated copy of document to which this alternative belongs */
  @Basic(optional = false)
  @NotNull
  @Column(name = "sourceDocumentId", nullable=false, insertable=false, updatable=false)
  private int sourceDocumentId;
  
  /** Textual content of alternative */
  @Basic(optional = false)
  @Lob
  @Column(name = "content")
  private String content;
  
  /** Confidence of suggestion */
  @Basic(optional = false)
  @Column(name = "confidence")
  private Integer confidence;
  
  /** Id of alternative author (user) */
  @Column(name = "authorId", insertable=false, updatable=false)
  private String autorId;
  
  /** If this alternative is nested, here is id of parent annotation */
  @Column(name = "nestedIn", insertable=false, updatable=false)
  private String nestedIn;
  
  /** Main suggestion */
  @Column(name = "alternativeOf", insertable=false, updatable=false)
  private String alternativeOf;

  /** Was alternative used? */
  @Column(name = "used")
  private Boolean used;
  
  /** Type of alternative */
  @OneToOne(optional = false)
  @JoinColumn(name = "type", referencedColumnName = "id")
  private AnnotType annotType;
  
  /** Annotated copy of document to which this alternative belongs */
  @OneToOne(optional = false)
  @JoinColumn(name = "sourceDocumentId", referencedColumnName = "id")
  private AnnotDocument sourceDocument;
  
  /** List of attributes of alternative */
  @OneToMany(mappedBy = "refAlternative", cascade = CascadeType.ALL,
  targetEntity = AlternativeAttribute.class)
  private List<AlternativeAttribute> attributes;
  
  /** List of alternative fragments */
  @OneToMany(mappedBy = "refAlternative", cascade = CascadeType.ALL,
  targetEntity = AlternativeFragment.class)
  private List<AlternativeFragment> fragments;
  
  /** Author of alternative (user) */
  @OneToOne(optional = true)
  @JoinColumn(name = "authorId", referencedColumnName = "id")
  private User user;
  
  /** If this alternative is nested, here is parent suggestion */
  @OneToOne(optional = true)
  @JoinColumn(name = "nestedIn", referencedColumnName = "id")
  private Alternative nestedInAlternative;
  
  /** Id of main suggestion */
  @OneToOne(optional = true)
  @JoinColumn(name = "alternativeOf", referencedColumnName = "id")
  private Suggestion alternativeOfSuggestion;
  
  /** If this alternative is nested, here is parent annotation */
  @Transient
  private Annotation nestedInAnnot;
  
  /** Identifier of entity from SEC API (to detect same suggestions on more places) */
  @Basic(optional = true)
  @Column(name = "SAEntityIdentifier")
  private String SAEntityIdentifier;

  /** Temporary id to identify targets of links in alternatives from client */
  @Transient
  private String tmpId;
  
  
  /**
   * Constructor
   */
  public Alternative() {
  }

  /**
   * Constructor
   *
   * @param type Type of alternative
   * @param content Textual content of alternative
   * @param nestedIn If this alternative is nested, then parent alternative, null otherwise
   */
  public Alternative(AnnotType type, String content, String nestedIn) {
    this.used = false;
    this.annotType = type;
    this.content = content;
    this.nestedIn = nestedIn;
    this.attributes = new ArrayList<AlternativeAttribute>();
    this.fragments = new ArrayList<AlternativeFragment>();
    this.confidence = SuggestionManager.INITIAL_CONFIDENCE;
  }
  
  /**
   * Constructor
   *
   * @param id Id of alternative
   * @param authorIdStr URI of alternative author (user)
   * @param authorName Name of alternative author (user)
   * @param authorAddress E-mail of alternative author (user)
   * @param sourceDocument Annotated copy of document to which this alternative belongs
   * @param content Textual content of alternative
   * @param nestedIn If this alternative is nested, then parent alternative, null otherwise
   */
  public Alternative(Integer id, String authorIdStr, String authorName, String authorAddress, AnnotDocument sourceDocument, String content, String nestedIn) {
    this.used = false;
    this.id = id;
    this.authorIdStr = authorIdStr;
    this.authorName = authorName;
    this.authorAddress = authorAddress;
    this.sourceDocument = sourceDocument;
    if (sourceDocument != null) {
      this.source = sourceDocument.getUriForAnnot();
    }
    this.content = content;
    this.nestedIn = nestedIn;
    this.nestedInAlternative = null;
    this.attributes = new ArrayList<AlternativeAttribute>();
    this.fragments = new ArrayList<AlternativeFragment>();
    this.confidence = SuggestionManager.INITIAL_CONFIDENCE;
  }

  /**
   * Constructor
   *
   * @param annotType Type of alternative
   * @param created Date of creation
   * @param authorIdStr URI of alternative author (user)
   * @param authorName Name of alternative author (user)
   * @param authorAddress E-mail of alternative author (user)
   * @param sourceDocument Annotated copy of document to which this alternative belongs
   * @param content Textual content of alternative
   */
  public Alternative(AnnotType annotType, Date created, String authorIdStr, String authorName, String authorAddress, AnnotDocument sourceDocument, String content) {
    this.used = false;
    this.annotType = annotType;
    this.created = created;
    this.authorIdStr = authorIdStr;
    this.authorName = authorName;
    this.authorAddress = authorAddress;
    this.sourceDocument = sourceDocument;
    if (sourceDocument != null) {
      this.source = sourceDocument.getUriForAnnot();
    }
    this.content = content;
    this.nestedInAlternative = null;
    this.attributes = new ArrayList<AlternativeAttribute>();
    this.fragments = new ArrayList<AlternativeFragment>();
    this.confidence = SuggestionManager.INITIAL_CONFIDENCE;
  }

  /**
   * Constructor
   *
   * @param annotType Type of alternative
   * @param created Date of creation
   * @param authorIdStr URI of alternative author (user)
   * @param authorName Name of alternative author (user)
   * @param authorAddress E-mail of alternative author (user)
   * @param sourceDocument Annotated copy of document to which this alternative belongs
   * @param content Textual content of alternative
   * @param nestedInAlternative If this alternative is nested, then parent alternative, null otherwise
   */
  public Alternative(AnnotType annotType, Date created, String authorIdStr, String authorName, String authorAddress, AnnotDocument sourceDocument, String content, Alternative nestedInAlternative) {
    this.used = false;
    this.annotType = annotType;
    this.created = created;
    this.authorIdStr = authorIdStr;
    this.authorName = authorName;
    this.authorAddress = authorAddress;
    this.sourceDocument = sourceDocument;
    if (sourceDocument != null) {
      this.source = sourceDocument.getUriForAnnot();
    }
    this.content = content;
    this.nestedInAlternative = nestedInAlternative;
    this.attributes = new ArrayList<AlternativeAttribute>();
    this.fragments = new ArrayList<AlternativeFragment>();
    this.confidence = SuggestionManager.INITIAL_CONFIDENCE;
  }

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

  /**
   * Sets id of alternative
   *
   * @param id Id of alternative
   */
  public void setId(Integer id) {
    this.id = id;
  }
  /**
   * Gets confidence of alternative
   *
   * @return Returns confidence of alternative
   */
  public Integer getConfidence() {
    return confidence;
  }

  /**
   * Sets confidence of alternative
   *
   * @param confidence Confidence of alternative
   */
  public void setConfidence(Integer confidence) {
    this.confidence = confidence;
  }
  
  /**
   * Gets type of alternative
   *
   * @return Returns type of alternative
   */
  public AnnotType getAnnotType() {
    return annotType;
  }

  /**
   * Sets type of alternative
   *
   * @param annotType Type of alternative
   */
  public void setAnnotType(AnnotType annotType) {
    this.annotType = annotType;
  }
  
   /**
   * Gets date of creation
   *
   * @return Returns date of creation
   */
  public Date getCreated() {
    return created;
  }

  /**
   * Sets date of creation
   *
   * @param created Date of creation
   */
  public void setCreated(Date created) {
    this.created = created;
  }
  
  /**
   * Gets author of alternative (user)
   *
   * @return Returns author of alternative (user)
   */
  public User getUser() {
    return user;
  }

  /**
   * Sets author of alternative (user)
   * URI is also set and if available, full name and e-mail too
   *
   * @param user Author of alternative (user)
   */
  public void setUser(User user) {
    this.user = user;
    if (user != null) {
      authorIdStr = user.getURI();
      if (user.getName() != null && !user.getName().contentEquals("")) {
        authorName = user.getName();
      }
      if (user.getEmail() != null && !user.getEmail().contentEquals("")) {
        authorAddress = user.getEmail();
      }
    }
  }

  /**
   * Gets URI of author of alternative (user)
   *
   * @return Returns URI of author of alternative (user)
   */
  public String getAuthorIdStr() {
    return authorIdStr;
  }

  /**
   * Sets URI of author of alternative (user)
   *
   * @param authorIdStr URI of author of alternative (user)
   */
  public void setAuthorIdStr(String authorIdStr) {
    this.authorIdStr = authorIdStr;
  }

  /**
   * Gets name of author of alternative (user)
   *
   * @return Returns name of author of alternative (user)
   */
  public String getAuthorName() {
    return authorName;
  }

  /**
   * Sets name of author of alternative (user)
   *
   * @param authorName Name of author of alternative (user)
   */
  public void setAuthorName(String authorName) {
    this.authorName = authorName;
  }

  /**
   * Gets e-mail of author of alternative (user)
   *
   * @return Returns e-mail of author of alternative (user)
   */
  public String getAuthorAddress() {
    return authorAddress;
  }

  /**
   * Sets e-mail of author of alternative (user)
   *
   * @param authorAddress E-mail of author of alternative (user)
   */
  public void setAuthorAddress(String authorAddress) {
    this.authorAddress = authorAddress;
  }

   /**
   * Gets annotated copy of document to which this alternative belongs
   *
   * @return Returns annotated copy of document to which this alternative belongs
   */
  public String getSource() {
    return source;
  }

  /**
   * Sets annotated copy of document to which this alternative belongs
   *
   * @param source Annotated copy of document to which this alternative belongs
   */
  public void setSource(String source) {
    this.source = source;
  }

  /**
   * Gets id of annotated copy of document to which this alternative belongs
   *
   * @return Returns id of annotated copy of document to which this alternative belongs
   */
  public Integer getSourceDocumentId() {
    return sourceDocumentId;
  }

  /**
   * Sets id of annotated copy of document to which this alternative belongs
   * 
   * @param sourceDocumentId id of annotated copy of document to which this alternative belongs
   */
  public void setSourceDocumentId(Integer sourceDocumentId) {
    this.sourceDocumentId = sourceDocumentId;
  }

  /**
   * Gets id of type of alternative
   *
   * @return Returns id of type of alternative
   */
  public Integer getType() {
    return type;
  }

  /**
   * Sets id of type of alternative
   * 
   * @param type id of type of alternative
   */
  public void setType(Integer type) {
    this.type = type;
  }

 /**
   * Gets textual content of alternative
   *
   * @return Returns textual content of alternative
   */
  public String getContent() {
    return content;
  }

  /**
   * Sets textual content of alternative
   *
   * @param content Textual content of alternative
   */
  public void setContent(String content) {
    this.content = content;
  }

  /**
   * Gets id of annotation author (user)
   *
   * @return Returns id of annotation author (user)
   */
  public String getAutorId() {
    return autorId;
  }

  /**
   * Sets id of annotation author (user)
   * 
   * @param autorId id of annotation author (user)
   */
  public void setAutorId(String autorId) {
    this.autorId = autorId;
  }
  
  /**
   * Gets annotated copy of document to which this alternative belongs
   *
   * @return Returns annotated copy of document to which this alternative belongs
   */
  public AnnotDocument getSourceDocument() {
    return sourceDocument;
  }

  /**
   * Sets annotated copy of document to which this alternative belongs
   * (if  document is not null, his URI is also set)
   *
   * @param sourceDocument Annotated copy of document to which this alternative belongs
   */
  public void setSourceDocument(AnnotDocument sourceDocument) {
    this.sourceDocument = sourceDocument;
    if (sourceDocument != null) {
      this.source = sourceDocument.getUriForAnnot();
    }
  }

  /**
   * Gets URI of alternative in which is this alternative nested
   * 
   * @return Returns URI of alternative in which is this alternative nested
   */
  public String getNestedIn() {
    return nestedIn;
  }

  /**
   * Sets URI of alternative in which is this alternative nested
   * 
   * @param nestedIn URI of alternative in which is this alternative nested
   */
  public void setNestedIn(String nestedIn) {
    this.nestedIn = nestedIn;
  }

  /**
   * Gets list of alternative attributes
   *
   * @return Returns list of alternative attributes
   */
  public List<AlternativeAttribute> getAttributes() {
    return attributes;
  }

  /**
   * Sets list of alternative attributes
   *
   * @param attributes List of alternative attributes
   */
  public void setAttributes(ArrayList<AlternativeAttribute> attributes) {
    this.attributes = attributes;
  }
  
  /**
   * Adds an attribute to list of alternative attributes
   *
   * @param attribute Attribute to add
   */
  public void addAttribute(AlternativeAttribute attribute) {
    this.attributes.add(attribute);
  }
  
  /**
   * Gets list of suggested fragments
   *
   * @return Returns list of suggested fragments
   */
  @Override
  public List getFragments() {
    return fragments;
  }

  /**
   * Gets list of suggested fragments as ArrayList
   *
   * @return Returns list of suggested fragments as ArrayList
   */
  public ArrayList<AlternativeFragment> getFragmentsAL() {
    return new ArrayList<AlternativeFragment>(fragments);
  }

  /**
   * Sets list of suggested fragments
   *
   * @param fragments List of suggested fragments
   */
  public void setFragments(ArrayList<AlternativeFragment> fragments) {
    this.fragments = fragments;
  }

  /**
   * Adds fragment to the list of suggested fragments
   *
   * @param fragment Suggested fragment
   */
  public void addFragment(AlternativeFragment fragment) {
    if(fragments == null){
      fragments = new ArrayList<AlternativeFragment>();
    }
    fragments.add(fragment);
  }

  /**
   * Adds fragment to the list of suggested fragments
   *
   * @param fragment Suggested fragment
   */
  @Override
  public void addSecFragment(SecFragment fragment) {
    if (fragment instanceof AlternativeFragment) {
      fragments.add((AlternativeFragment) fragment);
    }
  }

  /**
   * Gets parent suggestion of nested suggestion
   *
   * @return If this suggestion is nested, returns parent annotation, null otherwise
   */
  public Alternative getNestedInAlternative() {
    return nestedInAlternative;
  }

  /**
   * Sets parent suggestion of nested suggestion
   *
   * @param nestedInAlternative If this annotation is nested, then parent annotation, null otherwise
   */
  public void setNestedInAlternative(Alternative nestedInAlternative) {
    this.nestedInAlternative = nestedInAlternative;
  }

  /**
   * Gets main suggestion 
   *
   * @return Main suggestion
   */
  public Suggestion getAlternativeOfSuggestion() {
    return alternativeOfSuggestion;
  }

  /**
   * Sets main suggestion 
   *
   * @param alternativeOfSuggestion Main suggestion
   */
  public void setAlternativeOfSuggestion(Suggestion alternativeOfSuggestion) {
    this.alternativeOfSuggestion = alternativeOfSuggestion;
  }

  /**
   * Gets annotation in which is this alternative nested
   * 
   * @return annotation in which is this alternative nested
   */
  public Annotation getNestedInAnnot() {
    return nestedInAnnot;
  }
  
  /**
   * Sets annotation in which is this suggestion nested
   * 
   * @param nestedInAnnot Annotation in which is this suggestion nested
   */
  public void setNestedInAnnot(Annotation nestedInAnnot) {
    this.nestedInAnnot = nestedInAnnot;
  }
  
  /**
   * Gets SEC API Entity Identifier (to detect same suggestions)
   * 
   * @return isFromSECAPI SEC API Entity Identifier
   */
  public String getSAEntityIdentifier() {
    return SAEntityIdentifier;
  }

  /**
   * Sets SEC API Entity Identifier
   * 
   * @param SAEntityIdentifier SEC API Entity Identifier
   */
  @Override
  public void setSAEntityIdentifier(String SAEntityIdentifier) {
    this.SAEntityIdentifier = SAEntityIdentifier;
  }

  /**
   * Gets tmpId of this suggestion 
   * (warning - tmpId is in id field for suggestion - this is an auxiliary value)
   * 
   * @return Returns tmpId of this suggestion
   */
  public String getTmpId() {
    return tmpId;
  }

  /**
   * Sets tmpId of this suggestion 
   * (warning - tmpId is in id field for suggestion - this is an auxiliary value)
   * 
   * @param tmpId tmpId of this suggestion
   */
  public void setTmpId(String tmpId) {
    this.tmpId = tmpId;
  }

  /**
   * Gets whether alternative was used
   * 
   * @return Returns whether alternative was used
   */
  public Boolean getUsed() {
    return used;
  }

  /**
   * Sets whether alternative was used
   * 
   * @param used If true, alternative was used, if false, it was not used
   */
  public void setUsed(Boolean used) {
    this.used = used;
  }

  /**
   * Get hash code.
   * 
   * @return Hash code
   */
  @Override
  public int hashCode() {
    int hash = 0;
    hash += (id != null ? id.hashCode() : 0);
    return hash;
  }
  
  /**
   * Compares this with other object and returns, whether objects are same type
   * and have same id.
   *
   * @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 Alternative)) {
      return false;
    }
    Alternative other = (Alternative) object;
    if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
      return false;
    }
    
    if(other.id == null && this.id == null){
      if(!contentEquals(object)){
        return false;
      }
    }
    
    return true;
  }
  
  /**
   * Compares this with other object and returns, whether objects are same type
   * and have same id, but not go to deeper comparation if noLinek is set to true.
   *
   * @param object Object to compare with
   * @param noLinked No trace links and compare them if is set to true
   * @return If object is same type and have same id, returns true, false otherwise
   */
  public boolean equals(Object object, boolean noLinked){
    if (!(object instanceof Alternative)) {
      return false;
    }
    Alternative other = (Alternative) object;
    if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
      return false;
    }
    
    if(other.id == null && this.id == null){
      if(!contentEquals(object,false,noLinked)){
        return false;
      }
    }
    
    return true;
  }
  
  /**
   * Compares this with other object and returns, whether objects are same type
   * and have same content (id is irelevant). Contents of fragments
   * and attributes are also compared.
   *
   * @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) {
    return contentEquals(obj,false,false);
  }
  
  /**
   * Compares this with other object and returns, whether objects are same type
   * and have same content (id is irrelevant). Contents of fragments
   * and attributes are also compared.
   *
   * @param obj Object to compare with
   * @param withCreated If true, dates of creation will be compared, if false, dates will be omitted
   * @param noLinked If true, links in attributes will be omitted, if false, links will be compared
   * @return If object is same type and have same content, returns true, false otherwise
   */
  public boolean contentEquals(Object obj, boolean withCreated, boolean noLinked) {
    if (obj == null) {
      return false;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    final Alternative other = (Alternative) obj;
    if (withCreated) {
      if (this.created != other.created && (this.created == null || !this.created.equals(other.created))) {
        return false;
      }
    }
    if ((this.authorIdStr == null) ? (other.authorIdStr != null) : !this.authorIdStr.equals(other.authorIdStr)) {
      return false;
    }
    if ((this.authorName == null) ? (other.authorName != null) : !this.authorName.equals(other.authorName)) {
      return false;
    }
    if ((this.authorAddress == null) ? (other.authorAddress != null) : !this.authorAddress.equals(other.authorAddress)) {
      return false;
    }
    if ((this.source == null) ? (other.source != null) : !this.source.equals(other.source)) {
      return false;
    }
    if ((this.content == null) ? (other.content != null) : !this.content.equals(other.content)) {
      return false;
    }
    if (this.annotType != other.annotType && (this.annotType == null || !this.annotType.equals(other.annotType))) {
      return false;
    }
    if (this.sourceDocument != other.sourceDocument && (this.sourceDocument == null || !this.sourceDocument.equals(other.sourceDocument))) {
      return false;
    }

    if (this.attributes == null && other.attributes != null) {
      return false;
    } else if (this.attributes != null && other.attributes == null) {
      return false;
    } else if (this.attributes != other.attributes && this.attributes != null && other.attributes != null) {
      if (this.attributes.size() != other.attributes.size()) {
        return false;
      }
      Iterator<AlternativeAttribute> atIt = this.attributes.iterator();
      while (atIt.hasNext()) {
        AlternativeAttribute at = atIt.next();
        boolean found = false;
        Iterator<AlternativeAttribute> oAtIt = other.attributes.iterator();
        while (oAtIt.hasNext()) {
          AlternativeAttribute oAt = oAtIt.next();
          
          if (at.contentEquals(oAt,false)) {
            found = true;
            break;
          }
        }
        if (!found) {
          return false;
        }
      }
    }
    if (this.fragments == null && other.fragments != null) {
      return false;
    } else if (this.fragments != null && other.fragments == null) {
      return false;
    } else if (this.fragments != other.fragments && this.fragments != null && other.fragments != null) {
      if (this.fragments.size() != other.fragments.size()) {
        return false;
      }
      Iterator frIt = this.fragments.iterator();
      while (frIt.hasNext()) {
        AlternativeFragment fr = (AlternativeFragment) frIt.next();
        boolean found = false;
        Iterator oFrIt = other.fragments.iterator();
        while (oFrIt.hasNext()) {
          AlternativeFragment oFr = (AlternativeFragment) oFrIt.next();
          if (fr.contentEquals(oFr)) {
            found = true;
            break;
          }
        }
        if (!found) {
          return false;
        }
      }
    }
    if (this.user != other.user && (this.user == null || !this.user.equals(other.user))) {
      return false;
    }
    if (this.nestedInAlternative == null && other.nestedInAlternative != null) {
      return false;
    } else if (this.nestedInAlternative != null && other.nestedInAlternative == null) {
      return false;
    }
    return true;
  }  // contentEquals()
  
  
  /**
   * Compares this with suggestion and returns, whether objects are same type
   * and have same content (id is irrelevant). Contents of fragments
   * and attributes are also compared.
   * 
   * @param other Object to compare with
   * @param linearizedFragments Linearized fragments of suggestion.
   * @param testFragments If true, fragments will be compared, if false, fragments will be omitted
   * @return 
   */
  public boolean contentEqualsForSec(Suggestion other, ArrayList<SuggestionFragment> linearizedFragments, boolean testFragments) {
    if (other == null) {
      return false;
    }
    if ((this.content == null) ? (other.getContent() != null) : !this.content.equals(other.getContent())) {
      return false;
    }
    if (this.annotType != other.getAnnotType() && (this.annotType == null || !this.annotType.equals(other.getAnnotType()))) {
      return false;
    }

    if (this.attributes == null && other.getAttributes() != null) {
      return false;
    } else if (this.attributes != null && other.getAttributes() == null) {
      return false;
    } else if (this.attributes != null && other.getAttributes() != null) {
      if (this.attributes.size() != other.getAttributes().size()) {
        return false;
      }
      Iterator<AlternativeAttribute> atIt = this.attributes.iterator();
      while (atIt.hasNext()) {
        AlternativeAttribute at = atIt.next();
        boolean found = false;
        Iterator<SugBaseAttribute> oAtIt = other.getAttributes().iterator();
        if(oAtIt instanceof SugLinkedAttribute){
          continue;
        }
        while (oAtIt.hasNext()) {
          SugBaseAttribute oAt = oAtIt.next();
          
          if (at.contentEqualsForSec(oAt)) {
            found = true;
            break;
          }
        }
        if (!found) {
          return false;
        }
      }
    }
    if (testFragments) {
      if (this.fragments == null && linearizedFragments != null) {
        return false;
      } else if (this.fragments != null && linearizedFragments == null) {
        return false;
      } else if (this.fragments != null && linearizedFragments != null) {
        if (this.fragments.size() != linearizedFragments.size()) {
          return false;
        }
        Iterator frIt = this.fragments.iterator();
        while (frIt.hasNext()) {
          AlternativeFragment fr = (AlternativeFragment) frIt.next();
          boolean found = false;
          Iterator<SuggestionFragment> oFrIt = linearizedFragments.iterator();
          while (oFrIt.hasNext()) {
            SuggestionFragment oFr = oFrIt.next();
            if (fr.contentEqualsForSec(oFr)) {
              found = true;
              break;
            }
          }
          if (!found) {
            return false;
          }
        }
      }
    }
    return true;
  }  // contentEqualsForSec()
  
  @Override
  public String toString() {
    return "cz.vutbr.fit.knot.annotations.modules.auggestionManager.alternative.Alternative[ id=" + id + " ]";
  }
}  // public class Alternative