*/
public class TermManager {
- private static final String TERMS = "terms";
- private static final String TERM = "term";
- private static final String HIDE = "hide";
-
- private static final String CLASS = "class";
- private static final String UUID_STRING = "uuid";
-
-
private Map<Object, List> cachedTermMap = new HashMap<>();
-
//new cache for features!!
//dinstinguish preferences for both
//load at start
@SuppressWarnings("unchecked")
List<T> terms = cachedTermMap.get(termVocabulary.getUuid());
if(terms==null){
- terms = getFilteredTerms(new ArrayList<T>(TermStore.getTerms(termVocabulary,null)));
+ terms = getFilteredTerms(new ArrayList<>(TermStore.getTerms(termVocabulary,null)));
cachedTermMap.put(termVocabulary.getUuid(), terms);
}
return terms;
return null;
}
- private TermVocabularyDto getTermVocabularyByDto(Collection<TermDto> initialTerms){
- if(!initialTerms.isEmpty()){
- TermDto entity = initialTerms.iterator().next();
- return entity.getVocabularyDto();
- }
- return null;
- }
-
-
/**
* Generic method to set term preferences
*
clearTermMapForTermVoc(voc.getUuid());
}
-
/**
* Generic method to set term preferences
*
public <T extends DefinedTermBase> List<T> getTerms(List<UUID> uuidList, Class clazz){
List<T> filteredTerms = new ArrayList<>();
- List<T> terms = TermStore.getTerms(clazz);
+ @SuppressWarnings("unchecked")
+ List<T> terms = TermStore.getTerms(clazz);
if (uuidList == null || uuidList.isEmpty()){
return terms;
}
* @return a sorted list of terms
*/
public static <TERM extends DefinedTermBase> List<TERM> getTerms(Class<TERM> clazz, Comparator<TERM> comparator, boolean filtered){
- List<TERM> terms = new ArrayList<TERM>();
+ List<TERM> terms = new ArrayList<>();
ITermStoreEdgeCase<TERM> edgeCase = getEdgeCase(clazz);
if(filtered && edgeCase != null){
}
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>();
return terms;
}
- /**
- *
- * @param termClass
- * @param comparator
- * @return
- */
private static <T extends DefinedTermBase> List<T> getTermsFromService(Class<T> termClass, Comparator<T> comparator){
if (comparator == null){
comparator = new DefaultTermComparator<T>();
return terms;
}
- /**
- * @param term a {@link eu.etaxonomy.cdm.model.term.DefinedTermBase} object.
- */
public static void saveTerm(DefinedTermBase term){
CdmStore.getService(ITermService.class).saveOrUpdate(term);
}
/**
* Handingling of special cases
*/
-
- private static Set<ITermStoreEdgeCase<? extends DefinedTermBase>> termStoreEdgeCases = new HashSet<ITermStoreEdgeCase<? extends DefinedTermBase>>();
+ private static Set<ITermStoreEdgeCase<? extends DefinedTermBase>> termStoreEdgeCases = new HashSet<>();
static {
termStoreEdgeCases.add(new ITermStoreEdgeCase<Feature>() {
@Override
public List<MarkerType> getTerms() {
// filter out non technical markers
- List<MarkerType> nonTechnicalMarkerTypes = new ArrayList<MarkerType>();
+ List<MarkerType> nonTechnicalMarkerTypes = new ArrayList<>();
List<MarkerType> markerTypes = TermStore.getTermsFromService(MarkerType.class, null);
for (Object type : markerTypes) {
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);
- }
-
- });
+ @Override
+ public int compare(Rank o1, Rank o2) {
+ return o1.compareTo(o2);
+ }
+ });
}else{
return TermStore.getTermsFromService(Rank.class, null);
}
}
-
});
termStoreEdgeCases.add(new ITermStoreEdgeCase<PresenceAbsenceTerm>() {
-
@Override
public Class<PresenceAbsenceTerm> getTermClass() {
return PresenceAbsenceTerm.class;
}
-
@Override
public List<PresenceAbsenceTerm> getTerms() {
List<PresenceAbsenceTerm> presenceAbsenceTerms = TermStore.getTermsFromService(PresenceAbsenceTerm.class, null);
}
});
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.ALL_RELATIONSHIPS()
});
- List<TaxonRelationshipTypeInverseContainer> relationshipTypeInverseContainers = new ArrayList<TaxonRelationshipTypeInverseContainer>();
+ List<TaxonRelationshipTypeInverseContainer> relationshipTypeInverseContainers = new ArrayList<>();
List<TaxonRelationshipType> relationshipTypes = TermStore.getTerms(TaxonRelationshipType.class);