EDIT

/**

* 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.name;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.FetchType;

import javax.persistence.Inheritance;

import javax.persistence.InheritanceType;

import javax.persistence.JoinColumn;

import javax.persistence.JoinTable;

import javax.persistence.ManyToMany;

import javax.persistence.ManyToOne;

import javax.persistence.OneToMany;

import javax.persistence.Transient;

import javax.validation.Valid;

import javax.validation.constraints.Min;

import javax.validation.constraints.NotNull;

import javax.validation.constraints.Pattern;

import javax.xml.bind.annotation.XmlAccessType;

import javax.xml.bind.annotation.XmlAccessorType;

import javax.xml.bind.annotation.XmlAttribute;

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.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.hibernate.annotations.Cascade;

import org.hibernate.annotations.CascadeType;

import org.hibernate.annotations.Table;

import org.hibernate.envers.Audited;

import org.hibernate.search.annotations.Analyze;

import org.hibernate.search.annotations.Analyzer;

import org.hibernate.search.annotations.Field;

import org.hibernate.search.annotations.Fields;

import org.hibernate.search.annotations.Index;

import org.hibernate.search.annotations.IndexedEmbedded;

import org.hibernate.search.annotations.Store;

import org.hibernate.validator.constraints.NotEmpty;

import org.springframework.util.ReflectionUtils;

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.cdm.model.agent.INomenclaturalAuthor;

import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.common.IParsable;

import eu.etaxonomy.cdm.model.common.IRelated;

import eu.etaxonomy.cdm.model.common.IdentifiableEntity;

import eu.etaxonomy.cdm.model.common.RelationshipBase;

import eu.etaxonomy.cdm.model.description.TaxonNameDescription;

import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;

import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.cdm.model.taxon.Synonym;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.model.taxon.TaxonBase;

import eu.etaxonomy.cdm.strategy.cache.TaggedText;

import eu.etaxonomy.cdm.strategy.cache.name.CacheUpdate;

import eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy;

import eu.etaxonomy.cdm.strategy.cache.name.INonViralNameCacheStrategy;

import eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy;

import eu.etaxonomy.cdm.strategy.match.IMatchable;

import eu.etaxonomy.cdm.strategy.match.Match;

import eu.etaxonomy.cdm.strategy.match.Match.ReplaceMode;

import eu.etaxonomy.cdm.strategy.match.MatchMode;

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

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

import eu.etaxonomy.cdm.strategy.parser.INonViralNameParser;

import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl;

import eu.etaxonomy.cdm.strategy.parser.ParserProblem;

import eu.etaxonomy.cdm.validation.Level2;

import eu.etaxonomy.cdm.validation.Level3;

import eu.etaxonomy.cdm.validation.annotation.NullOrNotEmpty;

import eu.etaxonomy.cdm.validation.annotation.ValidTaxonomicYear;

/**

 * The upmost (abstract) class for scientific taxon names regardless of any

 * particular {@link NomenclaturalCode nomenclature code}. The scientific taxon name does not depend

 * on the use made of it in a publication or a treatment

 * ({@link eu.etaxonomy.cdm.model.taxon.TaxonBase taxon concept respectively potential taxon})

 * as an {@link eu.etaxonomy.cdm.model.taxon.Taxon "accepted" respectively "correct" (taxon) name}

 * or as a {@link eu.etaxonomy.cdm.model.taxon.Synonym synonym}.

 * <P>

 * This class corresponds partially to: <ul>

 * <li> TaxonName according to the TDWG ontology

 * <li> ScientificName and CanonicalName according to the TCS

 * <li> ScientificName according to the ABCD schema

 * </ul>

 *

 * @author m.doering

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

 */

@XmlAccessorType(XmlAccessType.FIELD)

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

    "appendedPhrase",

    "nomenclaturalMicroReference",

    "nomenclaturalReference",

    "rank",

    "fullTitleCache",

    "protectedFullTitleCache",

    "homotypicalGroup",

    "typeDesignations",

    "relationsFromThisName",

    "relationsToThisName",

    "status",

    "descriptions",

    "taxonBases",

    "nameCache",

    "genusOrUninomial",

    "infraGenericEpithet",

    "specificEpithet",

    "infraSpecificEpithet",

    "combinationAuthorship",

    "exCombinationAuthorship",

    "basionymAuthorship",

    "exBasionymAuthorship",

    "authorshipCache",

    "protectedAuthorshipCache",

    "protectedNameCache",

    "hybridParentRelations",

    "hybridChildRelations",

    "hybridFormula",

    "monomHybrid",

    "binomHybrid",

    "trinomHybrid",

    "acronym",

    "subGenusAuthorship",

    "nameApprobation",

    "breed",

    "publicationYear",

    "originalPublicationYear"

//    "anamorphic",

})

@XmlRootElement(name = "TaxonNameBase")

@Entity

@Audited

@Inheritance(strategy=InheritanceType.SINGLE_TABLE)

@Table(appliesTo="TaxonNameBase", indexes = { @org.hibernate.annotations.Index(name = "taxonNameBaseTitleCacheIndex", columnNames = { "titleCache" }),  @org.hibernate.annotations.Index(name = "taxonNameBaseNameCacheIndex", columnNames = { "nameCache" }) })

