/**
* @author n.hoffmann
* @created Dec 7, 2010
- * @version 1.0
*/
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
public TermManager(){
}
- /**
- *
- * @param clazz
- * @return
- */
+ public void reset(){
+ cachedTermMap = new HashMap<>();
+ }
+
public <T extends DefinedTermBase> List<T> getPreferredTerms(TermType termType){
- List terms = cachedTermMap.get(termType);
+ List<?> terms = cachedTermMap.get(termType.getUuid());
+ List<T> termBaseList = new ArrayList<>();
if(terms==null || terms.isEmpty()){
- terms = getFilteredTerms(TermStore.<T>getTerms(termType, null));
- cachedTermMap.put(termType, terms);
+ termBaseList = getFilteredTerms(TermStore.<T>getTerms(termType, null));
+ if (termBaseList != null){
+ cachedTermMap.put(termType.getUuid(), termBaseList);
+ }
+ }else{
+ Iterator<?> iterator = terms.iterator();
+ List<UUID> uuids = new ArrayList<>();
+ while (iterator.hasNext()){
+ Object term = iterator.next();
+ if (term instanceof TermDto){
+ TermDto dto = (TermDto)term;
+ uuids.add(dto.getUuid());
+ }else {
+ termBaseList.add((T)term);
+ }
+
+ }
+ if (!uuids.isEmpty()){
+ termBaseList.addAll(getTerms(uuids, termType));
+ }
}
- return terms;
+ return termBaseList;
}
- /**
- *
- * @param clazz
- * @return
- */
public <T extends DefinedTermBase> List<T> getPreferredTerms(TermVocabulary<T> termVocabulary){
- List terms = cachedTermMap.get(termVocabulary.getUuid());
+ @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;
}
- /**
- *
- * @param clazz
- * @return
- */
public List<TermDto> getPreferredTerms(TermVocabularyDto termVocabularyDto){
- List terms = cachedTermMap.get(termVocabularyDto.getUuid());
- if(terms==null){
+ @SuppressWarnings("unchecked")
+ List<TermDto> terms = cachedTermMap.get(termVocabularyDto.getUuid());
+ if(terms==null || terms.isEmpty()){
terms = getFilteredTermDtos(new ArrayList<>(termVocabularyDto.getTerms()));
cachedTermMap.put(termVocabularyDto.getUuid(), terms);
}
return terms;
}
- /**
- *
- * @param clazz
- * @return
- */
- public <T extends DefinedTermBase> List<T> getPreferredTerms(TermVocabulary<T> termVocabulary, Comparator comp){
+ public <T extends DefinedTermBase> List<T> getPreferredTerms(TermVocabulary<T> termVocabulary,
+ Comparator comp){
if (comp == null){
comp = new DefaultTermComparator<T>();
}
- List terms = cachedTermMap.get(termVocabulary.getUuid());
- List<T> termBaseList = new ArrayList();
+ @SuppressWarnings("unchecked")
+ List<T> terms = cachedTermMap.get(termVocabulary.getUuid());
+ List<T> termBaseList = new ArrayList<>();
if(terms==null){
- terms = getFilteredTerms(new ArrayList<T>(TermStore.getTerms(termVocabulary,comp)));
- cachedTermMap.put(termVocabulary.getUuid(), terms);
+ termBaseList = getFilteredTerms(new ArrayList<T>(TermStore.getTerms(termVocabulary, comp)));
+ cachedTermMap.put(termVocabulary.getUuid(), termBaseList);
}else{
- Iterator iterator = terms.iterator();
- DefinedTermBase termBase = null;
- List<UUID> uuids = new ArrayList();
+ Iterator<?> iterator = terms.iterator();
+ List<UUID> uuids = new ArrayList<>();
while (iterator.hasNext()){
Object term = iterator.next();
if (term instanceof TermDto){
}else {
termBaseList.add((T)term);
}
-
}
+
if (!uuids.isEmpty()){
termBaseList.addAll(this.getTerms(uuids, DefinedTermBase.class));
}
terms = termBaseList;
return terms;
}
- /**
- *
- * @param clazz
- * @return
- */
+
public <T extends DefinedTermBase> List<T> getPreferredTerms(Class<T> clazz){
- List terms = cachedTermMap.get(clazz);
+ @SuppressWarnings("unchecked")
+ List<T> terms = cachedTermMap.get(clazz);
if(terms==null){
terms = getFilteredTerms(TermStore.getTerms(clazz));
cachedTermMap.put(clazz, terms);
-
}
return terms;
}
* @return a {@link java.util.List} object.
*/
public <T extends DefinedTermBase> List<T> getFilteredTerms(List<T> initialTerms){
-
- List<T> filteredTerms = new ArrayList<T>();
+ List<T> filteredTerms = new ArrayList<>();
+ if (initialTerms == null || initialTerms.isEmpty()){
+ return filteredTerms;
+ }
for (T term : initialTerms){
-
if (term instanceof TaxonRelationshipTypeInverseContainer){
- if(!PreferencesUtil.getBooleanValue(getPrefName(term))){
+ if(!PreferencesUtil.getBooleanValue(getPrefName(term), true)){
T type = (T)((TaxonRelationshipTypeInverseContainer) term).getType();
filteredTerms.add(type);
-
}
}
- if(PreferencesUtil.getBooleanValue(getPrefName(term))){
+ if(PreferencesUtil.getBooleanValue(getPrefName(term), true)){
filteredTerms.add(term);
}
}
if (filteredTerms.isEmpty()){
- return initialTerms;
+ //check for dtos
+ List<TermDto> preferredTerms = null;
+ if (initialTerms.get(0).getVocabulary() != null){
+ preferredTerms = cachedTermMap.get(initialTerms.get(0).getVocabulary().getUuid());
+ }
+ if (preferredTerms == null){
+ preferredTerms = cachedTermMap.get(initialTerms.get(0).getTermType());
+ }
+ if (preferredTerms == null){
+ return initialTerms;
+ }
+ for (T term : initialTerms){
+ if (preferredTerms.contains(TermDto.fromTerm(term))){
+ filteredTerms.add(term);
+ }
+ }
+ if (filteredTerms.isEmpty()){
+ return initialTerms;
+ }
}
return filteredTerms;
*/
public List<TermDto> getFilteredTermDtos(List<TermDto> initialTerms){
- List<TermDto> filteredTerms = new ArrayList();
+ List<TermDto> filteredTerms = new ArrayList<>();
for (TermDto term : initialTerms){
-
- //TODO:inverse terms!!
-
+ //TODO:inverse terms!!
if(PreferencesUtil.getBooleanValue(getPrefNameByDto(term))){
filteredTerms.add(term);
}
private <T extends TermBase> String getPrefName(T term) {
return term.getTermType()!=null?term.getTermType().toString()+term.getUuid().toString():""+term.getUuid().toString();
}
+
private String getPrefNameByDto(TermDto term) {
return term.getTermType()!=null?term.getTermType().toString()+term.getUuid().toString():""+term.getUuid().toString();
}
private <T extends DefinedTermBase> TermVocabulary<T> getTermVocabulary(Collection<T> initialTerms){
- TermType result = null;
if(!initialTerms.isEmpty()){
T entity = initialTerms.iterator().next();
return entity.getVocabulary();
return null;
}
- private TermVocabularyDto getTermVocabularyByDto(Collection<TermDto> initialTerms){
-
- TermType result = null;
- if(!initialTerms.isEmpty()){
- TermDto entity = initialTerms.iterator().next();
- return entity.getVocabularyDto();
- }
- return null;
- }
-
-
/**
* Generic method to set term preferences
*
*/
public <T extends DefinedTermBase> void setPreferredTerms(Collection<T> preferredTerms, Collection<T> initialTerms){
TermVocabulary<T> voc = getTermVocabulary(initialTerms);
-
- Collection<UUID> undesiredTermUuids = new ArrayList<UUID>();
-
+ Collection<UUID> undesiredTermUuids = new ArrayList<>();
for(TermBase term : initialTerms){
if(! preferredTerms.contains(term)){
undesiredTermUuids.add(term.getUuid());
}
}
clearTermMapForTermVoc(voc.getUuid());
-
-
-
}
-
- /**
+ /**
* Generic method to set term preferences
*
* @param preferredTerms a {@link java.util.List} object.
* @param initialTerms a {@link java.util.List} object.
* @param <T> a T object.
*/
- public <T extends DefinedTermBase> void setPreferredTermsByType(Collection<T> preferredTerms, TermType type){
-
-
-
- List<DefinedTermBase> oldValues = getPreferredTerms(type);
- for (DefinedTermBase term: oldValues){
- PreferencesUtil.setBooleanValue(getPrefName(term), false);
- }
- for(TermBase term : preferredTerms){
- PreferencesUtil.setBooleanValue(getPrefName(term), true);
-
+ public void setPreferredTermsByType(Collection<TermDto> preferredTerms, TermType type){
+ List<?> oldValues = getPreferredTerms(type);
+ if (oldValues != null){
+ for (Object term: oldValues){
+ if (term instanceof TermDto){
+ PreferencesUtil.setBooleanValue(getPrefNameByDto((TermDto)term), false);
+ }else{
+ PreferencesUtil.setBooleanValue(getPrefName((DefinedTermBase)term), false);
+ }
+ }
}
+// for(TermDto term : preferredTerms){
+// PreferencesUtil.setBooleanValue(getPrefNameByDto(term), true);
+//
+// }
clearTermMapForTermType(type);
- List<DefinedTermBase> list = new ArrayList<>(preferredTerms);
- cachedTermMap.put(type.getUuid(), list);
-
-
-
+ List<TermDto> list = new ArrayList<>(preferredTerms);
+ cachedTermMap.put(type, list);
}
- /**
+
+ /**
* Generic method to set term preferences
*
* @param preferredTerms a {@link java.util.List} object.
for (TermDto term: oldValues){
PreferencesUtil.setBooleanValue(getPrefNameByDto(term), false);
}
+ TermType type = null;
+ boolean allSameType = true;
for(TermDto term : preferredTerms){
- PreferencesUtil.setBooleanValue(getPrefNameByDto(term), true);
-
+ PreferencesUtil.setBooleanValue(getPrefNameByDto(term), true);
+ if (type == null){
+ type = term.getTermType();
+ }else if (!type.equals(term.getTermType())){
+ allSameType = false;
+ }
}
//if (initialTerms.iterator().hasNext()){
clearTermMapForTermVoc(vocDto.getUuid());
List<TermDto> list = new ArrayList<>(preferredTerms);
cachedTermMap.put(vocDto.getUuid(), list);
+ if (allSameType){
+ cachedTermMap.put(type, list);
+ }
//}
-
}
*/
public <T extends DefinedTermBase> List<T> getTerms(List<UUID> uuidList, Class clazz){
- List<T> filteredTerms = new ArrayList<T>();
- List<T> terms = TermStore.getTerms(clazz);
+ List<T> filteredTerms = new ArrayList<>();
+ @SuppressWarnings("unchecked")
+ List<T> terms = TermStore.getTerms(clazz);
+ if (uuidList == null || uuidList.isEmpty()){
+ return terms;
+ }
+ for (T term : terms){
+ if(uuidList.contains(term.getUuid())){
+ filteredTerms.add(term);
+ }
+ }
+
+ return filteredTerms;
+ }
+
+ /**
+ * Generic method to get term preferences for a term vocabulary
+ *
+ * @param initialTerms a {@link java.util.List} object.
+ * @return a {@link java.util.List} object.
+ */
+ public <T extends DefinedTermBase> List<T> getTerms(List<UUID> uuidList, TermType type){
+
+ List<T> filteredTerms = new ArrayList<>();
+ List<T> terms = TermStore.getTerms(type, null);
if (uuidList == null || uuidList.isEmpty()){
return terms;
}
BGBM BDI Projects / taxeditor.git / blobdiff