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