public abstract class TaxonNameBase<T extends TaxonNameBase<?,?>, S extends INameCacheStrategy>

            extends IdentifiableEntity<S>

            implements ITaxonNameBase, INonViralName, IViralName, IBacterialName, IZoologicalName,

                IParsable, IRelated, IMatchable, Cloneable {

    private static final long serialVersionUID = -791164269603409712L;

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

    static private INonViralNameParser<?> nameParser = new NonViralNameParserImpl();

    @XmlElement(name = "FullTitleCache")

    @Column(length=800, name="fullTitleCache")  //see #1592

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

    @CacheUpdate(noUpdate ="titleCache")

    @NotEmpty(groups = Level2.class)

    protected String fullTitleCache;

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

    @XmlElement(name = "ProtectedFullTitleCache")

    @CacheUpdate(value ="fullTitleCache", noUpdate ="titleCache")

    private boolean protectedFullTitleCache;

    @XmlElementWrapper(name = "Descriptions")

    @XmlElement(name = "Description")

    @OneToMany(mappedBy="taxonName", fetch= FetchType.LAZY, orphanRemoval=true)

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

    @NotNull

    private Set<TaxonNameDescription> descriptions = new HashSet<TaxonNameDescription>();

    @XmlElement(name = "AppendedPhrase")

    @Field

    @CacheUpdate(value ="nameCache")

    //TODO Val #3379

//    @NullOrNotEmpty

    @Column(length=255)

    private String appendedPhrase;

    @XmlElement(name = "NomenclaturalMicroReference")

    @Field

    @CacheUpdate(noUpdate ="titleCache")

    //TODO Val #3379

//    @NullOrNotEmpty

    @Column(length=255)

    private String nomenclaturalMicroReference;

    @XmlAttribute

    @CacheUpdate(noUpdate ={"titleCache","fullTitleCache"})

    private int parsingProblem = 0;

    @XmlAttribute

    @CacheUpdate(noUpdate ={"titleCache","fullTitleCache"})

    private int problemStarts = -1;

    @XmlAttribute

    @CacheUpdate(noUpdate ={"titleCache","fullTitleCache"})

    private int problemEnds = -1;

    @XmlElementWrapper(name = "TypeDesignations")

    @XmlElement(name = "TypeDesignation")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToMany(fetch = FetchType.LAZY)

    @JoinTable(

        name="TaxonNameBase_TypeDesignationBase",

        joinColumns=@javax.persistence.JoinColumn(name="TaxonNameBase_id"),

        inverseJoinColumns=@javax.persistence.JoinColumn(name="typedesignations_id")

    )

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

    @NotNull

    private Set<TypeDesignationBase> typeDesignations = new HashSet<>();

    @XmlElement(name = "HomotypicalGroup")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY)

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

    @Match(MatchMode.IGNORE)

    @CacheUpdate(noUpdate ="titleCache")

    //TODO Val #3379

//    @NotNull

    private HomotypicalGroup homotypicalGroup;

    @XmlElementWrapper(name = "RelationsFromThisName")

    @XmlElement(name = "RelationFromThisName")

    @OneToMany(mappedBy="relatedFrom", fetch= FetchType.LAZY, orphanRemoval=true)

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

    @Merge(MergeMode.RELATION)

    @NotNull

    @Valid

    private Set<NameRelationship> relationsFromThisName = new HashSet<>();

    @XmlElementWrapper(name = "RelationsToThisName")

    @XmlElement(name = "RelationToThisName")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @OneToMany(mappedBy="relatedTo", fetch= FetchType.LAZY, orphanRemoval=true)

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

    @Merge(MergeMode.RELATION)

    @NotNull

    @Valid

    private Set<NameRelationship> relationsToThisName = new HashSet<>();

    @XmlElementWrapper(name = "NomenclaturalStatuses")

    @XmlElement(name = "NomenclaturalStatus")

    @OneToMany(fetch= FetchType.LAZY, orphanRemoval=true)

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

    @NotNull

    @IndexedEmbedded(depth=1)

    private Set<NomenclaturalStatus> status = new HashSet<>();

    @XmlElementWrapper(name = "TaxonBases")

    @XmlElement(name = "TaxonBase")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @OneToMany(mappedBy="name", fetch= FetchType.LAZY)

    @NotNull

    @IndexedEmbedded(depth=1)

    private Set<TaxonBase> taxonBases = new HashSet<>();

    @XmlElement(name = "Rank")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.EAGER)

    @CacheUpdate(value ="nameCache")

    //TODO Val #3379, handle maybe as groups = Level2.class ??

//    @NotNull

    @IndexedEmbedded(depth=1)

    private Rank rank;

    @XmlElement(name = "NomenclaturalReference")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY)

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

    @CacheUpdate(noUpdate ="titleCache")

    @IndexedEmbedded

    private Reference nomenclaturalReference;

