3 * Copyright (C) 2007 EDIT
4 * European Distributed Institute of Taxonomy
5 * http://www.e-taxonomy.eu
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.
11 package eu
.etaxonomy
.taxeditor
.store
;
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
;
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
.common
.TermVocabulary
;
27 import eu
.etaxonomy
.cdm
.model
.description
.AbsenceTerm
;
28 import eu
.etaxonomy
.cdm
.model
.description
.Feature
;
29 import eu
.etaxonomy
.cdm
.model
.description
.PresenceAbsenceTermBase
;
30 import eu
.etaxonomy
.cdm
.model
.description
.PresenceTerm
;
31 import eu
.etaxonomy
.cdm
.model
.name
.Rank
;
32 import eu
.etaxonomy
.cdm
.model
.taxon
.TaxonRelationshipType
;
33 import eu
.etaxonomy
.taxeditor
.model
.DefaultTermComparator
;
34 import eu
.etaxonomy
.taxeditor
.model
.TaxonRelationshipTypeInverseContainer
;
35 import eu
.etaxonomy
.taxeditor
.preference
.PreferencesUtil
;
38 * All terms may be accessed through this store.
39 * Note: This is for internal use. When using vocabularies in the UI, try to use the preferred terms from
46 public class TermStore
{
49 * Returns an alphabetically sorted list of terms (anything that extends {@link DefinedTermBase}) of the given type currently available in the system.
51 * @param clazz a class that inherits from {@link DefinedTermBase}
52 * @return an alphabetically sorted list of terms
54 public static <TERM
extends DefinedTermBase
> List
<TERM
> getTerms(Class
<TERM
> clazz
){
55 return getTerms(clazz
, null, true);
59 * Returns an alphabetically sorted list of terms (anything that extends {@link DefinedTermBase}) of the given {@link TermType})
60 * currently available in the system.
62 * @param termType the term type
63 * @return an alphabetically sorted list of terms
65 public static List
<DefinedTermBase
<?
>> getTerms(TermType termType
, Comparator
<DefinedTermBase
<?
>> comparator
){
66 return getTermsFromService(termType
, comparator
);
70 * Returns an alphabetically sorted list of terms (anything that extends {@link DefinedTermBase}) of the given {@link TermType})
71 * currently available in the system.
73 * @param termType the term type
74 * @return an alphabetically sorted list of terms
76 public static <TERM
extends DefinedTermBase
> Set
<TERM
> getTerms(TermVocabulary
<TERM
> termVocabulary
, Comparator
<DefinedTermBase
<?
>> comparator
){
77 return termVocabulary
.getTerms();
81 * Returns a list of terms of the given type currently available in the system.
82 * If <code>filtered</code> is set to <code>true</code>, all terms for certain types will be
83 * gathered from edge cases.
85 * @param clazz a class that inherits from {@link DefinedTermBase}
86 * @param comparator a {@link Comparator} that defines the sorting algorithm. If set to null, {@link DefaultTermComparator} will be used
87 * @param filtered if set to true, some terms are filtered from the result (according to definition in {@link ITermStoreEdgeCase}s)
88 * @return a sorted list of terms
90 public static <TERM
extends DefinedTermBase
> List
<TERM
> getTerms(Class
<TERM
> clazz
, Comparator
<TERM
> comparator
, boolean filtered
){
91 List
<TERM
> terms
= new ArrayList
<TERM
>();
93 ITermStoreEdgeCase
<TERM
> edgeCase
= getEdgeCase(clazz
);
94 if(filtered
&& edgeCase
!= null){
95 terms
= edgeCase
.getTerms();
97 terms
= getTermsFromService(clazz
, comparator
);
110 private static List
<DefinedTermBase
<?
>> getTermsFromService(TermType termType
, Comparator
<DefinedTermBase
<?
>> comparator
){
111 if (comparator
== null){
112 comparator
= new DefaultTermComparator
<DefinedTermBase
<?
>>();
115 List
<DefinedTermBase
<?
>> terms
= CdmStore
.getService(ITermService
.class).listByTermType(termType
, null, null, null, null);
116 Collections
.sort(terms
, comparator
);
126 private static <T
extends DefinedTermBase
> List
<T
> getTermsFromService(Class
<T
> termClass
, Comparator
<T
> comparator
){
127 if (comparator
== null){
128 comparator
= new DefaultTermComparator
<T
>();
131 List
<T
> terms
= CdmStore
.getService(ITermService
.class).list(termClass
, null, null, null, null);
132 Collections
.sort(terms
, comparator
);
137 * @param term a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object.
139 public static void saveTerm(DefinedTermBase term
){
140 CdmStore
.getService(ITermService
.class).saveOrUpdate(term
);
146 * @param selected a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object.
147 * @throws ReferencedObjectUndeletableException
149 public static void delete(DefinedTermBase selected
) throws ReferencedObjectUndeletableException
{
150 CdmStore
.getService(ITermService
.class).delete(selected
);
154 * Save a vacabulary to data store
156 * @param term a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object.
158 public static void updateVocabulary(DefinedTermBase term
) {
159 CdmStore
.getService(ITermService
.class).saveOrUpdate(term
);
163 * Handingling of special cases
166 private static Set
<ITermStoreEdgeCase
<?
extends DefinedTermBase
>> termStoreEdgeCases
= new HashSet
<ITermStoreEdgeCase
<?
extends DefinedTermBase
>>();
169 termStoreEdgeCases
.add(new ITermStoreEdgeCase
<Feature
>() {
172 public Class
<Feature
> getTermClass() {
173 return Feature
.class;
177 public List
<Feature
> getTerms() {
178 List
<Feature
> features
= TermStore
.getTermsFromService(Feature
.class, null);
179 features
.remove(Feature
.IMAGE());
183 termStoreEdgeCases
.add(new ITermStoreEdgeCase
<MarkerType
>(){
186 public Class
<MarkerType
> getTermClass() {
187 return MarkerType
.class;
191 public List
<MarkerType
> getTerms() {
192 // filter out non technical markers
193 List
<MarkerType
> nonTechnicalMarkerTypes
= new ArrayList
<MarkerType
>();
194 List
<MarkerType
> markerTypes
= TermStore
.getTermsFromService(MarkerType
.class, null);
196 for (Object type
: markerTypes
) {
197 if (((MarkerType
) type
).isTechnical() == false) {
198 nonTechnicalMarkerTypes
.add((MarkerType
) type
);
202 return nonTechnicalMarkerTypes
;
206 termStoreEdgeCases
.add(new ITermStoreEdgeCase
<Rank
>() {
209 public Class
<Rank
> getTermClass() {
214 public List
<Rank
> getTerms() {
215 if(PreferencesUtil
.getSortRanksHierarchichally()){
216 return TermStore
.getTermsFromService(Rank
.class, new Comparator
<Rank
>(){
219 public int compare(Rank o1
, Rank o2
) {
220 return o1
.compareTo(o2
);
225 return TermStore
.getTermsFromService(Rank
.class, null);
230 termStoreEdgeCases
.add(new ITermStoreEdgeCase
<PresenceAbsenceTermBase
>() {
233 public Class
<PresenceAbsenceTermBase
> getTermClass() {
234 return PresenceAbsenceTermBase
.class;
238 public List
<PresenceAbsenceTermBase
> getTerms() {
239 List presenceAbsenceTerms
= TermStore
.getTermsFromService(PresenceTerm
.class, null);
240 presenceAbsenceTerms
.addAll(TermStore
.getTermsFromService(AbsenceTerm
.class, null));
242 return presenceAbsenceTerms
;
245 termStoreEdgeCases
.add(new ITermStoreEdgeCase
<TaxonRelationshipTypeInverseContainer
>() {
248 public Class
<TaxonRelationshipTypeInverseContainer
> getTermClass() {
249 return TaxonRelationshipTypeInverseContainer
.class;
253 public List
<TaxonRelationshipTypeInverseContainer
> getTerms() {
254 List
<TaxonRelationshipType
> excludeTaxonRelationshipTypes
= Arrays
.asList(new TaxonRelationshipType
[]{
255 TaxonRelationshipType
.TAXONOMICALLY_INCLUDED_IN(),
256 TaxonRelationshipType
.MISAPPLIED_NAME_FOR(),
257 TaxonRelationshipType
.ALL_RELATIONSHIPS()
260 List
<TaxonRelationshipTypeInverseContainer
> relationshipTypeInverseContainers
= new ArrayList
<TaxonRelationshipTypeInverseContainer
>();
262 List
<TaxonRelationshipType
> relationshipTypes
= TermStore
.getTerms(TaxonRelationshipType
.class);
264 relationshipTypes
.removeAll(excludeTaxonRelationshipTypes
);
266 for (TaxonRelationshipType relationshipType
: relationshipTypes
){
267 if(!relationshipType
.isSymmetric()){
268 TaxonRelationshipTypeInverseContainer inverseContainer
= new TaxonRelationshipTypeInverseContainer(relationshipType
, true);
269 relationshipTypeInverseContainers
.add(inverseContainer
);
271 TaxonRelationshipTypeInverseContainer container
= new TaxonRelationshipTypeInverseContainer(relationshipType
, false);
272 relationshipTypeInverseContainers
.add(container
);
275 return relationshipTypeInverseContainers
;
280 private static <T
extends DefinedTermBase
> ITermStoreEdgeCase
<T
> getEdgeCase(Class
<T
> termClass
) {
282 for (ITermStoreEdgeCase termStoreEdgeCase
: termStoreEdgeCases
){
283 if (termStoreEdgeCase
.getTermClass().equals(termClass
)){
284 return termStoreEdgeCase
;
291 private interface ITermStoreEdgeCase
<TERM
> {
293 public abstract Class
<TERM
> getTermClass();
295 public abstract List
<TERM
> getTerms();