AnnotTypeAttr.java

Go to the documentation of this file.

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

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

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

import cz.vutbr.fit.knot.annotations.app.Constants;
import cz.vutbr.fit.knot.annotations.entity.attribute.AnyAnnotationAttribute;
import cz.vutbr.fit.knot.annotations.entity.attribute.AttributeManager;
import cz.vutbr.fit.knot.annotations.entity.attribute.BaseAttribute;
import java.io.Serializable;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.Lob;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToOne;
import javax.persistence.Table;

/**
 * Class representing attribute of type of annotation
 *
 * @brief Class representing attribute of type of annotation
 * @author idytrych
 */
@Entity
@Table(name = "annotTypeAttr")
@NamedQueries({
  @NamedQuery(name = "AnnotTypeAttr.findAll", query = "SELECT a FROM AnnotTypeAttr a"),
  @NamedQuery(name = "AnnotTypeAttr.findById", query = "SELECT a FROM AnnotTypeAttr a WHERE a.id = :id"),
  @NamedQuery(name = "AnnotTypeAttr.findByAnnotType", query = "SELECT a FROM AnnotTypeAttr a WHERE a.annotType = :annotType"),
  @NamedQuery(name = "AnnotTypeAttr.findByName", query = "SELECT a FROM AnnotTypeAttr a WHERE a.name = :name"),
  @NamedQuery(name = "AnnotTypeAttr.findBySimpleType", query = "SELECT a FROM AnnotTypeAttr a WHERE a.simpleType = :simpleType"),
  @NamedQuery(name = "AnnotTypeAttr.findByType", query = "SELECT a FROM AnnotTypeAttr a WHERE a.type = :type")})
public class AnnotTypeAttr implements Serializable, Comparable<Object> {
  private static final long serialVersionUID = 1L;
  /** Id of attribute of type of annotation */
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Basic(optional = false)
  @Column(name = "id")
  private Integer id;
  /** Id of type of annotation to which this attribute belongs */
  @Basic(optional = false)
  @Column(name = "annotType", nullable=false, insertable=false, updatable=false)
  private int annotType;
  /** Name of attribute */
  @Basic(optional = false)
  @Column(name = "name")
  private String name;
  /** Name of simple type of attribute */
  @Column(name = "simpleType")
  private String simpleType;
  /** Id of type of attribute in case that this is attribute of structured type
   * (type of annotation)
   */
  @Basic(optional = true)
  @Column(name = "type", insertable=false, updatable=false)
  private Integer type;
  /** Indicates whether this attribute is required */
  @Basic(optional = false)
  @Column(name = "required")
  private Boolean required;
  /** URI in original ontology */
  @Basic(optional = true)
  @Column(name = "uriInOntology")
  private String uriInOntology;
  /** Comment */
  @Basic(optional = true)
  @Lob
  @Column(name = "commentary")
  private String comment;
  /** Attribute priority (for order) */
  @Column(name = "priority")
  protected Integer priority;

  /** Type of annotation to which this attribute belongs */
  @ManyToOne(optional = false)
  @JoinColumn(name = "annotType", referencedColumnName = "id")
  private AnnotType annotationType;
  /** Type of attribute in case that this is attribute of structured type (type of annotation) */
  @OneToOne(optional = true)
  @JoinColumn(name = "type", referencedColumnName = "id")
  private AnnotType attributeType;
    
  /**
   * Constructor
   */
  public AnnotTypeAttr() {
  }

  /**
   * Constructor
   * 
   * @param id id of attribute of type of annotation
   */
  public AnnotTypeAttr(Integer id) {
    this.id = id;
  }

  /**
   * Constructor of attribute of simple type
   * 
   * @param annotationType Type of annotation to which this attribute belongs
   * @param name Name of attribute
   * @param simpleType Name of simple type of attribute
   * @param required Indicator whether this attribute is required
   */
  public AnnotTypeAttr(AnnotType annotationType, String name, String simpleType, Boolean required) {
    this.annotationType = annotationType;
    this.name = name;
    this.simpleType = simpleType;
    this.type = null;
    this.attributeType = null;
    this.required = required;
    this.uriInOntology = null;
    this.comment = null;
  }

