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