cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/Rank.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 import java.util.HashMap;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.UUID;
  16
  17 import javax.persistence.Entity;
  18 import javax.persistence.Transient;
  19 import javax.xml.bind.annotation.XmlAccessType;
  20 import javax.xml.bind.annotation.XmlAccessorType;
  21 import javax.xml.bind.annotation.XmlType;
  22
  23 import org.apache.log4j.Logger;
  24 import org.hibernate.envers.Audited;
  25 import org.hibernate.search.annotations.Indexed;
  26
  27 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  28 import eu.etaxonomy.cdm.model.common.Language;
  29 import eu.etaxonomy.cdm.model.common.OrderedTermBase;
  30 import eu.etaxonomy.cdm.model.common.Representation;
  31 import eu.etaxonomy.cdm.model.common.TermVocabulary;
  32 import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;
  33
  34 /**
  35  * The class representing the taxonomical ranks (like "Family", "Genus" or
  36  * "Species") used for {@link TaxonNameBase taxon names} across all {@link NomenclaturalCode nomenclatural codes}
  37  * for bacteria (ICNB), viruses (ICVCN), plants and fungi (ICBN),
  38  * cultivars (ICNCP) and animals (ICZN).
  39  * <P>
  40  * A standard (ordered) list of taxonomical rank instances will be automatically
  41  * created as the project starts. But this class allows to extend this standard
  42  * list by creating new instances of additional taxonomical ranks if needed.
  43  * <P>
  44  * This class corresponds to: <ul>
  45  * <li> TaxonRankTerm according to the TDWG ontology
  46  * <li> TaxonomicRankEnum according to the TCS
  47  * <li> Rank according to the ABCD schema
  48  * </ul>
  49  *
  50  * @author m.doering
  51  * @version 1.0
  52  * @created 08-Nov-2007 13:06:46
  53  */
  54 @XmlAccessorType(XmlAccessType.FIELD)
  55 @XmlType(name = "Rank")
  56 @Entity
  57 @Indexed(index = "eu.etaxonomy.cdm.model.common.DefinedTermBase")
  58 @Audited
  59 public class Rank extends OrderedTermBase<Rank> {
  60         private static final long serialVersionUID = -8648081681348758485L;
  61         private static final Logger logger = Logger.getLogger(Rank.class);
  62
  63         private static final UUID uuidEmpire = UUID.fromString("ac470211-1586-4b24-95ca-1038050b618d");
  64         private static final UUID uuidDomain = UUID.fromString("ffca6ec8-8b88-417b-a6a0-f7c992aac19b");
  65         private static final UUID uuidSuperkingdom = UUID.fromString("64223610-7625-4cfd-83ad-b797bf7f0edd");
  66         private static final UUID uuidKingdom = UUID.fromString("fbe7109d-66b3-498c-a697-c6c49c686162");
  67         private static final UUID uuidSubkingdom = UUID.fromString("a71bd9d8-f3ab-4083-afb5-d89315d71655");
  68         private static final UUID uuidInfrakingdom = UUID.fromString("1e37930c-86cf-44f6-90fd-7822928df260");
  69         private static final UUID uuidSuperphylum = UUID.fromString("0d0cecb1-e254-4607-b210-6801e7ecbb04");
  70         private static final UUID uuidPhylum = UUID.fromString("773430d2-76b4-438c-b817-97a543a33287");
  71         private static final UUID uuidSubphylum = UUID.fromString("23a9b6ff-9408-49c9-bd9e-7a2ca5ab4725");
  72         private static final UUID uuidInfraphylum = UUID.fromString("1701de3a-7693-42a5-a2d3-42697f944190");
  73         private static final UUID uuidSuperdivision = UUID.fromString("a735a48f-4fc8-49a7-ae0c-6a984f658131");
  74         private static final UUID uuidDivision = UUID.fromString("7e56f5cc-123a-4fd1-8cbb-6fd80358b581");
  75         private static final UUID uuidSubdivision = UUID.fromString("931c840f-7a6b-4d76-ad38-bfdd77d7b2e8");
  76         private static final UUID uuidInfradivision = UUID.fromString("c0ede273-be52-4dee-b411-66ee08d30c94");
  77         private static final UUID uuidSuperclass = UUID.fromString("e65b4e1a-21ec-428d-9b9f-e87721ab967c");
  78         private static final UUID uuidClass = UUID.fromString("f23d14c4-1d34-4ee6-8b4e-eee2eb9a3daf");
  79         private static final UUID uuidSubclass = UUID.fromString("8cb26733-e2f5-46cb-ab5c-f99254f877aa");
  80         private static final UUID uuidInfraclass = UUID.fromString("ad23cfda-879a-4021-8629-c54d27caf717");
  81         private static final UUID uuidSuperorder = UUID.fromString("c8c67a22-301a-4219-b882-4a49121232ff");
  82         private static final UUID uuidOrder = UUID.fromString("b0785a65-c1c1-4eb4-88c7-dbd3df5aaad1");
  83         private static final UUID uuidSuborder = UUID.fromString("768ad378-fa85-42ab-b668-763225832f57");
  84         private static final UUID uuidInfraorder = UUID.fromString("84099182-a6f5-47d7-8586-33c9e9955a10");
  85         private static final UUID uuidSectionZoology = UUID.fromString("691d371e-10d7-43f0-93db-3d7fa1a62c54");
  86         private static final UUID uuidSubsectionZoology = UUID.fromString("0ed32d28-adc4-4303-a9ca-68e2acd67e33");
  87         private static final UUID uuidSuperfamily = UUID.fromString("2cfa510a-dcea-4a03-b66a-b1528f9b0796");
  88         private static final UUID uuidFamily = UUID.fromString("af5f2481-3192-403f-ae65-7c957a0f02b6");
  89         private static final UUID uuidSubfamily = UUID.fromString("862526ee-7592-4760-a23a-4ff3641541c5");
  90         private static final UUID uuidInfrafamily = UUID.fromString("c3f2e3bb-6eef-4a26-9fb7-b14f4c8c5e4f");
  91         private static final UUID uuidSupertribe = UUID.fromString("11e94828-8c61-499b-87d6-1de35ce2c51c");
  92         private static final UUID uuidTribe = UUID.fromString("4aa6890b-0363-4899-8d7c-ee0cb78e6166");
  93         private static final UUID uuidSubtribe = UUID.fromString("ae41ecc5-5165-4126-9d24-79939ae5d822");
  94         private static final UUID uuidInfratribe = UUID.fromString("1ec02e8f-f2b7-4c65-af9f-b436b34c79a3");
  95         private static final UUID uuidSupragenericTaxon = UUID.fromString("1fdc0b93-c354-441a-8406-091e0303ff5c");
  96         private static final UUID uuidGenus = UUID.fromString("1b11c34c-48a8-4efa-98d5-84f7f66ef43a");
  97         private static final UUID uuidSubgenus = UUID.fromString("78786e16-2a70-48af-a608-494023b91904");
  98         private static final UUID uuidInfragenus = UUID.fromString("a9972969-82cd-4d54-b693-a096422f13fa");
  99         private static final UUID uuidSectionBotany = UUID.fromString("3edff68f-8527-49b5-bf91-7e4398bb975c");
 100         private static final UUID uuidSubsectionBotany = UUID.fromString("d20f5b61-d463-4448-8f8a-c1ff1f262f59");
 101         private static final UUID uuidSeries = UUID.fromString("d7381ecf-48f8-429b-9c54-f461656978cd");
 102         private static final UUID uuidSubseries = UUID.fromString("80c9a263-f4db-4a13-b6c2-b7fec1aa1200");
 103         private static final UUID uuidSpeciesAggregate = UUID.fromString("1ecae058-4217-4f75-9c27-6d8ba099ac7a");
 104         private static final UUID uuidSpeciesGroup = UUID.fromString("d1988a11-292b-46fa-8fb7-bc64ea6d8fc6");
 105         private static final UUID uuidInfragenericTaxon = UUID.fromString("41bcc6ac-37d3-4fd4-bb80-3cc5b04298b9");
 106         private static final UUID uuidSpecies = UUID.fromString("b301f787-f319-4ccc-a10f-b4ed3b99a86d");
 107         private static final UUID uuidSubspecificAggregate = UUID.fromString("72c248b9-027d-4402-b375-dd4f0850c9ad");
 108         private static final UUID uuidSubspecies = UUID.fromString("462a7819-8b00-4190-8313-88b5be81fad5");
 109         private static final UUID uuidInfraspecies = UUID.fromString("f28ebc9e-bd50-4194-9af1-42f5cb971a2c");
 110         private static final UUID uuidNatio = UUID.fromString("965f2f38-7f97-4270-ab5a-1999bf050a22");
 111         private static final UUID uuidVariety = UUID.fromString("d5feb6a5-af5c-45ef-9878-bb4f36aaf490");
 112         private static final UUID uuidBioVariety = UUID.fromString("a3a364cb-1a92-43fc-a717-3c44980a0991");
 113         private static final UUID uuidPathoVariety = UUID.fromString("2f4f4303-a099-47e3-9048-d749d735423b");
 114         private static final UUID uuidSubvariety = UUID.fromString("9a83862a-7aee-480c-a98d-4bceaf8712ca");
 115         private static final UUID uuidSubsubvariety = UUID.fromString("bff22f84-553a-4429-a4e7-c4b3796c3a18");
 116         private static final UUID uuidConvar = UUID.fromString("2cc740c9-cebb-43c8-9b06-1bef79e6a56a");
 117         private static final UUID uuidForm = UUID.fromString("0461281e-458a-47b9-8d41-19a3d39356d5");
 118         private static final UUID uuidSpecialForm = UUID.fromString("bed20aee-2f5a-4635-9c02-eff06246d067");
 119         private static final UUID uuidSubform = UUID.fromString("47cfc5b0-0fb7-4ceb-b61d-e1dd8de8b569");
 120         private static final UUID uuidSubsubform = UUID.fromString("1c8ac389-4349-4ae0-87be-7239f6635068");
 121         private static final UUID uuidInfraspecificTaxon = UUID.fromString("eb75c27d-e154-4570-9d96-227b2df60474");
 122         private static final UUID uuidCandidate = UUID.fromString("ead9a1f5-dfd4-4de2-9121-70a47accb10b");
 123         private static final UUID uuidDenominationClass = UUID.fromString("49bdf74a-2170-40ed-8be2-887a0db517bf");
 124         private static final UUID uuidGrex = UUID.fromString("08dcb4ff-ac58-48a3-93af-efb3d836ac84");
 125         private static final UUID uuidGraftChimaera = UUID.fromString("6b4063bc-f934-4796-9bf3-0ef3aea5c1cb");
 126         private static final UUID uuidCultivarGroup = UUID.fromString("d763e7d3-e7de-4bb1-9d75-225ca6948659");
 127         private static final UUID uuidCultivar = UUID.fromString("5e98415b-dc6e-440b-95d6-ea33dbb39ad0");
 128         private static final UUID uuidUnknownRank = UUID.fromString("5c4d6755-2cf6-44ca-9220-cccf8881700b");
 129
 130
 131         private static Map<String, UUID> abbrevMap = null;
 132         private static Map<String, UUID> labelMap = null;
 133
 134         protected static Map<UUID, Rank> termMap = null;
 135
 136
 137 // ********************* CONSTRUCTORS ************************************+/
 138         /**
 139          * Class constructor: creates a new empty rank instance.
 140          *
 141          * @see         #Rank(String, String, String)
 142          */
 143         public Rank() {
 144         }
 145
 146         /**
 147          * Class constructor: creates an additional rank instance with a description
 148          * (in the {@link eu.etaxonomy.cdm.model.common.Language#DEFAULT() default language}), a label and a label abbreviation.
 149          *
 150          * @param       term             the string (in the default language) describing the
 151          *                                               new rank to be created
 152          * @param       label            the string identifying the new rank to be created
 153          * @param       labelAbbrev  the string identifying (in abbreviated form) the
 154          *                                               new rank to be created
 155          * @see         #Rank()
 156          */
 157         public Rank(String term, String label, String labelAbbrev) {
 158                 super(term, label, labelAbbrev);
 159         }
 160
 161         /**
 162          * Creates a new empty rank.
 163          *
 164          * @see #NewInstance(String, String, String)
 165          */
 166         private static Rank NewInstance(){
 167                 return new Rank();
 168         }
 169
 170         /**
 171          * Creates an additional rank with a description (in the {@link Language#DEFAULT() default language}),
 172          * a label and a label abbreviation.
 173          *
 174          * @param       term             the string (in the default language) describing the
 175          *                                               new rank to be created
 176          * @param       label            the string identifying the new rank to be created
 177          * @param       labelAbbrev  the string identifying (in abbreviated form) the
 178          *                                               new rank to be created
 179          * @see                                  #NewInstance()
 180          */
 181         private static Rank NewInstance(String term, String label, String labelAbbrev){
 182                 return new Rank(term, label, labelAbbrev);
 183         }
 184
 185 //********* METHODS **************************************/
 186
 187         protected static Rank getTermByUuid(UUID uuid){
 188                 if (termMap == null){
 189                         return null;  //better return null then initialize the termMap in an unwanted way
 190                 }
 191                 return (Rank)termMap.get(uuid);
 192         }
 193
 194         public static final Rank EMPIRE(){
 195           return getTermByUuid(uuidEmpire);
 196         }
 197         public static final Rank DOMAIN(){
 198                   return getTermByUuid(uuidDomain);
 199         }
 200         public static final Rank SUPERKINGDOM(){
 201                 return getTermByUuid(uuidSuperkingdom);
 202         }
 203         public static final Rank KINGDOM(){
 204                 return getTermByUuid(uuidKingdom);
 205         }
 206         public static final Rank SUBKINGDOM(){
 207                 return getTermByUuid(uuidSubkingdom);
 208         }
 209         public static final Rank INFRAKINGDOM(){
 210                 return getTermByUuid(uuidInfrakingdom);
 211         }
 212         public static final Rank SUPERPHYLUM(){
 213                 return getTermByUuid(uuidSuperphylum);
 214         }
 215         public static final Rank PHYLUM(){
 216                 return getTermByUuid(uuidPhylum);
 217         }
 218         public static final Rank SUBPHYLUM(){
 219                 return getTermByUuid(uuidSubphylum);
 220         }
 221         public static final Rank INFRAPHYLUM(){
 222                 return getTermByUuid(uuidInfraphylum);
 223         }
 224         public static final Rank SUPERDIVISION(){
 225                 return getTermByUuid(uuidSuperdivision);
 226         }
 227         public static final Rank DIVISION(){
 228                 return getTermByUuid(uuidDivision);
 229         }
 230         public static final Rank SUBDIVISION(){
 231                 return getTermByUuid(uuidSubdivision);
 232         }
 233         public static final Rank INFRADIVISION(){
 234                 return getTermByUuid(uuidInfradivision);
 235         }
 236         public static final Rank SUPERCLASS(){
 237                 return getTermByUuid(uuidSuperclass);
 238         }
 239         public static final Rank CLASS(){
 240                 return getTermByUuid(uuidClass);
 241         }
 242         public static final Rank SUBCLASS(){
 243                 return getTermByUuid(uuidSubclass);
 244         }
 245         public static final Rank INFRACLASS(){
 246                 return getTermByUuid(uuidInfraclass);
 247         }
 248         public static final Rank SUPERORDER(){
 249                 return getTermByUuid(uuidSuperorder);
 250         }
 251         public static final Rank ORDER(){
 252                 return getTermByUuid(uuidOrder);
 253         }
 254         public static final Rank SUBORDER(){
 255                 return getTermByUuid(uuidSuborder);
 256         }
 257         public static final Rank INFRAORDER(){
 258                 return getTermByUuid(uuidInfraorder);
 259         }
 260         public static final Rank SUPERFAMILY(){
 261                 return getTermByUuid(uuidSuperfamily);
 262         }
 263         public static final Rank FAMILY(){
 264                 return getTermByUuid(uuidFamily);
 265         }
 266         public static final Rank SUBFAMILY(){
 267                 return getTermByUuid(uuidSubfamily);
 268         }
 269         public static final Rank INFRAFAMILY(){
 270                 return getTermByUuid(uuidInfrafamily);
 271         }
 272         public static final Rank SUPERTRIBE(){
 273                 return getTermByUuid(uuidSupertribe);
 274         }
 275         public static final Rank TRIBE(){
 276                 return getTermByUuid(uuidTribe);
 277         }
 278         public static final Rank SUBTRIBE(){
 279                 return getTermByUuid(uuidSubtribe);
 280         }
 281         public static final Rank INFRATRIBE(){
 282                 return getTermByUuid(uuidInfratribe);
 283         }
 284         public static final Rank SUPRAGENERICTAXON(){
 285                 return getTermByUuid(uuidSupragenericTaxon);
 286         }
 287         public static final Rank GENUS(){
 288                 return getTermByUuid(uuidGenus);
 289         }
 290         public static final Rank SUBGENUS(){
 291                 return getTermByUuid(uuidSubgenus);
 292         }
 293         public static final Rank INFRAGENUS(){
 294                 return getTermByUuid(uuidInfragenus);
 295         }
 296         public static final Rank SECTION_BOTANY(){
 297                 return getTermByUuid(uuidSectionBotany);
 298         }
 299         public static final Rank SUBSECTION_BOTANY(){
 300                 return getTermByUuid(uuidSubsectionBotany);
 301         }
 302         public static final Rank SECTION_ZOOLOGY(){
 303                 return getTermByUuid(uuidSectionZoology);
 304         }
 305         public static final Rank SUBSECTION_ZOOLOGY(){
 306                 return getTermByUuid(uuidSubsectionZoology);
 307         }
 308         public static final Rank SERIES(){
 309                 return getTermByUuid(uuidSeries);
 310         }
 311         public static final Rank SUBSERIES(){
 312                 return getTermByUuid(uuidSubseries);
 313         }
 314         public static final Rank SPECIESAGGREGATE(){
 315                 return getTermByUuid(uuidSpeciesAggregate);
 316         }
 317         public static final Rank SPECIESGROUP(){
 318                 return getTermByUuid(uuidSpeciesGroup);
 319         }
 320         public static final Rank INFRAGENERICTAXON(){
 321                 return getTermByUuid(uuidInfragenericTaxon);
 322         }
 323         public static final Rank SPECIES(){
 324                 return getTermByUuid(uuidSpecies);
 325         }
 326         public static final Rank SUBSPECIFICAGGREGATE(){
 327                 return getTermByUuid(uuidSubspecificAggregate);
 328         }
 329         public static final Rank SUBSPECIES(){
 330                 return getTermByUuid(uuidSubspecies);
 331         }
 332         public static final Rank INFRASPECIES(){
 333                 return getTermByUuid(uuidInfraspecies);
 334         }
 335         public static final Rank VARIETY(){
 336                 return getTermByUuid(uuidVariety);
 337         }
 338         public static final Rank BIOVARIETY(){
 339                 return getTermByUuid(uuidBioVariety);
 340         }
 341         public static final Rank PATHOVARIETY(){
 342                 return getTermByUuid(uuidPathoVariety);
 343         }
 344         public static final Rank SUBVARIETY(){
 345                 return getTermByUuid(uuidSubvariety);
 346         }
 347         public static final Rank SUBSUBVARIETY(){
 348                 return getTermByUuid(uuidSubsubvariety );
 349         }
 350         public static final Rank CONVAR(){
 351                 return getTermByUuid(uuidConvar);
 352         }
 353         public static final Rank FORM(){
 354                 return getTermByUuid(uuidForm);
 355         }
 356         public static final Rank SPECIALFORM(){
 357                 return getTermByUuid(uuidSpecialForm);
 358         }
 359         public static final Rank SUBFORM(){
 360                 return getTermByUuid(uuidSubform);
 361         }
 362         public static final Rank SUBSUBFORM(){
 363                 return getTermByUuid(uuidSubsubform);
 364         }
 365         public static final Rank INFRASPECIFICTAXON(){
 366                 return getTermByUuid(uuidInfraspecificTaxon);
 367         }
 368         public static final Rank CANDIDATE(){
 369                 return getTermByUuid(uuidCandidate);
 370         }
 371         public static final Rank DENOMINATIONCLASS(){
 372                 return getTermByUuid(uuidDenominationClass);
 373         }
 374         public static final Rank GREX(){
 375                 return getTermByUuid(uuidGrex);
 376         }
 377         public static final Rank GRAFTCHIMAERA(){
 378                 return getTermByUuid(uuidGraftChimaera);
 379         }
 380         public static final Rank CULTIVARGROUP(){
 381                 return getTermByUuid(uuidCultivarGroup);
 382         }
 383         public static final Rank CULTIVAR(){
 384                 return getTermByUuid(uuidCultivar);
 385         }
 386         public static final Rank UNKNOWN_RANK(){
 387                 return getTermByUuid(uuidUnknownRank);
 388         }
 389         public static final Rank NATIO(){
 390                 return getTermByUuid(uuidNatio);
 391         }
 392
 393
 394         /**
 395          * Returns the boolean value indicating whether <i>this</i> rank is higher than
 396          * the genus rank (true) or not (false). Returns false if <i>this</i> rank is null.
 397          *
 398          * @see  #isGenus()
 399          * @see  #isInfraGeneric()
 400          * @see  #isSpecies()
 401          * @see  #isInfraSpecific()
 402          */
 403         @Transient
 404         public boolean isSupraGeneric(){
 405                 return (this.isHigher(Rank.GENUS()));
 406         }
 407
 408         /**
 409          * Returns the boolean value indicating whether <i>this</i> rank is the genus rank
 410          * (true) or not (false). Returns false if <i>this</i> rank is null.
 411          *
 412          * @see  #isSupraGeneric()
 413          * @see  #isInfraGeneric()
 414          * @see  #isSpecies()
 415          * @see  #isInfraSpecific()
 416          */
 417         @Transient
 418         public boolean isGenus(){
 419                 return (this.equals(Rank.GENUS()));
 420         }
 421
 422         /**
 423          * Returns the boolean value indicating whether <i>this</i> rank is higher than the
 424          * species rank and lower than the genus rank (true) or not (false).
 425          * Returns false if <i>this</i> rank is null.
 426          *
 427          * @see  #isSupraGeneric()
 428          * @see  #isGenus()
 429          * @see  #isSpecies()
 430          * @see  #isInfraSpecific()
 431          */
 432         @Transient
 433         public boolean isInfraGeneric(){
 434                 return (this.isLower(Rank.GENUS()) && this.isHigher(Rank.SPECIES()));
 435         }
 436
 437         /**
 438          * Returns true if this rank indicates a rank that aggregates species
 439          * like species aggregates or species groups, false otherwise. This methods
 440          * currently returns false for all user defined ranks.
 441          * @return
 442          */
 443         @Transient
 444         public boolean isSpeciesAggregate(){
 445                 return (this.equals(Rank.SPECIESAGGREGATE()) || (this.isLower(Rank.SPECIESAGGREGATE()) && this.isHigher(Rank.SPECIES())));
 446         }
 447
 448         /**
 449          * Returns the boolean value indicating whether <i>this</i> rank is the species
 450          * rank (true) or not (false). Returns false if <i>this</i> rank is null.
 451          *
 452          * @see  #isSupraGeneric()
 453          * @see  #isGenus()
 454          * @see  #isInfraGeneric()
 455          * @see  #isInfraSpecific()
 456          */
 457         @Transient
 458         public boolean isSpecies(){
 459                 return (this.equals(Rank.SPECIES()));
 460         }
 461
 462         /**
 463          * Returns the boolean value indicating whether <i>this</i> rank is lower than the
 464          * species rank (true) or not (false). Returns false if <i>this</i> rank is null.
 465          *
 466          * @see  #isSupraGeneric()
 467          * @see  #isGenus()
 468          * @see  #isInfraGeneric()
 469          * @see  #isSpecies()
 470          */
 471         @Transient
 472         public boolean isInfraSpecific(){
 473                 return (this.isLower(Rank.SPECIES()));
 474         }
 475
 476
 477         /**
 478          * Returns the rank identified through a name (abbreviated or not).
 479          * Preliminary implementation for BotanicalNameParser.
 480          *
 481          * @param       strRank the string identifying the rank
 482          * @return              the rank
 483          */
 484         public static Rank getRankByNameOrAbbreviation(String strRank)
 485                                 throws UnknownCdmTypeException{
 486                 return getRankByNameOrAbbreviation(strRank, false);
 487         }
 488
 489         /**
 490          * Returns the rank identified through a name (abbreviated or not) for a given nomenclatural code.
 491          * Preliminary implementation for BotanicalNameParser.
 492          *
 493          * @param       strRank the string identifying the rank
 494          * @param   nc      the nomenclatural code
 495          * @return              the rank
 496          */
 497         public static Rank getRankByNameOrAbbreviation(String strRank, NomenclaturalCode nc)
 498                                 throws UnknownCdmTypeException{
 499                 return getRankByNameOrAbbreviation(strRank, nc, false);
 500         }
 501
 502         // TODO
 503         // Preliminary implementation for BotanicalNameParser.
 504         // not yet complete
 505         /**
 506          * Returns the rank identified through a name (abbreviated or not).
 507          * Preliminary implementation for BotanicalNameParser.
 508          *
 509          * @param       strRank the string identifying the rank
 510          * @param       useUnknown      if true the rank UNKNOWN_RANK is returned if the abbrev is
 511          *                      unknown or not yet implemented
 512          * @return              the rank
 513          */
 514         public static Rank getRankByNameOrAbbreviation(String strRank, boolean useUnknown)
 515                         throws UnknownCdmTypeException{
 516                 try {
 517                         return getRankByAbbreviation(strRank);
 518                 } catch (UnknownCdmTypeException e) {
 519                         return getRankByName(strRank, useUnknown);
 520                 }
 521         }
 522
 523         // TODO
 524         // Preliminary implementation for BotanicalNameParser.
 525         // not yet complete
 526         /**
 527          * Returns the rank identified through a name (abbreviated or not).
 528          * Preliminary implementation for BotanicalNameParser.
 529          *
 530          * @param       strRank the string identifying the rank
 531          * @param   nc      the nomenclatural code
 532          * @param       useUnknown      if true the rank UNKNOWN_RANK is returned if the abbrev is
 533          *                      unknown or not yet implemented
 534          * @return              the rank
 535          */
 536         public static Rank getRankByNameOrAbbreviation(String strRank, NomenclaturalCode nc, boolean useUnknown)
 537                         throws UnknownCdmTypeException{
 538                 try {
 539                         return getRankByAbbreviation(strRank, nc);
 540                 } catch (UnknownCdmTypeException e) {
 541                         return getRankByName(strRank, nc, useUnknown);
 542                 }
 543         }
 544
 545         /**
 546          * Returns the rank identified through an abbreviated name.
 547          * Preliminary implementation for BotanicalNameParser.
 548          *
 549          * @param       abbrev  the string for the name abbreviation
 550          * @return              the rank
 551          */
 552         public static Rank getRankByAbbreviation(String abbrev)
 553                                                 throws UnknownCdmTypeException{
 554                 return getRankByAbbreviation(abbrev, false);
 555         }
 556
 557         /**
 558          * Returns the rank identified through an abbreviated name for a given nomenclatural code.
 559          * See also {@link #getRankByAbbreviation(String, boolean)}
 560          *
 561          * @param       abbrev  the string for the name abbreviation
 562          * @param       nc          the nomenclatural code
 563          * @return              the rank
 564          */
 565         public static Rank getRankByAbbreviation(String abbrev, NomenclaturalCode nc) throws UnknownCdmTypeException{
 566                 return getRankByAbbreviation(abbrev, nc, false);
 567         }
 568
 569         // TODO
 570         // Preliminary implementation for BotanicalNameParser.
 571         // not yet complete
 572         /**
 573          * Returns the rank identified through an abbreviated representation.
 574          * At the moment it uses the English abbreviations (being Latin because
 575          * we do not have Latin representations yet.
 576          * TODO
 577          * If no according abbreviation is available it throws either an UnknownCdmTypeException
 578          * or an #Rank.UNKNOWN() object depending on the useUnknown flag.
 579          *
 580          * @param       abbrev          the string for the name abbreviation
 581          * @param       useUnknown      if true the rank UNKNOWN_RANK is returned if the abbrev is
 582          *                      unknown or not yet existent
 583          * @return  the rank
 584          */
 585         public static Rank getRankByAbbreviation(String abbrev, boolean useUnknown) throws UnknownCdmTypeException{
 586                 Rank result = null;
 587                 if (abbrev == null){
 588                         throw new NullPointerException("Abbrev is NULL in getRankByAbbreviation");
 589                 }
 590                 if (abbrevMap == null){
 591                         return null;
 592                 }
 593                 UUID uuid = abbrevMap.get(abbrev);
 594                 if (uuid != null ){
 595                         result = getTermByUuid(uuid);
 596                 }
 597                 if (result != null){
 598                         return result;
 599                 }else {
 600                         if (abbrev == null){
 601                                 abbrev = "(null)";
 602                         }
 603                         if (useUnknown){
 604                                 logger.info("Unknown rank name: " + abbrev + ". Rank 'UNKNOWN_RANK' created instead");
 605                                 return Rank.UNKNOWN_RANK();
 606                         }else{
 607                                 throw new UnknownCdmTypeException("Unknown rank abbreviation: " + abbrev);
 608                         }
 609                 }
 610         }
 611
 612         // TODO
 613         // Preliminary implementation to cover Botany and Zoology.
 614         /**
 615          * Returns the rank identified through an abbreviated name for a given nomenclatural code.
 616          * Preliminary implementation for ICBN and ICZN.
 617          * See also {@link #getRankByAbbreviation(String, boolean)}
 618
 619          *
 620          * @param       abbrev          the string for the name abbreviation
 621          * @param       nc              the nomenclatural code
 622          * @param       useUnknown      if true the rank UNKNOWN_RANK is returned if the abbrev is
 623          *                      unknown or not yet implemented
 624          * @return  the rank
 625          */
 626         public static Rank getRankByAbbreviation(String abbrev, NomenclaturalCode nc,  boolean useUnknown)
 627         throws UnknownCdmTypeException{
 628
 629                 if (nc.equals(NomenclaturalCode.ICZN)) {
 630                         if (abbrev.equalsIgnoreCase("sect.")) { return Rank.SECTION_ZOOLOGY();
 631                         } else if (abbrev.equalsIgnoreCase("subsect.")) { return Rank.SUBSECTION_ZOOLOGY();
 632                         }
 633                 }
 634                 return getRankByAbbreviation(abbrev, useUnknown);
 635         }
 636
 637         // TODO
 638         // Preliminary implementation for BotanicalNameParser.
 639         // not yet complete
 640         /**
 641          * Returns the rank identified through a name.
 642          * Preliminary implementation for BotanicalNameParser.
 643          *
 644          * @param       rankName        the string for the name of the rank
 645          * @return                      the rank
 646          */
 647         public static Rank getRankByName(String rankName) throws UnknownCdmTypeException{
 648                 return getRankByName(rankName, false);
 649         }
 650
 651
 652         // TODO
 653         // Preliminary implementation for ICBN and ICZN.
 654         // not yet complete
 655         /**
 656          * Returns the rank identified through a name for a given nomenclatural code.
 657          * Preliminary implementation for ICBN and ICZN.
 658          *
 659          * @param       rankName        the string for the name of the rank
 660          * @param       nc              the nomenclatural code
 661          * @return                      the rank
 662          */
 663         public static Rank getRankByName(String rankName, NomenclaturalCode nc) throws UnknownCdmTypeException{
 664                 return getRankByName(rankName, nc, false);
 665         }
 666
 667         /**
 668          * Returns the rank identified through a name.
 669          * Preliminary implementation for BotanicalNameParser.
 670          * TODO At the moment we do not have Latin representations yet.
 671          *
 672          * @param       rankName        the string for the name of the rank
 673          * @param       useUnknown      if true the rank UNKNOWN_RANK is returned if the rank name is
 674          *                      unknown or not yet implemented
 675          * @return                      the rank
 676          */
 677         public static Rank getRankByName(String rankName, boolean useUnknown)
 678                         throws UnknownCdmTypeException{
 679                 if (rankName.equalsIgnoreCase("Regnum")){ return Rank.KINGDOM();
 680                 }else if (rankName.equalsIgnoreCase("Subregnum")){ return Rank.SUBKINGDOM();
 681                 }else if (rankName.equalsIgnoreCase("Phylum")){ return Rank.PHYLUM();
 682                 }else if (rankName.equalsIgnoreCase("Subphylum")){ return Rank.SUBPHYLUM();
 683                 }else if (rankName.equalsIgnoreCase("Divisio")){ return Rank.DIVISION();
 684                 }else if (rankName.equalsIgnoreCase("Subdivisio")){ return Rank.SUBDIVISION();
 685                 }else if (rankName.equalsIgnoreCase("Classis")){ return Rank.CLASS();
 686                 }else if (rankName.equalsIgnoreCase("Subclassis")){ return Rank.SUBCLASS();
 687                 }else if (rankName.equalsIgnoreCase("Superordo")){ return Rank.SUPERORDER();
 688                 }else if (rankName.equalsIgnoreCase("Ordo")){ return Rank.ORDER();
 689                 }else if (rankName.equalsIgnoreCase("Subordo")){ return Rank.SUBORDER();
 690                 }else if (rankName.equalsIgnoreCase("Familia")){ return Rank.FAMILY();
 691                 }else if (rankName.equalsIgnoreCase("Subfamilia")){ return Rank.SUBFAMILY();
 692                 }else if (rankName.equalsIgnoreCase("Tribus")){ return Rank.TRIBE();
 693                 }else if (rankName.equalsIgnoreCase("Subtribus")){ return Rank.SUBTRIBE();
 694                 }else if (rankName.equalsIgnoreCase("Genus")){ return Rank.GENUS();
 695                 }else if (rankName.equalsIgnoreCase("Subgenus")){ return Rank.SUBGENUS();
 696                 }else if (rankName.equalsIgnoreCase("Sectio")){ return Rank.SECTION_BOTANY();
 697                 }else if (rankName.equalsIgnoreCase("Subsectio")){ return Rank.SUBSECTION_BOTANY();
 698                 }else if (rankName.equalsIgnoreCase("Series")){ return Rank.SERIES();
 699                 }else if (rankName.equalsIgnoreCase("Subseries")){ return Rank.SUBSERIES();
 700                 }else if (rankName.equalsIgnoreCase("Aggregate")){ return Rank.SPECIESAGGREGATE();
 701                 }else if (rankName.equalsIgnoreCase("Speciesgroup")){ return Rank.SPECIESGROUP();
 702                 }else if (rankName.equalsIgnoreCase("Species")){ return Rank.SPECIES();
 703                 }else if (rankName.equalsIgnoreCase("Subspecies")){ return Rank.SUBSPECIES();
 704                 }else if (rankName.equalsIgnoreCase("Convarietas")){ return Rank.CONVAR();
 705                 }else if (rankName.equalsIgnoreCase("Varietas")){ return Rank.VARIETY();
 706                 }else if (rankName.equalsIgnoreCase("Subvarietas")){ return Rank.SUBVARIETY();
 707                 }else if (rankName.equalsIgnoreCase("Forma")){ return Rank.FORM();
 708                 }else if (rankName.equalsIgnoreCase("Subforma")){ return Rank.SUBFORM();
 709                 }else if (rankName.equalsIgnoreCase("Forma spec.")){ return Rank.SPECIALFORM();
 710                 }else if (rankName.equalsIgnoreCase("tax.infragen.")){ return Rank.INFRAGENERICTAXON();
 711                 }else if (rankName.equalsIgnoreCase("tax.infrasp.")){ return Rank.INFRASPECIFICTAXON();
 712                 // old ranks
 713                 }else if (rankName.equalsIgnoreCase("proles")){ return Rank.INFRASPECIFICTAXON(); //to create the name put prol. and the infraspeciesepi to the field unnamed namephrase
 714                 }else if (rankName.equalsIgnoreCase("race")){ return Rank.INFRASPECIFICTAXON(); //to create the name put prol. and the infraspeciesepi to the field unnamed namephrase
 715                 }else if (rankName.equalsIgnoreCase("taxon")){ return Rank.INFRASPECIFICTAXON(); //to create the name put prol. and the infraspeciesepi to the field unnamed namephrase
 716                 }else if (rankName.equalsIgnoreCase("sublusus")){ return Rank.INFRASPECIFICTAXON(); //to create the name put prol. and the infraspeciesepi to the field unnamed namephrase
 717
 718                 }else{
 719                         if (rankName == null){
 720                                 rankName = "(null)";
 721                         }
 722                         if (useUnknown){
 723                                 logger.info("Unknown rank name: " + rankName+". Rank 'UNKNOWN_RANK' created instead");
 724                                 return Rank.UNKNOWN_RANK();
 725                         }else{
 726                                 if (rankName == null){
 727                                         rankName = "(null)";
 728                                 }
 729                                 throw new UnknownCdmTypeException("Unknown rank name: " + rankName);
 730                         }
 731                 }
 732         }
 733
 734         public static Rank getRankByEnglishName(String rankName, NomenclaturalCode nc, boolean useUnknown) throws UnknownCdmTypeException{
 735                 Rank result = null;
 736                 if (rankName == null){
 737                         throw new NullPointerException("Abbrev is NULL in getRankByAbbreviation");
 738                 }
 739                 if (labelMap == null){
 740                         return null;
 741                 }
 742                 //handle section and subsection (not unique representations)
 743                 if (rankName.equalsIgnoreCase("Section")){
 744                         if (nc != null && nc.equals(NomenclaturalCode.ICZN)){   return Rank.SECTION_ZOOLOGY();
 745                         }else if (nc != null && nc.equals(NomenclaturalCode.ICBN)){return Rank.SECTION_BOTANY();
 746                         }else{
 747                                 String errorWarning = "Section is only defined for ICZN and ICBN at the moment but here needed for " + ((nc == null)? "(null)": nc.toString());
 748                                 logger.warn(errorWarning);
 749                                 throw new UnknownCdmTypeException (errorWarning);
 750                         }
 751                 }else if (rankName.equalsIgnoreCase("Subsection")){
 752                         if (nc != null && nc.equals(NomenclaturalCode.ICZN)){ return Rank.SECTION_ZOOLOGY();
 753                         }else if (nc != null && nc.equals(NomenclaturalCode.ICBN)){ return Rank.SECTION_BOTANY();
 754                         }else{
 755                                 String errorWarning = "Subsection is only defined for ICZN and ICBN at the moment but here needed for " + ((nc == null)? "(null)": nc.toString());
 756                                 logger.warn(errorWarning);
 757                                 throw new UnknownCdmTypeException (errorWarning);
 758                         }
 759                 }
 760
 761                 rankName = rankName.toLowerCase();
 762
 763                 UUID uuid = labelMap.get(rankName);
 764                 if (uuid != null ){
 765                         result = getTermByUuid(uuid);
 766                 }
 767                 if (result != null){
 768                         return result;
 769                 }else {
 770                         if (rankName == null){
 771                                 rankName = "(null)";
 772                         }
 773                         if (useUnknown){
 774                                 logger.info("Unknown rank name: " + rankName + ". Rank 'UNKNOWN_RANK' created instead");
 775                                 return Rank.UNKNOWN_RANK();
 776                         }else{
 777                                 throw new UnknownCdmTypeException("Unknown rank: " + rankName);
 778                         }
 779                 }
 780         }
 781
 782
 783         public static Rank getRankByName(String rankName, NomenclaturalCode nc, boolean useUnknown)
 784                 throws UnknownCdmTypeException {
 785
 786                 if (nc.equals(NomenclaturalCode.ICZN)) {
 787                         if (rankName.equalsIgnoreCase("Sectio")) { return Rank.SECTION_ZOOLOGY();
 788                         }else if (rankName.equalsIgnoreCase("Subsectio")) { return Rank.SUBSECTION_ZOOLOGY();
 789                         }
 790                 }
 791                 return getRankByName(rankName, useUnknown);
 792         }
 793
 794         /**
 795          * Returns the abbreviated rank name for <i>this</i> rank according to the English representation
 796          * abbreviated label.
 797          * TODO Needs to be changed to Latin as soon as Latin representations are available.
 798          *
 799          * @return      the abbreviation string for <i>this</i> rank
 800          */
 801         public String getAbbreviation(){
 802                 Language language = Language.ENGLISH();
 803                 String result = this.getRepresentation(language).getAbbreviatedLabel();
 804                 if (result== null) {
 805                         logger.warn("Abbreviation for this Rank " + this.toString() +  " not yet implemented");
 806                         return "no abbreviation available.";
 807                 }else{
 808                         return result;
 809                 }
 810         }
 811         @Transient
 812         public String getInfraGenericMarker() throws UnknownCdmTypeException{
 813                 String result = null;
 814                 if (! this.isInfraGeneric()){
 815                         throw new IllegalStateException("An infrageneric marker is only available for a infrageneric rank but was asked for rank: " + this.toString());
 816                 }else{
 817                         result = this.getAbbreviation();
 818                 }
 819                 if (result == null){
 820                         throw new UnknownCdmTypeException("Abbreviation for rank unknown: " + this.toString());
 821                 }
 822                 return result;
 823         }
 824
 825
 826
 827         @Override
 828         public Rank readCsvLine(Class<Rank> termClass, List<String> csvLine, Map<UUID, DefinedTermBase> terms) {
 829                 return super.readCsvLine(termClass, csvLine, terms);
 830         }
 831
 832         @Override
 833         protected void setDefaultTerms(TermVocabulary<Rank> termVocabulary) {
 834                 termMap = new HashMap<UUID, Rank>();
 835                 for (Rank term : termVocabulary.getTerms()){
 836                         termMap.put(term.getUuid(), (Rank)term);
 837                         addRank(term);
 838                 }
 839         }
 840
 841         /**
 842          * @param term
 843          */
 844         private void addRank(Rank rank) {
 845                 if (rank == null){
 846                         logger.warn("rank is NULL");
 847                         return;
 848                 }
 849                 if (rank.getUuid().equals(uuidSectionZoology) || rank.getUuid().equals(uuidSubsectionZoology )){
 850                         //sect./subsect. is used for botanical sections, see also #getRankByAbbreviation(String, NomenclaturalCode, boolean)
 851                         return;
 852                 }
 853                 Language lang = Language.DEFAULT();  //TODO should be Latin but at the moment we have only English representations
 854                 Representation representation = rank.getRepresentation(lang);
 855                 String abbrevLabel = representation.getAbbreviatedLabel();
 856                 String label = representation.getLabel();
 857                 if (abbrevLabel == null){
 858                         logger.warn("label is NULL");
 859                         return;
 860                 }
 861                 //initialize maps
 862                 if (abbrevMap == null){
 863                         abbrevMap = new HashMap<String, UUID>();
 864                 }
 865                 if (labelMap == null){
 866                         labelMap = new HashMap<String, UUID>();
 867                 }
 868                 //add to map
 869                 abbrevMap.put(abbrevLabel, rank.getUuid());
 870                 labelMap.put(label.toLowerCase(), rank.getUuid());
 871         }
 872
 873 }