  /**
   * Constructor of attribute of simple type
   * 
   * @param annotationType Type of annotation to which this attribute belongs
   * @param name Name of attribute
   * @param simpleType Name of simple type of attribute
   * @param required Indicator whether this attribute is required
   * @param priority Priority of attribute
   */
  public AnnotTypeAttr(AnnotType annotationType, String name, String simpleType, Boolean required, Integer priority) {
    this.annotationType = annotationType;
    this.name = name;
    this.simpleType = simpleType;
    this.type = null;
    this.attributeType = null;
    this.required = required;
    this.uriInOntology = null;
    this.comment = null;
    this.priority = priority;
  }
  
  /**
   * Constructor of attribute of structured type
   *
   * @param annotationType Type of annotation to which this attribute belongs
   * @param name Name of attribute
   * @param structuredType Type of structured attribute (type of annotation)
   * @param required Indicator whether this attribute is required
   */
  public AnnotTypeAttr(AnnotType annotationType, String name, AnnotType structuredType, Boolean required) {
    this.annotationType = annotationType;
    this.name = name;
    this.simpleType = null;
    this.type = structuredType.getId();
    this.attributeType = structuredType;
    this.required = required;
    this.uriInOntology = null;
    this.comment = null;
  }
  
  /**
   * Constructor of attribute of structured type that is inicialized from another 
   * attribute.
   *
   * @param annotTypeAttr another attribute
   */
  public AnnotTypeAttr(AnnotTypeAttr annotTypeAttr) {
    this.name = annotTypeAttr.getName();
    this.simpleType = annotTypeAttr.getSimpleType();
    this.type = annotTypeAttr.getType();
    this.attributeType = annotTypeAttr.getAttributeType();
    this.required = annotTypeAttr.getRequired();
    this.uriInOntology = annotTypeAttr.getUriInOntology();
    this.comment = annotTypeAttr.getComment();
  }

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

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

  /**
   * Gets id of type of annotation to which this attribute belongs
   *
   * @return Returns id of type of annotation to which this attribute belongs
   */
  public int getAnnotType() {
    return annotType;
  }

  /**
   * Sets id of type of annotation to which this attribute belongs
   * 
   * @param annotType id of type of annotation to which this attribute belongs
   */
  public void setAnnotType(int annotType) {
    this.annotType = annotType;
  }

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

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

  /**
   * Gets name of simple type of annotation
   *
   * @return If type of attribute is simple, returns name of type, else returns ""
   */
  public String getSimpleType() {
    return simpleType;
  }

  /**
   * Sets name of simple type of annotation (only for attributes of simple type)
   *
   * @param simpleType Name of simple type of annotation ("" for structured type)
   */
  public void setSimpleType(String simpleType) {
    this.simpleType = simpleType;
  }

  /**
   * Gets id of type of attribute in case that this is attribute of structured type
   * (type of annotation)
   *
   * @return If type of attribute is structured, returns id of type of annotation, else returns null
   */
  public Integer getType() {
    return type;
  }

  /**
   * Sets id of type of attribute in case that this is attribute of structured type
   * (type of annotation)
   * 
   * @param type id of type of attribute in case that this is attribute of structured type
   */
  public void setType(Integer type) {
    this.type = type;
  }

  /**
   * Gets type of annotation to which this attribute belongs
   *
   * @return Returns type of annotation to which this attribute belongs
   */
  public AnnotType getAnnotationType() {
    return annotationType;
  }

  /**
   * Sets type of annotation to which this attribute belongs
   *
   * @param annotationType Type of annotation to which this attribute belongs
   */
  public void setAnnotationType(AnnotType annotationType) {
    this.annotationType = annotationType;
  }

  /**
   * Gets type of attribute in case that this is attribute of structured type
   * (type of annotation)
   *
   * @return If type of attribute is structured, returns type of annotation, else returns null
   */
  public AnnotType getAttributeType() {
    return attributeType;
  }

  /**
   * Sets structured type of attribute (only for attribute of structured type)
   *
   * @param attributeType Structured type of attribute (type of annotation), or null for simple type
   */
  public void setAttributeType(AnnotType attributeType) {
    this.attributeType = attributeType;
  }

  /**
   * Gets indicator whether this attribute is required
   *
   * @return If this attribute is required, returns true, false otherwise
   */
  public Boolean getRequired() {
    return required;
  }

  /**
   * Sets indicator whether this attribute is required
   *
   * @param required If this attribute is required, then true, false otherwise
   */
  public void setRequired(Boolean required) {
    this.required = required;
  }

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

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

