EDIT

/**

* Copyright (C) 2007 EDIT

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.model.common;

import java.beans.PropertyChangeListener;

import javax.persistence.OneToMany;

import javax.validation.constraints.Size;

import javax.xml.bind.annotation.XmlAccessorType;

import javax.xml.bind.annotation.XmlElement;

import javax.xml.bind.annotation.XmlElementWrapper;

import javax.xml.bind.annotation.XmlTransient;

import javax.xml.bind.annotation.XmlType;

import org.hibernate.annotations.Cascade;

import org.hibernate.annotations.CascadeType;

import org.hibernate.search.annotations.Analyze;

import eu.etaxonomy.cdm.jaxb.LSIDAdapter;

import eu.etaxonomy.cdm.strategy.merge.MergeMode;

/**

 * All subclasses inherit the ability to store additional properties that are stored as {@link Extension Extensions}, basically a string value with a type term.

 * A Taxon for example that was taken from 2 sources like FaunaEuropaea and IPNI would have two originalSource objects.

 * The originalSource representing that taxon as it was found in IPNI would contain IPNI as the reference, the IPNI id of the taxon and the name of the taxon exactly as it was used in IPNI.

 * @version 1.0

 * @created 08-Nov-2007 13:06:27

 */

@XmlType(name = "IdentifiableEntity", propOrder = {

    "lsid",

    "titleCache",

    "protectedTitleCache",

    "rights",

    "extensions",

})

        implements IIdentifiableEntity /*, ISourceable<IdentifiableSource> */ {

    private static final long serialVersionUID = -5610995424730659058L;

    private static final Logger logger = Logger.getLogger(IdentifiableEntity.class);

    @XmlTransient

    public static final boolean PROTECTED = true;

    @XmlTransient

    public static final boolean NOT_PROTECTED = false;

    @XmlElement(name = "LSID", type = String.class)

    @XmlJavaTypeAdapter(LSIDAdapter.class)

    @Embedded

    private LSID lsid;

    @XmlElement(name = "TitleCache", required = true)

    @XmlJavaTypeAdapter(FormattedTextAdapter.class)

    @Column(length=255, name="titleCache")

    @Match(value=MatchMode.CACHE, cacheReplaceMode=ReplaceMode.ALL)

    @NotEmpty(groups = Level2.class) // implictly NotNull

        @Field(store=Store.YES),

    //if true titleCache will not be automatically generated/updated

    @XmlElement(name = "ProtectedTitleCache")

    protected boolean protectedTitleCache;

    @Cascade({CascadeType.SAVE_UPDATE, CascadeType.MERGE, CascadeType.DELETE})

    @Merge(MergeMode.ADD_CLONE)

    @NotNull

    private Set<Rights> rights = new HashSet<Rights>();

    @Cascade({CascadeType.SAVE_UPDATE, CascadeType.MERGE, CascadeType.DELETE})

    @NotNull

    private List<Credit> credits = new ArrayList<Credit>();

    @Cascade({CascadeType.SAVE_UPDATE, CascadeType.MERGE, CascadeType.DELETE})

    @NotNull

    private Set<Extension> extensions = new HashSet<Extension>();

    @Cascade({CascadeType.SAVE_UPDATE, CascadeType.MERGE, CascadeType.DELETE})

    @NotNull

    private Set<IdentifiableSource> sources = new HashSet<IdentifiableSource>();

    protected S cacheStrategy;

                    titleCache = null;

                }

            }

        };

        addPropertyChangeListener(listener);

    }

    /**

     * By default, we expect most cdm objects to be abstract things

     * i.e. unable to return a data representation.

     *

     * Specific subclasses (e.g. Sequence) can override if necessary.

     */

    }

