AnnotType.java

Go to the documentation of this file.

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

/**
 * @file AnnotType.java
 *
 * @brief Class representing type of annotation
 */

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

import cz.vutbr.fit.knot.annotations.app.AppBean;
import cz.vutbr.fit.knot.annotations.comet.MessageProcessor;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.Lob;
import javax.persistence.ManyToMany;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;

/**
 * Class representing type of annotation
 *
 * @brief Class representing type of annotation
 * @author idytrych
 */
@Entity
@Table(name = "annotType")
@NamedQueries({
  @NamedQuery(name = "AnnotType.findAll", query = "SELECT a FROM AnnotType a"),
  @NamedQuery(name = "AnnotType.findByUri", query = "SELECT a FROM AnnotType a WHERE a.uri = :uri"),
  @NamedQuery(name = "AnnotType.findByUriAndGroup", query = "SELECT a FROM AnnotType a WHERE a.uri = :uri AND a.groupId = :groupId"),
  @NamedQuery(name = "AnnotType.findById", query = "SELECT a FROM AnnotType a WHERE a.id = :id"),
  @NamedQuery(name = "AnnotType.findByName", query = "SELECT a FROM AnnotType a WHERE a.name = :name"),
  @NamedQuery(name = "AnnotType.findByAncestor", query = "SELECT a FROM AnnotType a WHERE a.ancestor = :ancestor"),
  @NamedQuery(name = "AnnotType.findByUserGroup", query = "SELECT a FROM AnnotType a WHERE a.groupId = :groupId"),
  @NamedQuery(name = "AnnotType.findByNUA", query = "SELECT a FROM AnnotType a WHERE a.name = :name AND a.uri = :uri AND a.ancestor = :ancestor")})
public class AnnotType implements Serializable {
  private static final long serialVersionUID = 1L;
  /** Annotation type id */
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Basic(optional = false)
  @Column(name = "id")
  private Integer id;
  /** URI of type */
  @Basic(optional = false)
  @Column(name = "uri")
  private String uri;
  /** Name of type */
  @Basic(optional = false)
  @Column(name = "name")
  private String name;
  /** Id of primary ancestor of type (ancestor for old clients) */
  @Basic(optional = true)
  @Column(name = "ancestor", insertable=false, updatable=false)
  private Integer ancestor;
  /** Id of user group to which this type belongs */
  @Basic(optional = true)
  @Column(name = "groupId", insertable=false, updatable=false)
  private Integer groupId;
  /** Indicator of restricted attributes */
  @Basic(optional = false)
  @Column(name = "restrictedAtt")
  private Boolean restrictedAtt;
  /** URI in original ontology */
  @Basic(optional = true)
  @Column(name = "uriInOntology")
  private String uriInOntology;
  /** Comment */
  @Basic(optional = true)
  @Lob
  @Column(name = "commentary")
  private String comment;

  /** Attributes of annotation type */
  @OneToMany(mappedBy = "annotationType", cascade = CascadeType.ALL,
  targetEntity = AnnotTypeAttr.class, fetch = FetchType.EAGER)
  private List<AnnotTypeAttr> attributes;
  /** Primary ancestor of type (ancestor for old clients) */
  @OneToOne(optional = true)
  @JoinColumn(name = "ancestor", referencedColumnName = "id")
  private AnnotType ancestorType;
  /** User group to which this type belongs */
  @OneToOne(optional = true)
  @JoinColumn(name = "groupId", referencedColumnName = "id")
  private UserGroup group;

  /** List of ancestors of this type */
  @ManyToMany(cascade = CascadeType.MERGE)
  @JoinTable(name = "typeAncestor",
    joinColumns =
      @JoinColumn(name = "type", referencedColumnName = "id"),
    inverseJoinColumns =
      @JoinColumn(name = "ancestor", referencedColumnName = "id"))
  public List<AnnotType> ancestorTypes;

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

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

