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
.Collection
;
15 import java
.util
.HashMap
;
16 import java
.util
.List
;
18 import java
.util
.UUID
;
20 import org
.eclipse
.core
.runtime
.IProgressMonitor
;
21 import org
.eclipse
.ui
.IMemento
;
23 import eu
.etaxonomy
.cdm
.model
.common
.DefinedTermBase
;
24 import eu
.etaxonomy
.cdm
.model
.common
.TermBase
;
25 import eu
.etaxonomy
.cdm
.model
.common
.TermType
;
26 import eu
.etaxonomy
.cdm
.model
.common
.TermVocabulary
;
27 import eu
.etaxonomy
.taxeditor
.model
.ContextListenerAdapter
;
28 import eu
.etaxonomy
.taxeditor
.model
.TaxonRelationshipTypeInverseContainer
;
32 * @created Dec 7, 2010
35 public class TermManager
extends ContextListenerAdapter
{
37 private static final String TERMS
= "terms";
38 private static final String TERM
= "term";
39 private static final String HIDE
= "hide";
41 private static final String CLASS
= "class";
42 private static final String UUID_STRING
= "uuid";
44 private final Map
<String
, Collection
<UUID
>> hiddenTermsMap
= new HashMap
<String
, Collection
<UUID
>>();
47 CdmStore
.getContextManager().addContextListener(this);
55 public List
<DefinedTermBase
<?
>> getPreferredTerms(TermType termType
){
56 return getFilteredTerms(TermStore
.getTerms(termType
, null));
64 public <T
extends DefinedTermBase
> List
<T
> getPreferredTerms(TermVocabulary
<T
> termVocabulary
){
65 return getFilteredTerms(new ArrayList
<T
>(TermStore
.getTerms(termVocabulary
, null)));
73 public <T
extends DefinedTermBase
> List
<T
> getPreferredTerms(Class
<T
> clazz
){
74 return getFilteredTerms(TermStore
.getTerms(clazz
));
78 * @see eu.etaxonomy.taxeditor.model.ContextListenerAdapter#contextStart(org.eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
81 public void contextStart(IMemento memento
, IProgressMonitor monitor
) {
82 // read preferred terms from memento into an in memory representation
87 IMemento terms
= memento
.getChild(TERMS
);
93 for(IMemento term
: terms
.getChildren(TERM
)){
94 String typeName
= term
.getString(CLASS
);
95 Collection
<UUID
> hiddenTermUuids
= new ArrayList
<UUID
>();
96 for(IMemento hide
: term
.getChildren(HIDE
)){
97 String uuidString
= hide
.getString(UUID_STRING
);
98 UUID uuid
= UUID
.fromString(uuidString
);
99 hiddenTermUuids
.add(uuid
);
101 hiddenTermsMap
.put(typeName
, hiddenTermUuids
);
106 * @see eu.etaxonomy.taxeditor.model.ContextListenerAdapter#contextAboutToStop(org.eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
109 public void contextStop(IMemento memento
, IProgressMonitor monitor
) {
110 saveTerms(memento
, monitor
);
114 * @see eu.etaxonomy.taxeditor.model.ContextListenerAdapter#workbenchShutdown(org.eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
117 public void workbenchShutdown(IMemento memento
, IProgressMonitor monitor
) {
118 saveTerms(memento
, monitor
);
121 private void saveTerms(IMemento memento
, IProgressMonitor monitor
){
122 if(memento
== null) {
126 IMemento terms
= memento
.createChild(TERMS
);
127 for (String preferredTerm
: hiddenTermsMap
.keySet()){
128 IMemento term
= terms
.createChild(TERM
);
129 term
.putString(CLASS
, preferredTerm
);
130 for(UUID uuid
: hiddenTermsMap
.get(preferredTerm
)){
131 IMemento hide
= term
.createChild(HIDE
);
132 hide
.putString(UUID_STRING
, uuid
.toString());
138 * Generic method to get term preferences for a term vocabulary
140 * @param initialTerms a {@link java.util.List} object.
141 * @return a {@link java.util.List} object.
143 public <T
extends DefinedTermBase
> List
<T
> getFilteredTerms(List
<T
> initialTerms
){
145 List
<T
> filteredTerms
= new ArrayList
<T
>();
147 String typeName
= getTermClass(initialTerms
);
148 Collection
<UUID
> hiddenTermUuids
= hiddenTermsMap
.get(typeName
);
151 if(hiddenTermUuids
== null){
155 for (T term
: initialTerms
){
156 if (term
instanceof TaxonRelationshipTypeInverseContainer
){
157 if(! hiddenTermUuids
.contains(((TaxonRelationshipTypeInverseContainer
) term
).getType().getUuid())){
158 T type
= (T
)((TaxonRelationshipTypeInverseContainer
) term
).getType();
159 filteredTerms
.add(type
);
163 if(! hiddenTermUuids
.contains(term
.getUuid())){
164 filteredTerms
.add(term
);
168 return filteredTerms
;
171 private <T
extends DefinedTermBase
> String
getTermClass(Collection
<T
> initialTerms
){
173 String result
= null;
174 if(!initialTerms
.isEmpty()){
176 //TODO: there should be a more generic solution!!
177 T entity
= initialTerms
.iterator().next();
178 if (entity
instanceof TaxonRelationshipTypeInverseContainer
){
179 result
= ((TaxonRelationshipTypeInverseContainer
) entity
).getType().getClass().getName();
181 result
= entity
.getClass().getName();
189 // * <p>getPreferredSpecimenTypeDesignationStatus</p>
191 // * @return a {@link java.util.List} object.
193 // public List<SpecimenTypeDesignationStatus> getPreferredSpecimenTypeDesignationStatus() { return getFilteredTerms(TermStore.getSpecimenTypeDesignationStatus());}
196 // * <p>getPreferredNameTypeDesignationStatus</p>
198 // * @return a {@link java.util.List} object.
200 // public List<NameTypeDesignationStatus> getPreferredNameTypeDesignationStatus() { return getFilteredTerms(TermStore.getNameTypeDesignationStatus()); }
203 // * <p>getPreferredTaxonRelationshipTypes</p>
205 // * @return a {@link java.util.List} object.
207 // public List<TaxonRelationshipType> getPreferredTaxonRelationshipTypes() { return getFilteredTerms(TermStore.getTaxonRelationshipTypes());}
209 // private static List<TaxonRelationshipType> excludeTaxonRelationshipTypes = Arrays.asList(new TaxonRelationshipType[]{
210 // TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),
211 // TaxonRelationshipType.MISAPPLIED_NAME_FOR(),
212 // TaxonRelationshipType.ALL_RELATIONSHIPS()
216 // * Please note that the {@link TaxonRelationshipType}s TAXONOMICALLY_INCLUDED_IN, MISAPPLIED_NAME_FOR and ALL_RELATIONSHIPS
217 // * are filtered out as they are most likely not needed. If you do need them please refactor this method to your needs.
219 // * @return a list of {@link TaxonRelationshipTypeInverseContainer} elements
221 // public List<TaxonRelationshipTypeInverseContainer> getPreferredRelationshipTypesWithInverses(){
222 // List<TaxonRelationshipTypeInverseContainer> relationshipTypeInverseContainers = new ArrayList<TaxonRelationshipTypeInverseContainer>();
224 // List<TaxonRelationshipType> relationshipTypes = getPreferredTaxonRelationshipTypes();
226 // relationshipTypes.removeAll(excludeTaxonRelationshipTypes);
228 // for (TaxonRelationshipType relationshipType : relationshipTypes){
229 // if(!relationshipType.isSymmetric()){
230 // TaxonRelationshipTypeInverseContainer inverseContainer = new TaxonRelationshipTypeInverseContainer(relationshipType, true);
231 // relationshipTypeInverseContainers.add(inverseContainer);
233 // TaxonRelationshipTypeInverseContainer container = new TaxonRelationshipTypeInverseContainer(relationshipType, false);
234 // relationshipTypeInverseContainers.add(container);
237 // return relationshipTypeInverseContainers;
245 // * <p>getPreferredFeatures</p>
247 // * @return a {@link java.util.List} object.
249 // public List<Feature> getPreferredFeatures() { return getFilteredTerms(TermStore.getFeatures());}
252 // * <p>getPreferredRanks</p>
254 // * @return a {@link java.util.List} object.
256 // public List<Rank> getPreferredRanks() { return getFilteredTerms(TermStore.getRanks());}
259 // * <p>getPreferredPresenceAbsenceTerms</p>
261 // * @return a {@link java.util.List} object.
263 // public List<PresenceAbsenceTermBase> getPreferredPresenceAbsenceTerms(){ return getFilteredTerms(TermStore.getPresenceAbsenceTerms());}
266 // * <p>getPreferredNomenclaturalStatusTypes</p>
268 // * @return a {@link java.util.List} object.
270 // public List<NomenclaturalStatusType> getPreferredNomenclaturalStatusTypes(){ return getFilteredTerms(TermStore.getNomenclaturalStatusTypes());}
273 // * <p>getPreferredNameRelationshipTypes</p>
275 // * @return a {@link java.util.List} object.
277 // public List<NameRelationshipType> getPreferredNameRelationshipTypes(){ return getFilteredTerms(TermStore.getNameRelationshipTypes());}
280 // * <p>getPreferredLanguages</p>
282 // * @return a {@link java.util.List} object.
284 // public List<Language> getPreferredLanguages() { return getFilteredTerms(TermStore.getLanguages()); }
287 // * <p>getPreferredMarkerTypes</p>
289 // * @return a {@link java.util.List} object.
291 // public List<MarkerType> getPreferredMarkerTypes() { return getFilteredTerms(TermStore.getNonTechnicalMarkerTypes()); }
294 // * <p>getPreferredExtensionTypes</p>
296 // * @return a {@link java.util.List} object.
298 // public List<ExtensionType> getPreferredExtensionTypes() { return getFilteredTerms(TermStore.getExtensionTypes()); }
301 // * <p>getPreferredRightsTypes</p>
303 // * @return a {@link java.util.List} object.
305 // public List<RightsType> getPreferredRightsTypes() { return getFilteredTerms(TermStore.getRightsTypes());}
308 // * <p>getPreferredNamedAreaTypes</p>
310 // * @return a {@link java.util.List} object.
312 // public List<NamedAreaType> getPreferredNamedAreaTypes() { return getFilteredTerms(TermStore.getNamedAreaTypes()); }
315 // * <p>getPreferredNamedAreaTypes</p>
317 // * @return a {@link java.util.List} object.
319 // public List<NamedAreaLevel> getPreferredNamedAreaLevels() { return getFilteredTerms(TermStore.getNamedAreaLevels()); }
322 // * <p>getPreferredAnnotationTypes</p>
324 // * @return a {@link java.util.List} object.
326 // public List<AnnotationType> getPreferredAnnotationTypes() { return getFilteredTerms(TermStore.getAnnotationTypes()); }
329 // * <p>getPreferredStages</p>
331 // * @return a {@link java.util.List} object.
333 // public List<Stage> getPreferredStages() { return getFilteredTerms(TermStore.getStages()); }
336 // * <p>getPreferredPreservationMethods</p>
338 // * @return a {@link java.util.List} object.
340 // public List<PreservationMethod> getPreferredPreservationMethods() { return getFilteredTerms(TermStore.getPreservationMethods()); }
343 // * <p>getPreferredMeasurementUnits</p>
345 // * @return a {@link java.util.List} object.
347 // public List<MeasurementUnit> getPreferredMeasurementUnits() { return getFilteredTerms(TermStore.getMeasurementUnits()); }
350 // * <p>getPreferredStates</p>
352 // * @return a {@link java.util.List} object.
354 // public List<State> getPreferredStates() { return getFilteredTerms(TermStore.getStates()); }
357 // * <p>getPreferredModifiers</p>
359 // * @return a {@link java.util.List} object.
361 // public List<Modifier> getPreferredModifiers() { return getFilteredTerms(TermStore.getModifiers()); }
364 // * <p>getPreferredStatisticalMeasures</p>
366 // * @return a {@link java.util.List} object.
368 // public List<StatisticalMeasure> getPreferredStatisticalMeasures() { return getFilteredTerms(TermStore.getStatisticalMeasures()); }
371 // * <p>getPreferredScopes</p>
373 // * @return a {@link java.util.List} object.
375 // public List<Scope> getPreferredScopes() { return getFilteredTerms(TermStore.getScopes()); }
378 // * <p>getPreferredDeterminationModifiers</p>
380 // * @return a {@link java.util.List} object.
382 // public List<DeterminationModifier> getPreferredDeterminationModifiers() { return getFilteredTerms(TermStore.getDeterminationModifiers()); }
385 * Generic method to set term preferences
387 * @param preferredTerms a {@link java.util.List} object.
388 * @param initialTerms a {@link java.util.List} object.
389 * @param <T> a T object.
391 public <T
extends DefinedTermBase
> void setPreferredTerms(Collection
<T
> preferredTerms
, Collection
<T
> initialTerms
){
392 String typeName
= getTermClass(initialTerms
);
394 Collection
<UUID
> undesiredTermUuids
= new ArrayList
<UUID
>();
396 for(TermBase term
: initialTerms
){
397 if(! preferredTerms
.contains(term
)){
398 undesiredTermUuids
.add(term
.getUuid());
402 hiddenTermsMap
.put(typeName
, undesiredTermUuids
);