cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/NameRelationshipType.java

   1 /**
   2 * Copyright (C) 2007 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9
  10 package eu.etaxonomy.cdm.model.name;
  11
  12
  13 import java.util.HashMap;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.UUID;
  17
  18 import javax.persistence.Entity;
  19 import javax.persistence.Transient;
  20 import javax.xml.bind.annotation.XmlAccessType;
  21 import javax.xml.bind.annotation.XmlAccessorType;
  22 import javax.xml.bind.annotation.XmlType;
  23
  24 import org.apache.commons.lang.StringUtils;
  25 import org.apache.log4j.Logger;
  26 import org.hibernate.envers.Audited;
  27 import org.hibernate.search.annotations.Indexed;
  28
  29 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  30 import eu.etaxonomy.cdm.model.common.RelationshipTermBase;
  31 import eu.etaxonomy.cdm.model.common.TermType;
  32 import eu.etaxonomy.cdm.model.common.TermVocabulary;
  33
  34 /**
  35  * The class representing the categories of {@link NameRelationship taxon name relationships} between
  36  * two {@link TaxonNameBase taxon names}. These name relationship types are
  37  * based on the concrete {@link NomenclaturalCode nomenclatural code} governing
  38  * the taxon names involved in the name relationship or on decisions taken by
  39  * the competent authorities; they do not depend on the use made of these
  40  * taxon names in a particular reference or in a particular taxonomic treatment.
  41  * Most relationships are to be understood as 'is .... of': for instance
  42  * <i>Linum radiola</i> L. is a replaced synonym of <i>Radiola linoides</i> Roth or
  43  * <i>Astragalus rhizanthus</i> Boiss. is a later homonym of
  44  * <i>Astragalus rhizanthus</i> Royle.
  45  * <P>
  46  * A standard (ordered) list of name relationship type instances will be
  47  * automatically created as the project starts. But this class allows to extend
  48  * this standard list by creating new instances of additional name relationship
  49  * types if needed.
  50  * <P>
  51  * This class corresponds partially to: <ul>
  52  * <li> TaxonRelationshipTerm and NomenclaturalNoteTypeTerm according to the TDWG ontology
  53  * <li> RelationshipType and NomenclaturalNoteType according to the TCS
  54  * </ul>
  55  *
  56  * @author m.doering
  57  * @created 08-Nov-2007 13:06:38
  58  */
  59 @XmlAccessorType(XmlAccessType.FIELD)
  60 @XmlType(name = "NameRelationshipType")
  61 @Entity
  62 @Indexed(index = "eu.etaxonomy.cdm.model.common.DefinedTermBase")
  63 @Audited
  64 public class NameRelationshipType extends RelationshipTermBase<NameRelationshipType> {
  65         private static final long serialVersionUID = 8504916205254159334L;
  66
  67         static Logger logger = Logger.getLogger(NameRelationshipType.class);
  68
  69         private static final UUID uuidOrthographicVariant = UUID.fromString("eeaea868-c4c1-497f-b9fe-52c9fc4aca53");
  70         private static final UUID uuidMisspelling = UUID.fromString("c6f9afcb-8287-4a2b-a6f6-4da3a073d5de");
  71         private static final UUID uuidEmendation = UUID.fromString("6e23ad45-3f2a-462b-ad87-d2389cd6e26c");
  72         private static final UUID uuidLaterHomonym = UUID.fromString("80f06f65-58e0-4209-b811-cb40ad7220a6");
  73         private static final UUID uuidTreatedAsLaterHomonym = UUID.fromString("2990a884-3302-4c8b-90b2-dfd31aaa2778");
  74         private static final UUID uuidAlternativeName = UUID.fromString("049c6358-1094-4765-9fae-c9972a0e7780");
  75         private static final UUID uuidBasionym = UUID.fromString("25792738-98de-4762-bac1-8c156faded4a");
  76         private static final UUID uuidReplacedSynonym = UUID.fromString("71c67c38-d162-445b-b0c2-7aba56106696");
  77         private static final UUID uuidConservedAgainst = UUID.fromString("e6439f95-bcac-4ebb-a8b5-69fa5ce79e6a");
  78         private static final UUID uuidValidatedByName = UUID.fromString("a176c9ad-b4c2-4c57-addd-90373f8270eb");
  79         private static final UUID uuidLaterValidatedByName = UUID.fromString("a25ee4c1-863a-4dab-9499-290bf9b89639");
  80         private static final UUID uuidBlockingNameFor = UUID.fromString("1dab357f-2e12-4511-97a4-e5153589e6a6");
  81         private static final UUID uuidLaterIsonym = UUID.fromString("29ab238d-598d-45b9-addd-003cf39ccc3e");
  82         private static final UUID uuidOriginalSpellingFor = UUID.fromString("264d2be4-e378-4168-9760-a9512ffbddc4");
  83
  84
  85         public static NameRelationshipType NewInstance(String term, String label, String labelAbbrev, boolean symmetric, boolean transitive) {
  86                 return new NameRelationshipType(term, label, labelAbbrev, symmetric, transitive);
  87         }
  88
  89
  90         protected static Map<UUID, NameRelationshipType> termMap = null;
  91
  92         protected static NameRelationshipType findTermByUuid(UUID uuid){
  93                 if (termMap == null || termMap.isEmpty()){
  94                     return getTermByClassAndUUID(NameRelationshipType.class, uuid);
  95                 } else {
  96                     return termMap.get(uuid);
  97                 }
  98         }
  99
 100
 101 //********************************** Constructor *********************************/
 102
 103         //for hibernate use only
 104         @Deprecated
 105         protected  NameRelationshipType() {
 106                 super(TermType.NameRelationshipType);
 107         }
 108
 109         /**
 110          * Class constructor: creates an additional name relationship type
 111          * instance with a description, a label, a label abbreviation and the flags
 112          * indicating whether <i>this</i> new name relationship type is symmetric and/or
 113          * transitive.
 114          *
 115          * @param       term             the string (in the default language) describing the
 116          *                                               new name relationship type to be created
 117          * @param       label            the string identifying the new name relationship
 118          *                                               type to be created
 119          * @param       labelAbbrev  the string identifying (in abbreviated form) the
 120          *                                               new name relationship type to be created
 121          * @param       symmetric        the boolean indicating whether the new name
 122          *                                               relationship type to be created is symmetric
 123          * @param       transitive       the boolean indicating whether the new name
 124          *                                               relationship type to be created is transitive
 125          * @see                                  #NameRelationshipType()
 126          */
 127         private NameRelationshipType(String term, String label, String labelAbbrev, boolean symmetric, boolean transitive) {
 128                 super(TermType.NameRelationshipType, term, label, labelAbbrev, symmetric, transitive);
 129         }
 130
 131
 132
 133 //************************** METHODS ********************************
 134
 135         /* (non-Javadoc)
 136          * @see eu.etaxonomy.cdm.model.common.DefinedTermBase#resetTerms()
 137          */
 138         @Override
 139         public void resetTerms(){
 140                 termMap = null;
 141         }
 142
 143         // TODO this method should be moved to consistency proof classes
 144         /**
 145          * Returns the boolean value indicating whether the nomenclatural status
 146          * type of the {@link eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedFrom() first taxon name}
 147          * involved in a name relationship with <i>this</i> name relationship type should
 148          * be "invalid" (true) or not (false). Returns false if <i>this</i> name
 149          * relationship status type is null.
 150          *
 151          * @see  #isLegitimateType()
 152          * @see  #isIllegitimateType()
 153          * @see  NomenclaturalStatusType#isInvalidType()
 154          * @see  eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedFrom()
 155          */
 156         @Transient
 157         public boolean isInvalidType(){
 158                 if (this.equals(VALIDATED_BY_NAME()) ||
 159                                 this.equals(LATER_VALIDATED_BY_NAME())
 160                         ){
 161                         return true;
 162                 }else{
 163                         return false;
 164                 }
 165         }
 166
 167         // TODO this method should be moved to consistency proof classes
 168         /**
 169          * Returns the boolean value indicating whether the nomenclatural status
 170          * type of the {@link eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedFrom() first taxon name}
 171          * involved in a name relationship with <i>this</i> name relationship type should
 172          * be "legitimate" (true) or not (false). Returns false if <i>this</i> name
 173          * relationship status type is null.
 174          *
 175          * @see  #isInvalidType()
 176          * @see  #isIllegitimateType()
 177          * @see  NomenclaturalStatusType#isLegitimateType()
 178          * @see  eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedFrom()
 179          */
 180         @Transient
 181         public boolean isLegitimateType(){
 182                 if (this.equals(BASIONYM()) ||
 183                                 this.equals(REPLACED_SYNONYM()) ||
 184                                 this.equals(ALTERNATIVE_NAME()) ||
 185                                 this.equals(CONSERVED_AGAINST())
 186                         ){
 187                         return true;
 188                 }else{
 189                         return false;
 190                 }
 191         }
 192
 193         // TODO this method should be moved to consistency proof classes
 194         /**
 195          * Returns the boolean value indicating whether the nomenclatural status
 196          * type of the {@link eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedFrom() first taxon name}
 197          * involved in a name relationship with <i>this</i> name relationship type should
 198          * be "illegitimate" (true) or not (false). Returns false if <i>this</i> name
 199          * relationship status type is null.
 200          *
 201          * @see  #isInvalidType()
 202          * @see  #isLegitimateType()
 203          * @see  NomenclaturalStatusType#isIllegitimateType()
 204          * @see  eu.etaxonomy.cdm.model.common.RelationshipBase#getRelatedFrom()
 205          */
 206         @Transient
 207         public boolean isIllegitimateType(){
 208                 //TODO: implement isX method. Maybe as persistent class attribute?
 209                 //TODO: RejectedInFavour,
 210                 if (this.equals(LATER_HOMONYM()) ||
 211                                 this.equals(TREATED_AS_LATER_HOMONYM())
 212                         ){
 213                         return true;
 214                 }else{
 215                         return false;
 216                 }
 217         }
 218
 219         @Transient
 220         public boolean isBasionymRelation(){
 221                 if (BASIONYM() == null){
 222                         throw new IllegalStateException("NameRelationships have not been initialized yet. Please initialize DefinedTerms first");
 223                 }
 224                 return this.equals(BASIONYM());
 225         }
 226
 227         @Transient
 228         public boolean isReplacedSynonymRelation(){
 229                 if (REPLACED_SYNONYM() == null){
 230                         throw new IllegalStateException("NameRelationships have not been initialized yet. Please initialize DefinedTerms first");
 231                 }
 232                 return this.equals(REPLACED_SYNONYM());
 233         }
 234
 235
 236         /**
 237          * Returns the "orthographic variant" name relationship type. The first
 238          * {@link TaxonNameBase taxon name} involved in such a relationship is an
 239          * orthographic variant of the second taxon name. The two {@link TaxonNameBase taxon names}
 240          * involved in such a relationship must have the same {@link NonViralName#getAuthorshipCache() authorship}
 241          * and {@link Rank rank}, belong to the same {@link HomotypicalGroup homotypical group} and their name parts
 242          * must be almost identical (so one usually does not differentiate them).<BR>
 243          * For instance <i>Angelica silvestris</i> L. is an orthographic variant of
 244          * <i>Angelica sylvestris</i> L.<BR>
 245          * This type is symmetric and transitive but usually orthographic variant relationships should be organized
 246          * in a star schema with the correct variant in the middle and other variants pointing to it.
 247          * @see #ORIGINAL_SPELLING()()
 248          */
 249         public static final NameRelationshipType ORTHOGRAPHIC_VARIANT(){
 250                   return findTermByUuid(uuidOrthographicVariant);
 251         }
 252
 253         /**
 254          * Returns the {@link TaxonNameBase taxon name} as it is spelled in the original
 255          * publication of the given name. The first (left) name in the relationship takes the role
 256          * of the original spelling whereas the second (right) name takes the role of the
 257          * current/correct spelling.<BR>
 258          * Original spelling is a specialization of {@link #ORTHOGRAPHIC_VARIANT()}.
 259          * <BR>
 260          * @see #ORTHOGRAPHIC_VARIANT()
 261          * @see #MISSPELLING()
 262          */
 263         public static final NameRelationshipType ORIGINAL_SPELLING(){
 264                 return findTermByUuid(uuidOriginalSpellingFor);
 265         }
 266
 267         /**
 268          * Returns the "misspelling" name relationship type. The first
 269          * {@link TaxonNameBase taxon name} involved in such a relationship is a
 270          * misspelling of the second taxon name. The two {@link TaxonNameBase taxon names}
 271          * involved in such a relationship must have the same {@link NonViralName#getAuthorshipCache() authorship}
 272          * and {@link Rank rank}, belong to the same {@link HomotypicalGroup homotypical group} and their name parts
 273          * must be almost identical (so one usually does not differentiate them).<BR>
 274          * For instance <i>Anhelica silvestris</i> L. is a misspelling of
 275          * <i>Angelica silvestris</i> L.<BR>
 276          * A misspelling is always accicentally (not on purpose). Therefore misspellings are a
 277          * subset of {@link #ORTHOGRAPHIC_VARIANT orthographic variants} and are complementary to
 278          * emendations. A misspelling is always an {@link #ORTHOGRAPHIC_VARIANT orthographic variant}, too.
 279          * This type is symmetric and transitive but usually the misspelling relationships should be organized
 280          * in a star schema with the correct variant in the middle and the misspellings pointing to it.
 281          * @see #ORTHOGRAPHIC_VARIANT()
 282          * @see #ORIGINAL_SPELLING()
 283          */
 284         public static final NameRelationshipType MISSPELLING(){
 285                   return findTermByUuid(uuidMisspelling);
 286         }
 287         /**
 288          * Returns the "emendation" name relationship type. The first
 289          * {@link TaxonNameBase taxon name} involved in such a relationship is a
 290          * misspelling of the second taxon name. The two {@link TaxonNameBase taxon names}
 291          * involved in such a relationship must have the same {@link NonViralName#getAuthorshipCache() authorship}
 292          * and {@link Rank rank}, belong to the same {@link HomotypicalGroup homotypical group} and their name parts
 293          * must be almost identical (so one usually does not differentiate them).<BR>
 294          * For instance <i>Angelica silvestris</i> L. is a emendation of
 295          * <i>Angelica sylvestris</i> L.<BR>
 296          * The name corrected by an emendation has originally been used on purpose (not accidentially)
 297          * Therefore emendations are a subset of {@link #ORTHOGRAPHIC_VARIANT orthographic variants} and are
 298          * complementary to {@link #MISSPELLING missepllings}. An emendation is always an
 299          * {@link #ORTHOGRAPHIC_VARIANT orthographic variant}, too.<BR>
 300          * This type is symmetric and transitive but usually the misspelling relationships should be organized
 301          * in a star schema with the correct variant in the middle and the misspellings pointing to it.
 302          */
 303         public static final NameRelationshipType EMENDATION(){
 304                   return findTermByUuid(uuidEmendation);
 305         }
 306         /**
 307          * Returns the "later homonym" name relationship type. The first
 308          * {@link TaxonNameBase taxon name} involved in such a relationship should
 309          * have been published after the second taxon name. The two {@link TaxonNameBase taxon names}
 310          * involved in such a relationship must belong to different
 311          * {@link HomotypicalGroup homotypical groups}, have in general different
 312          * {@link NonViralName#getAuthorshipCache() authorship} and their name parts (excluding infraspecific
 313          * {@link Rank ranks}) must be (almost) identical, so one could be mistaken for
 314          * the other one. The first taxon name is "illegitimate" and the second one
 315          * is "legitimate" (this corresponds to "invalid" and "valid" in case of
 316          * {@link ZoologicalName zoological names}).<BR>
 317          * For instance <i>Astragalus rhizanthus</i> Boiss. is a later homonym of
 318          * <i>Astragalus rhizanthus</i> Royle.<BR>
 319          * This type is not symmetric but transitive.
 320          *
 321          * @see NomenclaturalStatusType#isIllegitimateType()
 322          * @see NomenclaturalStatusType#isLegitimateType()
 323          */
 324         public static final NameRelationshipType LATER_HOMONYM(){
 325           return findTermByUuid(uuidLaterHomonym);
 326         }
 327
 328
 329         /**
 330          * Returns the "treated as later homonym" name relationship type. The first
 331          * {@link TaxonNameBase taxon name} involved in such a relationship is
 332          * treated as an homonym although it has been published before the second
 333          * taxon name. The two taxon names involved must belong to different
 334          * {@link HomotypicalGroup homotypical groups} and their name parts (excluding
 335          * {@link Rank#isInfraSpecific() infraspecific ranks} and {@link NonViralName#getAuthorshipCache() authorship}) must be
 336          * almost identical (so one could be mistaken for the other). The first
 337          * taxon name is "illegitimate" and the second one is "legitimate" (this
 338          * corresponds to "invalid" and "valid" in case of {@link ZoologicalName zoological names}).<BR>
 339          * This type is not symmetric but transitive.
 340          *
 341          * @see #LATER_HOMONYM()
 342          * @see NomenclaturalStatusType#isIllegitimateType()
 343          * @see NomenclaturalStatusType#isLegitimateType()
 344          */
 345         public static final NameRelationshipType TREATED_AS_LATER_HOMONYM(){
 346           return findTermByUuid(uuidTreatedAsLaterHomonym);
 347         }
 348
 349         /**
 350          * Returns the "later isonym" name relationship type where the first
 351          * {@link TaxonNameBase taxon name} involved has been published after the second taxon name.<BR>
 352          * In contrast to the {@link #LATER_HOMONYM() later homonym} relationship the two
 353          * {@link TaxonNameBase taxon names} involved have the type(s) so they belong to the
 354          * same {@link HomotypicalGroup homotypical groups}. As later homonyms they have in general
 355          * different {@link NonViralName#getAuthorshipCache() authorship} and their name parts
 356          * must be (almost) identical, so one could be mistaken for the other one.<BR>
 357          * Later isonyms are validly published names but with a wrong citation. So there are rather errors
 358          * then independent names.<BR>
 359          * Isonyms are handled in Article 6, Note 2 of the ICNAFP (Melbourne Code):
 360          * <code>When the same name, based on the same type, has been published independently at different
 361          *  times perhaps by different authors, then only the earliest of these �isonyms� has
 362          *  nomenclatural status. The name is always to be cited from its original
 363          *  place of valid publication, and later isonyms may be disregarded (but see Art. 14.15).</code>
 364          * <BR><BR>
 365          * See discussion at: <a href=http://dev.e-taxonomy.eu/trac/ticket/2901>#2901</a>
 366          *
 367          */
 368         public static final NameRelationshipType LATER_ISONYM(){
 369                 return findTermByUuid(uuidLaterIsonym);
 370         }
 371
 372         /**
 373          * Returns the "alternative name" name relationship type. Both {@link TaxonNameBase taxon names}
 374          * involved in such a relationship are family names. The first one is a
 375          * classical name long in use, in some cases, even before 1753 and is considered as
 376          * {@link NomenclaturalStatusType#VALID() valid} and also {@link NomenclaturalStatusType#isLegitimateType() legitimate}
 377          * although it does not follow the rules for family names (see Article 18 of
 378          * the ICBN). An alternative name is typified by the type of the name
 379          * it is alternative to (so both must belong to the same
 380          * {@link HomotypicalGroup homotypical group}).<BR>
 381          * For instance <i>Cruciferae</i> Adans is an alternative name to
 382          * <i>Brassicaceae</i> Lindl.<BR>
 383          * This type is neither symmetric nor transitive.
 384          */
 385         public static final NameRelationshipType ALTERNATIVE_NAME(){
 386           return findTermByUuid(uuidAlternativeName);
 387         }
 388         /**
 389          * Returns the "basionym" name relationship type. The first {@link TaxonNameBase taxon name}
 390          * involved in such a relationship is the "basionym" of the second taxon
 391          * name. Both taxon names belong to the same {@link HomotypicalGroup homotypical group}).
 392          * The basionym is the epithet-bringing taxon name (first taxon name
 393          * ever validly published given to the same {@link Rank#isInfraGeneric() infrageneric}
 394          * taxon, the epithet of which is the same as in the second taxon name
 395          * originated through a reclassification).<BR>
 396          * According to the ICBN the author of the basionym must be mentioned in the
 397          * later taxon name (by placing it in parentheses before the authority of
 398          * the new combination). For instance <i>Pinus abies</i> L. is the basionym of
 399          * <i>Picea abies</i> (L.) H. Karst.<BR>
 400          * This type is neither symmetric nor transitive.
 401          */
 402         public static final NameRelationshipType BASIONYM(){
 403           return findTermByUuid(uuidBasionym);
 404         }
 405         /**
 406          * Returns the "replaced synonym" name relationship type. The first
 407          * {@link TaxonNameBase taxon name} involved in such a relationship is the
 408          * "replaced synonym" of the second taxon name. Both taxon names belong to
 409          * the same {@link HomotypicalGroup homotypical group}. The replaced synonym is the
 410          * first taxon name ever validly published given to the same
 411          * {@link Rank#isInfraGeneric() infrageneric} taxon that is either itself a
 412          * "later homonym" or the epithet of which could not be used in the new
 413          * taxon name originated through a reclassification. A new epithet must be
 414          * proposed if the use of the original epithet leads to an already existing
 415          * taxon name (for another taxon) or in botany to autonyms (since the ICBN
 416          * does not allow such names where epithet and genus name are the same).<BR>
 417          * For instance <i>Spartium biflorum</i> Desf. is the replaced synonym of
 418          * of <i>Cytisus fontanesii</i> Spach ("novum" taxon name) because at the time
 419          * of reclassification a taxon name <i>Cytisus biflorum</i> had been already
 420          * published by L'H�r.<BR>
 421          * This type is neither symmetric nor transitive.
 422          *
 423          * @see #BASIONYM()
 424          * @see #LATER_HOMONYM()
 425          * @see NomenclaturalStatusType#NOVUM()
 426          */
 427         public static final NameRelationshipType REPLACED_SYNONYM(){
 428           return findTermByUuid(uuidReplacedSynonym);
 429         }
 430         /**
 431          * Returns the "conserved against" name relationship type. Both {@link TaxonNameBase taxon names}
 432          * involved in such a relationship belong to the same {@link HomotypicalGroup homotypical group}.
 433          * Competent authorities decided, regardless of the general
 434          * nomenclatural rules, to handle the first one as the "legitimate"
 435          * one and the second taxon name as "illegitimate" (this corresponds to
 436          * "valid" and "invalid" in case of {@link ZoologicalName zoological names}).<BR>
 437          * For instance <i>Cephaloziella</i> (Spruce) Schiffn. is conserved against
 438          * <i>Dichiton</i> Mont.<BR>
 439          * This type is neither symmetric nor transitive.
 440          *
 441          * @see NomenclaturalStatusType#CONSERVED()
 442          * @see NomenclaturalStatusType#REJECTED()
 443          * @see NomenclaturalStatusType#isLegitimateType()
 444          * @see NomenclaturalStatusType#isIllegitimateType()
 445          */
 446         public static final NameRelationshipType CONSERVED_AGAINST(){
 447           return findTermByUuid(uuidConservedAgainst);
 448         }
 449         /**
 450          * Returns the "validated by name" name relationship type. The two
 451          * {@link TaxonNameBase taxon names} involved in such a relationship were published
 452          * in order to define the same taxonomical group but the first
 453          * (earlier) taxon name was invalidly published whereas the second (later)
 454          * taxon name is the one which was validly published for the first time.<BR>
 455          * This type is neither symmetric nor transitive.
 456          *
 457          * @see         NomenclaturalStatusType#isInvalidType()
 458          * @see         NomenclaturalStatusType#VALID()
 459          */
 460         public static final NameRelationshipType VALIDATED_BY_NAME(){
 461           return findTermByUuid(uuidValidatedByName);
 462         }
 463         /**
 464          * Returns the "later validated by name" name relationship type. The two
 465          * {@link TaxonNameBase taxon names} involved in such a relationship were published
 466          * in order to define the same taxonomical group but the first
 467          * (earlier) taxon name was invalidly published whereas the second (later)
 468          * taxon name is the one which was validly published for the first time.<BR>
 469          * This type is neither symmetric nor transitive.
 470          *
 471          * @see         NomenclaturalStatusType#isInvalidType()
 472          * @see         NomenclaturalStatusType#VALID()
 473          */
 474         public static final NameRelationshipType LATER_VALIDATED_BY_NAME(){
 475           return findTermByUuid(uuidLaterValidatedByName);
 476         }
 477         /**
 478          * Returns the "blocking name" name relationship type. The first
 479          * {@link TaxonNameBase taxon name} involved in such a relationship is the
 480          * "blocking name" for the second taxon name. Both taxon names belong to
 481          * different {@link HomotypicalGroup homotypical groups}). The blocking taxon name is the
 482          * {@link Rank#isInfraGeneric() infrageneric} taxon name, already published at the time of
 483          * reclassification, which makes illegitim (because of homonymy) the use of
 484          * the epithet in the second taxon name originated through a reclassification.
 485          * Therefore a "replaced synonym" name relationship arises.<BR>
 486          * For instance  <i>Cytisus biflorum</i> L'H�r. is the blocking name for
 487          * <i>Cytisus fontanesii</i> Spach ("novum" taxon name) when reclassifying
 488          * <i>Spartium biflorum</i> Desf. from <i>Spartium</i> to <i>Cytisus</i>.<BR>
 489          * This type is neither symmetric nor transitive.
 490          *
 491          * @see #REPLACED_SYNONYM()
 492          * @see #LATER_HOMONYM()
 493          * @see NomenclaturalStatusType#NOVUM()
 494          */
 495         public static final NameRelationshipType BLOCKING_NAME_FOR(){
 496           return  findTermByUuid(uuidBlockingNameFor);
 497         }
 498
 499         @Override
 500         protected void setDefaultTerms(TermVocabulary<NameRelationshipType> termVocabulary) {
 501                 termMap = new HashMap<UUID, NameRelationshipType>();
 502                 for (NameRelationshipType term : termVocabulary.getTerms()){
 503                         termMap.put(term.getUuid(), term);
 504                 }
 505         }
 506
 507         @Override
 508         public NameRelationshipType readCsvLine(Class<NameRelationshipType> termClass, List<String> csvLine, Map<UUID,DefinedTermBase> terms, boolean abbrevAsId) {
 509                 NameRelationshipType result = super.readCsvLine(termClass, csvLine, terms, abbrevAsId);
 510                 String kindOfString = csvLine.get(10).trim();
 511                 if (StringUtils.isNotBlank(kindOfString)){
 512                         UUID uuidKindOf = UUID.fromString(kindOfString);
 513                         DefinedTermBase<?> kindOf = terms.get(uuidKindOf);
 514                         result.setKindOf((NameRelationshipType)kindOf);
 515                 }
 516                 return result;
 517         }
 518 }