DequeSequence.java

package jetbrains.mps.internal.collections.runtime;

/*Generated by MPS */

import java.io.Serializable;
import java.util.Deque;
import java.util.Iterator;
import jetbrains.mps.baseLanguage.closures.runtime.AdapterClass;
import jetbrains.mps.baseLanguage.closures.runtime._FunctionTypes;
import jetbrains.mps.internal.collections.runtime.impl.NullDequeSequence;
import java.util.LinkedList;
import java.util.Collection;
import java.util.List;
import java.util.Arrays;

public class DequeSequence<T> extends AbstractQueueSequence<T> implements IDequeSequence<T>, Serializable {
  private static final long serialVersionUID = 6994676498844479086L;
  private DequeSequence(Deque<T> deque) {
    super(deque);
  }
  @Override
  public void addFirst(T t) {
    getDeque().addFirst(t);
  }
  @Override
  public void addLast(T t) {
    getDeque().addLast(t);
  }
  @Override
  public Iterator<T> descendingIterator() {
    return getDeque().descendingIterator();
  }
  @Override
  public T getFirst() {
    return getDeque().getFirst();
  }
  @Override
  public T getLast() {
    return getDeque().getLast();
  }
  @Override
  public boolean offerFirst(T t) {
    return getDeque().offerFirst(t);
  }
  @Override
  public boolean offerLast(T t) {
    return getDeque().offerLast(t);
  }
  @Override
  public T peekFirst() {
    return getDeque().peekFirst();
  }
  @Override
  public T peekLast() {
    return getDeque().peekLast();
  }
  @Override
  public T pollFirst() {
    return getDeque().pollFirst();
  }
  @Override
  public T pollLast() {
    return getDeque().pollLast();
  }
  @Override
  public T pop() {
    return getDeque().pop();
  }
  @Override
  public void push(T t) {
    getDeque().push(t);
  }
  @Override
  public T removeFirst() {
    return getDeque().removeFirst();
  }
  @Override
  public boolean removeFirstOccurrence(Object o) {
    return getDeque().removeFirstOccurrence(o);
  }
  @Override
  public T removeLast() {
    return getDeque().removeLast();
  }
  @Override
  public boolean removeLastOccurrence(Object o) {
    return getDeque().removeLastOccurrence(o);
  }
  @Override
  public T addFirstElement(T t) {
    getDeque().addFirst(t);
    return t;
  }
  @Override
  public T removeLastElement() {
    if (Sequence.NULL_WHEN_EMPTY) {
      if (getDeque().isEmpty()) {
        return null;
      }
    }
    return getDeque().removeLast();
  }
  @Override
  public T peekElement() {
    if (Sequence.NULL_WHEN_EMPTY) {
      if (getDeque().isEmpty()) {
        return null;
      }
    }
    return getDeque().peek();
  }
  @Override
  public T popElement() {
    if (Sequence.NULL_WHEN_EMPTY) {
      if (getDeque().isEmpty()) {
        return null;
      }
    }
    return getDeque().pop();
  }
  @Override
  public T pushElement(T t) {
    getDeque().push(t);
    return t;
  }
  @Override
  public IDequeSequence<T> addSequence(ISequence<? extends T> seq) {
    return (IDequeSequence<T>) super.addSequence(seq);
  }
  @Override
  public IDequeSequence<T> removeSequence(ISequence<? extends T> seq) {
    return (IDequeSequence<T>) super.removeSequence(seq);
  }
  @Override
  public IDequeSequence<T> removeWhere(@AdapterClass(value = "IWhereFilter") _FunctionTypes._return_P1_E0<? extends Boolean, ? super T> filter) {
    return (IDequeSequence<T>) super.removeWhere(filter);
  }
  @Override
  public IDequeSequence<T> asUnmodifiable() {
    throw new UnsupportedOperationException();
  }
  @Override
  public IDequeSequence<T> asSynchronized() {
    throw new UnsupportedOperationException();
  }
  protected Deque<T> getDeque() {
    return (Deque<T>) getQueue();
  }

