<br />
<b>Warning</b>:  session_start(): open(/var/lib/php/sessions/sess_u49t9bp1n7d7g7jfpsc2th0bcd, O_RDWR) failed: No space left on device (28) in <b>/var/www/tb-usercake/models/config.php</b> on line <b>51</b><br />
<br />
<b>Warning</b>:  session_start(): Failed to read session data: files (path: /var/lib/php/sessions) in <b>/var/www/tb-usercake/models/config.php</b> on line <b>51</b><br />
// differences to AbstractList.subList / ArrayList.subList:
// -probably doesn't handle modCount the same way
//
// made from AbstractList.subList
sclass SubList<E> extends AbstractList<E> implements ISubList<E> {
  L<E> root;
  SubList<E> parent;
  int offset;
  int size;

  /**
   * Constructs a sublist of an arbitrary AbstractList, which is
   * not a SubList itself.
   */
  public SubList(L<E> root, int fromIndex, int toIndex) {
    if (root cast SubList) {
      this.parent = root;
      this.root = root.root;
      this.offset = root.offset + fromIndex;
    } else {
      this.parent = null;
      this.root = root;
      this.offset = fromIndex;
    }
    this.size = toIndex - fromIndex;
  }

  public E set(int index, E element) {
      Objects.checkIndex(index, size);
      checkForComodification();
      return root.set(offset + index, element);
  }

  public E get(int index) {
      Objects.checkIndex(index, size);
      checkForComodification();
      return root.get(offset + index);
  }

  public int size() {
      checkForComodification();
      return size;
  }

  public void add(int index, E element) {
      rangeCheckForAdd(index);
      checkForComodification();
      root.add(offset + index, element);
      updateSizeAndModCount(1);
  }

  public E remove(int index) {
      Objects.checkIndex(index, size);
      checkForComodification();
      E result = root.remove(offset + index);
      updateSizeAndModCount(-1);
      return result;
  }

  protected void removeRange(int fromIndex, int toIndex) {
      checkForComodification();
      root.subList(offset + fromIndex, offset + toIndex).clear();
      updateSizeAndModCount(fromIndex - toIndex);
  }

  public boolean addAll(Collection<? extends E> c) {
      return addAll(size, c);
  }

  public boolean addAll(int index, Collection<? extends E> c) {
      rangeCheckForAdd(index);
      int cSize = c.size();
      if (cSize==0)
          return false;
      checkForComodification();
      root.addAll(offset + index, c);
      updateSizeAndModCount(cSize);
      return true;
  }

  public Iterator<E> iterator() {
      return listIterator();
  }

  public ListIterator<E> listIterator(int index) {
      checkForComodification();
      rangeCheckForAdd(index);

      return new ListIterator<E>() {
          private final ListIterator<E> i =
                  root.listIterator(offset + index);

          public boolean hasNext() {
              return nextIndex() < size;
          }

          public E next() {
              if (hasNext())
                  return i.next();
              else
                  throw new NoSuchElementException();
          }

          public boolean hasPrevious() {
              return previousIndex() >= 0;
          }

          public E previous() {
              if (hasPrevious())
                  return i.previous();
              else
                  throw new NoSuchElementException();
          }

          public int nextIndex() {
              return i.nextIndex() - offset;
          }

          public int previousIndex() {
              return i.previousIndex() - offset;
          }

          public void remove() {
              i.remove();
              updateSizeAndModCount(-1);
          }

          public void set(E e) {
              i.set(e);
          }

          public void add(E e) {
              i.add(e);
              updateSizeAndModCount(1);
          }
      };
  }

  public List<E> subList(int fromIndex, int toIndex) {
      _subListRangeCheck(fromIndex, toIndex, size);
      return new SubList<>(this, fromIndex, toIndex);
  }

  private void rangeCheckForAdd(int index) {
      if (index < 0 || index > size)
          throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  }

  private String outOfBoundsMsg(int index) {
      return "Index: "+index+", Size: "+size;
  }

  private void checkForComodification() {}

  private void updateSizeAndModCount(int sizeChange) {
    SubList<E> slist = this;
    do {
      slist.size += sizeChange;
      slist = slist.parent;
    } while (slist != null);
  }
  
  public L<E> rootList() { ret root; }
  public L<E> parentList() { ret parent; }
  public int subListOffset() { ret offset; }
}