@Override public BankersQueue<T> enqueue(T value) { return cons(value); }
@Override default BankersQueue<T> minus() { return dequeue(null)._2(); }
@Override default BankersQueue<T> removeFirst(Predicate<? super T> pred) { return fromStream(stream().removeFirst(pred)); }
@Test public void enqueue2(){ BankersQueue<Integer> q = BankersQueue.cons(1) .enqueue(10); System.out.println(q); System.out.println(q.seq()); System.out.println(q.equals(q)); System.out.println(q.tail()); System.out.println(q.dequeue(-1)); assertThat(q.dequeue(-1),equalTo(Tuple.tuple(1,q.tail()))); BankersQueue<Integer> q2 = q.dequeue(-1)._2(); assertThat(q2.dequeue(-1),equalTo(Tuple.tuple(10,q2.tail()))); }
@Test public void get2(){ BankersQueue<Integer> q = BankersQueue.cons(1) .enqueue(2) .enqueue(3) .enqueue(4) .enqueue(5) .enqueue(6); //BankersQueue.of(1,2,3); System.out.println("0 " + q.get(0)); System.out.println("1 " + q.get(1)); System.out.println("2 " + q.get(2)); System.out.println("3 " + q.get(3)); System.out.println("4 " + q.get(4)); System.out.println("5 " + q.get(5)); System.out.println(q); System.out.println("0 " + q.dequeue(-1)); System.out.println("1 " + q.dequeue(-1)._2().dequeue(-1)); System.out.println("2 " + q.dequeue(-1)._2().dequeue(-1)._2().dequeue(-1)); for (Integer integer : q) { System.out.println(integer); } assertThat(q.get(0),equalTo(Option.some(1))); assertThat(q.get(1),equalTo(Option.some(2))); assertThat(q.get(2),equalTo(Option.some(3))); assertThat(q.get(3).isPresent(),equalTo(true)); assertThat(q.get(-1).isPresent(),equalTo(false)); }
/** * * <pre> * {@code * PersistentQueue<Integer> q = Reducers.toPersistentQueue() .foldMap(Stream.of(1,2,3,4)); * * } * </pre> * @return Reducer to PQueue types */ public static <T> Reducer<PersistentQueue<T>,T> toPersistentQueue() { return Reducer.fromMonoid(Monoids.<T,PersistentQueue<T>>concatPersistentCollection(BankersQueue.empty()), a -> BankersQueue.of(a)); } /**
@Override default BankersQueue<T> drop(long num) { if(num<=0) return this; if(num>=size()) return empty(); return this.foldBankersQueue(c -> { ImmutableList<T> newFront = c.front.drop(num); ImmutableList<T> newBack = c.back.dropRight((int) num - c.front.size()); if (newFront.size() > 0 || newBack.size() > 0) return new Cons<>(newFront, newBack); return empty(); }, nil -> nil); }
@Override default <R> BankersQueue<R> unitStream(Stream<R> stream){ return fromStream(stream); }
@Test public void fromStream(){ System.out.println(BankersQueue.of(1,2,3)); System.out.println(BankersQueue.fromStream(Stream.of(1,2,3))); BankersQueue.fromStream(Stream.of(1,2,3)).iterator(); assertThat(BankersQueue.fromStream(Stream.of(1,2,3)),equalTo(BankersQueue.of(1,2,3))); } }
@Override public ImmutableQueue<T> onEmpty(T value) { return BankersQueue.of(value); }
assertTrue(of(1).bankersQueue().size()>0); assertTrue(of(1).vector().size()>0); assertTrue(of(1).hashSet().size()>0); assertTrue(of(1).to().seq().size()>0); assertTrue(of(1).to().lazySeq().size()>0); assertTrue(of(1).to().bankersQueue().size()>0); assertTrue(of(1).to().vector().size()>0); assertTrue(of(1).to().hashSet().size()>0);
@Override default BankersQueue<T> emptyUnit(){ return empty(); }
@Override default BankersQueue<T> plus(T value){ return enqueue(value); }
public BankersQueue<T> tail() { if(size()==1) return empty(); if(sizeFront==0){ return BankersQueue.ofAll(back.fold(s->s.fold((h, t)->t), n->n)); } if(sizeFront==1){ return ofAll(back); } return new BankersQueue.Cons<>(sizeFront-1,front.fold(s->s.fold((h, t)->t), n->n),sizeBack,back); } public BankersQueue<T> replace(T currentElement, T newElement) {
@Test public void queueViewTest() { Queue<Integer> list = of(1, 2, 3).queueView(); assertThat(list.size(), equalTo(3)); assertThat(list.toArray(), equalTo(BankersQueue.of(1, 2, 3).toArray())); assertThat(list.contains(2), equalTo(true)); assertThat(list.containsAll(Arrays.asList(2, 3)), equalTo(true)); assertThat(list.containsAll(Arrays.asList(2, 3, 4)), equalTo(false)); } @Test
default BankersQueue<T> tail(){ return foldBankersQueue(cons-> cons, nil->nil); } @Override
@Override default BankersQueue<T> plusAll(Iterable<? extends T> list) { return appendAll(list); }