root/trunk/cdmlib/cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/TermVocabulary.java

/**
* Copyright (C) 2007 EDIT
* European Distributed Institute of Taxonomy 
* http://www.e-taxonomy.eu
* 
* The contents of this file are subject to the Mozilla Public License Version 1.1
* See LICENSE.TXT at the top of this package for the full license terms.
*/

package eu.etaxonomy.cdm.model.common;


import java.net.URI;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.UUID;

import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.OneToMany;
import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlIDREF;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSchemaType;
import javax.xml.bind.annotation.XmlType;

import org.apache.log4j.Logger;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
import org.hibernate.annotations.Type;
import org.hibernate.envers.Audited;
import org.hibernate.search.annotations.Field;
import org.hibernate.search.annotations.Indexed;
import org.hibernate.search.annotations.IndexedEmbedded;
import org.hibernate.validator.constraints.Length;


/**
 * A single enumeration must only contain DefinedTerm instances of one kind
 * (this means a subclass of DefinedTerm).
 * @author m.doering
 * @version 1.0
 * @created 08-Nov-2007 13:06:23
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "TermVocabulary", propOrder = {
    "termSourceUri",
    "terms"
})
@XmlRootElement(name = "TermVocabulary")
@Entity
@Indexed(index = "eu.etaxonomy.cdm.model.common.TermVocabulary")
@Audited
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
public class TermVocabulary<T extends DefinedTermBase> extends TermBase implements Iterable<T> {
        private static final long serialVersionUID = 1925052321596648672L;
        private static final Logger logger = Logger.getLogger(TermVocabulary.class);

        //The vocabulary source (e.g. ontology) defining the terms to be loaded when a database is created for the first time.  
        // Software can go and grap these terms incl labels and description. 
        // UUID needed? Further vocs can be setup through our own ontology.
        @XmlElement(name = "TermSourceURI")
        @Field(index=org.hibernate.search.annotations.Index.UN_TOKENIZED)
        @Length(max = 255)
        @Type(type="uriUserType")
        private URI termSourceUri;
        

        //TODO Changed
        @XmlElementWrapper(name = "Terms")
        @XmlElement(name = "Term")
    @XmlIDREF
    @XmlSchemaType(name = "IDREF")
    @OneToMany(mappedBy="vocabulary", fetch=FetchType.LAZY, targetEntity = DefinedTermBase.class)
        @Type(type="DefinedTermBase")
        @Cascade({CascadeType.SAVE_UPDATE, CascadeType.MERGE})
        @IndexedEmbedded(depth = 2)
        protected Set<T> terms = getNewTermSet();
        
// ********************************* FACTORY METHODS *****************************************/

        public static TermVocabulary NewInstance(String description, String label, String abbrev, URI termSourceUri){
                return new TermVocabulary(description, label, abbrev, termSourceUri);
        }
        
// ************************* CONSTRUCTOR *************************************************      

        protected TermVocabulary() {
        }
        
        protected TermVocabulary(String term, String label, String labelAbbrev, URI termSourceUri) {
                super(term, label, labelAbbrev);
                setTermSourceUri(termSourceUri);
        }
        

// ******************* METHODS *************************************************/       
        
        public T findTermByUuid(UUID uuid){
                for(T t : terms) {
                        if(t.getUuid().equals(uuid)) {
                                return t;
                        }
                }
                return null;
        }

        @Transient
        Set<T> getNewTermSet() {
                return new HashSet<T>();
        }

        public Set<T> getTerms() {
                return terms;
        }
        
        public void addTerm(T term) {
                term.setVocabulary(this);
                this.terms.add(term);
        }
        public void removeTerm(T term) {
                this.terms.remove(term);
                term.setVocabulary(null);
        }

        public URI getTermSourceUri() {
                return termSourceUri;
        }
        public void setTermSourceUri(URI vocabularyUri) {
                this.termSourceUri = vocabularyUri;
        }
        
        
        public Iterator<T> iterator() {
                return terms.iterator();  // OLD: new TermIterator<T>(this.terms);
        }
        
        public int size(){
                return terms.size();
        }
        
        
        /**
         * Returns all terms of this vocabulary sorted by their representation defined by the given language.
         * If such an representation does not exist, the representation of the default language is testing instead for ordering.
         * @param language
         * @return
         */
        public SortedSet<T> getTermsOrderedByLabels(Language language){
                TermLanguageComparator<T> comp = new TermLanguageComparator<T>();
                comp.setCompareLanguage(language);
                
                SortedSet<T> result = new TreeSet<T>(comp);
                result.addAll(getTerms());
                return result;
        }
        
        
        /* (non-Javadoc)
         * @see eu.etaxonomy.cdm.model.common.ILoadableTerm#readCsvLine(java.util.List)
         */
        public TermVocabulary<T> readCsvLine(List<String> csvLine) {
                return readCsvLine(csvLine, Language.CSV_LANGUAGE());
        }
        
        public TermVocabulary<T> readCsvLine(List<String> csvLine, Language lang) {
                this.setUuid(UUID.fromString(csvLine.get(0)));
                this.setUri(URI.create(csvLine.get(1)));
                //this.addRepresentation(Representation.NewInstance(csvLine.get(3), csvLine.get(2).trim(), lang) );
                return this;
        }
        
//*********************** CLONE ********************************************************/
        
        /** 
         * Clones <i>this</i> TermVocabulary. This is a shortcut that enables to create
         * a new instance that differs only slightly from <i>this</i> TermVocabulary.
         * The terms of the original vocabulary are cloned
         * 
         * @see eu.etaxonomy.cdm.model.common.TermBase#clone()
         * @see java.lang.Object#clone()
         */
        @Override
        public Object clone() {
                TermVocabulary result;
                try {
                        result = (TermVocabulary) super.clone();
                        
                }catch (CloneNotSupportedException e) {
                        logger.warn("Object does not implement cloneable");
                        e.printStackTrace();
                        return null;
                }
                result.terms = new HashSet<T>();
                for (T term: this.terms){
                        result.addTerm((T)term.clone());
                }
                
                return result;
        }
    
}