cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/EnumeratedTermVoc.java

   1 /**
   2 * Copyright (C) 2007 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9
  10 package eu.etaxonomy.cdm.model.common;
  11
  12 import java.util.HashMap;
  13 import java.util.HashSet;
  14 import java.util.Map;
  15 import java.util.Set;
  16 import java.util.UUID;
  17
  18 /**
  19  * @author a.mueller
  20  *
  21  */
  22 public class EnumeratedTermVoc<T extends IEnumTerm<T>> {
  23
  24         private static Map<Class<? extends IEnumTerm<?>>,EnumeratedTermVoc<?>> vocsMap= new HashMap<>();
  25
  26         private final Map<T,SingleEnumTerm<T>> lookup = new HashMap<>();
  27
  28 //      public interface EnumTerm<R extends EnumTerm<?>> extends ISimpleTerm<R>{
  29 //              public String getKey();
  30 //      }
  31
  32         private class SingleEnumTerm<S extends T> implements IEnumTerm<T>{
  33                 private final S term;
  34                 private final String label;
  35                 private final UUID uuid;
  36                 private final String key;
  37                 private final Set<S> children = new HashSet<S>();
  38                 private final S parent;
  39
  40
  41
  42                 private SingleEnumTerm(S term, UUID uuid, String defaultString, String key, S parent){
  43                         this.term = term;
  44                         this.label = defaultString;
  45                         this.key = key;
  46                         this.uuid = uuid;
  47                         this.parent = parent;
  48                         SingleEnumTerm<T> parentSingleEnum = lookup.get(parent);
  49                         if (parentSingleEnum != null){
  50                                 parentSingleEnum.children.add(term);
  51                         }
  52                 }
  53
  54                 @Override
  55                 public UUID getUuid() { return uuid;}
  56                 @Override
  57                 public T getKindOf() {return parent;}
  58                 public T getTerm() {return term;}
  59                 @Override
  60                 public String getKey() {return key;     }
  61
  62                 @Override
  63                 public String getMessage() {return getMessage(Language.DEFAULT());}
  64
  65                 @Override
  66                 public String getMessage(Language language) {
  67                         //TODO make multi-lingual
  68                         return label;
  69                 }
  70
  71                 @Override
  72                 public Set<T> getGeneralizationOf() {
  73 //                      return Collections.unmodifiableSet( children );   //TODO creates stack overflow
  74                         return new HashSet<T>(children);
  75                 }
  76
  77                 @Override
  78                 public boolean isKindOf(T ancestor) {
  79                         if (parent == null || ancestor == null){
  80                                 return false;
  81                         }else if (parent.equals(ancestor)){
  82                                 return true;
  83                         }else{
  84                                 return parent.isKindOf(ancestor);
  85                         }
  86                 }
  87
  88                 @Override
  89                 public Set<T> getGeneralizationOf(boolean recursive) {
  90                         Set<T> result = new HashSet<T>();
  91                         result.addAll(this.children);
  92                         if (recursive){
  93                                 for (T child : this.children){
  94                                         result.addAll(child.getGeneralizationOf(recursive));
  95                                 }
  96                         }
  97                         return result;
  98                 }
  99
 100         } //end of inner class
 101
 102 //******************* DELEGATE NETHODS ************************
 103
 104         public String getKey(T term) {return lookup.get(term).getKey();}
 105
 106         public UUID getUuid(T term) {return lookup.get(term).getUuid();}
 107
 108         public T getKindOf(T term) {return lookup.get(term).getKindOf();}
 109
 110         public Set<T> getGeneralizationOf(T term) {return lookup.get(term).getGeneralizationOf();}
 111
 112 //******************* DELEGATE CLASS NETHODS ************************
 113
 114
 115         public static <S extends IEnumTerm<?>> IEnumTerm addTerm(Class<? extends IEnumTerm<?>> clazz, S term, UUID uuid, String defaultString, String key, S parent){
 116                 if (vocsMap.get(clazz) == null){
 117                         vocsMap.put(clazz, new EnumeratedTermVoc<>());
 118                 }
 119                 IEnumTerm<?> myTerm = vocsMap.get(clazz).add(term, uuid, defaultString, key, parent);
 120                 return myTerm;
 121         }
 122
 123         private  SingleEnumTerm<T> add(ISimpleTerm<?> term, UUID uuid, String defaultString, String key, ISimpleTerm<?> parent) {
 124                 SingleEnumTerm<T> singleTerm = new SingleEnumTerm<T>((T)term, uuid, defaultString, key, (T)parent);
 125                 if (containsKey(lookup, key)){
 126                         throw new RuntimeException(String.format("Key must be unique in enumeration but was not for '%s'", key));
 127                 }
 128                 if (containsUuid(lookup, uuid)){
 129                         throw new RuntimeException(String.format("UUID must be unique in enumeration but was not for '%s'", uuid));
 130                 }
 131                 lookup.put((T)term, singleTerm);
 132                 return singleTerm;
 133         }
 134
 135         public boolean containsKey(Map<T, SingleEnumTerm<T>> lookup, String key) {
 136                 for (SingleEnumTerm<T> term : lookup.values()){
 137                         if (term.getKey().equals(key)){
 138                                 return true;
 139                         }
 140                 }
 141                 return false;
 142         }
 143
 144         public boolean containsUuid(Map<T, SingleEnumTerm<T>> lookup, UUID uuid) {
 145                 for (SingleEnumTerm<T> term : lookup.values()){
 146                         if (term.getUuid().equals(uuid)){
 147                                 return true;
 148                         }
 149                 }
 150                 return false;
 151         }
 152
 153         public static <R extends IEnumTerm<R>> R byKey(Class<R> clazz, String key) {
 154                 EnumeratedTermVoc<R> voc = getVoc(clazz);
 155                 return voc == null? null:voc.getByKey(key);
 156         }
 157
 158         public static <R extends IEnumTerm<R>> R byUuid(Class<R> clazz, UUID uuid) {
 159                 EnumeratedTermVoc<R> voc = getVoc(clazz);
 160                 return voc == null? null:voc.getByUuid(uuid);
 161         }
 162
 163
 164         public T getByKey(String key) {
 165                 for (SingleEnumTerm<T> term : lookup.values()){
 166                         if (term.getKey().equals(key)){
 167                                 return term.getTerm();
 168                         }
 169                 }
 170                 return null;
 171         }
 172
 173         public T getByUuid(UUID uuid) {
 174                 for (SingleEnumTerm<T> term : lookup.values()){
 175                         if (term.getUuid().equals(uuid)){
 176                                 return term.getTerm();
 177                         }
 178                 }
 179                 return null;
 180         }
 181
 182         public static <R extends IEnumTerm<R>> EnumeratedTermVoc<R> getVoc(Class<R> clazz) {
 183                 return (EnumeratedTermVoc<R>)vocsMap.get(clazz);
 184         }
 185
 186 }