  /**
   * Gets attribute priority
   * 
   * @return Returns attribute priority
   */
  public Integer getPriority() {
    return priority;
  }

  /**
   * Sets attribute priority
   * 
   * @param priority Attribute priority
   */
  public void setPriority(Integer priority) {
    this.priority = priority;
  }
  
  /**
   * Compares attributes according to priority
   * 
   * @param o Object to compare with
   * @return Returns a negative integer, zero, or a positive integer as this 
   *         object is less than, equal to, or greater than the specified object. 
   */
  @Override
  public int compareTo(Object o) {
    if (o == null) {
      return 1;
    }
    if (!(o instanceof AnnotTypeAttr)) {
      throw new UnsupportedOperationException("Not supported yet.");
    }
    AnnotTypeAttr other = (AnnotTypeAttr) o;
    if (this.priority == null && other.getPriority() == null) {
      return 0;
    }
    if (this.priority == null && other.getPriority() != null) {
      return -1;
    }
    if (this.priority != null && other.getPriority() == null) {
      return 1;
    }
    return this.priority.compareTo(other.getPriority());
  }
  
  @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 AnnotTypeAttr)) {
      return false;
    }
    AnnotTypeAttr other = (AnnotTypeAttr) object;
    if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
      return false;
    }
    return true;
  }

  /**
   * Compares this with other object and returns, whether objects are same type
   * and have same content (id is irelevant).
   *
   * @param obj Object to compare with
   * @return If object is same type and have same content, returns true, false otherwise
   */
  public boolean contentEquals(Object obj) {
    if (obj == null) {
      return false;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    final AnnotTypeAttr other = (AnnotTypeAttr) obj;
    if (this.annotType != other.annotType) {
      return false;
    }
    if ((this.name == null) ? (other.name != null) : !this.name.equals(other.name)) {
      return false;
    }
    if ((this.simpleType == null) ? (other.simpleType != null) : !this.simpleType.equals(other.simpleType)) {
      return false;
    }
    if (this.type != other.type && (this.type == null || !this.type.equals(other.type))) {
      return false;
    }
    if (this.required != other.required && (this.required == null || !this.required.equals(other.required))) {
      return false;
    }
    if (this.annotationType != other.annotationType && (this.annotationType == null || !this.annotationType.equals(other.annotationType))) {
      return false;
    }
    if (this.attributeType != other.attributeType && (this.attributeType == null || !this.attributeType.equals(other.attributeType))) {
      return false;
    }
    if (this.comment == null ? other.comment != null : !this.comment.equals(other.comment)) {
      return false;
    }
    if (this.priority == null ? other.priority != null : !this.priority.equals(other.priority)) {
      return false;
    }
    return true;
  }

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

  /**
   * Returns serialized informations about attribute of simple type in XML
   *
   * @param withComment If true, comment will be serialized, if false, it will be omitted
   * @return Returns serialized informations about attribute of simple type in XML
   */
  private String simpleTypeToString(boolean withComment) {
    String rq = "";
    if (required) {
      rq = " required=\"true\"";
    }
    String serializedCom = "/";
    if (withComment && comment != null && !comment.isEmpty()) {
      serializedCom = "><a:comment>"
                    + "<![CDATA["
                    + comment
                    + "]]>"
                    + "</a:comment></a:attribute";
    }
    
    try {
        BaseAttribute buf = AttributeManager.createAttribute(name, simpleType, null);
        if (!(buf instanceof AnyAnnotationAttribute) || withComment)
            return "<a:attribute name=\"" + name + "\" type=\"" + buf.getSimpleType() + "\"" + rq + serializedCom + ">";
        return "";
    } catch (ClassNotFoundException e) {
        return "";
    }
  }

  /**
   * Returns serialized informations about attribute of type of annotation in XML
   *
   * @param withComment If true, comment will be serialized, if false, it will be omitted
   * @return Returns serialized informations about attribute of type of annotation in XML
   */
  public String toXMLString(boolean withComment) {
    if (simpleType == null || simpleType.isEmpty()) {
      String rq = "";
      if (required) {
        rq = " required=\"true\"";
      }
      String serializedCom = "/";
      if (withComment && comment != null && !comment.isEmpty()) {
        serializedCom = "><a:comment>"
        + "<![CDATA["
        + comment
        + "]]>"
        + "</a:comment></a:attribute";
      }
      return "<a:attribute name=\"" + name + "\" type=\"" + attributeType.getUri() 
             + "\"" + rq + serializedCom + ">";
    }
    return simpleTypeToString(withComment);
  }
  
  /**
   * Gets type of value of attribute for protocol v. 2.0
   * 
   * @return Returns type of value of attribute for protocol v 2.0
   */
  public String getValueType() {
    if (this.simpleType == null) {
      return "linked";
    }
    if(this.simpleType.equalsIgnoreCase("annotationLink")){
      return "linked";
    } else if (this.simpleType.equalsIgnoreCase("nestedAnnotation")) {
      return "nested";
    } else {
      return "simple";
    }
  }
  
  /**
   * Gets URI of type of attribute for protocol v. 2.0
   * 
   * @return REturns URI of type of attribute for protocol v. 2.0
   */
  public String getTypeUriV2() {
    int typeIndex = Constants.SIMPLE_TYPES_NAMES_V2.indexOf(simpleType);
    if (typeIndex != -1) {
      return Constants.SIMPLE_TYPES_URI_V2.get(typeIndex);
    } else {
      return this.attributeType.getUri();
    }
  }
  
  /**
   * Returns serialized informations about attribute of type of annotation in XML
   *
   * @param withComment If true, comment will be serialized, if false, it will be omitted
   * @return Returns serialized informations about attribute of type of annotation in XML
   */
  public String toXMLStringV2(boolean withComment){
    StringBuilder serializedAnnotTypeAttr = new StringBuilder();
    
    // make comment
    StringBuilder serializedCom = null;
    if (withComment && this.comment != null && !this.comment.isEmpty()) {
      serializedCom = new StringBuilder();
      serializedCom.append("<comment><![CDATA[");
      serializedCom.append(this.comment);
      serializedCom.append("]]></comment>");
    }
    
    if (simpleType != null && !simpleType.isEmpty()) {
      // is simple type
      serializedAnnotTypeAttr.append("<attribute valueType=\"");
      serializedAnnotTypeAttr.append(getValueType());
      serializedAnnotTypeAttr.append("\" name=\"");
      serializedAnnotTypeAttr.append(this.name);
      serializedAnnotTypeAttr.append("\" typeUri=\"");
      serializedAnnotTypeAttr.append(getTypeUriV2());
      serializedAnnotTypeAttr.append("\" required=\"");
      serializedAnnotTypeAttr.append(this.required.toString());
      serializedAnnotTypeAttr.append("\"");
      if(this.uriInOntology != null && !this.uriInOntology.isEmpty()){
        serializedAnnotTypeAttr.append(" ontologyUri=\"");
        serializedAnnotTypeAttr.append(this.uriInOntology);
        serializedAnnotTypeAttr.append("\"");
      }
      if(serializedCom == null){
        serializedAnnotTypeAttr.append("/>");
      }else{
        serializedAnnotTypeAttr.append(">");
        serializedAnnotTypeAttr.append(serializedCom.toString());
        serializedAnnotTypeAttr.append("</attribute>");
      }
      
      return serializedAnnotTypeAttr.toString();
    } else {
      // is other annotation type
      serializedAnnotTypeAttr.append("<attribute valueType=\"");
      serializedAnnotTypeAttr.append(getValueType());
      serializedAnnotTypeAttr.append("\" name=\"");
      serializedAnnotTypeAttr.append(this.name);
      serializedAnnotTypeAttr.append("\" typeUri=\"");
      serializedAnnotTypeAttr.append(this.attributeType.getUri());
      serializedAnnotTypeAttr.append("\" required=\"");
      serializedAnnotTypeAttr.append(this.required.toString());
      serializedAnnotTypeAttr.append("\"");
      if(this.uriInOntology != null && !this.uriInOntology.isEmpty()){
        serializedAnnotTypeAttr.append(" ontologyUri=\"");
        serializedAnnotTypeAttr.append(this.uriInOntology);
        serializedAnnotTypeAttr.append("\"");
      }
      if(serializedCom == null){
        serializedAnnotTypeAttr.append("/>");
      }else{
        serializedAnnotTypeAttr.append(">");
        serializedAnnotTypeAttr.append(serializedCom.toString());
        serializedAnnotTypeAttr.append("</attribute>");
      }
      
      return serializedAnnotTypeAttr.toString();
    }
  }  // toXMLStringV2()

}  // class AnnotTypeAttr