//******************************** CACHE *****************************************************/

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#getTitleCache()

     */

    // @Transient  - must not be transient, since this property needs to to be included in all serializations produced by the remote layer

            return this.titleCache;

        }

        // is title dirty, i.e. equal NULL?

        if (titleCache == null){

            this.titleCache = generateTitle();

            this.titleCache = getTruncatedCache(this.titleCache) ;

        }

        return titleCache;

    }

     * @return <code>true</code> if title cache was regenerated, <code>false</code> otherwise

        if (!protectedTitleCache) {

            this.titleCache = null;

            getTitleCache();

        }

        return protectedTitleCache;

    }

    @Deprecated

    	this.titleCache = getTruncatedCache(titleCache);

        this.titleCache = titleCache;

        this.protectedTitleCache = protectCache;

    }

    /**

     * @param cache

     * @return

     */

    @Transient

    protected String getTruncatedCache(String cache) {

    	if (cache != null && cache.length() > maxLength){

        return cache;

    }

    }

            this.rights = new HashSet<Rights>();

        }

        return this.rights;

    }

    }

    }

            this.credits = new ArrayList<Credit>();

        }

        return this.credits;

    }

    }

    }

    }

    }

    }

            this.extensions = new HashSet<Extension>();

        }

        return this.extensions;

    }

     * @param type

     * @return a Set of extension value strings

     */

       return getExtensions(type.getUuid());

    }

     * @param extensionTypeUuid

     * @return a Set of extension value strings

     */

        for (Extension extension : getExtensions()){

            if (extension.getType().getUuid().equals(extensionTypeUuid)){

                result.add(extension.getValue());

            }

        }

    }

    public void addExtension(String value, ExtensionType extensionType){

        Extension.NewInstance(this, value, extensionType);

    }

            extension.setExtendedObj(this);

            getExtensions().add(extension);

        }

    }

            extension.setExtendedObj(null);

            getExtensions().remove(extension);

        }

    }

    }

    }

            this.sources = new HashSet<IdentifiableSource>();

        }

        return this.sources;

    }

                oldSourcedObj.getSources().remove(source);

            }

            getSources().add(source);

            source.setSourcedObj(this);

        }

    }

            return null;

        }

        addSource(source);

        return source;

    }

    @Override

    public IdentifiableSource addImportSource(String id, String idNamespace, Reference<?> citation, String microCitation) {

        if (id == null && idNamespace == null && citation == null && microCitation == null){

            return null;

        }

        IdentifiableSource source = IdentifiableSource.NewInstance(OriginalSourceType.Import, id, idNamespace, citation, microCitation);

        return source;

    }

    }

