EDIT

/**

* Copyright (C) 2007 EDIT

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

*/

package eu.etaxonomy.cdm.model.taxon;

import javax.xml.bind.annotation.XmlAccessorType;

import org.hibernate.envers.Audited;

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

import eu.etaxonomy.cdm.model.term.TermType;

import eu.etaxonomy.cdm.model.term.TermVocabulary;

/**

 * (like "is congruent to" or "is misapplied name for").

 * <P>

 * A standard (ordered) list of taxon relationship type instances will be

 * automatically created as the project starts. But this class allows to extend

 * this standard list by creating new instances of additional taxon

 * This class corresponds in part to: <ul>

 * <li> TaxonRelationshipTerm according to the TDWG ontology

 * <li> RelationshipType according to the TCS

 * </ul>

@XmlType(name = "TaxonRelationshipType")

	@SuppressWarnings("unused")

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

	public static final UUID uuidPartialMisappliedNameFor = UUID.fromString("859fb615-b0e8-440b-866e-8a19f493cd36");

	public static final UUID uuidPartialSynonymFor = UUID.fromString("9d7a5e56-973c-474c-b6c3-a1cb00833a3c");

	private static final UUID uuidCongruentTo = UUID.fromString("60974c98-64ab-4574-bb5c-c110f6db634d");

	private static final UUID uuidIncludes = UUID.fromString("0501c385-cab1-4fbe-b945-fc747419bb13");

	private static final UUID uuidOverlaps = UUID.fromString("2046a0fd-4fd6-45a1-b707-2b91547f3ec7");

	private static final UUID uuidExcludes = UUID.fromString("4535a63c-4a3f-4d69-9350-7bf02e2c23be");

	private static final UUID uuidDoesNotExclude = UUID.fromString("0e5099bb-87c0-400e-abdc-bcfed5b5eece");

	private static final UUID uuidDoesNotOverlap = UUID.fromString("ecd2382b-3d94-4169-9dd2-2c4ea1d24605");

	private static final UUID uuidNotIncludedIn = UUID.fromString("89dffa4e-e004-4d42-b0d1-ae1827529e43");

	private static final UUID uuidNotCongruentTo = UUID.fromString("6c16c33b-cfc5-4a00-92bd-a9f9e448f389");

	private static final UUID uuidIncludedInOrIncludes = UUID.fromString("c3ed5089-6779-4051-bb24-f5ea0eca80d5");

	private static final UUID uuidCongruentIncludedInOrIncludes = UUID.fromString("0170cd83-93ad-43c2-9ad1-7ac879300e2f");

	private static final UUID uuidCongruentToOrOverlaps = UUID.fromString("78355cfa-5200-432f-8e00-82b97afad0ed");

	private static final UUID uuidIncludesOrOverlaps = UUID.fromString("f1ec567b-3c73-436b-8625-b4fd53588abb");

	private static final UUID uuidIncludedInOrIncludesOrOverlaps = UUID.fromString("43466aa9-e431-4f37-8bca-febfd9f63716");

	private static final UUID uuidCongruentToOrExcludes = UUID.fromString("758e6cf3-05a0-49ed-9496-d8c4a9fd02ae");

	private static final UUID uuidIncludesOrExcludes = UUID.fromString("6ee440bc-fd3d-4da2-ad85-906d35a94731");

	private static final UUID uuidCongruentToOrIncludesOrExcludes = UUID.fromString("d5c6953d-aa53-46f8-aafc-ebc6428ad5d0");

	private static final UUID uuidIncludedInOrIncludesOrExcludes = UUID.fromString("43d8492c-8bd5-4f38-a633-f1ad910a34dd");

	private static final UUID uuidOverlapsOrExcludes = UUID.fromString("623ecdeb-ff1f-471d-a8dc-0d75b2fe8d94");

	private static final UUID uuidCongruentToOrOverlapsOrExcludes = UUID.fromString("6fabef72-5264-44f1-bfc0-8e2e141375f2");

	private static final UUID uuidIncludesOrOverlapsOrExcludes = UUID.fromString("b7153c89-cc6c-4f8c-bf74-216f10feac46");

    private static final UUID uuidNotYetWorkedOn = UUID.fromString("8d47e59a-790d-428f-8060-01d443519166");

    //Taxon for some reason.

    public static final UUID uuidHeterotypicSynonymTaxonRelationship = UUID.fromString("8f1be54b-c693-4d58-ab36-6f389fc9bd1f");

    public static final UUID uuidHomotypicSynonymTaxonRelationship = UUID.fromString("bfe114b9-1a25-4199-b8b0-6599eb53ae8a");

    public static final UUID uuidSynonymOfTaxonRelationship = UUID.fromString("cc648276-0823-47b1-9deb-fa7c046e4afd");

		return new TaxonRelationshipType(term, label, labelAbbrev, symmetric, transitive);

//********************************** CONSTRUCTOR *********************************/

  	 * @deprecated for inner (hibernate) use only

  	 */

  	protected TaxonRelationshipType() {

		super(TermType.TaxonRelationshipType);

	 * relationship type is symmetric and/or transitive.

	 * 						 type to be created

	 * @param	labelAbbrev  the string identifying (in abbreviated form) the

	 * 						 new taxon relationship type to be created

	 * @param	symmetric	 the boolean indicating whether the new taxon

	 * 						 relationship type to be created is symmetric

	 * @param	transitive	 the boolean indicating whether the new taxon

	 * 						 relationship type to be created is transitive

	 * @see 				 #TaxonRelationshipType()

	 */

	public void resetTerms(){

		termMap = null;

	}

            return getTermByClassAndUUID(TaxonRelationshipType.class, uuid);

        } else {

            return termMap.get(uuid);

        }

     * <code>true</code> if this relationship type is {@link #isAnyMisappliedName()

     * any of the misapplied name relationship types} or an

     * {@link #INVALID_DESIGNATION_FOR() invalid designation}

     *

     * @see #isAnyMisappliedName()()

     */

	public boolean isMisappliedNameOrInvalidDesignation(){

        if (this.isAnyMisappliedName()){

            return true;

            return true;

        }

        return false;

    }

    /**

     * <code>true</code> if this relationship type is an

     * {@link #INVALID_DESIGNATION_FOR() invalid designation}

     *

     * @see #isAnyMisappliedName()()

     */

    public boolean isInvalidDesignation(){

        if (this.equals(INVALID_DESIGNATION_FOR())){

        }

        return false;

    }

    /**

     * <code>true</code> if this relationship type is any

     * of the misapplied name relationships such as

     * {@link #MISAPPLIED_NAME_FOR()} or {@link #PRO_PARTE_MISAPPLIED_NAME_FOR()}

     *

     * @see #isMisappliedNameOrInvalidDesignation()

     */

    public boolean isAnyMisappliedName(){

        return (allMisappliedNameTypes().contains(this));

    }

    /**

     * <code>true</code> if this relationship type is any

     * of the pro parte or partial synonym relationship types

     * {@link #PRO_PARTE_SYNONYM_FOR()} or {@link #PARTIAL_SYNONYM_FOR()}

     *

     * @see #isAnyMisappliedName()

     */

    public boolean isAnySynonym(){

        return (allSynonymTypes().contains(this));

    }

    /**

     * <code>true</code> if this relationship type is either

     * a pro parte synonym or a pro parte misapplied name relationship type

     * {@link #PRO_PARTE_SYNONYM_FOR()} or {@link #PRO_PARTE_MISAPPLIED_NAME_FOR}

     */

    public boolean isProParte(){

        return (allProParteTypes().contains(this));

    }

    /**

     * <code>true</code> if this relationship type is either

     * a partial synonym or a partial misapplied name relationship type

     * {@link #PARTIAL_SYNONYM_FOR()} or {@link #PARTIAL_MISAPPLIED_NAME_FOR}

     *

     * @see #isProParte()

     */

    public boolean isPartial(){

        return (allPartialTypes().contains(this));

    }

     * Returns a list of all misapplied name relationship

     * types such as "misapplied name for" and

     * "pro parte misapplied name for".

     *

     * @see #MISAPPLIED_NAME_FOR()

     * @see #PRO_PARTE_MISAPPLIED_NAME_FOR()

     */

    public static Set<TaxonRelationshipType> allMisappliedNameTypes(){

        Set<TaxonRelationshipType> result = new HashSet<>();

        result.add(MISAPPLIED_NAME_FOR());

        result.add(PRO_PARTE_MISAPPLIED_NAME_FOR());

        return result;

    }

    public static Set<TaxonRelationshipType> allSynonymTypes(){

        Set<TaxonRelationshipType> result = new HashSet<>();

        result.add(PRO_PARTE_SYNONYM_FOR());

        result.add(PARTIAL_SYNONYM_FOR());

        return result;

    }

    public static Set<TaxonRelationshipType> allProParteTypes(){

        Set<TaxonRelationshipType> result = new HashSet<>();

        result.add(PRO_PARTE_SYNONYM_FOR());

        result.add(PRO_PARTE_MISAPPLIED_NAME_FOR());

    }

        Set<TaxonRelationshipType> result = new HashSet<>();

        result.add(PARTIAL_SYNONYM_FOR());

        result.add(PARTIAL_MISAPPLIED_NAME_FOR());

        return result;

    }

	 * It assumes that all other relationships are concept relationships.

	 * @return

	 */

	public boolean isConceptRelationship(){

		}

		return true;

	}

	 * Returns the taxon relationship type "is taxonomically included in". This

	 * indicates that the {@link TaxonRelationship#getFromTaxon() source taxon}

	 * in such a {@link TaxonRelationship taxon relationship} has the target {@link Taxon taxon}

	 * except if the concept reference follows the taxonomical opinion of

	 * another reference.<BR>

	 * This type is neither symmetric nor transitive.

	 * Returns the taxon relationship type "is misapplied name for". This

	 * of the {@link TaxonRelationship#getFromTaxon() source taxon}

	 * the {@link TaxonBase#getSec() concept reference} to denominate the same real taxon

	 * as the one meant by the target {@link Taxon taxon}.<BR>

	 * This type is neither symmetric nor transitive.

	 */

     * Returns the taxon relationship type "is pro parte misapplied name for". This

     * indicates that the {@link eu.etaxonomy.cdm.model.name.TaxonName taxon name} of the

     * {@link TaxonRelationship#getFromTaxon() source taxon}

     * in such a {@link TaxonRelationship taxon relationship} has been erroneously used by

     * the {@link TaxonBase#getSec() concept reference} to (partly) denominate the same real taxon

     * as the one meant by the target {@link Taxon taxon}. Additionaly another real taxon

     * This type is neither symmetric nor transitive.

     *

     * @see #MISAPPLIED_NAME_FOR()

    public static final TaxonRelationshipType PRO_PARTE_MISAPPLIED_NAME_FOR(){

        return getTermByUuid(uuidProParteMisappliedNameFor);

    }

     * Returns the taxon relationship type "is partial misapplied name for". This

     * indicates that the {@link eu.etaxonomy.cdm.model.name.TaxonName taxon name} of the

     * {@link TaxonRelationship#getFromTaxon() source taxon}

     * in such a {@link TaxonRelationship taxon relationship} has been erroneously used by

     * the {@link TaxonBase#getSec() concept reference} to (partly) denominate the same real taxon

     * as the one meant by the target {@link Taxon taxon}. In contrary to a

     * {@link #PRO_PARTE_MISAPPLIED_NAME_FOR() pro parte misapplied name} no other real taxon

     * is (partly) demoninated by the given name in the concept reference. Therefore it is called

     * partial.<BR>

     * This type is neither symmetric nor transitive.

     *

     * @see #MISAPPLIED_NAME_FOR()

     * @see #PRO_PARTE_MISAPPLIED_NAME_FOR()

     * @see #PARTIAL_SYNONYM_FOR()

     * @see #INCLUDES()

     */

    public static final TaxonRelationshipType PARTIAL_MISAPPLIED_NAME_FOR(){

        return getTermByUuid(uuidPartialMisappliedNameFor);

    }

    /**

     * Returns the taxon relationship type "is pro parte synonym for". This

     * indicates that the {@link eu.etaxonomy.cdm.model.name.TaxonName taxon name} of the

     * {@link TaxonRelationship#getFromTaxon() source taxon}

     * in such a {@link TaxonRelationship taxon relationship} has been used as a

     * pro parte synonym.<BR>

     * This type is neither symmetric nor transitive.

     *

     * @see #PRO_PARTE_MISAPPLIED_NAME_FOR()

     */

    public static final TaxonRelationshipType PRO_PARTE_SYNONYM_FOR(){

        return getTermByUuid(uuidProParteSynonymFor);

    }

    /**

     * Returns the taxon relationship type "is partial synonym for". This

     * indicates that the {@link eu.etaxonomy.cdm.model.name.TaxonName taxon name} of the

     * {@link TaxonRelationship#getFromTaxon() source taxon}

     * in such a {@link TaxonRelationship taxon relationship} has been used as a

     * partial synonym.<BR>

     * This type is neither symmetric nor transitive.

     *

     * @see #PRO_PARTE_SYNONYM_FOR()

     * @see #PARTIAL_MISAPPLIED_NAME_FOR()

     */

    public static final TaxonRelationshipType PARTIAL_SYNONYM_FOR(){

        return getTermByUuid(uuidPartialSynonymFor);

    }

	 * Returns the taxon relationship type "is invalid designation for". This

	 * {@link eu.etaxonomy.cdm.model.name.NomenclaturalStatusType#isInvalidType() not been validly published} but was intended to denominate

	 */

	 * Returns the (concept) taxon relationship type "is impossible"

	 * (contradiction). This is a concept relationship type which means that the

	 * circumscriptions (the set of organisms/specimens that belong to a {@link Taxon taxon}

	 * according to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})

	 * of both taxa involved in such a {@link TaxonRelationship taxon relationship} are

	 * beeing compared. In a concept relationship the concept references of the

	 * involved taxa must be distinct. <BR>

	 * The "is impossible" (contradiction) taxon relationship type arises

	 * logically if two or more incompatible (concept) taxon relationships

	 * between the two taxa already exist (for instance with the types

	 * "is congruent to" and "excludes").<BR>

	 * This type is symmetric but not transitive.

	 */

	 * Returns the (concept) taxon relationship type "is congruent to".

	 * This is a concept relationship type which means that the circumscriptions

	 * (the set of organisms/specimens that belong to a {@link Taxon taxon} according

	 * to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})

	 * of both taxa involved in such a {@link TaxonRelationship taxon relationship} are

	 * beeing compared. In a concept relationship the concept references of the

	 * involved taxa must be distinct. <BR>

	 * The "is congruent to" taxon relationship type indicates that the

	 * circumscriptions of both taxa involved in the taxon relationship are

	 * identical.<BR>

	 * This type is symmetric and transitive.

	 */

	 * Returns the (concept) taxon relationship type "includes".

	 * This is a concept relationship type which means that the circumscriptions

	 * (the set of organisms/specimens that belong to a {@link Taxon taxon} according

	 * to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})

	 * of both taxa involved in such a {@link TaxonRelationship taxon relationship} are

	 * beeing compared. In a concept relationship the concept references of the

	 * involved taxa must be distinct. <BR>

	 * The "includes" taxon relationship type indicates that each element

	 * belonging to the circumscription of the target taxon involved in the

	 * taxon relationship belongs to the circumscription of the source taxon,

	 * but that some elements belonging to the circumscription of the source

	 * taxon do not belong to the circumscription of the target taxon.<BR>

	 * This type is not symmetric but transitive.

	 */

	 * Returns the (concept) taxon relationship type "overlaps".

	 * This is a concept relationship type which means that the circumscriptions

	 * (the set of organisms/specimens that belong to a {@link Taxon taxon} according

	 * to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})

	 * of both taxa involved in such a {@link TaxonRelationship taxon relationship} are

	 * beeing compared. In a concept relationship the concept references of the

	 * involved taxa must be distinct. <BR>

	 * The "overlaps" taxon relationship type indicates that both

	 * circumscriptions have common elements but that some elements belonging

	 * to the circumscription of the source taxon do not belong to the

	 * circumscription of the target taxon and vice-versa.<BR>

	 * This type is symmetric but not transitive.

	 */

	 * Returns the (concept) taxon relationship type "excludes".

	 * This is a concept relationship type which means that the circumscriptions

	 * (the set of organisms/specimens that belong to a {@link Taxon taxon} according

	 * to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})

	 * of both taxa involved in such a {@link TaxonRelationship taxon relationship} are

	 * beeing compared. In a concept relationship the concept references of the

	 * involved taxa must be distinct. <BR>

	 * The "excludes" taxon relationship type indicates that both

	 * circumscriptions have no common elements.<BR>

	 * This type is symmetric but not transitive.

	 */

	 * Returns the (concept) taxon relationship type "does not exclude".

	 * This is a concept relationship type which means that the circumscriptions

	 * (the set of organisms/specimens that belong to a {@link Taxon taxon} according

	 * to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})

	 * of both taxa involved in such a {@link TaxonRelationship taxon relationship} are

	 * beeing compared. In a concept relationship the concept references of the

	 * involved taxa must be distinct. <BR>

	 * The "does not exclude" taxon relationship type indicates that both

	 * circumscriptions have common elements. This type is a generalisation of

	 * Returns the (concept) taxon relationship type "does not overlap".

	 * This is a concept relationship type which means that the circumscriptions

	 * (the set of organisms/specimens that belong to a {@link Taxon taxon} according

	 * to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})

	 * of both taxa involved in such a {@link TaxonRelationship taxon relationship} are

	 * beeing compared. In a concept relationship the concept references of the

	 * involved taxa must be distinct. <BR>

	 * The "does not overlap" taxon relationship type is a generalisation of

	 * Returns the (concept) taxon relationship type "is not included in".

	 * This is a concept relationship type which means that the circumscriptions

	 * (the set of organisms/specimens that belong to a {@link Taxon taxon} according

	 * to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})

	 * of both taxa involved in such a {@link TaxonRelationship taxon relationship} are

	 * beeing compared. In a concept relationship the concept references of the

	 * involved taxa must be distinct. <BR>

	 * The "is not included in" taxon relationship type indicates that at least

	 * one element belonging to the circumscription of the source taxon involved

	 * in the taxon relationship does not belong to the circumscription of the

	 * target taxon. <BR>

	 * This type is neither symmetric nor transitive.

	 * Returns the (concept) taxon relationship type "is not congruent to".

	 * This is a concept relationship type which means that the circumscriptions

	 * (the set of organisms/specimens that belong to a {@link Taxon taxon} according

	 * to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})

	 * of both taxa involved in such a {@link TaxonRelationship taxon relationship} are

	 * beeing compared. In a concept relationship the concept references of the

	 * involved taxa must be distinct. <BR>

	 * The "is not congruent to" taxon relationship type indicates that at least

	 * one element belonging to one of both circumscriptions does not belong to

	 * the other circumscription. This type is a generalisation of

	public static final TaxonRelationshipType INCLUDED_OR_INCLUDES(){

	public static final TaxonRelationshipType CONGRUENT_OR_INCLUDED_OR_INCLUDES(){

	public static final TaxonRelationshipType CONGRUENT_OR_OVERLAPS(){

	public static final TaxonRelationshipType CONGRUENT_OR_INCLUDES_OR_EXCLUDES(){

	    return getTermByUuid(uuidUnclear);

	}

    public static final TaxonRelationshipType NOT_YET_WORKED_ON(){

        return getTermByUuid(uuidNotYetWorkedOn);

    }

    protected void setDefaultTerms(TermVocabulary<TaxonRelationshipType> termVocabulary) {

		}

		return getTermByUuid(uuidAllRelationships);

	}

            Map<UUID,DefinedTermBase> terms, boolean abbrevAsId) {

        TaxonRelationshipType newInstance = super.readCsvLine(termClass, csvLine, termType, terms, abbrevAsId);

        newInstance.setSymbol(newInstance.getIdInVocabulary());

        return newInstance;

    }

    /**

     * @return a set containing all UUIDs of relationship types representing

     * a pro parte or partial synonym relationship (e.g.

     * {@link #PRO_PARTE_SYNONYM_FOR()} or {@link #PARTIAL_SYNONYM_FOR()}

     */

    public static Set<UUID> proParteOrPartialSynonymUuids() {

        Set<UUID> result = new HashSet<>();

        result.add(uuidProParteSynonymFor);

        result.add(uuidPartialSynonymFor);

        return result;

    }

    /**

     * @return a set containing all UUIDs of relationship types representing

     * a misapplied name relationship (e.g. {@link #MISAPPLIED_NAME_FOR()},

     * {@link #PRO_PARTE_MISAPPLIED_NAME_FOR()} and {@link #PARTIAL_MISAPPLIED_NAME_FOR()}

     */

    public static Set<UUID> misappliedNameUuids() {

        Set<UUID> result = new HashSet<>();

        result.add(uuidMisappliedNameFor);

        result.add(uuidProParteMisappliedNameFor);

        result.add(uuidPartialMisappliedNameFor);

        return result;

    }

    /**

     * @return a set containing all UUIDs of relationship types representing

     * a partial relationship (e.g. {@link #PARTIAL_SYNONYM_FOR()} and

     * {@link #PARTIAL_MISAPPLIED_NAME_FOR()})

     */

    public static Set<UUID> partialUuids() {

        Set<UUID> result = new HashSet<>();

        result.add(uuidPartialSynonymFor);

        result.add(uuidPartialSynonymFor);

        return result;

    }

    /**

     * @return a set containing all UUIDs of relationship types representing

     * a pro parte relationship (e.g. {@link #PRO_PARTE_SYNONYM_FOR()} and

     * {@link #PRO_PARTE_MISAPPLIED_NAME_FOR()})

     */

    public static Set<UUID> proParteUuids() {

        Set<UUID> result = new HashSet<>();

        result.add(uuidProParteSynonymFor);

        result.add(uuidProParteMisappliedNameFor);

        return result;

    }

     * @return a set containing all UUIDs of relationship types representing

     * a pseudo taxon relationship (a synonym relationship expressed as

     * taxon relationship as the synonym side for some reason must be

     * handled as pseudo accepted taxon, e.g. because factual data

     * is attached from an import)

     */

    public static Set<UUID> pseudoTaxonUuids() {

        Set<UUID> result = new HashSet<>();

        result.add(uuidHomotypicSynonymTaxonRelationship);

        result.add(uuidHeterotypicSynonymTaxonRelationship);

        result.add(uuidSynonymOfTaxonRelationship);

        return result;

    }