//****** NonViralName attributes ***************************************/

    @XmlElement(name = "NameCache")

    @Fields({

        @Field(name = "nameCache_tokenized"),

        @Field(store = Store.YES, index = Index.YES, analyze = Analyze.YES)

    })

    @Analyzer(impl = org.apache.lucene.analysis.core.KeywordAnalyzer.class)

    @Match(value=MatchMode.CACHE, cacheReplaceMode=ReplaceMode.DEFINED,

            cacheReplacedProperties={"genusOrUninomial", "infraGenericEpithet", "specificEpithet", "infraSpecificEpithet"} )

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

    @Column(length=255)

    private String nameCache;

    @XmlElement(name = "ProtectedNameCache")

    @CacheUpdate(value="nameCache")

    protected boolean protectedNameCache;

    @XmlElement(name = "GenusOrUninomial")

    @Field(analyze = Analyze.YES, indexNullAs=Field.DEFAULT_NULL_TOKEN)

    @Match(MatchMode.EQUAL_REQUIRED)

    @CacheUpdate("nameCache")

    @Column(length=255)

    @Pattern(regexp = "[A-Z][a-z\\u00E4\\u00EB\\u00EF\\u00F6\\u00FC\\-]+", groups=Level2.class, message="{eu.etaxonomy.cdm.model.name.NonViralName.allowedCharactersForUninomial.message}")

    @NullOrNotEmpty

    @NotNull(groups = Level2.class)

    private String genusOrUninomial;

    @XmlElement(name = "InfraGenericEpithet")

    @Field(analyze = Analyze.YES,indexNullAs=Field.DEFAULT_NULL_TOKEN)

    @CacheUpdate("nameCache")

    //TODO Val #3379

//    @NullOrNotEmpty

    @Column(length=255)

    @Pattern(regexp = "[a-z\\u00E4\\u00EB\\u00EF\\u00F6\\u00FC\\-]+", groups=Level2.class,message="{eu.etaxonomy.cdm.model.name.NonViralName.allowedCharactersForEpithet.message}")

    private String infraGenericEpithet;

    @XmlElement(name = "SpecificEpithet")

    @Field(analyze = Analyze.YES,indexNullAs=Field.DEFAULT_NULL_TOKEN)

    @CacheUpdate("nameCache")

    //TODO Val #3379

//    @NullOrNotEmpty

    @Column(length=255)

    @Pattern(regexp = "[a-z\\u00E4\\u00EB\\u00EF\\u00F6\\u00FC\\-]+", groups=Level2.class, message = "{eu.etaxonomy.cdm.model.name.NonViralName.allowedCharactersForEpithet.message}")

    private String specificEpithet;

    @XmlElement(name = "InfraSpecificEpithet")

    @Field(analyze = Analyze.YES,indexNullAs=Field.DEFAULT_NULL_TOKEN)

    @CacheUpdate("nameCache")

    //TODO Val #3379

//    @NullOrNotEmpty

    @Column(length=255)

    @Pattern(regexp = "[a-z\\u00E4\\u00EB\\u00EF\\u00F6\\u00FC\\-]+", groups=Level2.class, message = "{eu.etaxonomy.cdm.model.name.NonViralName.allowedCharactersForEpithet.message}")

    private String infraSpecificEpithet;

    @XmlElement(name = "CombinationAuthorship", type = TeamOrPersonBase.class)

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY)

//    @Target(TeamOrPersonBase.class)

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

    @JoinColumn(name="combinationAuthorship_id")

    @CacheUpdate("authorshipCache")

    @IndexedEmbedded

    private TeamOrPersonBase<?> combinationAuthorship;

    @XmlElement(name = "ExCombinationAuthorship", type = TeamOrPersonBase.class)

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY)

//    @Target(TeamOrPersonBase.class)

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

    @JoinColumn(name="exCombinationAuthorship_id")

    @CacheUpdate("authorshipCache")

    @IndexedEmbedded

    private TeamOrPersonBase<?> exCombinationAuthorship;

    @XmlElement(name = "BasionymAuthorship", type = TeamOrPersonBase.class)

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY)

//    @Target(TeamOrPersonBase.class)

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

    @JoinColumn(name="basionymAuthorship_id")

    @CacheUpdate("authorshipCache")

    @IndexedEmbedded

    private TeamOrPersonBase<?> basionymAuthorship;

    @XmlElement(name = "ExBasionymAuthorship", type = TeamOrPersonBase.class)

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY)

//    @Target(TeamOrPersonBase.class)

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

    @JoinColumn(name="exBasionymAuthorship_id")

    @CacheUpdate("authorshipCache")

    @IndexedEmbedded

    private TeamOrPersonBase<?> exBasionymAuthorship;

    @XmlElement(name = "AuthorshipCache")

    @Fields({

        @Field(name = "authorshipCache_tokenized"),

        @Field(analyze = Analyze.NO)

    })

    @Match(value=MatchMode.CACHE, cacheReplaceMode=ReplaceMode.DEFINED,

            cacheReplacedProperties={"combinationAuthorship", "basionymAuthorship", "exCombinationAuthorship", "exBasionymAuthorship"} )

    //TODO Val #3379

