Annotation.java

Go to the documentation of this file.

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

/**
 * @file Annotation.java
 *
 * @brief Class representing annotation
 */

/**
 * @package cz.vutbr.fit.knot.annotations.entity
 * 
 * @brief Basic persistent entities
 */
package cz.vutbr.fit.knot.annotations.entity;

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.app.Localisation;
import cz.vutbr.fit.knot.annotations.comet.Linearizer;
import cz.vutbr.fit.knot.annotations.comet.Util;
import cz.vutbr.fit.knot.annotations.entity.attribute.*;
import cz.vutbr.fit.knot.annotations.fragmentUpdater.MatcherProvider;
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.attributes.SugBaseAttribute;
import java.io.Serializable;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
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.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.Transient;
import org.w3c.dom.Document;

/**
 * Class representing annotation
 *
 * @brief Class representing annotation
 * @author idytrych
 */
@Entity
@Table(name = "annotation")
@NamedQueries({
  @NamedQuery(name = "Annotation.findAll", query = "SELECT a FROM Annotation a"),
  @NamedQuery(name = "Annotation.findById", query = "SELECT a FROM Annotation a WHERE a.id = :id"),
  @NamedQuery(name = "Annotation.findByType", query = "SELECT a FROM Annotation a WHERE a.type = :type"),
  @NamedQuery(name = "Annotation.findByCreated", query = "SELECT a FROM Annotation a WHERE a.created = :created"),
  @NamedQuery(name = "Annotation.findByAuthor", query = "SELECT a FROM Annotation a WHERE a.authorId = :authorId"),
  @NamedQuery(name = "Annotation.findByAuthorName", query = "SELECT a FROM Annotation a WHERE a.authorName = :authorName"),
  @NamedQuery(name = "Annotation.findByAuthorAddress", query = "SELECT a FROM Annotation a WHERE a.authorAddress = :authorAddress"),
  @NamedQuery(name = "Annotation.findBySource", query = "SELECT a FROM Annotation a WHERE a.source = :source"),
  @NamedQuery(name = "Annotation.findBySourceDocumentID", query = "SELECT a FROM Annotation a WHERE a.sourceDocumentId = :sourceDocumentId"),
  @NamedQuery(name = "Annotation.findBySourceDocumentIDAndAuthor", query = "SELECT a FROM Annotation a WHERE a.sourceDocumentId = :sourceDocumentId AND a.authorId = :authorId"),
  @NamedQuery(name = "Annotation.findBySourceDocumentIDNoNested", query = "SELECT a FROM Annotation a WHERE a.sourceDocumentId = :sourceDocumentId AND a.nestedIn IS NULL"),
  @NamedQuery(name = "Annotation.findByNestedIn", query = "SELECT a FROM Annotation a WHERE a.nestedIn = :nestedIn")})
public class Annotation implements Serializable {
  private static final long serialVersionUID = 1L;
  /** Id of annotation */
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Basic(optional = false)
  @Column(name = "id")
  private Integer id;
  /** Id of type of annotation */
  @Basic(optional = false)
  @Column(name = "type", nullable=false, insertable=false, updatable=false)
  private Integer type;
  /** Date of creation */
  @Basic(optional = false)
  @Column(name = "created")
  @Temporal(TemporalType.TIMESTAMP)
  private Date created;
  /** URI of annotation author (user) */
  @Basic(optional = false)
  @Column(name = "authorIdStr")
  private String authorIdStr;
  /** Name of annotation author (user) */
  @Basic(optional = true)
  @Column(name = "authorName")
  private String authorName;
  /** E-mail of annotation author (user) */
  @Basic(optional = true)
  @Column(name = "authorAddress")
  private String authorAddress;
  /** Id of annotation author (user) */
  @Basic(optional = true)
  @Column(name = "authorId", insertable=false, updatable=false)
  private String authorId;
  /** URI of annotated copy of document to which this annotation belongs */
  @Basic(optional = false)
  @Column(name = "source")
  private String source;
  /** Id of annotated copy of document to which this annotation belongs */
  @Basic(optional = false)
  @Column(name = "sourceDocumentId", nullable=false, insertable=false, updatable=false)
  private Integer sourceDocumentId;
  /** Textual content of annotation */
  @Basic(optional = false)
  @Lob
  @Column(name = "content")
  private String content;
  /** If this annotation is nested, here is id of parent annotation */
  @Column(name = "nestedIn", insertable=false, updatable=false)
  private String nestedIn;

  /** Type of annotation */
  @OneToOne(optional = false)
  @JoinColumn(name = "type", referencedColumnName = "id")
  private AnnotType annotType;
  /** Annotated copy of document to which this annotation belongs */
  @OneToOne(optional = false)
  @JoinColumn(name = "sourceDocumentId", referencedColumnName = "id")
  private AnnotDocument sourceDocument;
  /** List of attributes of annotation */
  @OneToMany(mappedBy = "refAnnotation", cascade = CascadeType.ALL,
  targetEntity = BaseAttribute.class)
  private List<BaseAttribute> attributes;
  /** List of annotated fragments */
  @OneToMany(mappedBy = "refAnnotation", cascade = CascadeType.ALL,
  targetEntity = Fragment.class)
  private List<Fragment> fragments;
  /** Author of annotation (user) */
  @OneToOne(optional = true)
  @JoinColumn(name = "authorId", referencedColumnName = "id")
  private User user;
  /** If this annotation is nested, here is parent annotation */
  @OneToOne(optional = true)
  @JoinColumn(name = "nestedIn", referencedColumnName = "id")
  private Annotation nestedInAnnot;

