eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/store/TermStore.java

   1 // $Id$
   2 /**
   3 * Copyright (C) 2007 EDIT
   4 * European Distributed Institute of Taxonomy
   5 * http://www.e-taxonomy.eu
   6 *
   7 * The contents of this file are subject to the Mozilla Public License Version 1.1
   8 * See LICENSE.TXT at the top of this package for the full license terms.
   9 */
  10
  11 package eu.etaxonomy.taxeditor.store;
  12
  13 import java.util.ArrayList;
  14 import java.util.Arrays;
  15 import java.util.Collections;
  16 import java.util.Comparator;
  17 import java.util.HashSet;
  18 import java.util.List;
  19 import java.util.Set;
  20
  21 import eu.etaxonomy.cdm.api.service.ITermService;
  22 import eu.etaxonomy.cdm.api.service.exception.ReferencedObjectUndeletableException;
  23 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  24 import eu.etaxonomy.cdm.model.common.MarkerType;
  25 import eu.etaxonomy.cdm.model.common.TermType;
  26 import eu.etaxonomy.cdm.model.description.AbsenceTerm;
  27 import eu.etaxonomy.cdm.model.description.Feature;
  28 import eu.etaxonomy.cdm.model.description.PresenceAbsenceTermBase;
  29 import eu.etaxonomy.cdm.model.description.PresenceTerm;
  30 import eu.etaxonomy.cdm.model.name.Rank;
  31 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
  32 import eu.etaxonomy.taxeditor.model.DefaultTermComparator;
  33 import eu.etaxonomy.taxeditor.model.TaxonRelationshipTypeInverseContainer;
  34 import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
  35
  36 /**
  37  * All terms may be accessed through this store.
  38  * Note: This is for internal use. When using vocabularies in the UI, try to use the preferred terms from
  39  * PreferenceUtil
  40  *
  41  * @author n.hoffmann
  42  * @created 25.06.2009
  43  * @version 1.0
  44  */
  45 public class TermStore {
  46
  47         /**
  48          * Returns an alphabetically sorted list of terms (anything that extends {@link DefinedTermBase}) of the given type currently available in the system.
  49          *
  50          * @param clazz a class that inherits from {@link DefinedTermBase}
  51          * @return an alphabetically sorted list of terms
  52          */
  53         public static <TERM extends DefinedTermBase> List<TERM> getTerms(Class<TERM> clazz){
  54                 return getTerms(clazz, null, true);
  55         }
  56
  57         /**
  58          * Returns an alphabetically sorted list of terms (anything that extends {@link DefinedTermBase}) of the given {@link TermType})
  59          * currently available in the system.
  60          *
  61          * @param termType the term type
  62          * @return an alphabetically sorted list of terms
  63          */
  64         public static List<DefinedTermBase<?>> getTerms(TermType termType, Comparator<DefinedTermBase<?>> comparator){
  65         return getTermsFromService(termType, comparator);
  66         }
  67
  68         /**
  69          * Returns a list of terms of the given type currently available in the system.
  70          * If <code>filtered</code> is set to <code>true</code>, all terms for certain types will be
  71          * gathered from edge cases.
  72          *
  73          * @param clazz a class that inherits from {@link DefinedTermBase}
  74          * @param comparator a {@link Comparator} that defines the sorting algorithm. If set to null, {@link DefaultTermComparator} will be used
  75          * @param filtered if set to true, some terms are filtered from the result (according to definition in {@link ITermStoreEdgeCase}s)
  76          * @return a sorted list of terms
  77          */
  78         public static <TERM extends DefinedTermBase> List<TERM> getTerms(Class<TERM> clazz, Comparator<TERM> comparator, boolean filtered){
  79                 List<TERM> terms = new ArrayList<TERM>();
  80
  81                 ITermStoreEdgeCase<TERM> edgeCase = getEdgeCase(clazz);
  82                 if(filtered && edgeCase != null){
  83                         terms = edgeCase.getTerms();
  84                 }else{
  85                         terms = getTermsFromService(clazz, comparator);
  86                 }
  87
  88                 return terms;
  89
  90         }
  91
  92         /**
  93          *
  94          * @param termClass
  95          * @param comparator
  96          * @return
  97          */
  98         private static List<DefinedTermBase<?>> getTermsFromService(TermType termType, Comparator<DefinedTermBase<?>> comparator){
  99             if (comparator == null){
 100                 comparator = new DefaultTermComparator<DefinedTermBase<?>>();
 101             }
 102
 103             List<DefinedTermBase<?>> terms = CdmStore.getService(ITermService.class).listByTermType(termType, null, null, null, null);
 104             Collections.sort(terms, comparator);
 105             return terms;
 106         }
 107
 108         /**
 109          *
 110          * @param termClass
 111          * @param comparator
 112          * @return
 113          */
 114         private static <T extends DefinedTermBase> List<T> getTermsFromService(Class<T> termClass, Comparator<T> comparator){
 115                 if (comparator == null){
 116                         comparator = new DefaultTermComparator<T>();
 117                 }
 118
 119                 List<T> terms = CdmStore.getService(ITermService.class).list(termClass, null, null, null, null);
 120                 Collections.sort(terms, comparator);
 121                 return terms;
 122         }
 123
 124         /**
 125          * @param term a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object.
 126          */
 127         public static void saveTerm(DefinedTermBase term){
 128                 CdmStore.getService(ITermService.class).saveOrUpdate(term);
 129         }
 130
 131         /**
 132          * <p>delete</p>
 133          *
 134          * @param selected a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object.
 135          * @throws ReferencedObjectUndeletableException
 136          */
 137         public static void delete(DefinedTermBase selected) throws ReferencedObjectUndeletableException {
 138                 CdmStore.getService(ITermService.class).delete(selected);
 139         }
 140
 141         /**
 142          * Save a vacabulary to data store
 143          *
 144          * @param term a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object.
 145          */
 146         public static void updateVocabulary(DefinedTermBase term) {
 147                 CdmStore.getService(ITermService.class).saveOrUpdate(term);
 148         }
 149
 150         /**
 151          * Handingling of special cases
 152          */
 153
 154         private static Set<ITermStoreEdgeCase<? extends DefinedTermBase>> termStoreEdgeCases = new HashSet<ITermStoreEdgeCase<? extends DefinedTermBase>>();
 155
 156         static {
 157                 termStoreEdgeCases.add(new ITermStoreEdgeCase<Feature>() {
 158
 159                         @Override
 160                         public Class<Feature> getTermClass() {
 161                                 return Feature.class;
 162                         }
 163
 164                         @Override
 165                         public List<Feature> getTerms() {
 166                                 List<Feature> features = TermStore.getTermsFromService(Feature.class, null);
 167                                 features.remove(Feature.IMAGE());
 168                                 return features;
 169                         }
 170                 });
 171                 termStoreEdgeCases.add(new ITermStoreEdgeCase<MarkerType>(){
 172
 173                         @Override
 174                         public Class<MarkerType> getTermClass() {
 175                                 return MarkerType.class;
 176                         }
 177
 178                         @Override
 179                         public List<MarkerType> getTerms() {
 180                                 // filter out non technical markers
 181                                 List<MarkerType> nonTechnicalMarkerTypes = new ArrayList<MarkerType>();
 182                                 List<MarkerType> markerTypes = TermStore.getTermsFromService(MarkerType.class, null);
 183
 184                                 for (Object type : markerTypes) {
 185                                         if (((MarkerType) type).isTechnical() == false) {
 186                                                 nonTechnicalMarkerTypes.add((MarkerType) type);
 187                                         }
 188                                 }
 189
 190                                 return nonTechnicalMarkerTypes;
 191                         }
 192
 193                 });
 194                 termStoreEdgeCases.add(new ITermStoreEdgeCase<Rank>() {
 195
 196                         @Override
 197                         public Class<Rank> getTermClass() {
 198                                 return Rank.class;
 199                         }
 200
 201                         @Override
 202                         public List<Rank> getTerms() {
 203                                 if(PreferencesUtil.getSortRanksHierarchichally()){
 204                                         return TermStore.getTermsFromService(Rank.class, new Comparator<Rank>(){
 205
 206                                                 @Override
 207                                                 public int compare(Rank o1, Rank o2) {
 208                                                         return o1.compareTo(o2);
 209                                                 }
 210
 211                                         });
 212                                 }else{
 213                                         return TermStore.getTermsFromService(Rank.class, null);
 214                                 }
 215                         }
 216
 217                 });
 218                 termStoreEdgeCases.add(new ITermStoreEdgeCase<PresenceAbsenceTermBase>() {
 219
 220                         @Override
 221                         public Class<PresenceAbsenceTermBase> getTermClass() {
 222                                 return PresenceAbsenceTermBase.class;
 223                         }
 224
 225                         @Override
 226                         public List<PresenceAbsenceTermBase> getTerms() {
 227                                 List presenceAbsenceTerms = TermStore.getTermsFromService(PresenceTerm.class, null);
 228                                 presenceAbsenceTerms.addAll(TermStore.getTermsFromService(AbsenceTerm.class, null));
 229
 230                                 return presenceAbsenceTerms;
 231                         }
 232                 });
 233                 termStoreEdgeCases.add(new ITermStoreEdgeCase<TaxonRelationshipTypeInverseContainer>() {
 234
 235                         @Override
 236                         public Class<TaxonRelationshipTypeInverseContainer> getTermClass() {
 237                                 return TaxonRelationshipTypeInverseContainer.class;
 238                         }
 239
 240                         @Override
 241                         public List<TaxonRelationshipTypeInverseContainer> getTerms() {
 242                                 List<TaxonRelationshipType> excludeTaxonRelationshipTypes = Arrays.asList(new TaxonRelationshipType[]{
 243                                         TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),
 244                                         TaxonRelationshipType.MISAPPLIED_NAME_FOR(),
 245                                         TaxonRelationshipType.ALL_RELATIONSHIPS()
 246                                 });
 247
 248                                 List<TaxonRelationshipTypeInverseContainer> relationshipTypeInverseContainers = new ArrayList<TaxonRelationshipTypeInverseContainer>();
 249
 250                                 List<TaxonRelationshipType> relationshipTypes = TermStore.getTerms(TaxonRelationshipType.class);
 251
 252                                 relationshipTypes.removeAll(excludeTaxonRelationshipTypes);
 253
 254                                 for (TaxonRelationshipType relationshipType : relationshipTypes){
 255                                         if(!relationshipType.isSymmetric()){
 256                                                 TaxonRelationshipTypeInverseContainer inverseContainer = new TaxonRelationshipTypeInverseContainer(relationshipType, true);
 257                                                 relationshipTypeInverseContainers.add(inverseContainer);
 258                                         }
 259                                         TaxonRelationshipTypeInverseContainer container = new TaxonRelationshipTypeInverseContainer(relationshipType, false);
 260                                         relationshipTypeInverseContainers.add(container);
 261                                 }
 262
 263                                 return relationshipTypeInverseContainers;
 264                         }
 265                 });
 266         }
 267
 268         private static <T extends DefinedTermBase> ITermStoreEdgeCase<T> getEdgeCase(Class<T> termClass) {
 269
 270                 for (ITermStoreEdgeCase termStoreEdgeCase : termStoreEdgeCases){
 271                         if (termStoreEdgeCase.getTermClass().equals(termClass)){
 272                                 return termStoreEdgeCase;
 273                         }
 274                 }
 275
 276                 return null;
 277         }
 278
 279         private interface ITermStoreEdgeCase<TERM> {
 280
 281                 public abstract Class<TERM> getTermClass();
 282
 283                 public abstract List<TERM> getTerms();
 284
 285         }
 286 }