//    @NotNull

    @Column(length=255)

    @Pattern(regexp = "^[A-Za-z0-9 \\u00E4\\u00EB\\u00EF\\u00F6\\u00FC\\-\\&\\,\\(\\)\\.]+$", groups=Level2.class, message = "{eu.etaxonomy.cdm.model.name.NonViralName.allowedCharactersForAuthority.message}")

    private String authorshipCache;

    @XmlElement(name = "ProtectedAuthorshipCache")

    @CacheUpdate("authorshipCache")

    protected boolean protectedAuthorshipCache;

    @XmlElementWrapper(name = "HybridRelationsFromThisName")

    @XmlElement(name = "HybridRelationsFromThisName")

    @OneToMany(mappedBy="relatedFrom", fetch = FetchType.LAZY)

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

    @Merge(MergeMode.RELATION)

    @NotNull

    private Set<HybridRelationship> hybridParentRelations = new HashSet<>();

    @XmlElementWrapper(name = "HybridRelationsToThisName")

    @XmlElement(name = "HybridRelationsToThisName")

    @OneToMany(mappedBy="relatedTo", fetch = FetchType.LAZY, orphanRemoval=true) //a hybrid relation can be deleted automatically if the child is deleted.

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

    @Merge(MergeMode.RELATION)

    @NotNull

    private Set<HybridRelationship> hybridChildRelations = new HashSet<>();

    //if set: this name is a hybrid formula (a hybrid that does not have an own name) and no

    //other hybrid flags may be set. A

    //hybrid name  may not have either an authorteam nor other name components.

    @XmlElement(name ="IsHybridFormula")

    @CacheUpdate("nameCache")

    private boolean hybridFormula = false;

    @XmlElement(name ="IsMonomHybrid")

    @CacheUpdate("nameCache")

    private boolean monomHybrid = false;

    @XmlElement(name ="IsBinomHybrid")

    @CacheUpdate("nameCache")

    private boolean binomHybrid = false;

    @XmlElement(name ="IsTrinomHybrid")

    @CacheUpdate("nameCache")

    private boolean trinomHybrid = false;

// ViralName attributes ************************* /

    @XmlElement(name = "Acronym")

    @Field

    //TODO Val #3379

//  @NullOrNotEmpty

    @Column(length=255)

    private String acronym;

// BacterialName attributes ***********************/

    //Author team and year of the subgenus name

    @XmlElement(name = "SubGenusAuthorship")

    @Field

    private String subGenusAuthorship;

    //Approbation of name according to approved list, validation list, or validly published, paper in IJSB after 1980

    @XmlElement(name = "NameApprobation")

    @Field

    private String nameApprobation;

    //ZOOLOGICAL NAME

    //Name of the breed of an animal

    @XmlElement(name = "Breed")

    @Field

    @NullOrNotEmpty

    @Column(length=255)

    private String breed;

    @XmlElement(name = "PublicationYear")

    @Field(analyze = Analyze.NO)

    @CacheUpdate(value ="authorshipCache")

    @Min(0)

    private Integer publicationYear;

    @XmlElement(name = "OriginalPublicationYear")

    @Field(analyze = Analyze.NO)

    @CacheUpdate(value ="authorshipCache")

    @Min(0)

    private Integer originalPublicationYear;