  /** Temporary id for links between annotations which are not saved yet */
  @Transient
  private String tmpId;
  /** Holds IDs of annotations that have a linkedAnnotation attribute with
    * value pointing to this annotation. It is necessary to store these IDs
    * before the annotation is removed from the database (before persist).
    * The list is used during flier processing when user has annotations
    * that he is not subscribed to and they need to be removed from the client.
    */
  @Transient
  private List<Integer> linkedByBeforeRemove;

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

  /**
   * Constructor of reference objects for searching purposes - no initialization
   * needed
   *
   * @param id Id of annotation
   */
  public Annotation(Integer id) {
    this.id = id;
  }

  /**
   * Constructor
   *
   * @param id Id of annotation
   * @param created Date of creation
   * @param authorIdStr URI of annotation author (user)
   * @param authorName Name of annotation author (user)
   * @param authorAddress E-mail of annotation author (user)
   * @param sourceDocument Annotated copy of document to which this annotation belongs
   * @param content Textual content of annotation
   * @param nestedIn If this annotation is nested, then parent annotation, null otherwise
   */
  public Annotation(Integer id, Date created, String authorIdStr, String authorName, String authorAddress, AnnotDocument sourceDocument, String content, String nestedIn) {
    this.id = id;
    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.nestedIn = nestedIn;
    this.nestedInAnnot = null;
    this.attributes = new ArrayList<BaseAttribute>();
    this.fragments = new ArrayList<Fragment>();
  }

  /**
   * Constructor
   *
   * @param annotType Type of annotation
   * @param created Date of creation
   * @param authorIdStr URI of annotation author (user)
   * @param authorName Name of annotation author (user)
   * @param authorAddress E-mail of annotation author (user)
   * @param sourceDocument Annotated copy of document to which this annotation belongs
   * @param content Textual content of annotation
   */
  public Annotation(AnnotType annotType, Date created, String authorIdStr, String authorName, String authorAddress, AnnotDocument sourceDocument, String content) {
    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.nestedInAnnot = null;
    this.attributes = new ArrayList<BaseAttribute>();
    this.fragments = new ArrayList<Fragment>();
  }

  /**
   * Constructor
   *
   * @param annotType Type of annotation
   * @param created Date of creation
   * @param authorIdStr URI of annotation author (user)
   * @param authorName Name of annotation author (user)
   * @param authorAddress E-mail of annotation author (user)
   * @param sourceDocument Annotated copy of document to which this annotation belongs
   * @param content Textual content of annotation
   * @param nestedInAnnot If this annotation is nested, then parent annotation, null otherwise
   */
  public Annotation(AnnotType annotType, Date created, String authorIdStr, String authorName, String authorAddress, AnnotDocument sourceDocument, String content, Annotation nestedInAnnot) {
    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.nestedInAnnot = nestedInAnnot;
    this.attributes = new ArrayList<BaseAttribute>();
    this.fragments = new ArrayList<Fragment>();
  }

  /**
   * Updates data in this annotation with data from another annotation
   *
   * @param newData Annotation with new data
   */
  public void updateWithAnnotation(Annotation newData) {
    this.type = newData.getAnnotType().getId();
    this.created = newData.getCreated();
    this.authorIdStr = newData.getAuthorIdStr();
    this.authorName = newData.getAuthorName();
    this.authorAddress = newData.getAuthorAddress();
    this.source = newData.getSource();
    this.sourceDocumentId = newData.getSourceDocument().getId();
    this.content = newData.getContent();
    if (newData.getNestedInAnnot() != null) {
      this.nestedIn = newData.getNestedInAnnot().getId().toString();
    }
    this.annotType = newData.getAnnotType();
    this.sourceDocument = newData.getSourceDocument();
    this.attributes = newData.getAttributes();
    this.fragments = newData.getFragments();
    this.user = newData.getUser();
    this.nestedInAnnot = newData.getNestedInAnnot();
  }

  /**
   * Updates data in this annotation with data from some suggestion
   *
   * @param newData Suggestion with new data
   */
  public void updateWithSuggestion(Suggestion newData) {
    this.type = newData.getAnnotType().getId();
    this.created = newData.getCreated();
    this.authorIdStr = newData.getAuthorIdStr();
    this.authorName = newData.getAuthorName();
    this.authorAddress = newData.getAuthorAddress();
    this.source = newData.getSource();
    this.sourceDocumentId = newData.getSourceDocument().getId();
    this.content = newData.getContent();
    // We do not need to set this.nestedInAnnot - it will be set later
    this.annotType = newData.getAnnotType();
    this.sourceDocument = newData.getSourceDocument();
    this.fragments = new ArrayList<Fragment>();
    if (newData.getFragments() != null) {
      Iterator<SuggestionFragment> frIt = newData.getFragments().iterator();
      while (frIt.hasNext()) {
        SuggestionFragment sugFr = frIt.next();
        Fragment newFr = new Fragment(sugFr.getPath(), sugFr.getOffset(), sugFr.getLength(), sugFr.getAnnotatedText(), this);
        fragments.add(newFr);
      }
    }
    this.attributes = new ArrayList<BaseAttribute>();
    if (newData.getAttributes() != null) {
      Iterator<SugBaseAttribute> atIt = newData.getAttributes().iterator();
      while (atIt.hasNext()) {
        SugBaseAttribute sugAt = atIt.next();
        BaseAttribute newAt = null;
        String simpleType = sugAt.getSimpleType();
        if (simpleType != null && simpleType.equals("SuggestionLink")) {
          simpleType = "AnnotationLink";
        } else if (simpleType != null && simpleType.equals("NestedSuggestion")) {
          simpleType = "NestedAnnotation";
        }
        try {
          newAt = AttributeManager.createAttribute(sugAt.getName(), simpleType, this);
        } catch (ClassNotFoundException ex) {
          String msg = "Unable to create annotation attribute with type = " + sugAt.getSimpleType();
          Logger.getLogger(Annotation.class.getName()).log(Level.SEVERE, null, msg);
          continue;
        }
        newAt.updateFromSugBaseAttributeAll(sugAt);
        this.attributes.add(newAt);
      }
    }
    this.user = newData.getUser();
  }
  
