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

   1 /**
   2  *
   3  */
   4 package eu.etaxonomy.cdm.model.common;
   5
   6 import java.util.Iterator;
   7 import java.util.NoSuchElementException;
   8 import java.util.Set;
   9 import java.util.SortedSet;
  10 import java.util.TreeSet;
  11
  12 import javax.persistence.Entity;
  13 import javax.persistence.Transient;
  14
  15 import org.apache.log4j.Logger;
  16
  17 /**
  18  * @author a.mueller
  19  *
  20  */
  21 @Entity
  22 public class OrderedTermVocabulary<T extends OrderedTermBase> extends TermVocabulary<T> {
  23         private static final Logger logger = Logger.getLogger(OrderedTermVocabulary.class);
  24
  25         /**
  26          *
  27          */
  28         public OrderedTermVocabulary() {
  29                 super();
  30         }
  31
  32         /**
  33          * @param term
  34          * @param label
  35          * @param termSourceUri
  36          */
  37         public OrderedTermVocabulary(String term, String label, String termSourceUri) {
  38                 super(term, label, termSourceUri);
  39         }
  40
  41         @Override
  42         @Transient
  43         protected Set<T> getNewTermSet(){
  44                 return new TreeSet<T>();
  45         }
  46
  47         @Transient
  48         public SortedSet<T> getHigherAndEqualTerms(T otb) {
  49                 SortedSet<T> result = new TreeSet<T>();
  50                 SortedSet<T> sortedSet = new TreeSet<T>();
  51                 sortedSet.addAll(terms);
  52                 result.addAll( sortedSet.tailSet(otb));
  53                 return result;
  54         }
  55         @Transient
  56         public SortedSet<T> getHigherTerms(T otb) {
  57                 SortedSet<T> result = getHigherAndEqualTerms(otb);
  58                 for (T setObject : terms){
  59                         if (setObject.compareTo(otb) == 0){
  60                                 result.remove(setObject);
  61                         }
  62                 }
  63                 return result;
  64         }
  65
  66         @Transient
  67         public SortedSet<T> getLowerAndEqualTerms(T otb) {
  68                 SortedSet<T> result = new TreeSet<T>();
  69                 SortedSet<T> sortedSet = new TreeSet<T>();
  70                 sortedSet.addAll(terms);
  71                 result.addAll( sortedSet.headSet(otb));
  72                 return result;
  73         }
  74
  75         @Transient
  76         public SortedSet<T> getLowerTerms(T otb) {
  77                 SortedSet<T> result = getLowerAndEqualTerms(otb);
  78                 for (T setObject : terms){
  79                         if (setObject.compareTo(otb) == 0){
  80                                 result.remove(setObject);
  81                         }
  82                 }
  83                 return result;
  84         }
  85
  86         @Transient
  87         public SortedSet<T> getEqualTerms(T otb) {
  88                 SortedSet<T> result = new TreeSet<T>();
  89                 for (T setObject : terms){
  90                         if (setObject.compareTo(otb) == 0){
  91                                 result.add(setObject);
  92                         }
  93                 }
  94                 return result;
  95         }
  96
  97         @Transient
  98         public T getNextHigherTerm(T otb) {
  99                 try {
 100                         return getHigherTerms(otb).first();
 101                 } catch (NoSuchElementException e) {
 102                         return null;
 103                 }
 104         }
 105
 106         @Transient
 107         public T getNextLowerTerm(T otb) {
 108                 try {
 109                         return getLowerTerms(otb).last();
 110                 } catch (NoSuchElementException e) {
 111                         return null;
 112                 }
 113         }
 114
 115         @Transient
 116         public T getLowestTerm() {
 117                 try {
 118                         SortedSet<T> sortedSet = new TreeSet<T>();
 119                         sortedSet.addAll(terms);
 120                         return sortedSet.first();
 121                         //return ((SortedSet<T>)terms).first();
 122                 } catch (NoSuchElementException e) {
 123                         return null;
 124                 }
 125         }
 126
 127         @Transient
 128         public T getHighestTerm() {
 129                 try {
 130                         SortedSet<T> sortedSet = new TreeSet<T>();
 131                         sortedSet.addAll(terms);
 132                         return sortedSet.last();
 133                 } catch (NoSuchElementException e) {
 134                         return null;
 135                 }
 136         }
 137
 138         @Override
 139         public void addTerm(T term) throws WrongTermTypeException {
 140                 SortedSet sortedTerms = ((SortedSet<T>)terms);
 141                 int lowestOrderIndex;
 142                 if (sortedTerms.size() == 0){
 143                         lowestOrderIndex = 0;
 144                 }else{
 145                         Object first = (T)sortedTerms.first();
 146                         lowestOrderIndex = ((T)first).orderIndex;
 147                 }
 148                 term.orderIndex = lowestOrderIndex + 1;
 149                 super.addTerm(term);
 150         }
 151
 152         public void addTermAbove(T termToBeAdded, T lowerTerm) throws WrongTermTypeException {
 153                 int orderInd = lowerTerm.orderIndex;
 154                 termToBeAdded.orderIndex = orderInd;
 155                 //increment all orderIndexes of terms below
 156                 Iterator<T> iterator = terms.iterator();
 157                 while(iterator.hasNext()){
 158                         T term = iterator.next();
 159                         if (term.orderIndex >= orderInd){  //should always be true
 160                                 term.orderIndex++;
 161                         }
 162                 }
 163                 super.addTerm(termToBeAdded);
 164         }
 165
 166         public void addTermBelow(T termToBeAdded, T higherTerm) throws WrongTermTypeException {
 167                 int orderInd = higherTerm.orderIndex;
 168                 termToBeAdded.orderIndex = orderInd + 1;
 169                 //increment all orderIndexes of terms below
 170                 Iterator<T> iterator = getLowerTerms(higherTerm).iterator();
 171                 while(iterator.hasNext()){
 172                         T term = iterator.next();
 173                         if (term.orderIndex > orderInd){
 174                                 term.orderIndex++;
 175                         }
 176                 }
 177                 super.addTerm(termToBeAdded);
 178         }
 179
 180 //      public void addTermEqualLevel(T termToBeAdded, T equalLevelTerm) throws WrongTermTypeException {
 181 //              int orderInd = equalLevelTerm.orderIndex;
 182 //              termToBeAdded.orderIndex = orderInd;
 183 //              super.addTerm(termToBeAdded);
 184 //      }
 185
 186         @Override
 187         public void removeTerm(T term) {
 188                 if (term == null){
 189                         return;
 190                 }
 191                 if (this.getEqualTerms(term).size() == 0){
 192                         Iterator<T> iterator = getLowerTerms(term).iterator();
 193                         while (iterator.hasNext()){
 194                                 T otb = iterator.next();
 195                                 toBeChangedByObject = otb;
 196                                 otb.decreaseIndex(this);
 197                                 toBeChangedByObject = null;
 198                         }
 199                 }
 200                 term.setVocabulary(null);
 201         }
 202
 203         private T toBeChangedByObject;
 204
 205         public boolean indexChangeAllowed(T otb){
 206                 return otb == toBeChangedByObject ;
 207         }
 208
 209 }