// *************** FACTORY METHODS ********************************/

    /**

     * Creates a new non viral taxon name instance

     * only containing its {@link common.Rank rank} and

      * the {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy default cache strategy}.

     *

     * @param  rank  the rank to be assigned to <i>this</i> non viral taxon name

     * @see    #NewInstance(Rank, HomotypicalGroup)

     * @see    #NonViralName(Rank, HomotypicalGroup)

     * @see    #NonViralName()

     * @see    #NonViralName(Rank, String, String, String, String, TeamOrPersonBase, Reference, String, HomotypicalGroup)

     * @see    eu.etaxonomy.cdm.strategy.cache.name.INonViralNameCacheStrategy

     * @see    eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy

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

     */

    public static NonViralName NewNonViralInstance(Rank rank){

        return new NonViralName(rank, null);

    }

    /**

     * Creates a new non viral taxon name instance

     * only containing its {@link common.Rank rank},

     * its {@link HomotypicalGroup homotypical group} and

      * the {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy default cache strategy}.

     * The new non viral taxon name instance will be also added to the set of

     * non viral taxon names belonging to this homotypical group.

     *

     * @param  rank  the rank to be assigned to <i>this</i> non viral taxon name

     * @param  homotypicalGroup  the homotypical group to which <i>this</i> non viral taxon name belongs

     * @see    #NewInstance(Rank)

     * @see    #NonViralName(Rank, HomotypicalGroup)

     * @see    #NonViralName()

     * @see    #NonViralName(Rank, String, String, String, String, TeamOrPersonBase, Reference, String, HomotypicalGroup)

     * @see    eu.etaxonomy.cdm.strategy.cache.name.INonViralNameCacheStrategy

     * @see    eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy

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

     */

    public static NonViralName NewNonViralInstance(Rank rank, HomotypicalGroup homotypicalGroup){

        return new NonViralName(rank, homotypicalGroup);

    }

    /**

     * Creates a new viral taxon name instance only containing its {@link Rank rank}.

     *

     * @param   rank  the rank to be assigned to <i>this</i> viral taxon name

     * @see     #ViralName(Rank)

     */

    public static ViralName NewViralInstance(Rank rank){

        return new ViralName(rank);

    }

    /**

     * Creates a new bacterial taxon name instance

     * only containing its {@link Rank rank} and

     * the {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy default cache strategy}.

     *

     * @param  rank  the rank to be assigned to <i>this</i> bacterial taxon name

     * @see    #NewInstance(Rank, HomotypicalGroup)

     * @see    #BacterialName(Rank, HomotypicalGroup)

     * @see    eu.etaxonomy.cdm.strategy.cache.name.INonViralNameCacheStrategy

     * @see    eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy

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

     */

    public static BacterialName NewBacterialInstance(Rank rank){

        return new BacterialName(rank, null);

    }

    /**

     * Creates a new bacterial taxon name instance

     * only containing its {@link Rank rank},

     * its {@link HomotypicalGroup homotypical group} and

     * the {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy default cache strategy}.

     * The new bacterial taxon name instance will be also added to the set of

     * bacterial taxon names belonging to this homotypical group.

     *

     * @param  rank  the rank to be assigned to <i>this</i> bacterial taxon name

     * @param  homotypicalGroup  the homotypical group to which <i>this</i> bacterial taxon name belongs

     * @see    #NewInstance(Rank)

     * @see    #BacterialName(Rank, HomotypicalGroup)

     * @see    eu.etaxonomy.cdm.strategy.cache.name.INonViralNameCacheStrategy

     * @see    eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy

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

     */

    public static BacterialName NewBacterialInstance(Rank rank, HomotypicalGroup homotypicalGroup){

        return new BacterialName(rank, homotypicalGroup);

    }

    /**

     * Creates a new zoological taxon name instance

     * only containing its {@link Rank rank} and

     * the {@link eu.etaxonomy.cdm.strategy.cache.name.ZooNameDefaultCacheStrategy default cache strategy}.

     *

     * @param   rank    the rank to be assigned to <i>this</i> zoological taxon name

     * @see             #ZoologicalName(Rank, HomotypicalGroup)

     * @see             #NewInstance(Rank, HomotypicalGroup)

     * @see             #NewZoologicalInstance(Rank, String, String, String, String, TeamOrPersonBase, INomenclaturalReference, String, HomotypicalGroup)

     * @see             eu.etaxonomy.cdm.strategy.cache.name.ZooNameDefaultCacheStrategy

     */

    public static ZoologicalName NewZoologicalInstance(Rank rank){

        return new ZoologicalName(rank, null);

    }

    /**

     * Creates a new zoological taxon name instance

     * only containing its {@link Rank rank},

     * its {@link HomotypicalGroup homotypical group} and

     * the {@link eu.etaxonomy.cdm.strategy.cache.name.ZooNameDefaultCacheStrategy default cache strategy}.

     * The new zoological taxon name instance will be also added to the set of

     * zoological taxon names belonging to the given homotypical group.

     *

     * @param  rank  the rank to be assigned to <i>this</i> zoological taxon name

     * @param  homotypicalGroup  the homotypical group to which <i>this</i> zoological taxon name belongs

     * @see    #NewInstance(Rank)

     * @see    #NewZoologicalInstance(Rank, String, String, String, String, TeamOrPersonBase, INomenclaturalReference, String, HomotypicalGroup)

     * @see    #ZoologicalName(Rank, HomotypicalGroup)

     * @see    eu.etaxonomy.cdm.strategy.cache.name.ZooNameDefaultCacheStrategy

     */

    public static ZoologicalName NewZoologicalInstance(Rank rank, HomotypicalGroup homotypicalGroup){

        return new ZoologicalName(rank, homotypicalGroup);

    }

    /**

     * Creates a new zoological taxon name instance

     * containing its {@link Rank rank},

     * its {@link HomotypicalGroup homotypical group},

     * its scientific name components, its {@link eu.etaxonomy.cdm.agent.TeamOrPersonBase author(team)},

     * its {@link eu.etaxonomy.cdm.reference.INomenclaturalReference nomenclatural reference} and

     * the {@link eu.etaxonomy.cdm.strategy.cache.name.ZooNameDefaultCacheStrategy default cache strategy}.

     * The new zoological taxon name instance will be also added to the set of

     * zoological taxon names belonging to the given homotypical group.

     *

     * @param   rank  the rank to be assigned to <i>this</i> zoological taxon name

     * @param   genusOrUninomial the string for <i>this</i> zoological taxon name

     *          if its rank is genus or higher or for the genus part

     *          if its rank is lower than genus

     * @param   infraGenericEpithet  the string for the first epithet of

     *          <i>this</i> zoological taxon name if its rank is lower than genus

     *          and higher than species aggregate

     * @param   specificEpithet  the string for the first epithet of

     *          <i>this</i> zoological taxon name if its rank is species aggregate or lower

     * @param   infraSpecificEpithet  the string for the second epithet of

     *          <i>this</i> zoological taxon name if its rank is lower than species

     * @param   combinationAuthorship  the author or the team who published <i>this</i> zoological taxon name

     * @param   nomenclaturalReference  the nomenclatural reference where <i>this</i> zoological taxon name was published

     * @param   nomenclMicroRef  the string with the details for precise location within the nomenclatural reference

     * @param   homotypicalGroup  the homotypical group to which <i>this</i> zoological taxon name belongs

     * @see     #NewInstance(Rank)

     * @see     #NewInstance(Rank, HomotypicalGroup)

     * @see     #ZoologicalName(Rank, String, String, String, String, TeamOrPersonBase, INomenclaturalReference, String, HomotypicalGroup)

     * @see     eu.etaxonomy.cdm.strategy.cache.name.ZooNameDefaultCacheStrategy

     */

    public static ZoologicalName NewZoologicalInstance(Rank rank, String genusOrUninomial, String infraGenericEpithet, String specificEpithet, String infraSpecificEpithet, TeamOrPersonBase combinationAuthorship, INomenclaturalReference nomenclaturalReference, String nomenclMicroRef, HomotypicalGroup homotypicalGroup) {

        return new ZoologicalName(rank, genusOrUninomial, infraGenericEpithet, specificEpithet, infraSpecificEpithet, combinationAuthorship, nomenclaturalReference, nomenclMicroRef, homotypicalGroup);

    }

    /**

     * Creates a new botanical taxon name instance

     * only containing its {@link Rank rank} and

     * the {@link eu.etaxonomy.cdm.strategy.cache.name.BotanicNameDefaultCacheStrategy default cache strategy}.

     *

     * @param   rank    the rank to be assigned to <i>this</i> botanical taxon name

     * @see             #BotanicalName(Rank, HomotypicalGroup)

     * @see             #NewInstance(Rank, HomotypicalGroup)

     * @see             #NewBotanicalInstance(Rank, String, String, String, String, TeamOrPersonBase, INomenclaturalReference, String, HomotypicalGroup)

     * @see             eu.etaxonomy.cdm.strategy.cache.name.BotanicNameDefaultCacheStrategy

     */

    public static BotanicalName NewBotanicalInstance(Rank rank){

        return new BotanicalName(rank, null);

    }

    /**

     * Creates a new botanical taxon name instance

     * only containing its {@link Rank rank},

     * its {@link HomotypicalGroup homotypical group} and

     * the {@link eu.etaxonomy.cdm.strategy.cache.name.BotanicNameDefaultCacheStrategy default cache strategy}.

     * The new botanical taxon name instance will be also added to the set of

     * botanical taxon names belonging to this homotypical group.

     *

     * @param  rank  the rank to be assigned to <i>this</i> botanical taxon name

     * @param  homotypicalGroup  the homotypical group to which <i>this</i> botanical taxon name belongs

     * @see    #NewInstance(Rank)

     * @see    #NewBotanicalInstance(Rank, String, String, String, String, TeamOrPersonBase, INomenclaturalReference, String, HomotypicalGroup)

     * @see    #BotanicalName(Rank, HomotypicalGroup)

     * @see    eu.etaxonomy.cdm.strategy.cache.name.BotanicNameDefaultCacheStrategy

     */

    public static BotanicalName NewBotanicalInstance(Rank rank, HomotypicalGroup homotypicalGroup){

        return new BotanicalName(rank, homotypicalGroup);

    }

    /**

     * Creates a new botanical taxon name instance

     * containing its {@link Rank rank},

     * its {@link HomotypicalGroup homotypical group},

     * its scientific name components, its {@link eu.etaxonomy.cdm.model.agent.TeamOrPersonBase author(team)},

     * its {@link eu.etaxonomy.cdm.model.reference.INomenclaturalReference nomenclatural reference} and

     * the {@link eu.etaxonomy.cdm.strategy.cache.name.BotanicNameDefaultCacheStrategy default cache strategy}.

     * The new botanical taxon name instance will be also added to the set of

     * botanical taxon names belonging to this homotypical group.

     *

     * @param   rank  the rank to be assigned to <i>this</i> botanical taxon name

     * @param   genusOrUninomial the string for <i>this</i> botanical taxon name

     *          if its rank is genus or higher or for the genus part

     *          if its rank is lower than genus

     * @param   infraGenericEpithet  the string for the first epithet of

     *          <i>this</i> botanical taxon name if its rank is lower than genus

     *          and higher than species aggregate

     * @param   specificEpithet  the string for the first epithet of

     *          <i>this</i> botanical taxon name if its rank is species aggregate or lower

     * @param   infraSpecificEpithet  the string for the second epithet of

     *          <i>this</i> botanical taxon name if its rank is lower than species

     * @param   combinationAuthorship  the author or the team who published <i>this</i> botanical taxon name

     * @param   nomenclaturalReference  the nomenclatural reference where <i>this</i> botanical taxon name was published

     * @param   nomenclMicroRef  the string with the details for precise location within the nomenclatural reference

     * @param   homotypicalGroup  the homotypical group to which <i>this</i> botanical taxon name belongs

     * @see     #NewInstance(Rank)

     * @see     #NewInstance(Rank, HomotypicalGroup)

     * @see     ZoologicalName#ZoologicalName(Rank, String, String, String, String, TeamOrPersonBase, INomenclaturalReference, String, HomotypicalGroup)

     * @see     eu.etaxonomy.cdm.strategy.cache.name.BotanicNameDefaultCacheStrategy

     */

    public static  BotanicalName NewBotanicalInstance(Rank rank, String genusOrUninomial, String infraGenericEpithet, String specificEpithet, String infraSpecificEpithet, TeamOrPersonBase combinationAuthorship, INomenclaturalReference nomenclaturalReference, String nomenclMicroRef, HomotypicalGroup homotypicalGroup) {

        return new BotanicalName(rank, genusOrUninomial, infraGenericEpithet, specificEpithet, infraSpecificEpithet, combinationAuthorship, nomenclaturalReference, nomenclMicroRef, homotypicalGroup);

    }

