reactor.groovy.ext.ComposableExtensions.groovy Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2011-2013 GoPivotal, Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package reactor.groovy.ext

import groovy.transform.CompileStatic
import groovy.transform.TypeCheckingMode
import reactor.core.composable.Composable
import reactor.core.composable.Deferred
import reactor.core.composable.Promise
import reactor.core.composable.Stream
import reactor.function.*
import reactor.groovy.support.*
import reactor.tuple.Tuple2

/**
 * Glue for Groovy closures and operator overloading applied to Stream, Composable,
 * Promise and Deferred.
 * Also gives convenient Deferred handling by providing map/filter/consume operations
 *
 * @author Jon Brisbin
 * @author Stephane Maldini
 */
@CompileStatic
class ComposableExtensions {

	/**
	 * Alias
	 */
	static > X to(final X selfType, final Object key,
	                                         final reactor.core.Observable observable) {
		selfType.consume key, observable
	}

	/**
	 * Closure converters
	 */
	static  Composable map(final Deferred selfType, final Closure closure) {
		selfType.compose().map new ClosureFunction(closure)
	}

	static  Stream map(final Stream selfType, final Closure closure) {
		selfType.map new ClosureFunction(closure)
	}

	static  Promise map(final Promise selfType, final Closure closure) {
		selfType.map new ClosureFunction(closure)
	}

	static  Stream consume(final Stream selfType, final Closure closure) {
		selfType.consume new ClosureConsumer(closure)
	}

	static > Stream mapMany(final Stream selfType, final Closure closure) {
		selfType.mapMany new ClosureFunction(closure)
	}

	static > Promise bind(final Promise selfType, final Closure closure) {
		selfType.mapMany new ClosureFunction(closure)
	}

	static  Composable consume(final Deferred selfType, final Closure closure) {
		selfType.compose().consume new ClosureConsumer(closure)
	}

	static  Promise consume(final Promise selfType, final Closure closure) {
		selfType.consume new ClosureConsumer(closure)
	}

	static  Stream filter(final Stream selfType, final Closure closure) {
		selfType.filter new ClosurePredicate(closure)
	}

	static  Composable filter(final Deferred selfType, final Closure closure) {
		selfType.compose().filter new ClosurePredicate(closure)
	}

	static  Promise filter(final Promise selfType, final Closure closure) {
		selfType.filter new ClosurePredicate(closure)
	}

	static  Stream when(final Stream selfType, final Class exceptionType, final Closure closure) {
		selfType.when exceptionType, new ClosureConsumer(closure)
	}

	static  Composable when(final Deferred selfType, final Class exceptionType, final Closure closure) {
		selfType.compose().when exceptionType, new ClosureConsumer(closure)
	}

	static  Promise when(final Promise selfType, final Class exceptionType, final Closure closure) {
		selfType.when exceptionType, new ClosureConsumer(closure)
	}

	@CompileStatic(TypeCheckingMode.SKIP)
	static  Stream reduce(final Stream selfType, final Closure closure, V initial = null) {
		reduce selfType, closure, initial ? Functions.supplier((V)initial) : (Supplier)null
	}

	static  Stream reduce(final Stream selfType, final Closure closure, Closure initial) {
		reduce selfType, closure, new ClosureSupplier(initial)
	}

	@CompileStatic(TypeCheckingMode.SKIP)
	static  Stream reduce(final Stream selfType, final Closure closure, Supplier initial) {
		selfType.reduce new ClosureReduce(closure), initial
	}

	static  Promise onError(final Promise selfType, final Closure closure) {
		selfType.onError new ClosureConsumer(closure)
	}

	static  Promise onComplete(final Promise selfType, final Closure closure) {
		selfType.onComplete new ClosureConsumer>(closure)
	}

	static  Promise onSuccess(final Promise selfType, final Closure closure) {
		selfType.onSuccess new ClosureConsumer(closure)
	}

	static  Promise then(final Promise selfType, final Closure closureSuccess,
	                              final Closure closureError = null) {
		selfType.then(new ClosureFunction(closureSuccess), closureError ?
				new ClosureConsumer(closureError) : null)
	}

	/**
	 * Operator overloading
	 */

	@CompileStatic(TypeCheckingMode.SKIP)
	static  Stream mod(final Stream selfType, final Function, V> other) {
		selfType.reduce other, (Supplier)null
	}

	static  Stream mod(final Stream selfType, final Closure other) {
		reduce selfType, other
	}

	//Mapping
	static  Stream or(final Stream selfType, final Function other) {
		selfType.map other
	}

	static  Stream or(final Stream selfType, final Closure other) {
		map selfType, other
	}

	static  Composable or(final Deferred selfType, final Function other) {
		selfType.compose().map other
	}

	static  Composable or(final Deferred selfType, final Closure other) {
		map selfType, other
	}

	static  Promise or(final Promise selfType, final Function other) {
		selfType.then other, (Consumer) null
	}

	static  Promise or(final Promise selfType, final Closure other) {
		then selfType, other
	}


	//Filtering
	static  Stream and(final Stream selfType, final Closure other) {
		filter selfType, other
	}

	static  Promise and(final Promise selfType, final Closure other) {
		filter selfType, other
	}

	static  Composable and(final Deferred selfType, final Closure other) {
		filter selfType, other
	}

	static  Stream and(final Stream selfType, final Predicate other) {
		selfType.filter other
	}

	static  Promise and(final Promise selfType, final Predicate other) {
		selfType.filter other
	}

	static  Composable and(final Deferred selfType, final Predicate other) {
		selfType.compose().filter other
	}


	//Consuming
	static  Stream leftShift(final Stream selfType, final Consumer other) {
		selfType.consume other
	}

	static  Composable leftShift(final Deferred selfType, final Consumer other) {
		selfType.compose().consume other
	}

	static  Stream leftShift(final Stream selfType, final Closure other) {
		consume selfType, other
	}

	static  Composable leftShift(final Deferred selfType, final Closure other) {
		consume selfType, other
	}

	static  Promise leftShift(final Promise selfType, final Consumer other) {
		selfType.onSuccess other
	}

	static  Promise leftShift(final Promise selfType, final Closure other) {
		onSuccess selfType, other
	}

	//Accept
	static  Consumer leftShift(final Consumer selfType, T value) {
		selfType.accept value
		selfType
	}

	static > Deferred leftShift(final Deferred selfType, T value) {
		selfType.accept value
		selfType
	}

}