// $Id$
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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.
*/
import eu.etaxonomy.cdm.api.service.exception.ReferencedObjectUndeletableException;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.MarkerType;
-import eu.etaxonomy.cdm.model.description.AbsenceTerm;
+import eu.etaxonomy.cdm.model.common.TermType;
+import eu.etaxonomy.cdm.model.common.TermVocabulary;
import eu.etaxonomy.cdm.model.description.Feature;
-import eu.etaxonomy.cdm.model.description.PresenceAbsenceTermBase;
-import eu.etaxonomy.cdm.model.description.PresenceTerm;
+import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
import eu.etaxonomy.taxeditor.model.DefaultTermComparator;
* @version 1.0
*/
public class TermStore {
-
+
/**
- * Returns an alphabetically sorted list of terms (anything that extends {@link DefinedTermBase}) of the given type currently available in the system.
- *
+ * Returns an alphabetically sorted list of terms (anything that extends {@link DefinedTermBase}) of the given type currently available in the system.
+ *
* @param clazz a class that inherits from {@link DefinedTermBase}
* @return an alphabetically sorted list of terms
*/
public static <TERM extends DefinedTermBase> List<TERM> getTerms(Class<TERM> clazz){
return getTerms(clazz, null, true);
}
-
+
+ /**
+ * Returns an alphabetically sorted list of terms (anything that extends {@link DefinedTermBase}) of the given {@link TermType})
+ * currently available in the system.
+ *
+ * @param termType the term type
+ * @return an alphabetically sorted list of terms
+ */
+ public static <TERM extends DefinedTermBase> List<TERM> getTerms(TermType termType, Comparator<TERM> comparator){
+ return getTermsFromService(termType, comparator);
+ }
+
/**
- * Returns a list of terms of the given type currently available in the system.
+ * Returns an alphabetically sorted list of terms (anything that extends {@link DefinedTermBase}) of the given {@link TermType})
+ * currently available in the system.
+ *
+ * @param termType the term type
+ * @return an alphabetically sorted list of terms
+ */
+ public static <TERM extends DefinedTermBase> Set<TERM> getTerms(TermVocabulary<TERM> termVocabulary, Comparator<DefinedTermBase<?>> comparator){
+ return termVocabulary.getTerms();
+ }
+
+ /**
+ * Returns a list of terms of the given type currently available in the system.
* If <code>filtered</code> is set to <code>true</code>, all terms for certain types will be
* gathered from edge cases.
- *
+ *
* @param clazz a class that inherits from {@link DefinedTermBase}
* @param comparator a {@link Comparator} that defines the sorting algorithm. If set to null, {@link DefaultTermComparator} will be used
* @param filtered if set to true, some terms are filtered from the result (according to definition in {@link ITermStoreEdgeCase}s)
}else{
terms = getTermsFromService(clazz, comparator);
}
-
+
return terms;
-
+
+ }
+
+ /**
+ *
+ * @param termClass
+ * @param comparator
+ * @return
+ */
+ private static <T extends DefinedTermBase> List<T> getTermsFromService(TermType termType, Comparator<T> comparator){
+ if (comparator == null){
+ comparator = new DefaultTermComparator<T>();
+ }
+
+ List<T> terms = CdmStore.getService(ITermService.class).listByTermType(termType, null, null, null, null);
+ Collections.sort(terms, comparator);
+ return terms;
}
-
+
/**
- *
+ *
* @param termClass
* @param comparator
* @return
if (comparator == null){
comparator = new DefaultTermComparator<T>();
}
-
- List<T> terms = CdmStore.getService(ITermService.class).listByTermClass(termClass, null, null, null, null);
+
+ List<T> terms = CdmStore.getService(ITermService.class).list(termClass, null, null, null, null);
Collections.sort(terms, comparator);
return terms;
}
-
+
/**
* @param term a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object.
*/
public static void saveTerm(DefinedTermBase term){
CdmStore.getService(ITermService.class).saveOrUpdate(term);
}
-
+
/**
* <p>delete</p>
*
* @param selected a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object.
- * @throws ReferencedObjectUndeletableException
+ * @throws ReferencedObjectUndeletableException
*/
public static void delete(DefinedTermBase selected) throws ReferencedObjectUndeletableException {
CdmStore.getService(ITermService.class).delete(selected);
}
-
+
/**
* Save a vacabulary to data store
*
/**
* Handingling of special cases
*/
-
+
private static Set<ITermStoreEdgeCase<? extends DefinedTermBase>> termStoreEdgeCases = new HashSet<ITermStoreEdgeCase<? extends DefinedTermBase>>();
-
+
static {
termStoreEdgeCases.add(new ITermStoreEdgeCase<Feature>() {
// filter out non technical markers
List<MarkerType> nonTechnicalMarkerTypes = new ArrayList<MarkerType>();
List<MarkerType> markerTypes = TermStore.getTermsFromService(MarkerType.class, null);
-
+
for (Object type : markerTypes) {
if (((MarkerType) type).isTechnical() == false) {
nonTechnicalMarkerTypes.add((MarkerType) type);
}
}
-
+
return nonTechnicalMarkerTypes;
}
-
+
});
termStoreEdgeCases.add(new ITermStoreEdgeCase<Rank>() {
public List<Rank> getTerms() {
if(PreferencesUtil.getSortRanksHierarchichally()){
return TermStore.getTermsFromService(Rank.class, new Comparator<Rank>(){
-
+
@Override
public int compare(Rank o1, Rank o2) {
return o1.compareTo(o2);
}
-
+
});
}else{
return TermStore.getTermsFromService(Rank.class, null);
}
}
-
+
});
- termStoreEdgeCases.add(new ITermStoreEdgeCase<PresenceAbsenceTermBase>() {
+ termStoreEdgeCases.add(new ITermStoreEdgeCase<PresenceAbsenceTerm>() {
@Override
- public Class<PresenceAbsenceTermBase> getTermClass() {
- return PresenceAbsenceTermBase.class;
+ public Class<PresenceAbsenceTerm> getTermClass() {
+ return PresenceAbsenceTerm.class;
}
@Override
- public List<PresenceAbsenceTermBase> getTerms() {
- List presenceAbsenceTerms = TermStore.getTermsFromService(PresenceTerm.class, null);
- presenceAbsenceTerms.addAll(TermStore.getTermsFromService(AbsenceTerm.class, null));
+ public List<PresenceAbsenceTerm> getTerms() {
+ List<PresenceAbsenceTerm> presenceAbsenceTerms = TermStore.getTermsFromService(PresenceAbsenceTerm.class, null);
return presenceAbsenceTerms;
}
List<TaxonRelationshipType> excludeTaxonRelationshipTypes = Arrays.asList(new TaxonRelationshipType[]{
TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),
TaxonRelationshipType.MISAPPLIED_NAME_FOR(),
- TaxonRelationshipType.ALL_RELATIONSHIPS()
+ TaxonRelationshipType.ALL_RELATIONSHIPS()
});
-
+
List<TaxonRelationshipTypeInverseContainer> relationshipTypeInverseContainers = new ArrayList<TaxonRelationshipTypeInverseContainer>();
-
+
List<TaxonRelationshipType> relationshipTypes = TermStore.getTerms(TaxonRelationshipType.class);
-
+
relationshipTypes.removeAll(excludeTaxonRelationshipTypes);
-
+
for (TaxonRelationshipType relationshipType : relationshipTypes){
if(!relationshipType.isSymmetric()){
TaxonRelationshipTypeInverseContainer inverseContainer = new TaxonRelationshipTypeInverseContainer(relationshipType, true);
relationshipTypeInverseContainers.add(inverseContainer);
- }
+ }
TaxonRelationshipTypeInverseContainer container = new TaxonRelationshipTypeInverseContainer(relationshipType, false);
- relationshipTypeInverseContainers.add(container);
- }
-
+ relationshipTypeInverseContainers.add(container);
+ }
+
return relationshipTypeInverseContainers;
}
});
}
-
+
private static <T extends DefinedTermBase> ITermStoreEdgeCase<T> getEdgeCase(Class<T> termClass) {
-
+
for (ITermStoreEdgeCase termStoreEdgeCase : termStoreEdgeCases){
if (termStoreEdgeCase.getTermClass().equals(termClass)){
return termStoreEdgeCase;
}
}
-
+
return null;
}
-
+
private interface ITermStoreEdgeCase<TERM> {
public abstract Class<TERM> getTermClass();
-
+
public abstract List<TERM> getTerms();
-
+
}
}
BGBM BDI Projects / taxeditor.git / blobdiff