KezvhLib/src-lib/net/kezvh/collections/Range.java

   1 package net.kezvh.collections;
   2
   3 import java.util.Collection;
   4 import java.util.Comparator;
   5 import java.util.Iterator;
   6 import java.util.LinkedList;
   7 import java.util.List;
   8 import java.util.ListIterator;
   9 import java.util.NavigableSet;
  10 import java.util.NoSuchElementException;
  11 import java.util.SortedSet;
  12
  13 import net.kezvh.collections.unmodifiable.AbstractUnmodifiableList;
  14 import net.kezvh.development.UnimplementedException;
  15
  16 /**
  17  * @author afflux
  18  * @param <E> FIXME commment
  19  */
  20 public class Range<E> extends AbstractUnmodifiableList<E> implements NavigableSet<E> {
  21
  22         private final class RangeIterator implements ListIterator<E> {
  23                 private int index;
  24                 private E current;
  25
  26                 public RangeIterator() {
  27                         this(0, Range.this.firstOpen ? Range.this.navigator.next(Range.this.first) : Range.this.first);
  28                 }
  29
  30                 public RangeIterator(final int index, final E current) {
  31                         super();
  32                         this.index = index;
  33                         this.current = current;
  34                 }
  35
  36                 @Override
  37                 public void add(final E e) {
  38                         throw new UnsupportedOperationException();
  39                 }
  40
  41                 @Override
  42                 public boolean hasNext() {
  43                         return Range.this.contains(this.current);
  44                 }
  45
  46                 @Override
  47                 public boolean hasPrevious() {
  48                         return Range.this.contains(Range.this.navigator.previous(this.current));
  49                 }
  50
  51                 @Override
  52                 public E next() {
  53                         if (this.hasNext())
  54                                 try {
  55                                         return this.current;
  56                                 } finally {
  57                                         this.index++;
  58                                         this.current = Range.this.navigator.next(this.current);
  59                                 }
  60                         throw new NoSuchElementException();
  61                 }
  62
  63                 @Override
  64                 public int nextIndex() {
  65                         return this.index;
  66                 }
  67
  68                 @Override
  69                 public E previous() {
  70                         if (this.hasPrevious())
  71                                 try {
  72                                         return Range.this.navigator.previous(this.current);
  73                                 } finally {
  74                                         this.index--;
  75                                         this.current = Range.this.navigator.previous(this.current);
  76                                 }
  77                         throw new NoSuchElementException();
  78                 }
  79
  80                 @Override
  81                 public int previousIndex() {
  82                         return this.index - 1;
  83                 }
  84
  85                 @Override
  86                 public void remove() {
  87                         throw new UnsupportedOperationException();
  88                 }
  89
  90                 @Override
  91                 public void set(final E e) {
  92                         throw new UnsupportedOperationException();
  93                 }
  94         }
  95
  96         private final Navigator<E> navigator;
  97         private final boolean directlyNavigable;
  98
  99         private final E first;
 100         private final E last;
 101
 102         private final boolean firstOpen;
 103         private final boolean lastOpen;
 104
 105         /**
 106          * @param first first element
 107          * @param last last element
 108          */
 109         public Range(final E first, final E last) {
 110                 this(first, last, true, false, new Navigator<E>() {
 111                         @SuppressWarnings("unchecked")
 112                         public int compare(final E o1, final E o2) {
 113                                 return ((Comparable<E>) o1).compareTo(o2);
 114                         }
 115
 116                         @SuppressWarnings("unchecked")
 117                         public E next(final E current) {
 118                                 return ((Navigable<E>) current).next();
 119                         }
 120
 121                         @SuppressWarnings("unchecked")
 122                         public E previous(final E current) {
 123                                 return ((Navigable<E>) current).previous();
 124                         }
 125                 });
 126         }
 127
 128         /**
 129          * @param first first element
 130          * @param last last element
 131          * @param firstOpen exclude the first element. ignored if the first element is null.
 132          * @param lastOpen exclude the last element. ignored if the first element is null.
 133          * @param navigator navigator
 134          */
 135         public Range(final E first, final E last, final boolean firstOpen, final boolean lastOpen, final Navigator<E> navigator) {
 136                 throw new RuntimeException("too buggy to use");
 137                 //              this.first = first;
 138                 //              this.last = last;
 139                 //
 140                 //              if (navigator == null && first instanceof Number)
 141                 //                      this.navigator = Navigator.Utilities.getNumberNavigator(first.getClass());
 142                 //              else
 143                 //                      this.navigator = navigator;
 144                 //              this.firstOpen = firstOpen;
 145                 //              this.lastOpen = lastOpen;
 146                 //
 147                 //              this.directlyNavigable = navigator != null;
 148                 //
 149                 //              if (first == null || (this.directlyNavigable && !(first instanceof Navigable) && !(first instanceof Number)))
 150                 //                      throw new IllegalArgumentException(first + " is not comparable");
 151                 //
 152                 //              if (last == null || (this.directlyNavigable && !(last instanceof Navigable) && !(first instanceof Number)))
 153                 //                      throw new IllegalArgumentException(last + " is not comparable");
 154         }
 155
 156         /**
 157          * @see java.util.SortedSet#comparator()
 158          * @return compataror
 159          */
 160         public Comparator<? super E> comparator() {
 161                 return this.navigator;
 162         }
 163
 164         /**
 165          * @see java.util.Collection#contains(java.lang.Object)
 166          * @param o objoct
 167          * @return contains
 168          */
 169         @SuppressWarnings("unchecked")
 170         @Override
 171         public boolean contains(final Object o) {
 172                 final int f = this.navigator.compare(this.first, (E) o);
 173                 final int l = this.navigator.compare((E) o, this.last);
 174
 175                 if ((f > 0 && this.firstOpen) || f == 0) {
 176                         if (this.lastOpen)
 177                                 return l < 0;
 178                         return l <= 0;
 179                 }
 180                 return false;
 181         }
 182
 183         /**
 184          * @see java.util.Collection#containsAll(java.util.Collection)
 185          * @param c other collection
 186          * @return containsAll
 187          */
 188         @Override
 189         public boolean containsAll(final Collection<?> c) {
 190                 for (final Object o : c)
 191                         if (!this.contains(o))
 192                                 return false;
 193                 return true;
 194         }
 195
 196         /**
 197          * @see java.util.SortedSet#first()
 198          * @return first
 199          */
 200         public E first() {
 201                 return this.first;
 202         }
 203
 204         /**
 205          * @see java.util.SortedSet#headSet(java.lang.Object)
 206          * @param toElement COMMENT
 207          * @return headset
 208          */
 209         public SortedSet<E> headSet(final E toElement) {
 210                 return new Range<E>(this.first, toElement, this.firstOpen, this.lastOpen, this.navigator);
 211         }
 212
 213         /**
 214          * @see java.util.Collection#isEmpty()
 215          * @return isempty
 216          */
 217         @Override
 218         public boolean isEmpty() {
 219                 if (this.firstOpen && this.lastOpen)
 220                         return this.navigator.compare(this.navigator.next(this.first), this.last) > 0;
 221                 if (this.firstOpen || this.lastOpen)
 222                         return this.navigator.compare(this.first, this.last) > 0;
 223                 return this.navigator.compare(this.first, this.last) >= 0;
 224         }
 225
 226         /**
 227          * @see java.util.Collection#iterator()
 228          * @return iterator
 229          */
 230         @Override
 231         public Iterator<E> iterator() {
 232                 return new RangeIterator();
 233         }
 234
 235         /**
 236          * @see java.util.SortedSet#last()
 237          * @return last
 238          */
 239         public E last() {
 240                 return this.last;
 241         }
 242
 243         /**
 244          * @see java.util.Collection#size()
 245          * @return size
 246          */
 247         @Override
 248         public int size() {
 249                 return CollectionsUtilities.count(this.iterator());
 250         }
 251
 252         /**
 253          * @see java.util.SortedSet#subSet(java.lang.Object, java.lang.Object)
 254          * @param fromElement COMMENT
 255          * @param toElement COMMENT
 256          * @return subset
 257          */
 258         public SortedSet<E> subSet(final E fromElement, final E toElement) {
 259                 return new Range<E>(fromElement, toElement, this.firstOpen, this.lastOpen, this.navigator);
 260         }
 261
 262         /**
 263          * @see java.util.SortedSet#tailSet(java.lang.Object)
 264          * @param fromElement COMMENT
 265          * @return fromelement
 266          */
 267         public SortedSet<E> tailSet(final E fromElement) {
 268                 return new Range<E>(fromElement, this.last, this.firstOpen, this.lastOpen, this.navigator);
 269         }
 270
 271         /**
 272          * @see java.util.Collection#toArray()
 273          * @return toarray
 274          */
 275         @Override
 276         public Object[] toArray() {
 277                 return new LinkedList<E>(this).toArray();
 278         }
 279
 280         /**
 281          * @see java.util.Collection#toArray(T[])
 282          * @param <T> COMMENT
 283          * @param a COMMENT
 284          * @return toarray
 285          */
 286         @Override
 287         public <T> T[] toArray(final T[] a) {
 288                 return new LinkedList<E>(this).toArray(a);
 289         }
 290
 291         @Override
 292         public E ceiling(final E e) {
 293                 final E ceiling = this.higher(e);
 294                 if (ceiling == null && this.contains(e))
 295                         return e;
 296                 return ceiling;
 297         }
 298
 299         @Override
 300         public Iterator<E> descendingIterator() {
 301                 throw new UnimplementedException(); // FIXME
 302         }
 303
 304         @Override
 305         public NavigableSet<E> descendingSet() {
 306                 throw new UnimplementedException(); // FIXME
 307         }
 308
 309         @Override
 310         public E floor(final E e) {
 311                 final E floor = this.lower(e);
 312                 if (floor == null && this.contains(e))
 313                         return e;
 314                 return floor;
 315         }
 316
 317         @Override
 318         public NavigableSet<E> headSet(final E toElement, final boolean inclusive) {
 319                 throw new UnimplementedException(); // FIXME
 320         }
 321
 322         @Override
 323         public E higher(final E e) {
 324                 final E higher = this.navigator.next(e);
 325                 if (this.contains(higher))
 326                         return higher;
 327                 return null;
 328         }
 329
 330         @Override
 331         public E lower(final E e) {
 332                 final E lower = this.navigator.previous(e);
 333                 if (this.contains(lower))
 334                         return lower;
 335                 return null;
 336         }
 337
 338         @Override
 339         public E pollFirst() {
 340                 throw new UnimplementedException(); // FIXME
 341         }
 342
 343         @Override
 344         public E pollLast() {
 345                 throw new UnimplementedException(); // FIXME
 346         }
 347
 348         @Override
 349         public NavigableSet<E> subSet(final E fromElement, final boolean fromInclusive, final E toElement, final boolean toInclusive) {
 350                 throw new UnimplementedException(); // FIXME
 351         }
 352
 353         @Override
 354         public NavigableSet<E> tailSet(final E fromElement, final boolean inclusive) {
 355                 throw new UnimplementedException(); // FIXME
 356         }
 357
 358         @Override
 359         public E get(final int index) {
 360                 throw new UnimplementedException(); // FIXME
 361         }
 362
 363         @Override
 364         public int indexOf(final Object o) {
 365                 throw new UnimplementedException(); // FIXME
 366         }
 367
 368         @Override
 369         public int lastIndexOf(final Object o) {
 370                 throw new UnimplementedException(); // FIXME
 371         }
 372
 373         @Override
 374         public ListIterator<E> listIterator() {
 375                 return new RangeIterator();
 376         }
 377
 378         @Override
 379         public ListIterator<E> listIterator(final int index) {
 380                 return new RangeIterator(index, this.get(index));
 381         }
 382
 383         @Override
 384         public List<E> subList(final int fromIndex, final int toIndex) {
 385                 return new Range<E>(this.get(fromIndex), this.get(toIndex), false, true, this.navigator);
 386         }
 387
 388 }