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