EDIT

// $Id$

/**

* Copyright (C) 2007 EDIT

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.store;

import java.util.ArrayList;

import java.util.Comparator;

import eu.etaxonomy.cdm.model.common.MarkerType;

import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;

/**

 * All terms may be accessed through this store.

 * Note: This is for internal use. When using vocabularies in the UI, try to use the preferred terms from

 * PreferenceUtil

 * @created 25.06.2009

 * @version 1.0

 */

public class TermStore {

	 *

	 * @return an alphabetically sorted list of terms

	 */

		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

	 */

	}

	 * 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();

	}

	 * gathered from edge cases.

	 * @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)

	 * @return a sorted list of terms

		List<TERM> terms = new ArrayList<TERM>();

		if(filtered && edgeCase != null){

			terms = edgeCase.getTerms();

		}else{

			terms = getTermsFromService(clazz, comparator);

	/**

	 *

	 * @param termClass

	 * @param comparator

	 * @return

	 */

	    return terms;

	}

	 * @param comparator

	 * @return

	 */

		if (comparator == null){

		return terms;

	 */

	 *

	 * @param selected a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object.

	 * Save a vacabulary to data store

	 * @param term a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object.

	public static void updateVocabulary(DefinedTermBase term) {

	/**

	 * Handingling of special cases

	 */

		termStoreEdgeCases.add(new ITermStoreEdgeCase<Feature>() {

			@Override

			public Class<Feature> getTermClass() {

				return Feature.class;

			}

			@Override

			public List<Feature> getTerms() {

				List<Feature> features = TermStore.getTermsFromService(Feature.class, null);

				features.remove(Feature.IMAGE());

				return features;

			}

		});

		termStoreEdgeCases.add(new ITermStoreEdgeCase<MarkerType>(){

			@Override

			public Class<MarkerType> getTermClass() {

				return MarkerType.class;

			}

			@Override

			public List<MarkerType> getTerms() {

				// filter out non technical markers

				List<MarkerType> nonTechnicalMarkerTypes = new ArrayList<MarkerType>();

				List<MarkerType> markerTypes = TermStore.getTermsFromService(MarkerType.class, null);

					if (((MarkerType) type).isTechnical() == false) {

						nonTechnicalMarkerTypes.add((MarkerType) type);

					}

				}

			}

		termStoreEdgeCases.add(new ITermStoreEdgeCase<Rank>() {

			@Override

			public Class<Rank> getTermClass() {

				return Rank.class;

			}

			@Override

			public List<Rank> getTerms() {

				if(PreferencesUtil.getSortRanksHierarchichally()){

					return TermStore.getTermsFromService(Rank.class, new Comparator<Rank>(){

						public int compare(Rank o1, Rank o2) {

							return o1.compareTo(o2);

						}

				}else{

					return TermStore.getTermsFromService(Rank.class, null);

				}

			}

			@Override

				return PresenceAbsenceTerm.class;

			@Override

				List<PresenceAbsenceTerm> presenceAbsenceTerms = TermStore.getTermsFromService(PresenceAbsenceTerm.class, null);

				return presenceAbsenceTerms;

			}

		});

		termStoreEdgeCases.add(new ITermStoreEdgeCase<TaxonRelationshipTypeInverseContainer>() {

			@Override

			public Class<TaxonRelationshipTypeInverseContainer> getTermClass() {

				return TaxonRelationshipTypeInverseContainer.class;

			}

			@Override

			public List<TaxonRelationshipTypeInverseContainer> getTerms() {

				List<TaxonRelationshipType> excludeTaxonRelationshipTypes = Arrays.asList(new TaxonRelationshipType[]{

					TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),

					TaxonRelationshipType.MISAPPLIED_NAME_FOR(),

					if(!relationshipType.isSymmetric()){

						TaxonRelationshipTypeInverseContainer inverseContainer = new TaxonRelationshipTypeInverseContainer(relationshipType, true);

						relationshipTypeInverseContainers.add(inverseContainer);

				}

			}

		});

			if (termStoreEdgeCase.getTermClass().equals(termClass)){

				return termStoreEdgeCase;