// *********************** PARSER STATIC *******************************/

    /**

     * Returns a botanical taxon name based on parsing a string representing

     * all elements (according to the ICBN) of a botanical taxon name (where

     * the scientific name is an uninomial) including authorship but without

     * nomenclatural reference. If the {@link Rank rank} is not "Genus" it should be

     * set afterwards with the {@link TaxonNameBase#setRank(Rank) setRank} methode.

     *

     * @param   fullNameString  the string to be parsed

     * @return                  the new botanical taxon name

     */

    public static BotanicalName PARSED_BOTANICAL(String fullNameString){

        return PARSED_BOTANICAL(fullNameString, Rank.GENUS());

    }

    /**

     * Returns a botanical taxon name based on parsing a string representing

     * all elements (according to the ICBN) of a botanical taxon name including

     * authorship but without nomenclatural reference. The parsing result

     * depends on the given rank of the botanical taxon name to be created.

     *

     * @param   fullNameString  the string to be parsed

     * @param   rank            the rank of the taxon name

     * @return                  the new botanical taxon name

     */

    public static BotanicalName PARSED_BOTANICAL(String fullNameString, Rank rank){

        if (nameParser == null){

            nameParser = new NonViralNameParserImpl();

        }

        return (BotanicalName)nameParser.parseFullName(fullNameString, NomenclaturalCode.ICNAFP,  rank);

    }

    /**

     * Returns a botanical taxon name based on parsing a string representing

     * all elements (according to the ICBN) of a botanical taxon name (where

     * the scientific name is an uninomial) including authorship and

     * nomenclatural reference. Eventually a new {@link eu.etaxonomy.cdm.model.reference.INomenclaturalReference nomenclatural reference}

     * instance will also be created. If the {@link Rank rank} is not "Genus" it should be

     * set afterwards with the {@link TaxonNameBase#setRank(Rank) setRank} methode.

     *

     * @param   fullNameAndReferenceString  the string to be parsed

     * @return                              the new botanical taxon name

     */

    public static BotanicalName PARSED_BOTANICAL_REFERENCE(String fullNameAndReferenceString){

        return PARSED_BOTANICAL_REFERENCE(fullNameAndReferenceString, Rank.GENUS());

    }

    /**

     * Returns a botanical taxon name based on parsing a string representing

     * all elements (according to the ICBN) of a botanical taxon name including

     * authorship and nomenclatural reference. The parsing result depends on

     * the given rank of the botanical taxon name to be created.

     * Eventually a new {@link eu.etaxonomy.cdm.model.reference.INomenclaturalReference nomenclatural reference}

     * instance will also be created.

     *

     * @param   fullNameAndReferenceString  the string to be parsed

     * @param   rank                        the rank of the taxon name

     * @return                              the new botanical taxon name

     */

    public static BotanicalName PARSED_BOTANICAL_REFERENCE(String fullNameAndReferenceString, Rank rank){

        if (nameParser == null){

            nameParser = new NonViralNameParserImpl();

        }

        return (BotanicalName)nameParser.parseReferencedName(fullNameAndReferenceString, NomenclaturalCode.ICNAFP, rank);

    }

