import java.util.HashSet;
import java.util.List;
+import java.util.Map;
import java.util.Set;
import java.util.UUID;
import javax.persistence.Entity;
+import javax.persistence.FetchType;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.OneToMany;
-import javax.persistence.Transient;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;
import org.apache.log4j.Logger;
-import org.hibernate.annotations.Cascade;
-import org.hibernate.annotations.CascadeType;
+import org.hibernate.envers.Audited;
+import org.hibernate.search.annotations.Indexed;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
-import eu.etaxonomy.cdm.model.common.ILoadableTerm;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
import eu.etaxonomy.cdm.model.name.BotanicalName;
-import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
-import eu.etaxonomy.cdm.model.name.NameRelationship;
-import eu.etaxonomy.cdm.model.name.NameRelationshipType;
import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
-import eu.etaxonomy.cdm.model.name.NonViralName;
-import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.occurrence.Specimen;
import eu.etaxonomy.cdm.model.taxon.Taxon;
"supportsIndividualAssociation",
"supportsTaxonInteraction",
"supportsCommonTaxonName",
+ "supportsCategoricalData",
"recommendedModifierEnumeration",
"recommendedStatisticalMeasures",
"supportedCategoricalEnumerations"
})
@XmlRootElement(name = "Feature")
@Entity
-public class Feature extends DefinedTermBase {
- static Logger logger = Logger.getLogger(Feature.class);
+@Indexed(index = "eu.etaxonomy.cdm.model.common.DefinedTermBase")
+@Audited
+public class Feature extends DefinedTermBase<Feature> {
+ private static final long serialVersionUID = 6754598791831848704L;
+ private static final Logger logger = Logger.getLogger(Feature.class);
+ private static Feature IMAGE;
+ private static Feature CULTIVATION;
+ private static Feature CONSERVATION;
+ private static Feature USES;
+ private static Feature ADDITIONAL_PUBLICATION;
+ private static Feature CITATION;
+ private static Feature OCCURRENCE;
+ private static Feature PHENOLOGY;
+ private static Feature COMMON_NAME;
+ private static Feature PROTOLOG;
+ private static Feature INTRODUCTION;
+ private static Feature DIAGNOSIS;
+ private static Feature ETYMOLOGY;
+ private static Feature MATERIALS_METHODS;
+ private static Feature MATERIALS_EXAMINED;
+ private static Feature KEY;
+ private static Feature BIOLOGY_ECOLOGY;
+ private static Feature ECOLOGY;
+ private static Feature DISCUSSION;
+ private static Feature DISTRIBUTION;
+ private static Feature DESCRIPTION;
+ private static Feature UNKNOWN;
@XmlElement(name = "SupportsTextData")
private boolean supportsTextData;
@XmlElement(name = "SupportsTaxonInteraction")
private boolean supportsTaxonInteraction;
- @XmlElement(name = "SupportsCommonTaxonName")
- private boolean supportsCommonTaxonName;
+ @XmlElement(name = "SupportsCategoricalData")
+ private boolean supportsCategoricalData;
+ /*
+ * FIXME Should this be Many-To-Many or do we expect each Feature to have its own unique modifier enums?
+ */
@XmlElementWrapper(name = "RecommendedModifierEnumerations")
@XmlElement(name = "RecommendedModifierEnumeration")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
- private Set<TermVocabulary> recommendedModifierEnumeration = new HashSet<TermVocabulary>();
+ @OneToMany(fetch = FetchType.LAZY)
+ @JoinTable(name="DefinedTermBase_RecommendedModifierEnumeration")
+ private Set<TermVocabulary<Modifier>> recommendedModifierEnumeration = new HashSet<TermVocabulary<Modifier>>();
@XmlElementWrapper(name = "RecommendedStatisticalMeasures")
@XmlElement(name = "RecommendedStatisticalMeasure")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
+ @ManyToMany(fetch = FetchType.LAZY)
+ @JoinTable(name="DefinedTermBase_StatisticalMeasure")
private Set<StatisticalMeasure> recommendedStatisticalMeasures = new HashSet<StatisticalMeasure>();
+ /*
+ * FIXME Should this be Many-To-Many or do we expect each Feature to have its own unique state enums?
+ */
@XmlElementWrapper(name = "SupportedCategoricalEnumerations")
@XmlElement(name = "SupportedCategoricalEnumeration")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
- private Set<TermVocabulary> supportedCategoricalEnumerations = new HashSet<TermVocabulary>();
+ @OneToMany(fetch = FetchType.LAZY)
+ @JoinTable(name="DefinedTermBase_SupportedCategoricalEnumeration")
+ private Set<TermVocabulary<State>> supportedCategoricalEnumerations = new HashSet<TermVocabulary<State>>();
+ @XmlElement(name = "SupportsCommonTaxonName")
+ private boolean supportsCommonTaxonName;
/* ***************** CONSTRUCTOR AND FACTORY METHODS **********************************/
*
* @return the boolean value of the supportsQuantitativeData flag
*/
- public boolean isSupportsQuantitativeData() {
+ public boolean supportsQuantitativeData() {
return supportsQuantitativeData;
}
*
* @return the boolean value of the supportsTextData flag
*/
- public boolean isSupportsTextData() {
+ public boolean supportsTextData() {
return supportsTextData;
}
*
* @return the boolean value of the supportsDistribution flag
*/
- public boolean isSupportsDistribution() {
+ public boolean supportsDistribution() {
return supportsDistribution;
}
*
* @return the boolean value of the supportsIndividualAssociation flag
*/
- public boolean isSupportsIndividualAssociation() {
+ public boolean supportsIndividualAssociation() {
return supportsIndividualAssociation;
}
*
* @return the boolean value of the supportsTaxonInteraction flag
*/
- public boolean isSupportsTaxonInteraction() {
+ public boolean supportsTaxonInteraction() {
return supportsTaxonInteraction;
}
*
* @return the boolean value of the supportsCommonTaxonName flag
*/
- public boolean isSupportsCommonTaxonName() {
+ public boolean supportsCommonTaxonName() {
return supportsCommonTaxonName;
}
}
/**
- * Returns the set of {@link TermVocabulary term vocabularies} containing the
- * {@link Modifier modifiers} recommended to be used for {@link DescriptionElementBase description elements}
- * with <i>this</i> feature.
+ * Returns the boolean value of the flag indicating whether <i>this</i>
+ * feature can be described with {@link CategoricalData categorical data}
+ * (true) or not (false).
+ *
+ * @return the boolean value of the supportsCategoricalData flag
*/
- @OneToMany
- @JoinTable(
- name="DefinedTermBase_RecommendedModifierEnumeration"
- )
- public Set<TermVocabulary> getRecommendedModifierEnumeration() {
- return recommendedModifierEnumeration;
+ public boolean supportsCategoricalData() {
+ return supportsCategoricalData;
+ }
+
+ /**
+ * @see #supportsCategoricalData()
+ */
+ public void setSupportsCategoricalData(boolean supportsCategoricalData) {
+ this.supportsCategoricalData = supportsCategoricalData;
}
+
/**
- * @see #getRecommendedModifierEnumeration()
+ * Returns the set of {@link TermVocabulary term vocabularies} containing the
+ * {@link Modifier modifiers} recommended to be used for {@link DescriptionElementBase description elements}
+ * with <i>this</i> feature.
+ *
*/
- protected void setRecommendedModifierEnumeration(
- Set<TermVocabulary> recommendedModifierEnumeration) {
- this.recommendedModifierEnumeration = recommendedModifierEnumeration;
+ public Set<TermVocabulary<Modifier>> getRecommendedModifierEnumeration() {
+ return recommendedModifierEnumeration;
}
/**
* @see #getRecommendedModifierEnumeration()
*/
public void addRecommendedModifierEnumeration(
- TermVocabulary recommendedModifierEnumeration) {
+ TermVocabulary<Modifier> recommendedModifierEnumeration) {
this.recommendedModifierEnumeration.add(recommendedModifierEnumeration);
}
/**
* @see #addRecommendedModifierEnumeration(TermVocabulary)
*/
public void removeRecommendedModifierEnumeration(
- TermVocabulary recommendedModifierEnumeration) {
+ TermVocabulary<Modifier> recommendedModifierEnumeration) {
this.recommendedModifierEnumeration.remove(recommendedModifierEnumeration);
}
* Returns the set of {@link StatisticalMeasure statistical measures} recommended to be used
* in case of {@link QuantitativeData quantitative data} with <i>this</i> feature.
*/
- @ManyToMany
- @JoinTable(
- name="DefinedTermBase_StatisticalMeasure"
- )
-// @Cascade({CascadeType.SAVE_UPDATE})
public Set<StatisticalMeasure> getRecommendedStatisticalMeasures() {
return recommendedStatisticalMeasures;
}
- /**
- * @see #getRecommendedStatisticalMeasures()
- */
- protected void setRecommendedStatisticalMeasures(
- Set<StatisticalMeasure> recommendedStatisticalMeasures) {
- this.recommendedStatisticalMeasures = recommendedStatisticalMeasures;
- }
-
/**
* Adds a {@link StatisticalMeasure statistical measure} to the set of
* {@link #getRecommendedStatisticalMeasures() recommended statistical measures} assigned
* Returns the set of {@link TermVocabulary term vocabularies} containing the list of
* possible {@link State states} to be used in {@link CategoricalData categorical data}
* with <i>this</i> feature.
+ *
*/
- @OneToMany
- @JoinTable(
- name="DefinedTermBase_SupportedCategoricalEnumeration"
- )
- public Set<TermVocabulary> getSupportedCategoricalEnumerations() {
+ public Set<TermVocabulary<State>> getSupportedCategoricalEnumerations() {
return supportedCategoricalEnumerations;
}
- /**
- * @see #getSupportedCategoricalEnumerations()
- */
- protected void setSupportedCategoricalEnumerations(
- Set<TermVocabulary> supportedCategoricalEnumerations) {
- this.supportedCategoricalEnumerations = supportedCategoricalEnumerations;
- }
/**
* Adds a {@link TermVocabulary term vocabulary} to the set of
* {@link #getSupportedCategoricalEnumerations() supported state vocabularies} assigned
* @see #getSupportedCategoricalEnumerations()
*/
public void addSupportedCategoricalEnumeration(
- TermVocabulary supportedCategoricalEnumeration) {
+ TermVocabulary<State> supportedCategoricalEnumeration) {
this.supportedCategoricalEnumerations.add(supportedCategoricalEnumeration);
}
/**
* @see #addSupportedCategoricalEnumeration(TermVocabulary)
*/
public void removeSupportedCategoricalEnumeration(
- TermVocabulary supportedCategoricalEnumeration) {
+ TermVocabulary<State> supportedCategoricalEnumeration) {
this.supportedCategoricalEnumerations.remove(supportedCategoricalEnumeration);
}
-
private static final UUID uuidUnknown = UUID.fromString("910307f1-dc3c-452c-a6dd-af5ac7cd365c");
private static final UUID uuidDescription = UUID.fromString("9087cdcd-8b08-4082-a1de-34c9ba9fb493");
private static final UUID uuidCultivation = UUID.fromString("e28965b2-a367-48c5-b954-8afc8ac2c69b");
private static final UUID uuidIntroduction = UUID.fromString("e75255ca-8ff4-4905-baad-f842927fe1d3");
private static final UUID uuidDiscussion = UUID.fromString("d3c4cbb6-0025-4322-886b-cd0156753a25");
-
+ private static final UUID uuidImage = UUID.fromString("84193b2c-327f-4cce-90ef-c8da18fd5bb5");
// private static final UUID uuidDistribution = UUID.fromString("");
* @see #NewInstance(String, String, String)
*/
@Override
- public ILoadableTerm readCsvLine(List csvLine, Language lang) {
- // TODO Auto-generated method stub
- super.readCsvLine(csvLine, lang);
+ public Feature readCsvLine(Class<Feature> termClass, List<String> csvLine, Map<UUID,DefinedTermBase> terms) {
+ Feature newInstance = super.readCsvLine(termClass, csvLine, terms);
String text = (String)csvLine.get(4);
if (text != null && text.length() >= 6){
- if ("1".equals(text.substring(0, 1))){this.setSupportsTextData(true);};
- if ("1".equals(text.substring(1, 2))){this.setSupportsQuantitativeData(true);};
- if ("1".equals(text.substring(2, 3))){this.setSupportsDistribution(true);};
- if ("1".equals(text.substring(3, 4))){this.setSupportsIndividualAssociation(true);};
- if ("1".equals(text.substring(4, 5))){this.setSupportsTaxonInteraction(true);};
- if ("1".equals(text.substring(5, 6))){this.setSupportsCommonTaxonName(true);};
+ if ("1".equals(text.substring(0, 1))){newInstance.setSupportsTextData(true);};
+ if ("1".equals(text.substring(1, 2))){newInstance.setSupportsQuantitativeData(true);};
+ if ("1".equals(text.substring(2, 3))){newInstance.setSupportsDistribution(true);};
+ if ("1".equals(text.substring(3, 4))){newInstance.setSupportsIndividualAssociation(true);};
+ if ("1".equals(text.substring(4, 5))){newInstance.setSupportsTaxonInteraction(true);};
+ if ("1".equals(text.substring(5, 6))){newInstance.setSupportsCommonTaxonName(true);};
+ // if ("1".equals(text.substring(6, 7))){newInstance.setSupportsCategoricalData(true);};
}
- return this;
- }
-
- /**
- * Returns the feature identified through its immutable universally
- * unique identifier (UUID).
- *
- * @param uuid the universally unique identifier
- * @return the feature corresponding to the given
- * universally unique identifier
- */
- public static final Feature getByUuid(UUID uuid){
- return (Feature)findByUuid(uuid);
+ return newInstance;
}
/**
* not known what they mean.
*/
public static final Feature UNKNOWN(){
- return getByUuid(uuidUnknown);
+ return UNKNOWN;
}
/**
* The "description" feature is the highest level feature.
*/
public static final Feature DESCRIPTION(){
- return getByUuid(uuidDescription);
+ return DESCRIPTION;
}
/**
* @see #isSupportsDistribution()
*/
public static final Feature DISTRIBUTION(){
- return getByUuid(uuidDistribution);
+ return DISTRIBUTION;
}
/**
* @see #isSupportsTextData()
*/
public static final Feature DISCUSSION(){
- return getByUuid(uuidDiscussion);
+ return DISCUSSION;
}
/**
* ecological matters.
*/
public static final Feature ECOLOGY(){
- return getByUuid(uuidEcology);
+ return ECOLOGY;
}
/**
* @see #ECOLOGY()
*/
public static final Feature BIOLOGY_ECOLOGY(){
- return getByUuid(uuidBiologyEcology);
+ return BIOLOGY_ECOLOGY;
}
/**
* all features being used within an identification key.
*/
public static final Feature KEY(){
- return getByUuid(uuidKey);
+ return KEY;
}
* {@link SpecimenDescription specimen descriptions} or to {@link TaxonDescription taxon descriptions}.
*/
public static final Feature MATERIALS_EXAMINED(){
- return getByUuid(uuidMaterialsExamined);
+ return MATERIALS_EXAMINED;
}
/**
* {@link SpecimenDescription specimen descriptions} or to {@link TaxonDescription taxon descriptions}.
*/
public static final Feature MATERIALS_METHODS(){
- return getByUuid(uuidMaterialsMethods);
+ return MATERIALS_METHODS;
}
/**
* {@link TaxonNameDescription taxon name descriptions}.
*/
public static final Feature ETYMOLOGY(){
- return getByUuid(uuidEtymology);
+ return ETYMOLOGY;
}
/**
* {@link TaxonDescription taxon descriptions}.
*/
public static final Feature DIAGNOSIS(){
- return getByUuid(uuidDiagnosis);
+ return DIAGNOSIS;
}
* @see #isSupportsTextData()
*/
public static final Feature INTRODUCTION(){
- return getByUuid(uuidIntroduction);
+ return INTRODUCTION;
}
/**
* @see #isSupportsTextData()
*/
public static final Feature PROTOLOG(){
- return getByUuid(uuidProtolog);
+ return PROTOLOG;
}
/**
* Returns the "common_name" feature. This feature allows to handle only
* @see #isSupportsCommonTaxonName()
*/
public static final Feature COMMON_NAME(){
- return getByUuid(uuidCommonName);
+ return COMMON_NAME;
}
/**
* (such as "first flight of butterflies").
*/
public static final Feature PHENOLOGY(){
- return getByUuid(uuidPhenology);
+ return PHENOLOGY;
}
-
/**
* Returns the "occurrence" feature.
*/
public static final Feature OCCURRENCE(){
- return getByUuid(uuidOccurrence);
+ return OCCURRENCE;
}
/**
* @see #isSupportsTextData()
*/
public static final Feature CITATION(){
- return getByUuid(uuidCitation);
+ return CITATION;
}
/**
* @see #isSupportsTextData()
*/
public static final Feature ADDITIONAL_PUBLICATION(){
- return getByUuid(uuidAdditionalPublication);
+ return ADDITIONAL_PUBLICATION;
}
* particular uses (for instance "industrial use of seeds").
*/
public static final Feature USES(){
- return getByUuid(uuidUses);
+ return USES;
}
* methods and conditions for the conservation of {@link Specimen specimens}.<BR>
*/
public static final Feature CONSERVATION(){
- return getByUuid(uuidConservation);
+ return CONSERVATION;
}
* Returns the "cultivation" feature.
*/
public static final Feature CULTIVATION(){
- return getByUuid(uuidCultivation);
+ return CULTIVATION;
}
+ /**
+ * Returns the "cultivation" feature.
+ */
+ public static final Feature IMAGE(){
+ return IMAGE;
+ }
+
/**
* Returns the "hybrid_parent" feature. This feature can only be used
* by {@link TaxonInteraction taxon interactions}.<BR>
return null;
}
+ @Override
+ protected void setDefaultTerms(TermVocabulary<Feature> termVocabulary) {
+ Feature.ADDITIONAL_PUBLICATION = termVocabulary.findTermByUuid(Feature.uuidAdditionalPublication);
+ Feature.BIOLOGY_ECOLOGY = termVocabulary.findTermByUuid(Feature.uuidBiologyEcology);
+ Feature.CITATION = termVocabulary.findTermByUuid(Feature.uuidCitation);
+ Feature.COMMON_NAME = termVocabulary.findTermByUuid(Feature.uuidCommonName);
+ Feature.CONSERVATION = termVocabulary.findTermByUuid(Feature.uuidConservation);
+ Feature.CULTIVATION = termVocabulary.findTermByUuid(Feature.uuidCultivation);
+ Feature.DESCRIPTION = termVocabulary.findTermByUuid(Feature.uuidDescription);
+ Feature.DIAGNOSIS = termVocabulary.findTermByUuid(Feature.uuidDiagnosis);
+ Feature.DISCUSSION = termVocabulary.findTermByUuid(Feature.uuidDiscussion);
+ Feature.DISTRIBUTION = termVocabulary.findTermByUuid(Feature.uuidDistribution);
+ Feature.ECOLOGY = termVocabulary.findTermByUuid(Feature.uuidEcology);
+ Feature.ETYMOLOGY = termVocabulary.findTermByUuid(Feature.uuidEtymology);
+ Feature.IMAGE = termVocabulary.findTermByUuid(Feature.uuidImage);
+ Feature.INTRODUCTION = termVocabulary.findTermByUuid(Feature.uuidIntroduction);
+ Feature.KEY = termVocabulary.findTermByUuid(Feature.uuidKey);
+ Feature.MATERIALS_EXAMINED = termVocabulary.findTermByUuid(Feature.uuidMaterialsExamined);
+ Feature.MATERIALS_METHODS = termVocabulary.findTermByUuid(Feature.uuidMaterialsMethods);
+ Feature.OCCURRENCE = termVocabulary.findTermByUuid(Feature.uuidOccurrence);
+ Feature.PHENOLOGY = termVocabulary.findTermByUuid(Feature.uuidPhenology);
+ Feature.PROTOLOG = termVocabulary.findTermByUuid(Feature.uuidProtolog);
+ Feature.UNKNOWN = termVocabulary.findTermByUuid(Feature.uuidUnknown);
+ Feature.USES = termVocabulary.findTermByUuid(Feature.uuidUses);
+ }
+
}
\ No newline at end of file
BGBM BDI Projects / cdmlib.git / blobdiff