org.immutables.criteria.repository.async

Class AsyncReader<T>

java.lang.Object

org.immutables.criteria.repository.AbstractReader<AsyncReader<T>>

org.immutables.criteria.repository.async.AsyncReader<T>

All Implemented Interfaces:

AsyncFetcher<T>, AsyncFetcher.LimitOffset<T>, AsyncFetcher.Offset<T>, Fetcher<T>, Reader<AsyncReader<T>>

public class AsyncReader<T>
extends AbstractReader<AsyncReader<T>>
implements AsyncFetcher.LimitOffset<T>

Nested Class Summary

Nested classes/interfaces inherited from interface org.immutables.criteria.repository.async.AsyncFetcher

AsyncFetcher.DistinctLimitOffset<T>, AsyncFetcher.LimitOffset<T>, AsyncFetcher.Offset<T>

Method Summary

Modifier and Type	Method and Description
CompletionStage<Long>	count()
CompletionStage<Boolean>	exists()
CompletionStage<List<T>>	fetch()
AsyncFetcher.Offset<T>	limit(long limit)
protected AsyncReader<T>	newReader(Query query)
AsyncFetcher<T>	offset(long offset)
CompletionStage<T>	one()
CompletionStage<Optional<T>>	oneOrNone()
AsyncMapperTuple.DistinctLimitOffset	select(Iterable<Projection<?>> projections)
<T1> AsyncMapper1.DistinctLimitOffset<T1>	select(Projection<T1> proj1)
<T1,T2> AsyncMapper2.DistinctLimitOffset<T1,T2>	select(Projection<T1> proj1, Projection<T2> proj2)
<T1,T2,T3> AsyncMapper3.DistinctLimitOffset<T1,T2,T3>	select(Projection<T1> proj1, Projection<T2> proj2, Projection<T3> proj3)
<T1,T2,T3,T4> AsyncMapper4.DistinctLimitOffset<T1,T2,T3,T4>	select(Projection<T1> proj1, Projection<T2> proj2, Projection<T3> proj3, Projection<T4> proj4)
<T1,T2,T3,T4,T5> AsyncMapper5.DistinctLimitOffset<T1,T2,T3,T4,T5>	select(Projection<T1> proj1, Projection<T2> proj2, Projection<T3> proj3, Projection<T4> proj4, Projection<T5> proj5)

Methods inherited from class org.immutables.criteria.repository.AbstractReader

groupBy, orderBy

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

newReader

protected AsyncReader<T> newReader(Query query)

select

public <T1> AsyncMapper1.DistinctLimitOffset<T1> select(Projection<T1> proj1)

select

public <T1,T2> AsyncMapper2.DistinctLimitOffset<T1,T2> select(Projection<T1> proj1,
                                                              Projection<T2> proj2)

select

public <T1,T2,T3> AsyncMapper3.DistinctLimitOffset<T1,T2,T3> select(Projection<T1> proj1,
                                                                    Projection<T2> proj2,
                                                                    Projection<T3> proj3)

select

public <T1,T2,T3,T4> AsyncMapper4.DistinctLimitOffset<T1,T2,T3,T4> select(Projection<T1> proj1,
                                                                          Projection<T2> proj2,
                                                                          Projection<T3> proj3,
                                                                          Projection<T4> proj4)

select

public <T1,T2,T3,T4,T5> AsyncMapper5.DistinctLimitOffset<T1,T2,T3,T4,T5> select(Projection<T1> proj1,
                                                                                Projection<T2> proj2,
                                                                                Projection<T3> proj3,
                                                                                Projection<T4> proj4,
                                                                                Projection<T5> proj5)

select

public AsyncMapperTuple.DistinctLimitOffset select(Iterable<Projection<?>> projections)

fetch

public CompletionStage<List<T>> fetch()

one

public CompletionStage<T> one()

oneOrNone

public CompletionStage<Optional<T>> oneOrNone()

exists

public CompletionStage<Boolean> exists()

count

public CompletionStage<Long> count()

limit

public AsyncFetcher.Offset<T> limit(long limit)

offset

public AsyncFetcher<T> offset(long offset)