TypeAttrOnto.java

Go to the documentation of this file.

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

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

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

import com.hp.hpl.jena.graph.query.Expression;
import cz.vutbr.fit.knot.annotations.app.Constants;
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.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToOne;
import javax.persistence.Table;

/**
 * Class representing attribute of unknown type of annotation imported from ontology
 *
 * @brief Class representing attribute of unknown type of annotation
 * @author idytrych
 */
@Entity
@Table(name = "typeAttrOnto")
@NamedQueries({
  @NamedQuery(name = "TypeAttrOnto.findAll", query = "SELECT a FROM TypeAttrOnto a"),
  @NamedQuery(name = "TypeAttrOnto.findById", query = "SELECT a FROM TypeAttrOnto a WHERE a.id = :id"),
  @NamedQuery(name = "TypeAttrOnto.findByUserGroup", query = "SELECT a FROM TypeAttrOnto a WHERE a.groupId = :groupId"),
  @NamedQuery(name = "TypeAttrOnto.findByName", query = "SELECT a FROM TypeAttrOnto a WHERE a.name = :name"),
  @NamedQuery(name = "TypeAttrOnto.findByNameAndGroup", query = "SELECT a FROM TypeAttrOnto a WHERE a.name = :name AND a.groupId = :groupId"),
  @NamedQuery(name = "TypeAttrOnto.findBySimpleType", query = "SELECT a FROM TypeAttrOnto a WHERE a.simpleType = :simpleType"),
  @NamedQuery(name = "TypeAttrOnto.findByType", query = "SELECT a FROM TypeAttrOnto a WHERE a.type = :type")})
public class TypeAttrOnto implements Serializable {
  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 user group to which this attribute belongs */
  @Basic(optional = true)
  @Column(name = "groupId", insertable=false, updatable=false)
  private Integer groupId;
  /** 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;
  /** URI in original ontology */
  @Basic(optional = true)
  @Column(name = "uriInOntology")
  private String uriInOntology;
  /** Comment */
  @Basic(optional = true)
  @Lob
  @Column(name = "commentary")
  private String comment;

  /** 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;
  /** User group to which this attribute belongs */
  @OneToOne(optional = true)
  @JoinColumn(name = "groupId", referencedColumnName = "id")
  private UserGroup group;

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

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

  /**
   * Constructor of attribute of simple type
   *
   * @param group User group to which attribute belongs
   * @param name Name of attribute
   * @param simpleType Name of simple type of attribute
   */
  public TypeAttrOnto(UserGroup group, String name, String simpleType) {
    this.group = group;
    this.name = name;
    this.simpleType = simpleType;
    this.type = null;
    this.attributeType = null;
    this.uriInOntology = null;
    this.comment = null;
  }

  /**
   * Constructor of attribute of structured type
   *
   * @param group User group to which attribute belongs
   * @param name Name of attribute
   * @param structuredType Type of structured attribute (type of annotation)
   */
  public TypeAttrOnto(UserGroup group, String name, AnnotType structuredType) {
    this.group = group;
    this.name = name;
    this.simpleType = null;
    this.type = structuredType.getId();
    this.attributeType = structuredType;
    this.uriInOntology = null;
    this.comment = null;
  }

  /**
   * 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 user group to which attribute belongs
   *
   * @return Returns user group to which attribute belongs
   */
  public UserGroup getGroup() {
    return group;
  }

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

  /**
   * 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 new type
   */
  public void setType(Integer type) {
    this.type = type;
  }

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

  @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 TypeAttrOnto)) {
      return false;
    }
    TypeAttrOnto other = (TypeAttrOnto) 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 TypeAttrOnto other = (TypeAttrOnto) obj;
    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.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;
    }
    return true;
  }

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

  /**
   * Returns serialized informations about attribute of simple type in XML
   *
   * @return Returns serialized informations about attribute of simple type in XML
   */
  private String simpleTypeToString() {
    String serializedCom = "/";
    if (comment != null && !comment.isEmpty()) {
      serializedCom = "><a:comment>"
                    + "<![CDATA["
                    + comment
                    + "]]>"
                    + "</a:comment></a:attribute";
    }
    String grStr = "";
    if (group != null) {
      grStr = " group=\"" + group.getUri() + "\"";
    }
    
    try {
        BaseAttribute buf = AttributeManager.createAttribute(name, simpleType, null);
        return "<a:attribute name=\"" + name + "\" type=\"" + buf.getSimpleType() + "\"" + grStr + serializedCom + ">";
    } 
    // attribute not found
    catch (ClassNotFoundException e) {
        return "";
    }
  }

  /**
   * Returns serialized informations about attribute of type of annotation in XML
   *
   * @return Returns serialized informations about attribute of type of annotation in XML
   */
  public String toXMLString() {
    if (simpleType == null || simpleType.isEmpty()) {
      String serializedCom = "/";
      if (comment != null && !comment.isEmpty()) {
        serializedCom = "><a:comment>"
        + "<![CDATA["
        + comment
        + "]]>"
        + "</a:comment></a:attribute";
      }
      String grStr = "";
      if (group != null) {
        grStr = " group=\"" + group.getUri() + "\"";
      }
      return "<a:attribute name=\"" + name + "\" type=\"" + attributeType.getUri()
             + "\"" + grStr + serializedCom + ">";
    }
    return simpleTypeToString();
  }

  /**
   * Returns serialized informations about attribute of type of annotation in XML for protocol V2
   *
   * @return Returns serialized informations about attribute of type of annotation in XML for protocol V2
   */
  public String toXMLStringV2(){
    StringBuilder result = new StringBuilder();
    
    result.append("<attribute name=\"");
    result.append(name);
    result.append("\" uri=\"");
    result.append(uriInOntology);
    result.append("\" typeUri=\"");
    
    if(simpleType != null && !simpleType.isEmpty()){
      if(Constants.SIMPLE_TYPES_NAMES_V2.contains(simpleType)){
          Integer post = Constants.SIMPLE_TYPES_NAMES_V2.indexOf(simpleType);
          result.append(Constants.SIMPLE_TYPES_URI_V2.get(post));
      }else{
          result.append(simpleType);
      }
    }
    else{
      result.append(attributeType.getUri());
    }
    
    result.append("\"");
    
    if (group != null) {
      result.append(" groupUri=\"");
      result.append(group.getUri());
      result.append("\"");
    }
    
    if (comment != null && !comment.isEmpty()) {
        result.append("><comment><![CDATA[");
        result.append(comment);
        result.append("]]></comment></attribute>");
    }else{
        result.append("/>");
    }
    
    return result.toString();
  }

}  // class TypeAttrOnto