  /**
   * Constructor
   *
   * @param uri URI of type of annotation
   * @param name Name of type of annotation
   * @param ancestorT Ancestor of type of annotation
   * @param group User group to which type of annotation belongs
   */
  public AnnotType(String uri, String name, AnnotType ancestorT, UserGroup group) {
    this.uri = uri;
    this.name = name;
    if (ancestorT != null) {
      this.ancestor = ancestorT.getId();
    } else {
      this.ancestor = null;
    }
    this.ancestorType = ancestorT;
    this.group = group;
    this.attributes = new ArrayList<AnnotTypeAttr>();
    this.ancestorTypes = new ArrayList<AnnotType>();
    this.restrictedAtt = false;
    this.uriInOntology = null;
    this.comment = null;
  }

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

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

  /**
   * Gets URI of type of annotation
   * 
   * @return Returns URI of type of annotation
   */
  public String getUri() {
    return uri;
  }

  /**
   * Sets URI of type of annotation
   * 
   * @param uri URI of type of annotation
   */
  public void setUri(String uri) {
    this.uri = uri;
  }

  /**
   * Gets name of type of annotation
   * 
   * @return Returns name of type of annotation
   */
  public String getName() {
    return name;
  }

  /**
   * Sets name of type of annotation
   * 
   * @param name Name of type of annotation
   */
  public void setName(String name) {
    this.name = name;
  }

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

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

  /**
   * Sets ancestor type of annotation
   * 
   * @param ancestorType Ancestor type of annotation
   */
  public void setAncestorType(AnnotType ancestorType) {
    this.ancestorType = ancestorType;
  }

  /**
   * Gets list of ancestor types
   * 
   * @return Returns list of ancestor types
   */
  public List<AnnotType> getAncestorTypes() {
    return ancestorTypes;
  }

  /**
   * Sets list of ancestor types
   *
   * @param ancestorTypes List of ancestor types
   */
  public void setAncestorTypes(List<AnnotType> ancestorTypes) {
    this.ancestorTypes = ancestorTypes;
  }

  /**
   * Gets list of ancestor types in ArrayList
   *
   * @return Returns ArrayList with ancestor types
   */
  public ArrayList<AnnotType> getAncestorTypesAL() {
     return new ArrayList<AnnotType>(ancestorTypes);
  }

  /**
   * Adds ancestor to list of ancestor types
   *
   * @param ancestor Ancestor type
   */
  public void addAncestorType(AnnotType ancestor) {
    if(ancestorTypes == null){
      this.ancestorTypes = new ArrayList<AnnotType>();
    }
    if (ancestorTypes.indexOf(ancestor) < 0) { // type not yet in ancestor list
      this.ancestorTypes.add(ancestor);
    }
  }

  /**
   * Gets ancestor type of annotation
   * 
   * @return Returns ancestor type of annotation
   */
  public AnnotType getAncestorType() {
    return ancestorType;
  }

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

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

  /**
   * Gets user group to which type of annotation belongs
   *
   * @return Returns user group to which type of annotation belongs
   */
  public UserGroup getGroup() {
    return group;
  }

  /**
   * Sets user group to which type of annotation belongs
   *
   * @param group User group to which type of annotation belongs
   */
  public void setGroup(UserGroup group) {
    this.group = group;
  }

  /**
   * Gets URI in original ontology
   *
   * @return Returns URI in original ontology
   */
  public String getUriInOntology() {
    return uriInOntology;
  }

  /**
   * Sets URI in original ontology
   *
   * @param uriInOntology URI in original ontology
   */
  public void setUriInOntology(String uriInOntology) {
    this.uriInOntology = uriInOntology;
  }
  
