• Home
• com.aol.cyclops
• cyclops-reactor
• 8.0.0
• source code
• Reactor.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.aol.cyclops.reactor.Reactor Maven / Gradle / Ivy

package com.aol.cyclops.reactor;

import java.util.function.BiFunction;
import java.util.function.Function;

import org.reactivestreams.Publisher;

import com.aol.cyclops.control.AnyM;
import com.aol.cyclops.control.For;
import com.aol.cyclops.control.FutureW;
import com.aol.cyclops.control.ReactiveSeq;
import com.aol.cyclops.control.monads.transformers.FutureWT;
import com.aol.cyclops.control.monads.transformers.StreamT;
import com.aol.cyclops.control.monads.transformers.seq.FutureWTSeq;
import com.aol.cyclops.control.monads.transformers.seq.StreamTSeq;
import com.aol.cyclops.types.anyM.AnyMSeq;
import com.aol.cyclops.types.anyM.AnyMValue;
import com.aol.cyclops.util.function.QuadFunction;
import com.aol.cyclops.util.function.TriFunction;

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

public interface Reactor {

	public static  AnyMSeq flux(Flux flux){
		return AnyM.ofSeq(flux);
	}
	public static  StreamTSeq fluxT(Publisher> nested){
		return StreamT.fromPublisher(Flux.from(nested).map(f->ReactiveSeq.fromPublisher(f)));
	}
	
	public static  AnyMValue mono(Mono mono){
		return AnyM.ofValue(mono);
	}
	public static  FutureWTSeq monoT(Publisher> nested){
		return FutureWT.fromPublisher(Flux.from(nested).map(f->FutureW.of(f.toCompletableFuture())));
	}
	public interface ForFlux {

		static  Flux each4(Flux value1,
				Function> value2,
				BiFunction> value3,
				TriFunction> value4,
				QuadFunction yieldingFunction) {

			return AnyM.ofSeq(For.anyM(flux(value1)).anyM(a -> flux(value2.apply(a))).anyM(a -> b -> flux(value3.apply(a, b)))
							.anyM(a -> b -> c -> flux(value4.apply(a, b, c))).yield4(yieldingFunction).unwrap())
					.unwrap();

		}

		static  Flux each4(Flux value1,
				Function> value2,
				BiFunction> value3,
				TriFunction> value4,
				QuadFunction filterFunction,
				QuadFunction yieldingFunction) {

			return AnyM.ofSeq(For.anyM(flux(value1)).anyM(a -> flux(value2.apply(a)))
					.anyM(a -> b -> flux(value3.apply(a, b))).anyM(a -> b -> c -> flux(value4.apply(a, b, c)))
					.filter(a -> b -> c -> d -> filterFunction.apply(a, b, c, d)).yield4(yieldingFunction).unwrap())
					.unwrap();

		}

		static  Flux each3(Flux value1,
				Function> value2,
				BiFunction> value3,
				TriFunction yieldingFunction) {

			return AnyM.ofSeq(For.anyM(flux(value1)).anyM(a -> flux(value2.apply(a)))
					.anyM(a -> b -> flux(value3.apply(a, b))).yield3(yieldingFunction).unwrap()).unwrap();
			

		}

		static  Flux each3(Flux value1,
				Function> value2,
				BiFunction> value3,
				TriFunction filterFunction,
				TriFunction yieldingFunction) {

			return AnyM
					.ofSeq(For.anyM(flux(value1)).anyM(a -> flux(value2.apply(a))).anyM(a -> b -> flux(value3.apply(a, b)))
							.filter(a -> b -> c -> filterFunction.apply(a, b, c)).yield3(yieldingFunction).unwrap())
					.unwrap();
			

		}

		static  Flux each2(Flux value1, Function> value2,
				BiFunction yieldingFunction) {

			return AnyM.ofSeq(For.anyM(flux(value1)).anyM(a -> flux(value2.apply(a))).yield2(yieldingFunction).unwrap())
					.unwrap();
			

		}

		static  Flux each2(Flux value1, Function> value2,
				BiFunction filterFunction,
				BiFunction yieldingFunction) {

			return AnyM.ofSeq(For.anyM(flux(value1)).anyM(a -> flux(value2.apply(a)))
					.filter(a -> b -> filterFunction.apply(a, b)).yield2(yieldingFunction).unwrap()).unwrap();
			

		}
	}
	public interface ForMono {

		static  Mono each4(Mono value1,
				Function> value2,
				BiFunction> value3,
				TriFunction> value4,
				QuadFunction yieldingFunction) {

			return AnyM.ofValue(For.anyM(mono(value1)).anyM(a -> mono(value2.apply(a))).anyM(a -> b -> mono(value3.apply(a, b)))
							.anyM(a -> b -> c -> mono(value4.apply(a, b, c))).yield4(yieldingFunction).unwrap())
					.unwrap();

		}

		static  Mono each4(Mono value1,
				Function> value2,
				BiFunction> value3,
				TriFunction> value4,
				QuadFunction filterFunction,
				QuadFunction yieldingFunction) {

			return AnyM.ofValue(For.anyM(mono(value1)).anyM(a -> mono(value2.apply(a)))
					.anyM(a -> b -> mono(value3.apply(a, b))).anyM(a -> b -> c -> mono(value4.apply(a, b, c)))
					.filter(a -> b -> c -> d -> filterFunction.apply(a, b, c, d)).yield4(yieldingFunction).unwrap())
					.unwrap();

		}

		static  Mono each3(Mono value1,
				Function> value2,
				BiFunction> value3,
				TriFunction yieldingFunction) {

			return AnyM.ofValue(For.anyM(mono(value1)).anyM(a -> mono(value2.apply(a)))
					.anyM(a -> b -> mono(value3.apply(a, b))).yield3(yieldingFunction).unwrap()).unwrap();
			

		}

		static  Mono each3(Mono value1,
				Function> value2,
				BiFunction> value3,
				TriFunction filterFunction,
				TriFunction yieldingFunction) {

			return AnyM
					.ofValue(For.anyM(mono(value1)).anyM(a -> mono(value2.apply(a))).anyM(a -> b -> mono(value3.apply(a, b)))
							.filter(a -> b -> c -> filterFunction.apply(a, b, c)).yield3(yieldingFunction).unwrap())
					.unwrap();
			

		}

		static  Mono each2(Mono value1, Function> value2,
				BiFunction yieldingFunction) {

			return AnyM.ofValue(For.anyM(mono(value1)).anyM(a -> mono(value2.apply(a))).yield2(yieldingFunction).unwrap())
					.unwrap();
			

		}

		static  Mono each2(Mono value1, Function> value2,
				BiFunction filterFunction,
				BiFunction yieldingFunction) {

			return AnyM.ofValue(For.anyM(mono(value1)).anyM(a -> mono(value2.apply(a)))
					.filter(a -> b -> filterFunction.apply(a, b)).yield2(yieldingFunction).unwrap()).unwrap();
			

		}
	}
	
	
	
}