DoubleLinkedQueue() {
  _sentinel = new _DoubleLinkedQueueEntrySentinel<E>();
}

factory DoubleLinkedQueue.from(Iterable<E> other) {
  Queue<E> list = new DoubleLinkedQueue();
  for (final e in other) {
    list.addLast(e);
  }
  return list;
}

void add(E value) {
  addLast(value);
}

void addAll(Collection<E> collection) {
  for (final e in collection) {
    add(e);
  }
}

void addFirst(E value) {
  _sentinel.append(value);
}

void addLast(E value) {
  _sentinel.prepend(value);
}

void clear() {
  _sentinel._next = _sentinel;
  _sentinel._previous = _sentinel;
}

bool every(bool f(E element)) {
  DoubleLinkedQueueEntry<E> entry = _sentinel._next;
  while (entry !== _sentinel) {
    DoubleLinkedQueueEntry<E> nextEntry = entry._next;
    if (!f(entry._element)) return false;
    entry = nextEntry;
  }
  return true;
}

Queue<E> filter(bool f(E element)) {
  Queue<E> other = new Queue<E>();
  DoubleLinkedQueueEntry<E> entry = _sentinel._next;
  while (entry !== _sentinel) {
    DoubleLinkedQueueEntry<E> nextEntry = entry._next;
    if (f(entry._element)) other.addLast(entry._element);
    entry = nextEntry;
  }
  return other;
}

E first() {
  return _sentinel._next.element;
}

DoubleLinkedQueueEntry<E> firstEntry() {
  return _sentinel.nextEntry();
}

void forEach(void f(E element)) {
  DoubleLinkedQueueEntry<E> entry = _sentinel._next;
  while (entry !== _sentinel) {
    DoubleLinkedQueueEntry<E> nextEntry = entry._next;
    f(entry._element);
    entry = nextEntry;
  }
}

void forEachEntry(void f(DoubleLinkedQueueEntry<E> element)) {
  DoubleLinkedQueueEntry<E> entry = _sentinel._next;
  while (entry !== _sentinel) {
    DoubleLinkedQueueEntry<E> nextEntry = entry._next;
    f(entry);
    entry = nextEntry;
  }
}

bool isEmpty() {
  return (_sentinel._next === _sentinel);
}

_DoubleLinkedQueueIterator<E> iterator() {
  return new _DoubleLinkedQueueIterator<E>(_sentinel);
}

E last() {
  return _sentinel._previous.element;
}

DoubleLinkedQueueEntry<E> lastEntry() {
  return _sentinel.previousEntry();
}

int get length() {
  int counter = 0;
  forEach(void _(E element) { counter++; });
  return counter;
}

Queue map(f(E element)) {
  Queue other = new Queue();
  DoubleLinkedQueueEntry<E> entry = _sentinel._next;
  while (entry !== _sentinel) {
    DoubleLinkedQueueEntry<E> nextEntry = entry._next;
    other.addLast(f(entry._element));
    entry = nextEntry;
  }
  return other;
}

E removeFirst() {
  return _sentinel._next.remove();
}

E removeLast() {
  return _sentinel._previous.remove();
}

bool some(bool f(E element)) {
  DoubleLinkedQueueEntry<E> entry = _sentinel._next;
  while (entry !== _sentinel) {
    DoubleLinkedQueueEntry<E> nextEntry = entry._next;
    if (f(entry._element)) return true;
    entry = nextEntry;
  }
  return false;
}

String toString() {
  return Collections.collectionToString(this);
}