  @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 AnnotType)) {
      return false;
    }
    AnnotType other = (AnnotType) object;
    if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
      return false;
    }
    return true;
  }

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

  /**
   * Returns serialized informations about type of annotation in XML
   *
   * @param withAncestors If true, list of ancestors will be serialized, if false, list will be omitted
   * @return Returns serialized informations about type of annotation in XML
   */
  public String toXMLString(boolean withAncestors) {
    // serialize ancestors
    String serializedAnc = "";
    if (withAncestors) {  // if protocol version is greater then 1.0
      for (Iterator<AnnotType> it = ancestorTypes.iterator(); it.hasNext();) {
        AnnotType ancType = it.next();
        serializedAnc = serializedAnc + "<ancestor uri=\"" + ancType.getUri() + "\"/>";
      }
      if (comment != null && !comment.isEmpty()) {  // if comment is presented, it will be serialized
        serializedAnc = serializedAnc + "<comment>"
        + "<![CDATA["
        + comment
        + "]]>"
        + "</comment>";
      }
    }  // if protocol version is greater then 1.0
    // create group attribute
    String grString = "";
    if (group != null) {
      grString = " group=\"" + group.getUri() + "\"";
    }
    // create restrictedAttributes attribute
    String rAString = "";
    if (restrictedAtt) {
      rAString = " restrictedAttributes=\"true\"";
    }
    if (attributes.isEmpty() && ancestorType == null) {
      if (serializedAnc.equals("")) {
        serializedAnc = "/";
      } else {
        serializedAnc = ">" + serializedAnc + "</type";
      }
      return "<type name=\"" + name + "\" ancestor=\"\" uri=\""
             + uri + "\"" + grString + rAString + serializedAnc + ">";
    } else if (attributes.isEmpty()) {
      if (serializedAnc.equals("")) {
        serializedAnc = "/";
      } else {
        serializedAnc = ">" + serializedAnc + "</type";
      }
      return "<type name=\"" + name + "\" ancestor=\"" + ancestorType.getUri()
             + "\" uri=\"" + uri + "\"" + grString + rAString + serializedAnc + ">";
    }
    // serialize attributes
    String att = "";
    Collections.sort(attributes);
    Iterator<AnnotTypeAttr> li = attributes.iterator();
    AnnotTypeAttr at;
    while (li.hasNext()) {
      at = li.next();
      att = att + at.toXMLString(withAncestors);
    }
    
    if (ancestorType == null) {
      return "<type name=\"" + name + "\" ancestor=\"\" uri=\"" + uri + "\"" + grString
              + rAString + ">" + att + serializedAnc + "</type>";
    }
    return "<type name=\"" + name + "\" ancestor=\"" + ancestorType.getUri() + "\" uri=\""
           + uri + "\"" + grString + rAString + ">"
           + att + serializedAnc + "</type>";
  }  // toXMLString()

  /**
   * Returns serialized informations about type of annotation in XML for
   * protocol version 2.
   *
   * @param withAncestors If true, list of ancestors will be serialized, if false, list will be omitted
   * @return Returns serialized informations about type of annotation in XML for
   * protocol version 2
   */
  public String toXMLStringV2(boolean withAncestors) {
    // serialize ancestors
    StringBuilder serializedAnc = new StringBuilder();
    if(this.ancestorType != null && withAncestors){
      serializedAnc.append("<directAncestors primary=\"");
      serializedAnc.append(ancestorType.getUri());
      if(this.ancestorTypes != null && !this.ancestorTypes.isEmpty()){
        serializedAnc.append("\">");
        Iterator<AnnotType> ancestorsIt = this.ancestorTypes.iterator();
        while(ancestorsIt.hasNext()){
          serializedAnc.append("<ancestor uri=\"");
          serializedAnc.append(ancestorsIt.next().getUri());
          serializedAnc.append("\"/>");
        }
        serializedAnc.append("</directAncestors>");
      }else{
        serializedAnc.append("\"/>");
      }
    }
    
    // serialize attributes
    StringBuilder serializedAttrs = new StringBuilder();
    List<AnnotTypeAttr> attrList = getAttributes();
    if(attrList != null && !attrList.isEmpty()){
      serializedAttrs.append("<attributes>");
      Iterator<AnnotTypeAttr> attrsIt = attrList.iterator();
      while(attrsIt.hasNext()){
        serializedAttrs.append(attrsIt.next().toXMLStringV2(true));
      }
      serializedAttrs.append("</attributes>");
    }
    
    // serialize annotation attribute
    StringBuilder serializedAnnotAttr = new StringBuilder();
    serializedAnnotAttr.append("<type name=\"");
    serializedAnnotAttr.append(this.name);
    serializedAnnotAttr.append("\" uri=\"");
    serializedAnnotAttr.append(this.uri);
    serializedAnnotAttr.append("\" groupUri=\"");
    serializedAnnotAttr.append(this.group.getUri());
    serializedAnnotAttr.append("\" restrictedAttributes=\"");
    serializedAnnotAttr.append(this.restrictedAtt.toString());
    if(this.uriInOntology != null && !this.uriInOntology.isEmpty()){
      serializedAnnotAttr.append("\" ontologyUri=\"");
      serializedAnnotAttr.append(this.uriInOntology);
    }
    if(withAncestors || (this.comment != null && !this.comment.isEmpty()) 
            || serializedAnc.length() > 0 || serializedAttrs.length() > 0){
      serializedAnnotAttr.append("\">");
      serializedAnnotAttr.append(serializedAnc.toString());
      serializedAnnotAttr.append(serializedAttrs.toString());
      if(this.comment != null && !this.comment.isEmpty()){
        serializedAnnotAttr.append("<comment><![CDATA[");
        serializedAnnotAttr.append(this.comment);
        serializedAnnotAttr.append("]]></comment>");
      }
      serializedAnnotAttr.append("</type>");
    }else{
      serializedAnnotAttr.append("\"/>");
    }
    
    return serializedAnnotAttr.toString();
  }
  
  /**
   * Returns serialized informations about type of annotation without attributes in XML for
   * protocol version 2.
   *
   * @param withAncestors If true, list of ancestors will be serialized, if false, list will be omitted
   * @return Returns serialized informations about type of annotation without attributes in XML for
   * protocol version 2
   */
  public String toXMLStringWAV2(boolean withAncestors){
    // serialize ancestors
    StringBuilder serializedAnc = new StringBuilder();
    if(this.ancestorType != null && withAncestors){
      serializedAnc.append("<directAncestors primary=\"");
      serializedAnc.append(ancestorType.getUri());
      if(this.ancestorTypes != null && !this.ancestorTypes.isEmpty()){
        serializedAnc.append("\">");
        Iterator<AnnotType> ancestorsIt = this.ancestorTypes.iterator();
        while(ancestorsIt.hasNext()){
          serializedAnc.append("<ancestor uri=\"");
          serializedAnc.append(ancestorsIt.next().getUri());
          serializedAnc.append("\"/>");
        }
        serializedAnc.append("</directAncestors>");
      }else{
        serializedAnc.append("\"/>");
      }
    }
    
    // serialize annotation attribute
    StringBuilder serializedAnnotAttr = new StringBuilder();
    serializedAnnotAttr.append("<type name=\"");
    serializedAnnotAttr.append(this.name);
    serializedAnnotAttr.append("\" uri=\"");
    serializedAnnotAttr.append(this.uri);
    serializedAnnotAttr.append("\" groupUri=\"");
    serializedAnnotAttr.append(this.group.getUri());
    serializedAnnotAttr.append("\" restrictedAttributes=\"");
    serializedAnnotAttr.append(this.restrictedAtt.toString());
    
    if(withAncestors || (this.comment != null && !this.comment.isEmpty()) 
            || serializedAnc.length() > 0){
      serializedAnnotAttr.append("\">");
      serializedAnnotAttr.append(serializedAnc.toString());
      
      if(this.comment != null && !this.comment.isEmpty()){
        serializedAnnotAttr.append("<comment><![CDATA[");
        serializedAnnotAttr.append(this.comment);
        serializedAnnotAttr.append("]]></comment>");
      }
      
      serializedAnnotAttr.append("</type>");
    }else{
      serializedAnnotAttr.append("\"/>");
    }
    
    return serializedAnnotAttr.toString();
  }
  
  /**
   * Returns serialized informations about type of annotation without attributes in XML
   *
   * @param withAncestors If true, list of ancestors will be serialized, if false, list will be omitted
   * @return Returns serialized informations about type of annotation without attributes in XML
   */
  public String toXMLStringWA(boolean withAncestors) {
    String grString = "";
    if (group != null) {
      grString = " group=\"" + group.getUri() + "\"";
    }
    String ending = "/";
    if (withAncestors) {
      ending = ">";
      for (Iterator<AnnotType> it = ancestorTypes.iterator(); it.hasNext();) {
        AnnotType ancType = it.next();
        ending = ending + "<ancestor uri=\"" + ancType.getUri() + "\"/>";
      }
      ending = ending + "</type";
    }
    if (ancestorType == null) {
      return "<type name=\"" + name + "\" ancestor=\"\" uri=\""
             + uri + "\"" + grString + ending + ">";
    } else {
      return "<type name=\"" + name + "\" ancestor=\"" + ancestorType.getUri()
             + "\" uri=\"" + uri + "\"" + grString + ending + ">";
    }
  }  // toXMLStringWA()
  
  /**
   * Generate URI of type of annotation from his name, ancestor and user group
   * URI = base URI + "/g" + user group id + "/" 
   *       + names of ancestors separated by "/"
   *       + "/" + name of type
   * 
   * @return Generated URI of type of annotation
   */
  public String getGeneratedURI() {
    String linearized = AppBean.getBaseTypeUri();
    linearized = linearized + "g";
    if (group != null) {
      linearized = linearized + group.getId();
    }
    linearized = linearized + "/";
    AnnotType ancT = ancestorType;
    ArrayList<String> linArray = new ArrayList<String>();
    linArray.add(MessageProcessor.replaceArrows(name));
    while (ancT != null) {
      linArray.add(ancT.getName());
      ancT = ancT.getAncestorType();
    }
    // reverse iteration and creating linearized name
    for(int i = linArray.size() - 1; i>= 0; i--){
      linearized = linearized + linArray.get(i) + "/";
    }
    // trim last slash
    linearized = linearized.substring(0, linearized.length() - 1);

    return linearized;
  }

  /**
   * Gets linearized name of type of annotation
   * LN = names of ancestors separated by " -> " 
   *      + " -> " + name of type
   * 
   * @return Linearized name of type of annotation
   */
  public String getLinearizedName() {
    String linearized = "";
    AnnotType ancT = ancestorType;
    ArrayList<String> linArray = new ArrayList<String>();
    linArray.add(name);
    while (ancT != null) {
      linArray.add(ancT.getName());
      ancT = ancT.getAncestorType();
    }
    // reverse iteration and creating linearized name
    for(int i = linArray.size() - 1; i>= 0; i--){
      linearized = linearized + linArray.get(i) + " -> ";
    }
    // trim last arrow
    linearized = linearized.substring(0, linearized.length() - 4);

    return linearized;
  }

  /**
   * Converts linearized name of type of annotation to his URI
   *
   * @param linName Linearized name of type of annotation
   * @return URI of given type of annotation
   */
  public String linearizedNameToUri(String linName) {
    return AppBean.getBaseTypeUri() + MessageProcessor.replaceArrows(linName);
  }

  /**
   * Gets indicator of restricted attributes
   * If true, new attributes can't be added.
   * 
   * @return returns indicator of restricted attributes
   */
  public Boolean getRestrictedAtt() {
    return restrictedAtt;
  }

  /**
   * Sets indicator of restricted attributes
   * If true, new attributes can't be added.
   *
   * @param restrictedAtt Indicator of restricted attributes
   */
  public void setRestrictedAtt(Boolean restrictedAtt) {
    this.restrictedAtt = restrictedAtt;
  }

  /**
   * Gets textual comment
   * 
   * @return Returns textual comment
   */
  public String getComment() {
    return comment;
  }

  /**
   * Sets textual comment
   *
   * @param comment Textual comment
   */
  public void setComment(String comment) {
    this.comment = comment;
  }

}  // class AnnotType