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

/**
* Copyright (C) 2009 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 javax.persistence.FetchType;
import javax.persistence.MappedSuperclass;
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.XmlSeeAlso;
import javax.xml.bind.annotation.XmlType;

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

import eu.etaxonomy.cdm.model.description.FeatureTree;
import eu.etaxonomy.cdm.model.description.TextData;
import eu.etaxonomy.cdm.strategy.cache.common.TermDefaultCacheStrategy;
import eu.etaxonomy.cdm.validation.annotation.NullOrNotEmpty;

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "TermBase", propOrder = {
    "uri",
    "representations"
})
@XmlSeeAlso({
        DefinedTermBase.class,
        TermVocabulary.class,
        FeatureTree.class
})
@MappedSuperclass
public abstract class TermBase extends IdentifiableEntity{
        private static final long serialVersionUID = 1471561531632115822L;
        @SuppressWarnings("unused")
        private static final Logger logger = Logger.getLogger(TermBase.class);
        
        @XmlElement(name = "URI")
        @Field(index=org.hibernate.search.annotations.Index.UN_TOKENIZED)
        @NullOrNotEmpty
        @Length(max = 255)
        @Type(type="uriUserType")
        private URI uri;
        
        @XmlElementWrapper(name = "Representations")
        @XmlElement(name = "Representation")
    @OneToMany(fetch=FetchType.EAGER)
        @Cascade( { CascadeType.SAVE_UPDATE, CascadeType.MERGE, CascadeType.DELETE, CascadeType.DELETE_ORPHAN})
        @IndexedEmbedded(depth = 2)
        private Set<Representation> representations = new HashSet<Representation>();
        
        public TermBase(){
                super();
                initCacheStrategy();
                
        }
        private void initCacheStrategy() {
                this.cacheStrategy = new TermDefaultCacheStrategy<TermBase>();
        }
        public TermBase(String term, String label, String labelAbbrev) {
                super();
                this.addRepresentation(new Representation(term, label, labelAbbrev, Language.DEFAULT()) );
                initCacheStrategy();
        }

        public Set<Representation> getRepresentations() {
                return this.representations;
        }

        public void addRepresentation(Representation representation) {
                this.representations.add(representation);
        }

        public void removeRepresentation(Representation representation) {
                this.representations.remove(representation);
        }

        public Representation getRepresentation(Language lang) {
                for (Representation repr : representations){
                        Language reprLanguage = repr.getLanguage();
                        if (reprLanguage != null && reprLanguage.equals(lang)){
                                return repr;
                        }
                }
                return null;
        }
        
        /**
         * @see #getPreferredRepresentation(Language)
         * @param language
         * @return
         */
        public Representation getPreferredRepresentation(Language language) {
                Representation repr = getRepresentation(language); 
                if(repr == null){
                        repr = getRepresentation(Language.DEFAULT());
                }
                if(repr == null){
                        repr = getRepresentations().iterator().next();
                }
                return repr;
        }
        
        /**
         * Returns the Representation in the preferred language. Preferred languages
         * are specified by the parameter languages, which receives a list of
         * Language instances in the order of preference. If no representation in
         * any preferred languages is found the method falls back to return the
         * Representation in Language.DEFAULT() and if necessary further falls back
         * to return the first element found if any.
         * 
         * TODO think about this fall-back strategy & 
         * see also {@link TextData#getPreferredLanguageString(List)}
         * 
         * @param languages
         * @return
         */
        public Representation getPreferredRepresentation(List<Language> languages) {
                Representation repr = null;
                if(languages != null){
                        for(Language language : languages) {
                                repr = getRepresentation(language); 
                                if(repr != null){
                                        return repr;
                                }
                        }
                }
                if(repr == null){
                        repr = getRepresentation(Language.DEFAULT());
                }
                if(repr == null){
                        Iterator<Representation> it = getRepresentations().iterator();
                        if(it.hasNext()){
                                repr = getRepresentations().iterator().next();
                        }
                }
                return repr;
        }

        public URI getUri() {
                return this.uri;
        }

        public void setUri(URI uri) {
                this.uri = uri;
        }

        /* (non-Javadoc)
         * @see eu.etaxonomy.cdm.model.common.ITerm#getLabel()
         */
        @Transient
        public String getLabel() {
                if(getLabel(Language.DEFAULT())!=null){
                        Representation repr = getRepresentation(Language.DEFAULT());
                        return (repr == null)? null :repr.getLabel();
                }else{
                        for (Representation r : representations){
                                return r.getLabel();
                        }                       
                }
                return super.getUuid().toString();
        }
        
        /* (non-Javadoc)
         * @see eu.etaxonomy.cdm.model.common.ITerm#getLabel(eu.etaxonomy.cdm.model.common.Language)
         */
        public String getLabel(Language lang) {
                Representation repr = this.getRepresentation(lang);
                return (repr == null) ? null : repr.getLabel();
        }       
        
        public void setLabel(String label){
                Language lang = Language.DEFAULT();
                setLabel(label, lang);
        }

        public void setLabel(String label, Language language){
                if (language != null){
                        Representation repr = getRepresentation(language);
                        if (repr != null){
                                repr.setLabel(label);
                        }else{
                                repr = Representation.NewInstance(null, label, null, language);
                        }
                        this.addRepresentation(repr);
                }
        }

        /* (non-Javadoc)
         * @see eu.etaxonomy.cdm.model.common.ITerm#getDescription()
         */
        @Transient
        public String getDescription() {
                return this.getDescription(Language.DEFAULT());
        }

        /* (non-Javadoc)
         * @see eu.etaxonomy.cdm.model.common.ITerm#getDescription(eu.etaxonomy.cdm.model.common.Language)
         */
        public String getDescription(Language lang) {
                Representation repr = this.getRepresentation(lang);
                return (repr == null) ? null :repr.getDescription();
        }

        @Override
        public boolean equals(Object obj) {
                if (obj == null){
                        return false;
                }
                if (TermBase.class.isAssignableFrom(obj.getClass())){
                        TermBase dtb = (TermBase)obj;
                        if (dtb.getUuid().equals(this.getUuid())){
                                return true;
                        }
                }
                return false;
        }

        @Override
        public String toString() {
                //TODO eliminate nasty LazyInitializationException loggings
                try {
                        return super.toString(); 
                } catch (LazyInitializationException e) {
                        return super.toString()+" "+this.getUuid();
                }
        }
        
//*********************** CLONE ********************************************************/
        
        /** 
         * Clones <i>this</i> TermBase. This is a shortcut that enables to create
         * a new instance that differs only slightly from <i>this</i> TermBase by
         * modifying only some of the attributes.
         * 
         * @see eu.etaxonomy.cdm.model.common.IdentifiableEntity#clone()
         * @see java.lang.Object#clone()
         */
        @Override
        public Object clone()throws CloneNotSupportedException {
                
                TermBase result = (TermBase) super.clone();
                
                result.representations = new HashSet<Representation>();
                for (Representation rep : this.representations){
                        result.representations.add((Representation)rep.clone());
                }
                
                
                
                return result;
                
        }

}