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

   1 /**
   2 * Copyright (C) 2009 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9
  10 package eu.etaxonomy.cdm.model.common;
  11
  12 import java.util.Iterator;
  13 import java.util.NoSuchElementException;
  14 import java.util.Set;
  15 import java.util.SortedSet;
  16 import java.util.TreeSet;
  17
  18 import javax.persistence.Entity;
  19 import javax.persistence.Transient;
  20 import javax.xml.bind.annotation.XmlAccessType;
  21 import javax.xml.bind.annotation.XmlAccessorType;
  22 import javax.xml.bind.annotation.XmlRootElement;
  23 import javax.xml.bind.annotation.XmlType;
  24
  25 import org.apache.log4j.Logger;
  26 import org.hibernate.envers.Audited;
  27 import org.hibernate.search.annotations.Indexed;
  28
  29 /**
  30  * @author a.mueller
  31  *
  32  */
  33 @XmlAccessorType(XmlAccessType.FIELD)
  34 @XmlType(name = "OrderedTermVocabulary")
  35 @XmlRootElement(name = "OrderedTermVocabulary")
  36 @Entity
  37 @Indexed(index = "eu.etaxonomy.cdm.model.common.TermVocabulary")
  38 @Audited
  39 public class OrderedTermVocabulary<T extends OrderedTermBase> extends TermVocabulary<T> {
  40         private static final long serialVersionUID = 7871741306306371242L;
  41         @SuppressWarnings("unused")
  42         private static final Logger logger = Logger.getLogger(OrderedTermVocabulary.class);
  43
  44         /**
  45          * @param term
  46          * @param label
  47          * @param termSourceUri
  48          */
  49         public OrderedTermVocabulary(String term, String label, String labelAbbrev, String termSourceUri) {
  50                 super(term, label, labelAbbrev, termSourceUri);
  51         }
  52
  53         public OrderedTermVocabulary() {
  54                 super();
  55         }
  56
  57         @Transient
  58         @Override
  59         public Set<T> getNewTermSet() {
  60                 return new TreeSet<T>();
  61         }
  62
  63         @Transient
  64         public SortedSet<T> getOrderedTerms() {
  65                 SortedSet<T> result = getSortedSetOfTerms();
  66                 return result;
  67         }
  68
  69         public SortedSet<T> getHigherAndEqualTerms(T otb) {
  70                 SortedSet<T> result = new TreeSet<T>();
  71                 SortedSet<T> sortedSet = getSortedSetOfTerms();
  72                 result.addAll( sortedSet.tailSet(otb));
  73                 return result;
  74         }
  75
  76         public SortedSet<T> getHigherTerms(T otb) {
  77                 SortedSet<T> result = getHigherAndEqualTerms(otb);
  78                 for (T setObject : terms){
  79                         if (setObject.compareTo(otb) == 0){
  80                                 result.remove(setObject);
  81                         }
  82                 }
  83                 return result;
  84         }
  85
  86         public SortedSet<T> getLowerAndEqualTerms(T otb) {
  87                 SortedSet<T> result = new TreeSet<T>();
  88                 SortedSet<T> sortedSet = getSortedSetOfTerms();
  89
  90                 result.addAll( sortedSet.headSet(otb));
  91                 //headSet Returns a view of the portion of this set whose elements are STRICTLY less than toElement
  92                 for (T setObject : terms){
  93                         if (setObject.compareTo(otb) == 0){
  94                                 result.add(setObject);
  95                         }
  96                 }
  97                 return result;
  98         }
  99
 100         public SortedSet<T> getLowerTerms(T otb) {
 101                 SortedSet<T> result = getLowerAndEqualTerms(otb);
 102                 for (T setObject : terms){
 103                         if (setObject.compareTo(otb) == 0){
 104                                 result.remove(setObject);
 105                         }
 106                 }
 107                 return result;
 108         }
 109
 110         public SortedSet<T> getEqualTerms(T otb) {
 111                 SortedSet<T> result = new TreeSet<T>();
 112                 for (T setObject : terms){
 113                         if (setObject.compareTo(otb) == 0){
 114                                 result.add(setObject);
 115                         }
 116                 }
 117                 return result;
 118         }
 119
 120         public T getNextHigherTerm(T otb) {
 121                 try {
 122                         return getHigherTerms(otb).first();
 123                 } catch (NoSuchElementException e) {
 124                         return null;
 125                 }
 126         }
 127
 128         public T getNextLowerTerm(T otb) {
 129                 try {
 130                         return getLowerTerms(otb).last();
 131                 } catch (NoSuchElementException e) {
 132                         return null;
 133                 }
 134         }
 135
 136         @Transient
 137         public T getLowestTerm() {
 138                 try {
 139                         SortedSet<T> sortedSet = getSortedSetOfTerms();
 140                         return sortedSet.first();
 141                         //return ((SortedSet<T>)terms).first();
 142                 } catch (NoSuchElementException e) {
 143                         return null;
 144                 }
 145         }
 146
 147         @Transient
 148         public T getHighestTerm() {
 149                 try {
 150                         SortedSet<T> sortedSet = getSortedSetOfTerms();
 151                         return sortedSet.last();
 152                 } catch (NoSuchElementException e) {
 153                         return null;
 154                 }
 155         }
 156
 157         public void addTerm(T term) {
 158                 SortedSet<T> sortedTerms = getSortedSetOfTerms();
 159                 int lowestOrderIndex;
 160                 if (sortedTerms.size() == 0){
 161                         lowestOrderIndex = 0;
 162                 }else{
 163                         T first = sortedTerms.first();
 164                         lowestOrderIndex = first.orderIndex;
 165                 }
 166                 term.orderIndex = lowestOrderIndex + 1;
 167                 super.addTerm(term);
 168         }
 169
 170         public void addTermAbove(T termToBeAdded, T lowerTerm) throws WrongTermTypeException {
 171                 int orderInd = lowerTerm.orderIndex;
 172                 termToBeAdded.orderIndex = orderInd;
 173                 //increment all orderIndexes of terms below
 174                 Iterator<T> iterator = terms.iterator();
 175                 while(iterator.hasNext()){
 176                         T term = iterator.next();
 177                         if (term.orderIndex >= orderInd){  //should always be true
 178                                 term.orderIndex++;
 179                         }
 180                 }
 181                 super.addTerm(termToBeAdded);
 182         }
 183
 184         public void addTermBelow(T termToBeAdded, T higherTerm) throws WrongTermTypeException {
 185                 int orderInd = higherTerm.orderIndex;
 186                 termToBeAdded.orderIndex = orderInd + 1;
 187                 //increment all orderIndexes of terms below
 188                 Iterator<T> iterator = getLowerTerms(higherTerm).iterator();
 189                 while(iterator.hasNext()){
 190                         T term = iterator.next();
 191                         if (term.orderIndex > orderInd){
 192                                 term.orderIndex++;
 193                         }
 194                 }
 195                 super.addTerm(termToBeAdded);
 196         }
 197
 198         public void addTermEqualLevel(T termToBeAdded, T equalLevelTerm) throws WrongTermTypeException {
 199                 int orderInd = equalLevelTerm.orderIndex;
 200                 termToBeAdded.orderIndex = orderInd;
 201                 super.addTerm(termToBeAdded);
 202         }
 203
 204         @Override
 205         public void removeTerm(T term) {
 206                 if (term == null){
 207                         return;
 208                 }
 209                 if (this.getEqualTerms(term).size() == 0){
 210                         Iterator<T> iterator = getLowerTerms(term).iterator();
 211                         while (iterator.hasNext()){
 212                                 T otb = iterator.next();
 213                                 toBeChangedByObject = otb;
 214                                 otb.decreaseIndex(this);
 215                                 toBeChangedByObject = null;
 216                         }
 217                 }
 218                 super.removeTerm(term);
 219         }
 220
 221         @Transient
 222         private T toBeChangedByObject;
 223
 224         public boolean indexChangeAllowed(OrderedTermBase<T> orderedTermBase){
 225                 return orderedTermBase == toBeChangedByObject ;
 226         }
 227
 228
 229         @Transient
 230         private SortedSet<T> getSortedSetOfTerms(){
 231                 SortedSet<T> sortedSet = new TreeSet<T>();
 232                 sortedSet.addAll(terms);
 233                 return sortedSet;
 234         }
 235
 236 }