// ************* CONSTRUCTORS *************/

    /**

     * Class constructor: creates a new empty taxon name.

     *

     * @see #TaxonNameBase(Rank)

     * @see #TaxonNameBase(HomotypicalGroup)

     * @see #TaxonNameBase(Rank, HomotypicalGroup)

     */

    protected TaxonNameBase() {

        super();

        setNameCacheStrategy();

    }

    /**

     * Class constructor: creates a new taxon name

     * only containing its {@link Rank rank}.

     *

     * @param  rank  the rank to be assigned to <i>this</i> taxon name

     * @see    		 #TaxonNameBase()

     * @see    		 #TaxonNameBase(HomotypicalGroup)

     * @see    		 #TaxonNameBase(Rank, HomotypicalGroup)

     */

    protected TaxonNameBase(Rank rank) {

        this(rank, null);

    }

    /**

     * Class constructor: creates a new taxon name instance

     * only containing its {@link HomotypicalGroup homotypical group}.

     * The new taxon name will be also added to the set of taxon names

     * belonging to this homotypical group.

     *

     * @param  homotypicalGroup  the homotypical group to which <i>this</i> taxon name belongs

     * @see    					 #TaxonNameBase()

     * @see    					 #TaxonNameBase(Rank)

     * @see    					 #TaxonNameBase(Rank, HomotypicalGroup)

     */

    protected TaxonNameBase(HomotypicalGroup homotypicalGroup) {

        this(null, homotypicalGroup);

    }

    /**

     * Class constructor: creates a new taxon name instance

     * only containing its {@link Rank rank} and

     * its {@link HomotypicalGroup homotypical group} and

     * the {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy default cache strategy}.

     * The new taxon name will be also added to the set of taxon names

     * belonging to this homotypical group.

     *

     * @param  rank  			 the rank to be assigned to <i>this</i> taxon name

     * @param  homotypicalGroup  the homotypical group to which <i>this</i> taxon name belongs

     * @see    					 #TaxonNameBase()

     * @see    					 #TaxonNameBase(Rank)

     * @see    					 #TaxonNameBase(HomotypicalGroup)

     */

    protected TaxonNameBase(Rank rank, HomotypicalGroup homotypicalGroup) {

        super();

        this.setRank(rank);

        if (homotypicalGroup == null){

            homotypicalGroup = new HomotypicalGroup();

        }

        homotypicalGroup.addTypifiedName(this);

        this.homotypicalGroup = homotypicalGroup;

        setNameCacheStrategy();

    }

    /**

     * Class constructor: creates a new non viral taxon name instance

     * containing its {@link Rank rank},

     * its {@link HomotypicalGroup homotypical group},

     * its scientific name components, its {@link eu.etaxonomy.cdm.model.agent.TeamOrPersonBase author(team)},

     * its {@link eu.etaxonomy.cdm.model.reference.Reference nomenclatural reference} and

     * the {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy default cache strategy}.

     * The new non viral taxon name instance will be also added to the set of

     * non viral taxon names belonging to this homotypical group.

     *

     * @param   rank  the rank to be assigned to <i>this</i> non viral taxon name

     * @param   genusOrUninomial the string for <i>this</i> non viral taxon name

     *          if its rank is genus or higher or for the genus part

     *          if its rank is lower than genus

     * @param   infraGenericEpithet  the string for the first epithet of

     *          <i>this</i> non viral taxon name if its rank is lower than genus

     *          and higher than species aggregate

     * @param   specificEpithet  the string for the first epithet of

     *          <i>this</i> non viral taxon name if its rank is species aggregate or lower

     * @param   infraSpecificEpithet  the string for the second epithet of

     *          <i>this</i> non viral taxon name if its rank is lower than species

     * @param   combinationAuthorship  the author or the team who published <i>this</i> non viral taxon name

     * @param   nomenclaturalReference  the nomenclatural reference where <i>this</i> non viral taxon name was published

     * @param   nomenclMicroRef  the string with the details for precise location within the nomenclatural reference

     * @param   homotypicalGroup  the homotypical group to which <i>this</i> non viral taxon name belongs

     * @see     #NonViralName()

     * @see     #NonViralName(Rank, HomotypicalGroup)

     * @see     #NewInstance(Rank, HomotypicalGroup)

     * @see     eu.etaxonomy.cdm.strategy.cache.name.INonViralNameCacheStrategy

     * @see     eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy

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

     */

    protected TaxonNameBase(Rank rank, String genusOrUninomial, String infraGenericEpithet, String specificEpithet, String infraSpecificEpithet, TeamOrPersonBase combinationAuthorship, INomenclaturalReference nomenclaturalReference, String nomenclMicroRef, HomotypicalGroup homotypicalGroup) {

        this(rank, homotypicalGroup);

        setGenusOrUninomial(genusOrUninomial);

        setInfraGenericEpithet (infraGenericEpithet);

        setSpecificEpithet(specificEpithet);

        setInfraSpecificEpithet(infraSpecificEpithet);

        setCombinationAuthorship(combinationAuthorship);

        setNomenclaturalReference(nomenclaturalReference);

        this.setNomenclaturalMicroReference(nomenclMicroRef);

    }

    private void setNameCacheStrategy(){

        if (getClass() == NonViralName.class){

            this.cacheStrategy = (S)NonViralNameDefaultCacheStrategy.NewInstance();

        }

    }

    @Override

    public void initListener(){

        PropertyChangeListener listener = new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent e) {

                boolean protectedByLowerCache = false;

                //authorship cache

                if (fieldHasCacheUpdateProperty(e.getPropertyName(), "authorshipCache")){

                    if (protectedAuthorshipCache){

                        protectedByLowerCache = true;

                    }else{

                        authorshipCache = null;

                    }

                }

                //nameCache

                if (fieldHasCacheUpdateProperty(e.getPropertyName(), "nameCache")){

                    if (protectedNameCache){

                        protectedByLowerCache = true;

                    }else{

                        nameCache = null;

                    }

                }