cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/WrongTermTypeException.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/init/ITermInitializer.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/init/ITermLoader.java -text
-cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/init/IVocabularyStore.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/init/TermLoader.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/init/TermNotFoundException.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/package-info.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/NonViralName.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/Rank.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/SpecimenTypeDesignation.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/SpecimenTypeDesignationStatus.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/TaxonNameBase.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/TypeDesignationBase.java -text
-cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/TypeDesignationStatus.java -text
+cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/TypeDesignationStatusBase.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/ViralName.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/ZoologicalName.java -text
cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/name/package-info.java -text
cdmlib-model/src/main/resources/terms/Rank.csv -text
cdmlib-model/src/main/resources/terms/RightsTerm.csv -text
cdmlib-model/src/main/resources/terms/Sex.csv -text
+cdmlib-model/src/main/resources/terms/SpecimenTypeDesignationStatus.csv -text
cdmlib-model/src/main/resources/terms/StatisticalMeasure.csv -text
cdmlib-model/src/main/resources/terms/SynonymRelationshipType.csv -text
cdmlib-model/src/main/resources/terms/TaxonRelationshipType.csv -text
cdmlib-model/src/main/resources/terms/TdwgArea.csv -text
-cdmlib-model/src/main/resources/terms/TypeDesignationStatus.csv -text
cdmlib-model/src/main/resources/terms/WaterbodyOrCountry.csv -text
cdmlib-model/src/site/resources/images/uml/Agent.png -text
cdmlib-model/src/site/resources/images/uml/Base_classes.png -text
import eu.etaxonomy.cdm.model.name.NomenclaturalCode;\r
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;\r
import eu.etaxonomy.cdm.model.name.Rank;\r
-import eu.etaxonomy.cdm.model.name.TypeDesignationStatus;\r
+import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;\r
import eu.etaxonomy.cdm.model.occurrence.DerivationEventType;\r
import eu.etaxonomy.cdm.model.occurrence.DeterminationModifier;\r
import eu.etaxonomy.cdm.model.occurrence.PreservationMethod;\r
Continent.class,\r
WaterbodyOrCountry.class,\r
Rank.class,\r
- TypeDesignationStatus.class,\r
-// NameTypeDesignationStatus.class,\r
+ SpecimenTypeDesignationStatus.class,\r
NomenclaturalStatusType.class,\r
SynonymRelationshipType.class,\r
HybridRelationshipType.class,\r
DeterminationModifier.class,\r
StatisticalMeasure.class,\r
RightsTerm.class\r
+// NameTypeDesignationStatus.class\r
};\r
\r
public void initialize() {\r
+/**\r
+* Copyright (C) 2007 EDIT\r
+* European Distributed Institute of Taxonomy \r
+* http://www.e-taxonomy.eu\r
+* \r
+* The contents of this file are subject to the Mozilla Public License Version 1.1\r
+* See LICENSE.TXT at the top of this package for the full license terms.\r
+*/\r
package eu.etaxonomy.cdm.model.common;\r
\r
import java.util.HashSet;\r
+/**
+* Copyright (C) 2007 EDIT
+* European Distributed Institute of Taxonomy
+* http://www.e-taxonomy.eu
+*
+* The contents of this file are subject to the Mozilla Public License Version 1.1
+* See LICENSE.TXT at the top of this package for the full license terms.
+*/
package eu.etaxonomy.cdm.model.common;
import java.util.List;
* @param language
* @return
*/
- public abstract String getText(Language language);
+ public String getText(Language language);
/**
* @param languageString
* @return String the previous text in the MultilanguageSet that was associated with the language
* defined in languageString, or null if there was no such text before. (A null return can also indicate that the text was previously null.)
*/
- public abstract LanguageString add(LanguageString languageString);
+ public LanguageString add(LanguageString languageString);
/**
* Iterates on the languages. As soon as there exists a language string for this language in this multilanguage text
// TODO: Avoid using instanceof operator
// Use Class.getDeclaredMethod() instead to find out whether class has getNameCache() method?
- // Compare name cache
String specifiedNameCache = "";
String thisNameCache = "";
+ String specifiedTitleCache = "";
+ String thisTitleCache = "";
+ String specifiedReferenceTitleCache = "";
+ String thisReferenceTitleCache = "";
if(identifiableEntity instanceof NonViralName) {
specifiedNameCache = HibernateProxyHelper.deproxy(identifiableEntity, NonViralName.class).getNameCache();
+ specifiedTitleCache = identifiableEntity.getTitleCache();
} else if(identifiableEntity instanceof TaxonBase) {
TaxonBase taxonBase = HibernateProxyHelper.deproxy(identifiableEntity, TaxonBase.class);
TaxonNameBase<?,?> taxonNameBase= taxonBase.getName();
specifiedNameCache = HibernateProxyHelper.deproxy(taxonNameBase, NonViralName.class).getNameCache();
+ specifiedTitleCache = taxonNameBase.getTitleCache();
+ specifiedReferenceTitleCache = ((TaxonBase)identifiableEntity).getSec().getTitleCache();
}
if(this instanceof NonViralName) {
thisNameCache = HibernateProxyHelper.deproxy(this, NonViralName.class).getNameCache();
+ thisTitleCache = getTitleCache();
} else if(this instanceof TaxonBase) {
TaxonNameBase<?,?> taxonNameBase= HibernateProxyHelper.deproxy(this, TaxonBase.class).getName();
thisNameCache = HibernateProxyHelper.deproxy(taxonNameBase, NonViralName.class).getNameCache();
+ thisTitleCache = taxonNameBase.getTitleCache();
+ thisReferenceTitleCache = getTitleCache();
}
+ // Compare name cache of taxon names
+
if (!specifiedNameCache.equals("") && !thisNameCache.equals("")) {
result = thisNameCache.compareTo(specifiedNameCache);
}
- // Compare title cache
- if (result == 0) {
- String thisTitleCache = getTitleCache();
- String specifiedTitleCache = identifiableEntity.getTitleCache();
+ // Compare title cache of taxon names
+
+ if ((result == 0) && !specifiedTitleCache.equals("") && !thisTitleCache.equals("")) {
result = thisTitleCache.compareTo(specifiedTitleCache);
}
+
+ // Compare title cache of taxon references
+
+ if ((result == 0) && !specifiedReferenceTitleCache.equals("") && !thisReferenceTitleCache.equals("")) {
+ result = thisReferenceTitleCache.compareTo(specifiedReferenceTitleCache);
+ }
+
return result;
}
import eu.etaxonomy.cdm.model.location.NamedAreaLevel;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
import eu.etaxonomy.cdm.model.name.Rank;
-import eu.etaxonomy.cdm.model.name.TypeDesignationStatus;
+import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
/**
* @author m.doering
NamedAreaLevel.class,
NomenclaturalStatusType.class,
Rank.class,
- TypeDesignationStatus.class
+ SpecimenTypeDesignationStatus.class
})
@Entity
@Audited
+++ /dev/null
-package eu.etaxonomy.cdm.model.common.init;\r
-\r
-import java.util.UUID;\r
-\r
-import eu.etaxonomy.cdm.model.common.DefinedTermBase;\r
-import eu.etaxonomy.cdm.model.common.ILoadableTerm;\r
-import eu.etaxonomy.cdm.model.common.TermVocabulary;\r
-\r
-/**\r
- * Terms, vocabularies, and representations loaded during termloading by class TermLoader added \r
- * by the user maybe stored and accessed through this interface.\r
- * Care must be taken as TermLoader indirectly calls getTermByUuid(uuid) for the default \r
- * language uuid during the loading process. So make sure that initialize() and getTermByUuid(uuid) \r
- * are not implemeted in an endless recursion!\r
- * \r
- * @author a.mueller\r
- *\r
- */\r
-public interface IVocabularyStore {\r
- \r
- /**\r
- * TODO\r
- * @param vocabulary\r
- */\r
- public void saveOrUpdate(TermVocabulary vocabulary);\r
- \r
- \r
- \r
- /**\r
- * TODO\r
- * @param term\r
- */\r
- public void saveOrUpdate(ILoadableTerm term);\r
-\r
- \r
- /** ATTENTION: Be aware that TermLoader indirectly calls getTermByUuid(uuid)\r
- * for the default language. So make sure that before loading the Terms by the\r
- * TermLoader getTermByUuid() returns a valid Object without going to endless recursion.\r
- * @param uuid the definedTermBases UUID\r
- * @return the DefinedTermBase to return\r
- */\r
- public DefinedTermBase getTermByUuid(UUID uuid);\r
- \r
- public <T extends DefinedTermBase> T getTermByUuid(UUID uuid, Class<T> clazz);\r
- \r
- /**\r
- * @param uuid\r
- * @return\r
- */\r
- public TermVocabulary getVocabularyByUuid(UUID uuid);\r
- \r
- /** Initializes the IVocabularStore by making sure that all basic terms that are\r
- * loaded by the TermLoader are available afterwards.\r
- * ATTENTION: Be aware that TermLoader indirectly calls getTermByUuid(uuid)\r
- * for the default language. So make sure that before loading the Terms by the\r
- * TermLoader getTermByUuid() returns a valid Object without going to endless recursion.\r
- * @return true if terms where successfully loaded\r
- */\r
- public boolean initialize();\r
-\r
-}\r
})
@Entity
@Audited
-public class NameTypeDesignation extends TypeDesignationBase implements ITypeDesignation {
+public class NameTypeDesignation extends TypeDesignationBase<NameTypeDesignationStatus>
+implements ITypeDesignation {
static Logger logger = Logger.getLogger(NameTypeDesignation.class);
* @see #NameTypeDesignation(TaxonNameBase, ReferenceBase, String, String, boolean, boolean, boolean)
*/
protected NameTypeDesignation() {
- super();
}
/**
import org.hibernate.envers.Audited;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
+import eu.etaxonomy.cdm.model.common.OrderedTermBase;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
/**
@XmlType(name = "NameTypeDesignationStatus")
@Entity
@Audited
-public class NameTypeDesignationStatus extends DefinedTermBase<NameTypeDesignationStatus> {
+public class NameTypeDesignationStatus extends TypeDesignationStatusBase<NameTypeDesignationStatus> {
static Logger logger = Logger.getLogger(NameTypeDesignationStatus.class);
private static final UUID uuidAutomatic = UUID.fromString("e89d8b21-615a-4602-913f-1625bf39a69f");
* {@link eu.etaxonomy.cdm.model.occurrence.DerivedUnitBase specimen or a figure}. All {@link TaxonNameBase taxon names}
* which have a {@link Rank rank} "species aggregate" or lower can only be typified
* by specimens. Moreover each typification by a specimen (or by a figure) has a
- * {@link TypeDesignationStatus status} like "holotype" or "isotype".
+ * {@link SpecimenTypeDesignationStatus status} like "holotype" or "isotype".
* <P>
* This class corresponds to: <ul>
* <li> NomenclaturalType according to the TDWG ontology
@XmlRootElement(name = "SpecimenTypeDesignation")
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "SpecimenTypeDesignation", propOrder = {
- "typeSpecimen",
- "typeStatus"
+ "typeSpecimen"
})
@Entity
@Audited
-public class SpecimenTypeDesignation extends TypeDesignationBase implements ITypeDesignation {
+public class SpecimenTypeDesignation extends TypeDesignationBase<SpecimenTypeDesignationStatus>
+implements ITypeDesignation {
private static final Logger logger = Logger.getLogger(SpecimenTypeDesignation.class);
@Cascade(CascadeType.SAVE_UPDATE)
private DerivedUnitBase typeSpecimen;
- @XmlElement(name = "TypeStatus")
- @XmlIDREF
- @XmlSchemaType(name = "IDREF")
- @ManyToOne(fetch = FetchType.LAZY)
- private TypeDesignationStatus typeStatus;
-
// /**
// * Creates a new specimen type designation instance
// * (including its {@link reference.ReferenceBase reference source} and eventually
/**
* Class constructor: creates a new empty specimen type designation.
*
- * @see #SpecimenTypeDesignation(DerivedUnitBase, TypeDesignationStatus,
+ * @see #SpecimenTypeDesignation(DerivedUnitBase, SpecimenTypeDesignationStatus,
* ReferenceBase, String, String, boolean)
*/
protected SpecimenTypeDesignation(){
-
}
/**
* @param isNotDesignated the boolean flag indicating whether there is no specimen type at all for
* <i>this</i> specimen type designation
* @see #SpecimenTypeDesignation()
- * @see TaxonNameBase#addSpecimenTypeDesignation(Specimen, TypeDesignationStatus, ReferenceBase, String, String, boolean, boolean)
+ * @see TaxonNameBase#addSpecimenTypeDesignation(Specimen, SpecimenTypeDesignationStatus, ReferenceBase, String, String, boolean, boolean)
* @see TypeDesignationBase#isNotDesignated()
* @see eu.etaxonomy.cdm.model.occurrence.DerivedUnitBase
*/
- protected SpecimenTypeDesignation(DerivedUnitBase specimen, TypeDesignationStatus status, ReferenceBase citation, String citationMicroReference,
+ protected SpecimenTypeDesignation(DerivedUnitBase specimen, SpecimenTypeDesignationStatus status, ReferenceBase citation, String citationMicroReference,
String originalNameString, boolean isNotDesignated) {
super(citation, citationMicroReference, originalNameString, isNotDesignated);
this.setTypeSpecimen(specimen);
this.typeSpecimen = typeSpecimen;
}
- /**
- * Returns the {@link TypeDesignationStatus type designation status} for <i>this</i> specimen type
- * designation. This status describes which of the possible categories of
- * types like "holotype", "neotype", "syntype" or "isotype" applies to <i>this</i>
- * specimen type designation.
- */
- public TypeDesignationStatus getTypeStatus(){
- return this.typeStatus;
- }
- /**
- * @see #getTypeStatus()
- */
- public void setTypeStatus(TypeDesignationStatus typeStatus){
- this.typeStatus = typeStatus;
- }
-
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.model.name.ITypeDesignation#isLectoType()
*/
* holotype is found to belong to more than one taxon name,
* or as long as it is missing.
*
- * @see TypeDesignationStatus#isLectotype()
- * @see TypeDesignationStatus#HOLOTYPE()
+ * @see SpecimenTypeDesignationStatus#isLectotype()
+ * @see SpecimenTypeDesignationStatus#HOLOTYPE()
*/
@Transient
public boolean isLectoType() {
- return typeStatus.isLectotype();
+ return getTypeStatus().isLectotype();
}
}
\ No newline at end of file
@XmlType(name = "TypeDesignationStatus")
@Entity
@Audited
-public class TypeDesignationStatus extends OrderedTermBase<TypeDesignationStatus> {
- static Logger logger = Logger.getLogger(TypeDesignationStatus.class);
+public class SpecimenTypeDesignationStatus extends TypeDesignationStatusBase<SpecimenTypeDesignationStatus> {
+ static Logger logger = Logger.getLogger(SpecimenTypeDesignationStatus.class);
- private static TypeDesignationStatus PHOTOTYPE;
+ private static SpecimenTypeDesignationStatus PHOTOTYPE;
- private static TypeDesignationStatus ICONOTYPE;
+ private static SpecimenTypeDesignationStatus ICONOTYPE;
- private static TypeDesignationStatus ISOEPITYPE;
+ private static SpecimenTypeDesignationStatus ISOEPITYPE;
- private static TypeDesignationStatus PARALECTOTYPE;
+ private static SpecimenTypeDesignationStatus PARALECTOTYPE;
- private static TypeDesignationStatus SECOND_STEP_NEOTYPE;
+ private static SpecimenTypeDesignationStatus SECOND_STEP_NEOTYPE;
- private static TypeDesignationStatus SECOND_STEP_LECTOTYPE;
+ private static SpecimenTypeDesignationStatus SECOND_STEP_LECTOTYPE;
- private static TypeDesignationStatus PARANEOTYPE;
+ private static SpecimenTypeDesignationStatus PARANEOTYPE;
- private static TypeDesignationStatus ISONEOTYPE;
+ private static SpecimenTypeDesignationStatus ISONEOTYPE;
- private static TypeDesignationStatus ISOLECTOTYPE;
+ private static SpecimenTypeDesignationStatus ISOLECTOTYPE;
- private static TypeDesignationStatus PARATYPE;
+ private static SpecimenTypeDesignationStatus PARATYPE;
- private static TypeDesignationStatus SYNTYPE;
+ private static SpecimenTypeDesignationStatus SYNTYPE;
- private static TypeDesignationStatus ISOTYPE;
+ private static SpecimenTypeDesignationStatus ISOTYPE;
- private static TypeDesignationStatus EPITYPE;
+ private static SpecimenTypeDesignationStatus EPITYPE;
- private static TypeDesignationStatus NEOTYPE;
+ private static SpecimenTypeDesignationStatus NEOTYPE;
- private static TypeDesignationStatus LECTOTYPE;
+ private static SpecimenTypeDesignationStatus LECTOTYPE;
- private static TypeDesignationStatus HOLOTYPE;
+ private static SpecimenTypeDesignationStatus HOLOTYPE;
+ private static SpecimenTypeDesignationStatus UNSPECIFIC;
+
+ private static SpecimenTypeDesignationStatus ORIGINAL_MATERIAL;
+
private static final UUID uuidHolotype = UUID.fromString("a407dbc7-e60c-46ff-be11-eddf4c5a970d");
private static final UUID uuidLectotype = UUID.fromString("05002d46-083e-4b27-8731-2e7c28a8825c");
private static final UUID uuidNeotype = UUID.fromString("26e13359-8f77-4e40-a85a-56c01782fce0");
private static final UUID uuidIsoepitype = UUID.fromString("95b90696-e103-4bc0-b60b-c594983fb566");
private static final UUID uuidIconotype = UUID.fromString("643513d0-32f5-46ba-840b-d9b9caf8160f");
private static final UUID uuidPhototype = UUID.fromString("b7807acc-f559-474e-ad4a-e7a41e085e34");
+ private static final UUID uuidUnspecific = UUID.fromString("230fd762-b143-49de-ac2e-744bcc48a63b");
+ private static final UUID uuidOriginalMaterial = UUID.fromString("230fd762-b143-49de-ac2e-744bcc48a63b");
// ************* CONSTRUCTORS *************/
*
* @see #TypeDesignationStatus(String, String, String)
*/
- public TypeDesignationStatus() {
- super();
+ public SpecimenTypeDesignationStatus() {
}
* new type designation status to be created
* @see #TypeDesignationStatus()
*/
- public TypeDesignationStatus(String term, String label, String labelAbbrev) {
+ public SpecimenTypeDesignationStatus(String term, String label, String labelAbbrev) {
super(term, label, labelAbbrev);
}
*
* @see NameRelationshipType#VALIDATED_BY_NAME()
*/
- public static final TypeDesignationStatus HOLOTYPE(){
+ public static final SpecimenTypeDesignationStatus HOLOTYPE(){
return HOLOTYPE;
}
*
* @see #HOLOTYPE()
*/
- public static final TypeDesignationStatus LECTOTYPE(){
+ public static final SpecimenTypeDesignationStatus LECTOTYPE(){
return LECTOTYPE;
}
*
* @see #HOLOTYPE()
*/
- public static final TypeDesignationStatus NEOTYPE(){
+ public static final SpecimenTypeDesignationStatus NEOTYPE(){
return NEOTYPE;
}
* @see #LECTOTYPE()
* @see #NEOTYPE()
*/
- public static final TypeDesignationStatus EPITYPE(){
+ public static final SpecimenTypeDesignationStatus EPITYPE(){
return EPITYPE;
}
*
* @see #HOLOTYPE()
*/
- public static final TypeDesignationStatus ISOTYPE(){
+ public static final SpecimenTypeDesignationStatus ISOTYPE(){
return ISOTYPE;
}
*
* @see #HOLOTYPE()
*/
- public static final TypeDesignationStatus SYNTYPE(){
+ public static final SpecimenTypeDesignationStatus SYNTYPE(){
return SYNTYPE;
}
* @see #ISOTYPE()
* @see #SYNTYPE()
*/
- public static final TypeDesignationStatus PARATYPE(){
+ public static final SpecimenTypeDesignationStatus PARATYPE(){
return PARATYPE;
}
*
* @see #LECTOTYPE()
*/
- public static final TypeDesignationStatus ISOLECTOTYPE(){
+ public static final SpecimenTypeDesignationStatus ISOLECTOTYPE(){
return ISOLECTOTYPE;
}
*
* @see #NEOTYPE()
*/
- public static final TypeDesignationStatus ISONEOTYPE(){
+ public static final SpecimenTypeDesignationStatus ISONEOTYPE(){
return ISONEOTYPE;
}
/**
*
* @see #NEOTYPE()
*/
- public static final TypeDesignationStatus PARANEOTYPE(){
+ public static final SpecimenTypeDesignationStatus PARANEOTYPE(){
return PARANEOTYPE;
}
*
* @see #LECTOTYPE()
*/
- public static final TypeDesignationStatus SECOND_STEP_LECTOTYPE(){
+ public static final SpecimenTypeDesignationStatus SECOND_STEP_LECTOTYPE(){
return SECOND_STEP_LECTOTYPE;
}
*
* @see #LECTOTYPE()
*/
- public static final TypeDesignationStatus SECOND_STEP_NEOTYPE(){
+ public static final SpecimenTypeDesignationStatus SECOND_STEP_NEOTYPE(){
return SECOND_STEP_NEOTYPE;
}
*
* @see #LECTOTYPE()
*/
- public static final TypeDesignationStatus PARALECTOTYPE(){
+ public static final SpecimenTypeDesignationStatus PARALECTOTYPE(){
return PARALECTOTYPE;
}
*
* @see #EPITYPE()
*/
- public static final TypeDesignationStatus ISOEPITYPE(){
+ public static final SpecimenTypeDesignationStatus ISOEPITYPE(){
return ISOEPITYPE;
}
* Returns the "iconotype" designation status. An iconotype is a holotype or
* a lectotype that is a {@link eu.etaxonomy.cdm.model.occurrence.DerivedUnitBase drawing}
* and not a {@link eu.etaxonomy.cdm.model.occurrence.Specimen specimen}.
+ * "Iconotype" does not have type status according to the ICBN.
*
* @see #HOLOTYPE()
* @see #LECTOTYPE()
*/
- public static final TypeDesignationStatus ICONOTYPE(){
+ public static final SpecimenTypeDesignationStatus ICONOTYPE(){
return ICONOTYPE;
}
/**
- * Returns the "iconotype" designation status. An iconotype is a holotype or
- * a lectotype that is a {@link eu.etaxonomy.cdm.model.occurrence.DerivedUnitBase photograph}
- * and not a {@link eu.etaxonomy.cdm.model.occurrence.Specimen specimen}.
+ * Returns the "unspecific" type designation status. Used if from literature where it is not
+ * clear if it refers to another publication not cited or if it is a new designation.
+ *
+ */
+ public static final SpecimenTypeDesignationStatus UNSPECIFIC(){
+ return UNSPECIFIC;
+ }
+
+ /**
+ * Returns the "original material" type designation status.
+ * Botanical term for material from which a lectotype can be designated.
+ * "Original material" does not have type status according to the ICBN.
+ *
+ */
+ public static final SpecimenTypeDesignationStatus ORIGINAL_MATERIAL(){
+ return ORIGINAL_MATERIAL;
+ }
+
+
+ /**
+ * Returns the "phototype" type designation status.
+ * "Phototype" does not have type status according to the ICBN.
*
- * @see #HOLOTYPE()
- * @see #LECTOTYPE()
*/
- public static final TypeDesignationStatus PHOTOTYPE(){
+ public static final SpecimenTypeDesignationStatus PHOTOTYPE(){
return PHOTOTYPE;
}
@Override
- protected void setDefaultTerms(TermVocabulary<TypeDesignationStatus> termVocabulary) {
- TypeDesignationStatus.EPITYPE = termVocabulary.findTermByUuid(TypeDesignationStatus.uuidEpitype);
- TypeDesignationStatus.HOLOTYPE = termVocabulary.findTermByUuid(TypeDesignationStatus.uuidHolotype);
- TypeDesignationStatus.ICONOTYPE = termVocabulary.findTermByUuid(TypeDesignationStatus.uuidIconotype);
- TypeDesignationStatus.ISOEPITYPE = termVocabulary.findTermByUuid(TypeDesignationStatus.uuidIsoepitype);
- TypeDesignationStatus.ISOLECTOTYPE = termVocabulary.findTermByUuid(TypeDesignationStatus.uuidIsolectotype);
- TypeDesignationStatus.ISONEOTYPE = termVocabulary.findTermByUuid(TypeDesignationStatus.uuidIsoneotype);
- TypeDesignationStatus.ISOTYPE = termVocabulary.findTermByUuid(TypeDesignationStatus.uuidIsotype);
- TypeDesignationStatus.LECTOTYPE = termVocabulary.findTermByUuid(TypeDesignationStatus.uuidLectotype);
- TypeDesignationStatus.NEOTYPE = termVocabulary.findTermByUuid(TypeDesignationStatus.uuidNeotype);
- TypeDesignationStatus.PARALECTOTYPE = termVocabulary.findTermByUuid(TypeDesignationStatus.uuidParalectotype);
- TypeDesignationStatus.PARANEOTYPE = termVocabulary.findTermByUuid(TypeDesignationStatus.uuidParaneotype);
- TypeDesignationStatus.PARATYPE = termVocabulary.findTermByUuid(TypeDesignationStatus.uuidParatype);
- TypeDesignationStatus.PHOTOTYPE = termVocabulary.findTermByUuid(TypeDesignationStatus.uuidPhototype);
- TypeDesignationStatus.SECOND_STEP_LECTOTYPE= termVocabulary.findTermByUuid(TypeDesignationStatus.uuidSecondStepLectotype);
- TypeDesignationStatus.SECOND_STEP_NEOTYPE = termVocabulary.findTermByUuid(TypeDesignationStatus.uuidSecondStepNeotype);
- TypeDesignationStatus.SYNTYPE = termVocabulary.findTermByUuid(TypeDesignationStatus.uuidSyntype);
+ protected void setDefaultTerms(TermVocabulary<SpecimenTypeDesignationStatus> termVocabulary) {
+ SpecimenTypeDesignationStatus.EPITYPE = termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidEpitype);
+ SpecimenTypeDesignationStatus.HOLOTYPE = termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidHolotype);
+ SpecimenTypeDesignationStatus.ICONOTYPE = termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidIconotype);
+ SpecimenTypeDesignationStatus.ISOEPITYPE = termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidIsoepitype);
+ SpecimenTypeDesignationStatus.ISOLECTOTYPE = termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidIsolectotype);
+ SpecimenTypeDesignationStatus.ISONEOTYPE = termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidIsoneotype);
+ SpecimenTypeDesignationStatus.ISOTYPE = termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidIsotype);
+ SpecimenTypeDesignationStatus.LECTOTYPE = termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidLectotype);
+ SpecimenTypeDesignationStatus.NEOTYPE = termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidNeotype);
+ SpecimenTypeDesignationStatus.PARALECTOTYPE = termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidParalectotype);
+ SpecimenTypeDesignationStatus.PARANEOTYPE = termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidParaneotype);
+ SpecimenTypeDesignationStatus.PARATYPE = termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidParatype);
+ SpecimenTypeDesignationStatus.PHOTOTYPE = termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidPhototype);
+ SpecimenTypeDesignationStatus.SECOND_STEP_LECTOTYPE= termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidSecondStepLectotype);
+ SpecimenTypeDesignationStatus.SECOND_STEP_NEOTYPE = termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidSecondStepNeotype);
+ SpecimenTypeDesignationStatus.SYNTYPE = termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidSyntype);
+ SpecimenTypeDesignationStatus.UNSPECIFIC = termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidUnspecific);
+ SpecimenTypeDesignationStatus.ORIGINAL_MATERIAL = termVocabulary.findTermByUuid(SpecimenTypeDesignationStatus.uuidOriginalMaterial);
}
}
\ No newline at end of file
* added to all taxon names of the homotypical group the typified
* taxon name belongs to
* @see #getSpecimenTypeDesignations()
- * @see TypeDesignationStatus
+ * @see SpecimenTypeDesignationStatus
* @see SpecimenTypeDesignation
* @see TypeDesignationBase#isNotDesignated()
*/
public void addSpecimenTypeDesignation(Specimen typeSpecimen,
- TypeDesignationStatus status,
+ SpecimenTypeDesignationStatus status,
ReferenceBase citation,
String citationMicroReference,
String originalNameString,
@XmlType(name = "TypeDesignationBase", propOrder = {\r
"typifiedNames",\r
"homotypicalGroup",\r
- "notDesignated"\r
+ "notDesignated",\r
+ "typeStatus"\r
})\r
@Entity\r
@Audited\r
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)\r
-public abstract class TypeDesignationBase extends ReferencedEntityBase implements ITypeDesignation {\r
+public abstract class TypeDesignationBase<T extends TypeDesignationStatusBase> extends ReferencedEntityBase implements ITypeDesignation {\r
private static final Logger logger = Logger.getLogger(TypeDesignationBase.class);\r
\r
-\r
@XmlElement(name = "IsNotDesignated")\r
private boolean notDesignated;\r
\r
@Cascade(CascadeType.SAVE_UPDATE)\r
private HomotypicalGroup homotypicalGroup;\r
\r
+ @XmlElement(name = "TypeStatus")\r
+ @XmlIDREF\r
+ @XmlSchemaType(name = "IDREF")\r
+ @ManyToOne(fetch = FetchType.LAZY)\r
+ private T typeStatus;\r
+\r
// **************** CONSTRUCTOR *************************************/\r
\r
/** \r
// **************** METHODS *************************************/\r
\r
\r
+ /** \r
+ * Returns the {@link SpecimenTypeDesignationStatus type designation status} for <i>this</i> specimen type\r
+ * designation. This status describes which of the possible categories of\r
+ * types like "holotype", "neotype", "syntype" or "isotype" applies to <i>this</i>\r
+ * specimen type designation.\r
+ */\r
+ public T getTypeStatus(){\r
+ return this.typeStatus;\r
+ }\r
+ /**\r
+ * @see #getTypeStatus()\r
+ */\r
+ public void setTypeStatus(T typeStatus){\r
+ this.typeStatus = typeStatus;\r
+ }\r
+\r
/* (non-Javadoc)\r
* @see eu.etaxonomy.cdm.model.name.ITypeDesignation#getHomotypicalGroup()\r
*/\r
--- /dev/null
+/**
+* Copyright (C) 2007 EDIT
+* European Distributed Institute of Taxonomy
+* http://www.e-taxonomy.eu
+*
+* The contents of this file are subject to the Mozilla Public License Version 1.1
+* See LICENSE.TXT at the top of this package for the full license terms.
+*/
+
+package eu.etaxonomy.cdm.model.name;
+
+import java.util.UUID;
+
+import javax.persistence.Entity;
+import javax.persistence.Transient;
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlType;
+
+import org.apache.log4j.Logger;
+import org.hibernate.envers.Audited;
+
+import eu.etaxonomy.cdm.model.common.OrderedTermBase;
+import eu.etaxonomy.cdm.model.common.TermVocabulary;
+
+/**
+ * The class representing status (categories) of {@link SpecimenTypeDesignation specimen type designations}
+ * for a {@link TaxonNameBase taxon name} or a set of them. Within this set {@link NameRelationshipType#BASIONYM() basionyms}
+ * or {@link NameRelationshipType#REPLACED_SYNONYM() replaced synonyms}, in case of reclassifications,
+ * will be here referred as "type-bringing" taxon names.
+ * <P>
+ * The different status indicate whether the {@link eu.etaxonomy.cdm.model.occurrence.Specimen specimens} used as types
+ * in a designation are duplicates, replacements, related specimens etc.
+ * <P>
+ * A standard (ordered) list of type designation status instances will be
+ * automatically created as the project starts. But this class allows to extend
+ * this standard list by creating new instances of additional type designation
+ * status if needed.
+ * <P>
+ * This class corresponds to: <ul>
+ * <li> NomencalturalTypeTypeTerm according to the TDWG ontology
+ * <li> NomenclaturalTypeStatusOfUnitsEnum according to the TCS
+ * </ul>
+ *
+ * @author m.doering
+ * @version 1.0
+ * @created 08-Nov-2007 13:07:00
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "TypeDesignationStatusBase")
+@Entity
+@Audited
+public abstract class TypeDesignationStatusBase<T extends TypeDesignationStatusBase<?>> extends OrderedTermBase<T> {
+ static Logger logger = Logger.getLogger(TypeDesignationStatusBase.class);
+
+ // ************* CONSTRUCTORS *************/
+ /**
+ * Class constructor: creates a new empty type designation status instance.
+ *
+ * @see #NameTypeDesignationStatus(String, String, String)
+ * @see #SpecimenTypeDesignationStatus(String, String, String)
+ */
+ public TypeDesignationStatusBase() {
+ }
+
+
+ /**
+ * Class constructor: creates an additional type designation status instance
+ * with a description (in the {@link eu.etaxonomy.cdm.model.common.Language#DEFAULT() default language}), a label
+ * and a label abbreviation.
+ *
+ * @param term the string (in the default language) describing the
+ * new type designation status to be created
+ * @param label the string identifying the new type designation
+ * status to be created
+ * @param labelAbbrev the string identifying (in abbreviated form) the
+ * new type designation status to be created
+ * @see #SnameTypeDesignationStatus()
+ * @see #SpecimenTypeDesignationStatus()
+ */
+ public TypeDesignationStatusBase(String term, String label, String labelAbbrev) {
+ super(term, label, labelAbbrev);
+ }
+}
\ No newline at end of file
-"ab177bd7-d3c8-4e58-a388-226fff6ba3c2",,"TypeDesignationStatus","TypeDesignationStatus",\r
+"ab177bd7-d3c8-4e58-a388-226fff6ba3c2",,"SpecimenTypeDesignationStatus","SpecimenTypeDesignationStatus",\r
"a407dbc7-e60c-46ff-be11-eddf4c5a970d",,"Holotype",\r
"05002d46-083e-4b27-8731-2e7c28a8825c",,"Lectotype",\r
"26e13359-8f77-4e40-a85a-56c01782fce0",,"Neotype",\r
+"f3b60bdb-4638-4ca9-a0c7-36e77d8459bb",,"Syntype",\r
"989a2715-71d5-4fbe-aa9a-db9168353744",,"Epitype",\r
+"93ef8257-0a08-47bb-9b36-542417ae7560",,"Isotype",\r
"7a1a8a53-78f4-4fc0-89f7-782e94992d08",,"Isolectotype",\r
"7afc2f4f-f70a-4aa5-80a5-87764f746bde",,"Isoneotype",\r
-"93ef8257-0a08-47bb-9b36-542417ae7560",,"Isotype",\r
-"0c39e2a5-2fe0-4d4f-819a-f609b5340339",,"Paraneotype",\r
+"95b90696-e103-4bc0-b60b-c594983fb566",,"Isoepitype",\r
"eb7df2e5-d9a7-479d-970c-c6f2b0a761d7",,"Paratype",\r
+"7244bc51-14d8-41a6-9524-7dc5303bba29",,"Paralectotype",\r
+"0c39e2a5-2fe0-4d4f-819a-f609b5340339",,"Paraneotype",\r
+"230fd762-b143-49de-ac2e-744bcc48a63b",,"Unspecific",\r
"01d91053-7004-4984-aa0d-9f4de59d6205",,"Second Step Lectotype",\r
"8d2fed1f-242e-4bcf-bbd7-e85133e479dc",,"Second Step Neotype",\r
-"f3b60bdb-4638-4ca9-a0c7-36e77d8459bb",,"Syntype",\r
-"7244bc51-14d8-41a6-9524-7dc5303bba29",,"Paralectotype",\r
-"95b90696-e103-4bc0-b60b-c594983fb566",,"Isoepitype",\r
+"230fd762-b143-49de-ac2e-744bcc48a63b",,"Original Material",\r
"643513d0-32f5-46ba-840b-d9b9caf8160f",,"Iconotype",\r
"b7807acc-f559-474e-ad4a-e7a41e085e34",,"Phototype",\r
\r
abies = NonViralName.NewInstance(Rank.GENUS(), null);\r
abies.setNameCache("Abies");\r
- //abies.setTitleCache("Abies");\r
+ abies.setTitleCache("Abies");\r
\r
abiesMill = NonViralName.NewInstance(Rank.GENUS(), null);\r
abiesMill.setNameCache("Abies");\r
BGBM BDI Projects / cdmlib.git / commitdiff