  public static <U> IDequeSequence<U> fromDeque(Deque<U> deque) {
    //  change tempaltes to invoke this method and drop fromDequeNew 
    return fromDequeNew(deque);
  }

  public static <U> IDequeSequence<U> fromDequeNew(Deque<U> deque) {
    if (deque instanceof IDequeSequence) {
      return (IDequeSequence<U>) deque;
    }
    if (deque == null && Sequence.USE_NULL_SEQUENCE) {
      return NullDequeSequence.instance();
    }
    return new DequeSequence<U>(deque);
  }

  public static <U> IDequeSequence<U> fromIterable(Iterable<U> it) {
    if (Sequence.USE_NULL_SEQUENCE) {
      if (it == null) {
        return NullDequeSequence.instance();
      }
    }
    if (it instanceof IDequeSequence) {
      return (IDequeSequence<U>) it;
    }
    Deque<U> deque = new LinkedList<U>();
    if (Sequence.IGNORE_NULL_VALUES) {
      for (U u : it) {
        if (u != null) {
          deque.add(u);
        }
      }
    } else
    if (it instanceof Collection) {
      deque.addAll((Collection<? extends U>) it);
    } else {
      for (U u : it) {
        deque.add(u);
      }
    }
    return new DequeSequence<U>(deque);
  }

  public static <U> IDequeSequence<U> fromDequeAndArray(Deque<U> deque, U... array) {
    //  change templates to invoke this method and remove fromDequeAndArrayNew 
    return fromDequeAndArrayNew(deque, array);
  }

  public static <U> IDequeSequence<U> fromDequeAndArrayNew(Deque<U> deque, U... array) {
    if (Sequence.NULL_ARRAY_IS_SINGLETON) {
      if (array == null) {
        array = (U[]) Sequence.nullSingletonArray();
      }
    }
    if (Sequence.USE_NULL_SEQUENCE) {
      if (deque == null && array == null) {
        return NullDequeSequence.instance();
      } else
      if (deque == null) {
        deque = new LinkedList<U>();
      } else
      if (array == null) {
        if (deque instanceof IDequeSequence) {
          return (IDequeSequence<U>) deque;
        }
        return new DequeSequence<U>(deque);
      }
    }
    List<U> input = Arrays.asList(array);
    if (Sequence.IGNORE_NULL_VALUES) {
      for (U u : input) {
        if (u != null) {
          deque.add(u);
        }
      }
    } else {
      deque.addAll(input);
    }
    if (deque instanceof IDequeSequence) {
      return (IDequeSequence<U>) deque;
    }
    return new DequeSequence<U>(deque);
  }

  public static <U> IDequeSequence<U> fromDequeWithValues(Deque<U> deque, Iterable<? extends U> it) {
    // change generators to use this method and drop fromDequeWithValuesNew 
    return fromDequeWithValuesNew(deque, it);
  }
  public static <U> IDequeSequence<U> fromDequeWithValuesNew(Deque<U> deque, Iterable<? extends U> it) {
    Deque<U> tmp = deque;
    if (Sequence.USE_NULL_SEQUENCE) {
      if (deque == null && it == null) {
        return NullDequeSequence.instance();
      } else
      if (deque == null) {
        tmp = new LinkedList<U>();
      } else
      if (it == null) {
        return DequeSequence.fromDequeNew(deque);
      }
    }
    if (Sequence.IGNORE_NULL_VALUES) {
      for (U u : it) {
        if (u != null) {
          tmp.add(u);
        }
      }
    } else
    if (it instanceof Collection) {
      tmp.addAll((Collection<? extends U>) it);
    } else {
      for (U u : it) {
        tmp.add(u);
      }
    }
    if (tmp instanceof IDequeSequence) {
      return (IDequeSequence<U>) tmp;
    }
    return new DequeSequence<U>(tmp);
  }
}