  /**
   * Gets id of annotation
   *
   * @return Returns id of annotation
   */
  public Integer getId() {
    return id;
  }

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

  /**
   * Gets type of annotation
   *
   * @return Returns type of annotation
   */
  public AnnotType getAnnotType() {
    return annotType;
  }

  /**
   * Sets type of annotation
   *
   * @param annotType Type of annotation
   */
  public void setAnnotType(AnnotType annotType) {
    this.annotType = annotType;
  }

  /**
   * Gets author of annotation (user)
   *
   * @return Returns author of annotation (user)
   */
  public User getUser() {
    return user;
  }

  /**
   * Sets author of annotation (user)
   * URI is also set and if available, full name and e-mail too
   *
   * @param user Author of annotation (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 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 URI of author of annotation (user)
   *
   * @return Returns URI of author of annotation (user)
   */
  public String getAuthorIdStr() {
    return authorIdStr;
  }

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

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

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

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

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

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

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

  /**
   * Gets list of annotated fragments
   *
   * @return Returns list of annotated fragments
   */
  public List<Fragment> getFragments() {
    return fragments;
  }

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

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

  /**
   * Adds fragment to the list of annotated fragments
   *
   * @param fragment Annotated fragment
   */
  public void addFragment(Fragment fragment) {
    fragments.add(fragment);
  }

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

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

  /**
   * Gets id of parent annotation of nested annotation
   *
   * @return If this annotation is nested, returns id of parent annotation, null otherwise
   */
  public String getNestedIn() {
    return nestedIn;
  }
 
  /**
   * Sets id of parent annotation of nested annotation
   * 
   * @param nestedIn Id of parent annotation of nested annotation
   */
  public void setNestedIn(String nestedIn) {
    this.nestedIn = nestedIn;
  }

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

  /**
   * Sets list of annotation attributes
   *
   * @param attributes List of annotation attributes
   */
  public void setAttributes(ArrayList<BaseAttribute> attributes) {
    this.attributes = attributes;
  }

  /**
   * Adds attribute to the annotation
   *
   * @param attribute Annotation attribute to add
   */
  public void addAttribute(BaseAttribute attribute) {
    this.attributes.add(attribute);
  }

  /**
   * Gets parent annotation of nested annotation
   *
   * @return If this annotation is nested, returns parent annotation, null otherwise
   */
  public Annotation getNestedInAnnot() {
    return nestedInAnnot;
  }

  /**
   * Sets parent annotation of nested annotation
   *
   * @param nestedInAnnot If this annotation is nested, then parent annotation, null otherwise
   */
  public void setNestedInAnnot(Annotation nestedInAnnot) {
    this.nestedInAnnot = nestedInAnnot;
  }

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

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

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

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

  /**
   * Gets annotated copy of document to which this annotation belongs
   *
   * @return Returns annotated copy of document to which this annotation belongs
   */
  public AnnotDocument getSourceDocument() {
    return sourceDocument;
  }

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

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

  /**
   * Sets id of annotation author (user)
   * 
   * @param authorId id of annotation author (user)
   */
  public void setAuthorId(String authorId) {
    this.authorId = authorId;
  }

  /**
   * Gets URI of annotation
   *
   * @return URI of annotation
   */
  public String getURI() {
    if (id == null) {
      return "";
    }
    return AppBean.getBaseAnnotUri() + id;
  }
  
  /**
   * Gets URI of annotation for protocol V2
   *
   * @return URI of annotation
   */
  public String getURIV2() {
    if (id != null) {
      return AppBean.getBaseUri() + "/serv/" + id;
    }
    else if(tmpId != null){
      return AppBean.getBaseUri() + "/temp/" + tmpId;
    }
    else{
      return "";
    }
  }

