protected <R> Observable<R> wrap(Callable<R> callable) { return wrap(RxUtils.fromCallable(callable)); }
/** * Rx version of {@link AbstractDao#count()} returning an Observable. */ @Experimental public Observable<Long> count() { return wrap(new Callable<Long>() { @Override public Long call() throws Exception { return dao.count(); } }); }
/** * Rx version of {@link Query#list()} returning an Observable. */ @Experimental public Observable<List<T>> list() { return wrap(new Callable<List<T>>() { @Override public List<T> call() throws Exception { return query.forCurrentThread().list(); } }); }
/** * Rx version of {@link AbstractDaoSession#callInTx(Callable)} returning an Observable. */ @Experimental public <T> Observable<T> call(final Callable<T> callable) { return wrap(new Callable<T>() { @Override public T call() throws Exception { return daoSession.callInTx(callable); } }); }
/** * The returned {@link RxTransaction} allows DB transactions using Rx Observables without any Scheduler set for * subscribeOn. * * @see #rxTx() */ @Experimental public RxTransaction rxTxPlain() { if (rxTxPlain == null) { rxTxPlain = new RxTransaction(this); } return rxTxPlain; }
/** * DO NOT USE. * The returned {@link RxTransaction} allows getting query results using Rx Observables without any Scheduler set * for subscribeOn. * * @see #__InternalRx() */ @Internal public RxQuery __internalRxPlain() { if (rxTxPlain == null) { rxTxPlain = new RxQuery(this); } return rxTxPlain; }
/** * The returned RxDao is a special DAO that let's you interact with Rx Observables without any Scheduler set * for subscribeOn. * * @see #rx() */ @Experimental public RxDao<T, K> rxPlain() { if (rxDaoPlain == null) { rxDaoPlain = new RxDao<>(this); } return rxDaoPlain; }
/** * Rx version of {@link AbstractDao#deleteAll()} returning an Observable. */ @Experimental public Observable<Void> deleteAll() { return wrap(new Callable<Void>() { @Override public Void call() throws Exception { dao.deleteAll(); return null; } }); }
/** * Rx version of {@link Query#unique()} returning an Observable. */ @Experimental public Observable<T> unique() { return wrap(new Callable<T>() { @Override public T call() throws Exception { return query.forCurrentThread().unique(); } }); }
/** * Rx version of {@link AbstractDao#delete(Object)} returning an Observable. */ @Experimental public Observable<Void> delete(final T entity) { return wrap(new Callable<Void>() { @Override public Void call() throws Exception { dao.delete(entity); return null; } }); }
/** * Rx version of {@link AbstractDao#deleteInTx(Iterable)} returning an Observable. */ @Experimental public Observable<Void> deleteInTx(final Iterable<T> entities) { return wrap(new Callable<Void>() { @Override public Void call() throws Exception { dao.deleteInTx(entities); return null; } }); }
/** * Rx version of {@link AbstractDao#loadAll()} returning an Observable. */ @Experimental public Observable<List<T>> loadAll() { return wrap(new Callable<List<T>>() { @Override public List<T> call() throws Exception { return dao.loadAll(); } }); }
/** * Rx version of {@link AbstractDao#loadAll()} returning an Observable. */ @Experimental public Observable<T> load(final K key) { return wrap(new Callable<T>() { @Override public T call() throws Exception { return dao.load(key); } }); }
/** * Rx version of {@link AbstractDao#deleteByKeyInTx(Object[])} returning an Observable. */ @Experimental public Observable<Void> deleteByKeyInTx(final K... keys) { return wrap(new Callable<Void>() { @Override public Void call() throws Exception { dao.deleteByKeyInTx(keys); return null; } }); }
/** * Rx version of {@link AbstractDao#deleteByKey(Object)} returning an Observable. */ @Experimental public Observable<Void> deleteByKey(final K key) { return wrap(new Callable<Void>() { @Override public Void call() throws Exception { dao.deleteByKey(key); return null; } }); }
/** * Rx version of {@link AbstractDao#save(Object)} returning an Observable. * Note that the Observable will emit the given entity back to its subscribers. */ @Experimental public Observable<T> save(final T entity) { return wrap(new Callable<T>() { @Override public T call() throws Exception { dao.save(entity); return entity; } }); }
/** * Rx version of {@link AbstractDao#insert(Object)} returning an Observable. * Note that the Observable will emit the given entity back to its subscribers. */ @Experimental public Observable<T> insert(final T entity) { return wrap(new Callable<T>() { @Override public T call() throws Exception { dao.insert(entity); return entity; } }); }
/** * Rx version of {@link AbstractDao#updateInTx(Object[])} returning an Observable. * Note that the Observable will emit the given entities back to its subscribers. */ @Experimental public Observable<Object[]> updateInTx(final T... entities) { return wrap(new Callable<Object[]>() { @Override public Object[] call() throws Exception { dao.updateInTx(entities); return entities; } }); }
/** * Rx version of {@link AbstractDao#deleteInTx(Object[])} returning an Observable. */ @Experimental public Observable<Void> deleteInTx(final T... entities) { return wrap(new Callable<Void>() { @Override public Void call() throws Exception { dao.deleteInTx(entities); return null; } }); }
/** * Rx version of {@link AbstractDao#deleteByKeyInTx(Iterable)} returning an Observable. */ @Experimental public Observable<Void> deleteByKeyInTx(final Iterable<K> keys) { return wrap(new Callable<Void>() { @Override public Void call() throws Exception { dao.deleteByKeyInTx(keys); return null; } }); }