flatZip dans RxJava

Question

Je zipper plusieurs Observables ensemble, puis de les transformer d'une manière qui se traduit par un Observable:

final Observable<Observable<M>> result = Observable.zip(obs1, obs2, transformFunc); 

Ce que je voudrais être en mesure de faire est:

final Observable<M> result = Observable.flatZip(obs1, obs2, transformFunc); 

Quelle est la manière la plus propre de le faire, étant donné que flatZip n'existe pas (peut-être que je devrais en soumettre un). En ce moment je dois flatter le résultat sur lui-même.

Answer 1

public class RxHelper { 

    public static <T1, T2, R> Observable<R> flatZip(Observable<? extends T1> o1, Observable<? extends T2> o2, final Func2<? super T1, ? super T2, Observable<? extends R>> zipFunction) { 
     return Observable.merge(Observable.zip(o1, o2, zipFunction)); 
    } 

    public static <T1, T2, T3, R> Observable<R> flatZip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Func3<? super T1, ? super T2, ? super T3, Observable<? extends R>> zipFunction) { 
     return Observable.merge(Observable.zip(o1, o2, o3, zipFunction)); 
    } 

    public static <T1, T2, T3, T4, R> Observable<R> flatZip(Observable<? extends T1> o1, Observable<? extends T2> o2, Observable<? extends T3> o3, Observable<? extends T4> o4, Func4<? super T1, ? super T2, ? super T3, ? super T4, Observable<? extends R>> zipFunction) { 
     return Observable.merge(Observable.zip(o1, o2, o3, o4, zipFunction)); 
    } 
} 

Answer 2

bien de chose à faire le plus simple serait la suivante

final Observable<M> result = Observable.zip(obs1, obs2, (o1, o2) -> { 
    return new M(o1, o2); // construct a new M and return it from here. 
}); 

Hope this helps

anand raman

Answer 3

Qu'en est-ce:

public static <A,B,C> Observable<C> flatZip(Observable<A> o1, Observable<B> o2, F2<A,B,Observable<C>> transformer) { 
    Observable<Observable<C>> obob = Observable.zip(o1, o2, (a, b) -> { 
     return transformer.f(a, b); 


    }); 

    Observable<C> ob = obob.flatMap(x -> x); 

    return ob; 
} 

Bien sûr, vous J'en ai besoin d'un pour chaque nombre d'arguments, mais c'est aussi le cas avec zip. Deviner ce n'est pas le point de la douleur ici.

Answer 4

Voici ce que j'ai fini par utiliser dans mon projet:

/** 
* Zips results of two observables into the other observable. 
* Works like zip operator, except zip function must return an Observable 
*/ 
public static <T, V, R> Observable<R> flatZip(Observable<T> o1, Observable<V> o2, Func2<? super T, ? super V, Observable<R>> zipFunction) { 
    return Observable.zip(o1, o2, Pair::new).flatMap(r -> zipFunction.call(r.first, r.second)); 
}