  @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 Annotation)) {
      return false;
    }
    Annotation other = (Annotation) 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 Annotation)) {
      return false;
    }
    Annotation other = (Annotation) 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, linked attributes will be ignored, 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 Annotation other = (Annotation) 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.tmpId != other.tmpId && (this.tmpId == null || !this.tmpId.equals(other.tmpId))) {
      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<BaseAttribute> atIt = this.attributes.iterator();
      while (atIt.hasNext()) {
        BaseAttribute at = atIt.next();
        boolean found = false;
        Iterator<BaseAttribute> oAtIt = other.attributes.iterator();
        if(noLinked && at instanceof LinkedAnnotationAttribute){
          continue;
        }
        while (oAtIt.hasNext()) {
          BaseAttribute oAt = oAtIt.next();
          
          if(at instanceof LinkedAnnotationAttribute && oAt instanceof LinkedAnnotationAttribute){
            if(at.getValue() != null && ((Annotation)at.getValue()).equals(oAt,true)){
              found = true;
              break;
            }
          }
          
          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<Fragment> frIt = this.fragments.iterator();
      while (frIt.hasNext()) {
        Fragment fr = frIt.next();
        boolean found = false;
        Iterator<Fragment> oFrIt = other.fragments.iterator();
        while (oFrIt.hasNext()) {
          Fragment oFr = 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.nestedInAnnot == null && other.nestedInAnnot != null) {
      return false;
    } else if (this.nestedInAnnot != null && other.nestedInAnnot == null) {
      return false;
    }
    return true;
  }  // contentEquals()

  @Override
  public String toString() {
    return "cz.vutbr.fit.knot.annotations.entity.Annotation[id=" + id + ",content=" + content + "]";
  }
  
  /**
   * Returns serialized informations about annotation in SXML
   *
   * @param addSpaces If true, it will add space after each node during linearization 
   *                  (offset will be incremented by 1)
   * @return Returns serialized informations about annotation in SXML
   */
  public String toSXMLString(boolean addSpaces) {
    return toSXMLString(addSpaces, false);
  }
  
  /**
   * Returns serialized informations about annotation in SXML
   *
   * @param addSpaces If true, it will add space after each node during linearization 
   *                  (offset will be incremented by 1)
   * @param addCreated If true, date and time of creation will be added
   * @return Returns serialized informations about annotation in SXML
   */
  public String toSXMLString(boolean addSpaces, boolean addCreated){
    StringBuilder sb = new StringBuilder();

    ArrayList<Fragment> linearized = new ArrayList<Fragment>();
    
    if (fragments != null && !fragments.isEmpty()) {  // if there are some fragments
      
      //Linearize fragments
      ArrayList<ArrayList<Fragment>> tmpList = new ArrayList<ArrayList<Fragment>>();
      ArrayList<ArrayList<Fragment>> failed = new ArrayList<ArrayList<Fragment>>();
      tmpList.add(new ArrayList<Fragment>(fragments));
      MatcherProvider mProvider = new MatcherProvider();
      Document doc = null;

      try {
        doc = mProvider.getDocumentFromString(sourceDocument.getContent(), true, true);
      } catch (Exception ex) {
        String msg = "Error while parsing the annotated document.";
        Logger.getLogger(Annotation.class.getName()).log(Level.SEVERE, msg, ex);
      }

      linearized = Linearizer.fragmentsToLinFragments(tmpList, doc, failed, addSpaces);

      if (!failed.isEmpty()) {
        ArrayList<Fragment> failedList = failed.get(0);
        if (!failedList.isEmpty()) {
          String msg = "Error during linearization of fragments.";
          Logger.getLogger(Annotation.class.getName()).log(Level.SEVERE, msg);
        }
      }
    }  // if there are some fragments
    
    if (!linearized.isEmpty()) {
      Fragment fragment = linearized.get(0);
      if (fragment != null) {
        sb.append("<text s_offset=\"").append(fragment.getOffset()).append("\" ");
        sb.append("e_offset=\"").append((fragment.getOffset() + fragment.getLength())).append("\" ");
        sb.append("string=\"").append(Util.escapeForXml(fragment.getAnnotatedText())).append("\">");
      } else {
        String msg = "Error during linearization of fragments.";
        Logger.getLogger(Annotation.class.getName()).log(Level.SEVERE, msg);
        linearized = new ArrayList<Fragment>();
      }
    }

    String createdStr = "";
    if (addCreated) {
      createdStr = " created=\"" + Util.toRFC3339Date(created) + "\"";
    }
    
    sb.append("<annotation type=\"").append(annotType.getName()).append("\" id=\"").append(getURI()).append("\"").append(createdStr).append(">");

    //Serialize all annotation attributes

    if (attributes != null) {
      Iterator<BaseAttribute> attIt = attributes.iterator();

      while (attIt.hasNext()) {
        BaseAttribute tmpAtt = attIt.next();
        sb.append(tmpAtt.toSXMLString());
      }

    }

    sb.append("</annotation>");

    if (!linearized.isEmpty()) {
      sb.append("</text>");
    }

    return sb.toString();
  }

  /**
   * Returns serialized informations about annotation in XML for protocol V2
   *
   * @param attFilter Filter for attributes
   * @param langNum Number of language
   * @param KBRefMode Is KB_Ref mode on?
   * @return Returns serialized informations about annotation in XML for protocol V2
   */
  public String toXMLStringV2(ArrayList<String> attFilter, int langNum, Boolean KBRefMode){
    if (attFilter == null) {
      attFilter = new ArrayList<String>();
      attFilter.add(Constants.UPDATABLE_AN_AT_NAME);
    }
    if (KBRefMode == null) {
      KBRefMode = false;
    }
    StringBuilder result = new StringBuilder();
    String annotUri = getURIV2();
    
    // serialize annotation + annotation uri
    result.append("<oa:Annotation rdf:about=\"");
    result.append(annotUri);
    result.append("\">");
    
    // serialize annotation type
    result.append("<oa:hasBody>");
    result.append("<oa:SemanticTag rdf:about=\"");
    result.append(annotType.getUri());
    result.append("\"/>");
    result.append("</oa:hasBody>");

    // serialize fragments
    if(fragments == null || fragments.isEmpty()){
      // annotation of whole document
      result.append("<oa:hasTarget>");
      
      result.append("<dctypes:Text rdf:about=\"");
      result.append(source);
      result.append("\">");
      result.append("<dc:format>text/xml</dc:format>");
      result.append("</dctypes:Text>");
      
      result.append("</oa:hasTarget>");
    } else if (fragments.size() == 1) {
      // annotation have only one fragment
      result.append("<oa:hasTarget>");
      result.append(((Fragment) fragments.get(0)).toXMLStringV2());
      result.append("</oa:hasTarget>");
    } else if (fragments.size() > 1) {
      // annotation with multiple fragments
      result.append("<oa:hasTarget>");
      result.append("<oa:Composite rdf:about=\"");
      // make uri of composite 
      result.append(source);
      result.append(getFragmentXpointersV2());
      result.append("\">");

      Iterator<Fragment> fragIt = fragments.iterator();
      while(fragIt.hasNext()){
        Fragment tmpFrag = fragIt.next();
        result.append("<oa:item>");
        result.append(tmpFrag.toXMLStringV2());
        result.append("</oa:item>");
      }

      result.append("</oa:Composite>");
      result.append("</oa:hasTarget>");
    }

    // serialize annotation content
    result.append("<oa:hasBody>");
    
    result.append("<cnt:ContentAsText rdf:about=\"");
    result.append(annotUri);
    result.append("#body\">");
    
    result.append("<rdf:type rdf:resource=\"http://purl.org/dc/dcmitype/Text\"/>");
    result.append("<cnt:chars><![CDATA[");
    result.append(content);
    result.append("]]></cnt:chars><dc:format>text/plain</dc:format>");
    result.append("</cnt:ContentAsText>");
    result.append("</oa:hasBody>");
    

    // serialize attributes
    result.append("<oa:hasBody>");
    
    result.append("<cnt:ContentAsText rdf:about=\"");
    result.append(source);
    result.append("\">");
    
    result.append("<rdf:type rdf:resource=\"http://www.w3.org/2004/03/trix/rdfg-1/Graph\"/>");
    
    result.append("<trix:TriX>");
    result.append("<trix:graph>");
    
    if (KBRefMode 
        && !Constants.FORBIDDEN_ENTITY_TYPES.contains(this.getAnnotType().getName().toLowerCase())
        && canBeDisplayedInKBRefMode()) {
      // KB_Ref mode
      result.append(attributesToKBRefString(attFilter, langNum));
    } else {  
      Collections.sort(attributes);
      Iterator<BaseAttribute> attribIt = attributes.iterator();
      while (attribIt.hasNext()) {
        BaseAttribute tmpAttrib = attribIt.next();
        if (!AttributeManager.hasAttributeRightInstance(tmpAttrib)) {
          tmpAttrib = AttributeManager.changeAttributeInstance(tmpAttrib);
        }
        String aName = tmpAttrib.getName();
        if (attFilter.contains(aName)) {
          continue;
        }
        result.append(tmpAttrib.toXMLStringV2());
      }
    }
    
    result.append("</trix:graph>");
    result.append("</trix:TriX>");
    
    result.append("<dc:format>text/xml</dc:format>");
    result.append("</cnt:ContentAsText>");
    result.append("</oa:hasBody>");

    // serialize informations about date of creation
    result.append("<oa:annotatedBy>");
    
    result.append("<foaf:Person rdf:about=\"");
    result.append(user.getURIV2());
    result.append("\">");
    
    result.append("<foaf:mbox>mailto:");
    result.append(authorAddress);
    result.append("</foaf:mbox>");
    
    result.append("<foaf:name>");
    result.append(authorName);
    result.append("</foaf:name>");
    
    result.append("</foaf:Person>");
    result.append("</oa:annotatedBy>");
    
    
    // serialize time and date of creation
    SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ssZ");
    String date = df.format(created);
    
    result.append("<oa:annotatedAt>");
    result.append(date);
    result.append("</oa:annotatedAt>");
    
    result.append("<oa:serializedAt>");
    result.append(date);
    result.append("</oa:serializedAt>");
    
    // end of annotation
    result.append("</oa:Annotation>");

    //Serializing all nested annotations
    Iterator<BaseAttribute> attrNestedIt = attributes.iterator();
    while (attrNestedIt.hasNext()) {
      BaseAttribute tmpAttrib = attrNestedIt.next();
      String aName = tmpAttrib.getName();
      if (attFilter.contains(aName)) {
        continue;
      }
      if (tmpAttrib.getNestedAnnotation() != null) {
        result.append(tmpAttrib.getNestedAnnotation().toXMLStringV2(attFilter, langNum, KBRefMode));
      }
    }
    
    return result.toString();
  }
  
  /**
   * If this annotation can be displayed in KB Ref mode (KB_Ref attribute 
   * is not presented and updatable_annotation is presented and true), 
   * returns true, false otherwise
   * 
   * @return If this annotation can be displayed in KB Ref mode, returns true, false otherwise
   */
  private boolean canBeDisplayedInKBRefMode() {
    Iterator<BaseAttribute> attrIt = attributes.iterator();
    boolean isUpdatableAnnot = false;
    while(attrIt.hasNext()){
      BaseAttribute tmpAttrib = attrIt.next();
      if (tmpAttrib.getName().contentEquals(Constants.KB_REF_ATT_NAME)) {
        return false;
      }
      if (tmpAttrib.getName().contentEquals(Constants.UPDATABLE_AN_AT_NAME)) {
        isUpdatableAnnot = tmpAttrib.getBoolValue();
      }
    }
    return isUpdatableAnnot;
  }
  
  /**
   * Returns serialized attributes in KB Ref mode
   * 
   * @param attFilter Filter for attributes
   * @param langNum Number of language
   * @return Returns serialized attributes in KB Ref mode
   */
  private StringBuilder attributesToKBRefString(ArrayList<String> attFilter, int langNum) {
    StringBuilder result = new StringBuilder();
    StringBuilder tmpResult = new StringBuilder();
    Iterator<BaseAttribute> attribIt = attributes.iterator();
    EntityAttribute kRefAt = new EntityAttribute();
    kRefAt.setSimpleType("Entity");
    kRefAt.setEntityAdditionalAttributes(new ArrayList<EntityAdditionalAttribute>());
    kRefAt.setRefAnnotation(this);
    kRefAt.setName(Constants.KB_REF_ATT_NAME);
    kRefAt.setEntityType(this.getAnnotType().getName());
    Boolean nameSet = false;
    Boolean uriSet = false;  // was URI set?
    Boolean vrSet = false;
    Boolean desSet = false;
    while (attribIt.hasNext()) {
      BaseAttribute tmpAttrib = attribIt.next();
      Boolean processed = false;  // was attribute processed?
      if (!AttributeManager.hasAttributeRightInstance(tmpAttrib)) {
        tmpAttrib = AttributeManager.changeAttributeInstance(tmpAttrib);
      }
      if (tmpAttrib.getName().equalsIgnoreCase(Localisation.getKBStr(langNum, Localisation.KB_ARTWORK_NAME))) {
        if (tmpAttrib.getStringValue() != null && !nameSet) {
          kRefAt.setEntityName(tmpAttrib.getStringValue());
          nameSet = true;
          processed = true;
        }
      } else if (tmpAttrib.getName().equalsIgnoreCase(Localisation.getKBStr(langNum, Localisation.KB_DESCRIPTION))) {
        if (TextAttribute.class.isInstance(tmpAttrib)) {
          processed = true;
          if (tmpAttrib.getTextValue() != null) {
            if (desSet) {
              kRefAt.setDescription(kRefAt.getDescription() + tmpAttrib.getTextValue());
            } else {
              kRefAt.setDescription(tmpAttrib.getTextValue());
              desSet = true;
            }
          }
        } else if (StringAttribute.class.isInstance(tmpAttrib)) {
          processed = true;
          if (tmpAttrib.getStringValue() != null) {
            if (desSet) {
              kRefAt.setDescription(kRefAt.getDescription() + tmpAttrib.getStringValue());
            } else {
              kRefAt.setDescription(tmpAttrib.getStringValue());
              desSet = true;
            }
          }
        }
      } else if (tmpAttrib.getName().equalsIgnoreCase(Localisation.getKBStr(langNum, Localisation.KB_ENTITY_URI))) {
        if (tmpAttrib.getUri() != null && !uriSet) {
          kRefAt.setUri(tmpAttrib.getUri());
          uriSet = true;
          processed = true;
        }
      } else if (tmpAttrib.getName().equalsIgnoreCase(Localisation.getKBStr(langNum, Localisation.KB_VISUAL_REPRESENTATION))) {
        if (tmpAttrib.getUri() != null) {
          kRefAt.setEntityVisualURI(tmpAttrib.getUri());
          vrSet = true;
          processed = true;
        }
      }
      if (!processed) {
        String aName = tmpAttrib.getName();
        if (attFilter.contains(aName)) {
          continue;
        }
        if (tmpAttrib.getName().equalsIgnoreCase(Localisation.getKBStr(langNum, Localisation.KB_DISAMBIGUATION))) {
          tmpResult.append(tmpAttrib.toXMLStringV2());
        } else {  // it is not disambiguation attribute
          EntityAdditionalAttribute adAt = tmpAttrib.toEntityAdditionalAttribute();
          if (adAt != null) {
            adAt.setRefEntityAttribute(kRefAt);
            kRefAt.getEntityAdditionalAttributes().add(adAt);
          } else {
            tmpResult.append(tmpAttrib.toXMLStringV2());
          }
        }
      }  // if (!processed)
    }  // while (attribIt.hasNext ...
    if (nameSet && desSet && uriSet) {  // successfull conversion
      result.append(kRefAt.toXMLStringV2());
      result.append(tmpResult);
    } else {  // unsuccessfull conversion
      attribIt = attributes.iterator();
      while (attribIt.hasNext()) {
        BaseAttribute tmpAttrib = attribIt.next();
        if (!AttributeManager.hasAttributeRightInstance(tmpAttrib)) {
          tmpAttrib = AttributeManager.changeAttributeInstance(tmpAttrib);
        }
        String aName = tmpAttrib.getName();
        if (attFilter.contains(aName)) {
          continue;
        }
        result.append(tmpAttrib.toXMLStringV2());
      }
    }
    return result;
  }  // attributesToKBRefString()
  
  /**
   * Returns xpointers of all annotations fragments
   *
   * @return Returns xpointers of all annotations fragments
   */
  public String getFragmentXpointersV2(){
    String xpointers = "";

    Iterator<Fragment> fragIt = fragments.iterator();
    while(fragIt.hasNext()){
      xpointers += "#" + fragIt.next().getXpointerV2();
    }
    
    return xpointers;
  }

  /**
   * Returns serialized informations about annotation in XML
   *
   * @param proto11 If true, protocol version is greather then 1.0
   * @return Returns serialized informations about annotation in XML
   */
  public String toXMLString(boolean proto11) {
    return toXMLString(true, "", proto11, false);
  }

  /**
   * Returns serialized informations about annotation in XML
   *
   * @param annotTag Denotes whether wrapping tag annotation should be included
   * @param annotTagAttrs Attributes of created annotation tag
   * @param proto11 If true, protocol version is greather then 1.0
   * @param tmpIdForNested If true, nested annotations will have attribute tmpId
   * @return Returns serialized informations about annotation in XML
   */
  public String toXMLString(boolean annotTag, String annotTagAttrs, boolean proto11, boolean tmpIdForNested) {
    String authorAttr = "";
    if (authorName != null) {
      authorAttr = authorAttr + " name=\"" + authorName + "\"";
    }
    if (authorAddress != null) {
      authorAttr = authorAttr + " address=\"" + authorAddress + "\"";
    }
    String aboutStr = "";
    if (id != null) {
      aboutStr = AppBean.getBaseAnnotUri() + id;
    }
    String tIdForD = "";
    if (tmpIdForNested  && nestedInAnnot != null) {
      tIdForD = " tmpId=\"" + tmpId + "\"";
    }
    if (annotTag) {
      return "<annotation" + annotTagAttrs + ">"
        + "<rdf:Description" + tIdForD + " rdf:about=\"" + aboutStr + "\">"
          + "<rdf:type rdf:resource=\"" + annotType.getUri() + "\"/>"
          + "<a:dateTime rdf:value=\"" + Util.toRFC3339Date(created) + "\" />"
          + "<a:author id=\"" + authorIdStr + "\"" + authorAttr + "/>"
          + "<a:source rdf:resource=\"" + source + "\"/>"
          + fragmentsToXMLString()
          + "<a:content>"
          + "<![CDATA["
          + content
          + "]]>"
          + "</a:content>"
          + attributesToXMLString(proto11, tmpIdForNested)
        + "</rdf:Description>"
        + "</annotation>";
    }
    return "<rdf:Description" + tIdForD + " rdf:about=\"" + aboutStr + "\">"
        + "<rdf:type rdf:resource=\"" + annotType.getUri() + "\"/>"
        + "<a:dateTime rdf:value=\"" + Util.toRFC3339Date(created) + "\" />"
        + "<a:author id=\"" + authorIdStr + "\"" + authorAttr + "/>"
        + "<a:source rdf:resource=\"" + source + "\"/>"
        + fragmentsToXMLString()
        + "<a:content>"
        + "<![CDATA["
        + content
        + "]]>"
        + "</a:content>"
        + attributesToXMLString(proto11, tmpIdForNested)
      + "</rdf:Description>";
  }  // toXMLString()

  /**
   * Returns serialized informations about annotated fragments in XML
   *
   * @return Returns serialized informations about annotated fragments in XML
   */
  public String fragmentsToXMLString() {
    String fragmentsString = "";
    Iterator<Fragment> fragIt = fragments.iterator();
    Fragment fr;
    while (fragIt.hasNext()) {
      fr = fragIt.next();
      fragmentsString += fr.toXMLString();
    }
    return fragmentsString;
  }

  /**
   * Returns serialized informations about annotation attributes in XML
   *
   * @param proto11 If true, protocol version is greather then 1.0
   * @param tmpIdForNested If true, nested annotations will have attribute tmpId
   * @return Returns serialized informations about annotation attributes in XML
   */
  public String attributesToXMLString(boolean proto11, boolean tmpIdForNested) {
    String attrString = "";
    Collections.sort(attributes);
    Iterator<BaseAttribute> attrIt = attributes.iterator();
    BaseAttribute attr;
    while (attrIt.hasNext()) {
      attr = attrIt.next();
      attrString += attr.toXMLString(proto11, tmpIdForNested, false);
    }
    return attrString;
  }

  /**
   * Creates escaped version of the provided textual data. It is used when
   * text to be sent to the SEC Store server contains special characters like
   * quotes and backslash. Method expects SEC Store server to store strings
   * enclosed in double quote. That's why double quote character needs to be
   * escaped and single quote not.
   */
  private String EscapeCharsToSend(String source) {
    String result = source;
    // string can have null value if suggestions type is not requested
    if (result != null) {
      result = result.replace("\\", "\\\\");
      result = result.replace("\"", "\\\"");
    }
    return result;
  } //EscapeChars()

  /**
   * Stores annotation data into the JSON string representation. String could be
   * processed on the SEC Store API server. Method stores IDs of referenced
   * structures, so when creating an object from this representation,
   * one must look up for structures by IDs.
   *
   * @return String representation of JSON Annotation data
   */
  public String toJsonString(Integer sOffset, Integer eOffset) {
    String retJson = "{\"startOffset\":";
    StringBuilder sb = new StringBuilder(retJson);
    // offsets
    sb.append(sOffset);
    sb.append(",\"endOffset\":");
    sb.append(eOffset);
    sb.append(",\"uri\":\"");
    // URI of the annotation
    sb.append(this.getURI());
    // path of the type of the annotation
    sb.append("\",\"annotTypePath\":\"");
    if (this.getAnnotType() != null) {
      String typeUri = this.getAnnotType().getUri();
      // remove server address and group number
      String strippedServer = typeUri.replace(AppBean.getBaseTypeUri(), "");
      String strippedGroup = strippedServer.replaceFirst("g[0-9]+\\/", "");
      sb.append(strippedGroup);
    }
    sb.append("\",\"typeUriInOntology\":\"");
    if (this.getAnnotType() != null) {
      sb.append(this.getAnnotType().getUriInOntology());
    }
    // list of groups that author belongs to
    sb.append("\",\"authorGroups\":[");
    for (Iterator<UserGroup> ug = this.user.groups.iterator(); ug.hasNext();) {
      UserGroup nextUG = ug.next();
      sb.append("{\"uri\":\"");
      // URI of the group
      sb.append(nextUG.getUri());
      // name of the group
      sb.append("\",\"name\":\"");
      sb.append(nextUG.getName());
      sb.append("\"},");
    }
    sb.deleteCharAt(sb.length()-1);
    sb.append("],\"annotTypeGroup\":\"");
    if (this.getAnnotType() != null && this.getAnnotType().getGroup() != null) {
        sb.append(this.getAnnotType().getGroup().getUri());
    }
    sb.append("\",\"sourceUri\":\"");
    // URI of the document which the annotation belongs to
    sb.append(this.sourceDocument.getUri());
    sb.append("\",\"content\":\"");
    // content of the annotation
    sb.append(EscapeCharsToSend(this.content));
    sb.append("\",\"annoText\":\"");
    // text that has been annotated
    for (Iterator<Fragment> frIt = this.fragments.iterator(); frIt.hasNext();) {
      sb.append(EscapeCharsToSend(frIt.next().getAnnotatedText()));
    }
    sb.append("\",\"attributes\":[");
    if (this.attributes != null && !this.attributes.isEmpty()) {
      // a list of annotation's attributes
      for (Iterator<BaseAttribute> atIt = this.attributes.iterator(); atIt.hasNext();) {
        BaseAttribute att = atIt.next();
        sb.append(att.toJSONString());
        sb.append(",");
        // if attribute is annotation, set ID of parent annotation as nestedIn
        if (att.getSimpleType().equals("NestedAnnotation") && att.getNestedAnnotation() != null) {
          att.getNestedAnnotation().setNestedIn(this.id.toString());
        }
      }
      sb.deleteCharAt(sb.length()-1);
    }
    sb.append("],\"nestedIn\":\"");
    if (this.getNestedInAnnot() != null) {
      sb.append(this.getNestedInAnnot().getURI());
    }
    else {
      sb.append("null");  
    }
    sb.append("\"}");
    return sb.toString();
  }  // toJsonString()

  public String getNewAnnotMsg(){
    StringBuilder retStr = new StringBuilder();
    retStr.append("<annotation tempUri=\"");
    retStr.append(AppBean.getBaseAnnotUri());
    retStr.append("temp/");
    retStr.append(tmpId);
    retStr.append("\" servUri=\"");
    retStr.append(AppBean.getBaseAnnotUri());
    retStr.append("serv/");
    retStr.append(id.toString());
    retStr.append("/>");
    return retStr.toString();
  }
  
  /**
   * Gets tmpId of annotation
   *
   * @return Returns tmpId of annotation
   */
  public String getTmpId() {
      return this.tmpId;
  }

  /**
   * Sets tmpId of annotation
   * @param tmpId  New tmpId
   */
  public void setTmpId(String tmpId) {
      this.tmpId = tmpId;
  }
  
  /**
   * Returns a list containing IDs of annotations that links this annotation
   * 
   * @return list of integer IDs
   */
  public List<Integer> getLinkedByBeforeRemove() {
      return this.linkedByBeforeRemove;
  }
  
  /**
   * Inserts ID of annotation that links this particular annotation to the list
   * 
   * @param id ID of annotation that links this particular annotation
   */
  public void addLinkedByBeforeRemove(Integer id) {
    // create list only in case that it is needed
    if (this.linkedByBeforeRemove == null) {
      this.linkedByBeforeRemove = new ArrayList<Integer>();
    }
    // prevent duplicities
    if (!this.linkedByBeforeRemove.contains(id)) {
      this.linkedByBeforeRemove.add(id);
    }
  }
  
  /**
   * Clears the list containing ID. It should be used after the remove message
   * for this particular annotation has been created.
   */
  public void clearLinkedByBeforeRemove() {
    this.linkedByBeforeRemove.clear();
  }
  
  /**
   * Adds all IDs of linking annotations.
   * 
   * @param IDs list of IDs of annotations that contain attribute linking this particular annotation
   */
  public void addAllLinkedByBeforeRemove(List<Integer> IDs) {
    if(this.linkedByBeforeRemove == null){
      this.linkedByBeforeRemove = new ArrayList<Integer>();
    }
    this.linkedByBeforeRemove.addAll(IDs);
  }

}  // class Annotation