@Override public Observable<T> call(Observable<Observable<T>> source) { return source.flatMap(Functions.<Observable<T>> identity()); } };
/** * Returns a {@link Func1} that returns an empty {@link Observable}. * * @return */ public static <T> Func1<T, Observable<Object>> toEmpty() { return Functions.constant(Observable.<Object> empty()); }
@SuppressWarnings("unchecked") public static <T> Observable<T> concatButIgnoreFirstSequence(Observable<?> o1, Observable<T> o2) { return Observable.concat((Observable<T>) o1.filter(com.github.davidmoten.rx.Functions .<Object> alwaysFalse()), o2); }
public static <T> ResourceManager<T> create(Callable<T> resourceFactory, Action1<? super T> disposeAction) { return new ResourceManager<T>(Functions.toFunc0(resourceFactory), disposeAction, false); }
public <State> Builder2<State> initialState(final State initialState) { return new Builder2<State>(Functions.constant0(initialState)); }
@Override public Observable<Statistics> call(Observable<T> o) { return o.scan(Statistics.create(), Functions.collectStats()); } };
public static <T extends HasFix> Downsample<T> minTimeStep(long duration, TimeUnit unit) { return new Downsample<T>(unit.toMillis(duration), Functions.<T> alwaysFalse()); }
public static <T> ResourceManager<T> create(Callable<T> resourceFactory, Action1<? super T> disposeAction) { return new ResourceManager<T>(Functions.toFunc0(resourceFactory), disposeAction, false); }
private static Observable<Observable<byte[]>> createServerSocketObservable( ServerSocket serverSocket, final long timeoutMs, final int bufferSize, final Action0 preAcceptAction, final Func1<? super Socket, Boolean> acceptSocket) { return Observable.create( // SyncOnSubscribe.<ServerSocket, Observable<byte[]>> createSingleState( // Functions.constant0(serverSocket), // new Action2<ServerSocket, Observer<? super Observable<byte[]>>>() { @Override public void call(ServerSocket ss, Observer<? super Observable<byte[]>> observer) { acceptConnection(timeoutMs, bufferSize, ss, observer, preAcceptAction, acceptSocket); } })); }
@Override public Observable<Statistics> call(Observable<T> o) { return o.scan(Statistics.create(), Functions.collectStats()); } };
/** * Returns an {@link Observable} that is the result of running a sequence of * update commands (insert/update/delete, ddl) read from the given * {@link Observable} sequence. * * @param commands * @return */ public Observable<Integer> run(Observable<String> commands) { return commands.reduce(Observable.<Integer> empty(), new Func2<Observable<Integer>, String, Observable<Integer>>() { @Override public Observable<Integer> call(Observable<Integer> dep, String command) { return update(command).dependsOn(dep).count(); } }).flatMap(Functions.<Observable<Integer>> identity()); }
@Override public Observable<T> call(T t) { return db.beginTransaction().map(Functions.constant(t)); } });
public static <T extends Closeable> ResourceManager<T> create(Callable<T> resourceFactory) { return create(Functions.toFunc0(resourceFactory), CloserHolder.INSTANCE); }
public <State> Builder2<State> initialState(final State initialState) { return new Builder2<State>(Functions.constant0(initialState)); }
public Builder<T> memory() { Func1<Func1<T, String>, Func1<T, String>> message = chainMessage( new Func2<Func1<T, String>, T, String>() { @Override public String call(Func1<T, String> f, T t) { return memoryUsage(); } }); Func1<Action1<T>, Action1<T>> action = Functions.identity(); transitions.add(new Transition<T>(action, message)); return this; }
/** * Starts a transaction. Until commit() or rollback() is called on the * source this will set the query context for all created queries to be a * single threaded executor with one (new) connection. * * @param dependency * @return */ public Observable<Boolean> beginTransaction(Observable<?> dependency) { return update("begin").dependsOn(dependency).count().map(Functions.constant(true)); }
public static <T extends Closeable> ResourceManager<T> create(Callable<T> resourceFactory) { return create(Functions.toFunc0(resourceFactory), CloserHolder.INSTANCE); }
private static Observable<Observable<byte[]>> createServerSocketObservable( ServerSocket serverSocket, final long timeoutMs, final int bufferSize, final Action0 preAcceptAction, final Func1<? super Socket, Boolean> acceptSocket) { return Observable.create( // SyncOnSubscribe.<ServerSocket, Observable<byte[]>> createSingleState( // Functions.constant0(serverSocket), // new Action2<ServerSocket, Observer<? super Observable<byte[]>>>() { @Override public void call(ServerSocket ss, Observer<? super Observable<byte[]>> observer) { acceptConnection(timeoutMs, bufferSize, ss, observer, preAcceptAction, acceptSocket); } })); }