//******************************** TO STRING *****************************************************/

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#toString()

     */

     @Override

    public String toString() {

        String result;

        if (titleCache == null){

            result = super.toString();

        }else{

            result = this.titleCache;

        }

        return result;

    }

    public int compareTo(IdentifiableEntity identifiableEntity) {

         int result = 0;

         if (identifiableEntity == null) {

             throw new NullPointerException("Cannot compare to null.");

         }

         // First, compare the name cache.

         // TODO: Avoid using instanceof operator

         // Use Class.getDeclaredMethod() instead to find out whether class has getNameCache() method?

         String specifiedNameCache = "";

         String thisNameCache = "";

         String specifiedTitleCache = "";

         String thisTitleCache = "";

         String specifiedReferenceTitleCache = "";

         String thisReferenceTitleCache = "";

         String thisGenusString = "";

         String specifiedGenusString = "";

         int thisrank_order = 0;

         identifiableEntity = HibernateProxyHelper.deproxy(identifiableEntity, IdentifiableEntity.class);

             specifiedNameCache = HibernateProxyHelper.deproxy(identifiableEntity, NonViralName.class).getNameCache();

             specifiedTitleCache = identifiableEntity.getTitleCache();

            	 if (((BotanicalName)identifiableEntity).isAutonym()){

            		 boolean isProtected = false;

            		 String oldNameCache = ((BotanicalName) identifiableEntity).getNameCache();

            		 if ( ((BotanicalName)identifiableEntity).isProtectedNameCache()){

            			 isProtected = true;

            		 }

            		 ((BotanicalName)identifiableEntity).setProtectedNameCache(false);

            		 ((BotanicalName)identifiableEntity).setNameCache(null, false);

            		 specifiedNameCache = ((BotanicalName) identifiableEntity).getNameCache();

            		 ((BotanicalName)identifiableEntity).setNameCache(oldNameCache, isProtected);

            	 }

             }

         } else if(identifiableEntity instanceof TaxonBase) {

             TaxonBase taxonBase = HibernateProxyHelper.deproxy(identifiableEntity, TaxonBase.class);

             TaxonNameBase<?,?> taxonNameBase = taxonBase.getName();

             NonViralName nonViralName = HibernateProxyHelper.deproxy(taxonNameBase, NonViralName.class);

             specifiedNameCache = nonViralName.getNameCache();

             specifiedTitleCache = taxonNameBase.getTitleCache();

             specifiedReferenceTitleCache = ((TaxonBase)identifiableEntity).getSec().getTitleCache();

             Reference reference = taxonBase.getSec();

             if (reference != null) {

                 reference = HibernateProxyHelper.deproxy(reference, Reference.class);

                 specifiedReferenceTitleCache = reference.getTitleCache();

             }

         }

             thisTitleCache = getTitleCache();

             if (this instanceof BotanicalName){

            	 if (((BotanicalName)this).isAutonym()){

            		 boolean isProtected = false;

            		 String oldNameCache = ((BotanicalName) this).getNameCache();

            		 if ( ((BotanicalName)this).isProtectedNameCache()){

            			 isProtected = true;

            		 }

            		 ((BotanicalName)this).setProtectedNameCache(false);

            		 ((BotanicalName)this).setNameCache(null, false);

            		 thisNameCache = ((BotanicalName) this).getNameCache();

            		 ((BotanicalName)this).setNameCache(oldNameCache, isProtected);

            	 }

             }

             NonViralName nonViralName = HibernateProxyHelper.deproxy(taxonNameBase, NonViralName.class);

             thisNameCache = nonViralName.getNameCache();

             thisTitleCache = taxonNameBase.getTitleCache();

         }

         // Compare name cache of taxon names

         if (!specifiedNameCache.equals("") && !thisNameCache.equals("")) {

             result = thisNameCache.compareTo(specifiedNameCache);

         }

         // Compare title cache of taxon names

         if ((result == 0) && (!specifiedTitleCache.equals("") || !thisTitleCache.equals(""))) {

             result = thisTitleCache.compareTo(specifiedTitleCache);

         }

         // Compare title cache of taxon references

         if ((result == 0) && (!specifiedReferenceTitleCache.equals("") || !thisReferenceTitleCache.equals(""))) {

             result = thisReferenceTitleCache.compareTo(specifiedReferenceTitleCache);

         }

         return result;

     }

        /**

         * Returns the {@link eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy cache strategy} used to generate

         * several strings corresponding to <i>this</i> identifiable entity

         * (in particular taxon name caches and author strings).

         *

         * @return  the cache strategy used for <i>this</i> identifiable entity

         * @see     eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy

         */

        public S getCacheStrategy() {

            return this.cacheStrategy;

        }

        /**

         * @see 	#getCacheStrategy()

         */

        public void setCacheStrategy(S cacheStrategy) {

            this.cacheStrategy = cacheStrategy;

        }

                return this.getClass() + ": " + this.getUuid();

            }else{

        }

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.model.common.AnnotatableEntity#clone()

     */

    @Override

    public Object clone() throws CloneNotSupportedException{

        IdentifiableEntity result = (IdentifiableEntity)super.clone();

        //Extensions

        result.extensions = new HashSet<Extension>();

        for (Extension extension : getExtensions() ){

            Extension newExtension = (Extension)extension.clone();

            result.addExtension(newExtension);

        }

        //OriginalSources

        result.sources = new HashSet<IdentifiableSource>();

        for (IdentifiableSource source : getSources()){

            IdentifiableSource newSource = (IdentifiableSource)source.clone();

            result.addSource(newSource);

        }

        //Rights

        result.rights = new HashSet<Rights>();

        //Credits

        result.credits = new ArrayList<Credit>();

        //empty titleCache

        if (! protectedTitleCache){

            result.titleCache = null;

        }

        result.initListener();

        return result;

    }