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