/*******************************************************************************
 * Copyright (c) 2011 itemis AG (http://www.itemis.eu) and others.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0
 *******************************************************************************/
package org.eclipse.xtext.xbase.lib;

import org.eclipse.xtext.xbase.lib.Procedures.Procedure0;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure2;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure3;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure4;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure5;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure6;

import com.google.common.annotations.GwtCompatible;

/**
 * This is an extension library for {@link Procedures procedures}, e.g. side-effect only-closures.
 * 
 * @author Sebastian Zarnekow - Initial contribution and API
 * @see Procedures
 */
@GwtCompatible public class ProcedureExtensions {

	/**
	 * Curries a procedure that takes one argument.
	 * 
	 * @param procedure
	 *            the original procedure. May not be <code>null</code>.
	 * @param argument
	 *            the fixed argument.
	 * @return a procedure that takes no arguments. Never <code>null</code>.
	 */
	@Pure
	public static <P1> Procedure0 curry(final Procedure1<? super P1> procedure, final P1 argument) {
		if (procedure == null)
			throw new NullPointerException("procedure");
		return new Procedure0() {
			@Override
			public void apply() {
				procedure.apply(argument);
			}
		};
	}

	/**
	 * Curries a procedure that takes two arguments.
	 * 
	 * @param procedure
	 *            the original procedure. May not be <code>null</code>.
	 * @param argument
	 *            the fixed first argument of {@code procedure}.
	 * @return a procedure that takes one argument. Never <code>null</code>.
	 */
	@Pure
	public static <P1, P2> Procedure1<P2> curry(final Procedure2<? super P1, ? super P2> procedure, final P1 argument) {
		if (procedure == null)
			throw new NullPointerException("procedure");
		return new Procedure1<P2>() {
			@Override
			public void apply(P2 p) {
				procedure.apply(argument, p);
			}
		};
	}

	/**
	 * Curries a procedure that takes three arguments.
	 * 
	 * @param procedure
	 *            the original procedure. May not be <code>null</code>.
	 * @param argument
	 *            the fixed first argument of {@code procedure}.
	 * @return a procedure that takes two arguments. Never <code>null</code>.
	 */
	@Pure
	public static <P1, P2, P3> Procedure2<P2, P3> curry(final Procedure3<? super P1, ? super P2, ? super P3> procedure, final P1 argument) {
		if (procedure == null)
			throw new NullPointerException("procedure");
		return new Procedure2<P2, P3>() {
			@Override
			public void apply(P2 p2, P3 p3) {
				procedure.apply(argument, p2, p3);
			}
		};
	}

	/**
	 * Curries a procedure that takes four arguments.
	 * 
	 * @param procedure
	 *            the original procedure. May not be <code>null</code>.
	 * @param argument
	 *            the fixed first argument of {@code procedure}.
	 * @return a procedure that takes three arguments. Never <code>null</code>.
	 */
	@Pure
	public static <P1, P2, P3, P4> Procedure3<P2, P3, P4> curry(final Procedure4<? super P1, ? super P2, ? super P3, ? super P4> procedure,
			final P1 argument) {
		if (procedure == null)
			throw new NullPointerException("procedure");
		return new Procedure3<P2, P3, P4>() {
			@Override
			public void apply(P2 p2, P3 p3, P4 p4) {
				procedure.apply(argument, p2, p3, p4);
			}
		};
	}

	/**
	 * Curries a procedure that takes five arguments.
	 * 
	 * @param procedure
	 *            the original procedure. May not be <code>null</code>.
	 * @param argument
	 *            the fixed first argument of {@code procedure}.
	 * @return a procedure that takes four arguments. Never <code>null</code>.
	 */
	@Pure
	public static <P1, P2, P3, P4, P5> Procedure4<P2, P3, P4, P5> curry(final Procedure5<? super P1, ? super P2, ? super P3, ? super P4, ? super P5> procedure,
			final P1 argument) {
		if (procedure == null)
			throw new NullPointerException("procedure");
		return new Procedure4<P2, P3, P4, P5>() {
			@Override
			public void apply(P2 p2, P3 p3, P4 p4, P5 p5) {
				procedure.apply(argument, p2, p3, p4, p5);
			}
		};
	}

	/**
	 * Curries a procedure that takes six arguments.
	 * 
	 * @param procedure
	 *            the original procedure. May not be <code>null</code>.
	 * @param argument
	 *            the fixed first argument of {@code procedure}.
	 * @return a procedure that takes five arguments. Never <code>null</code>.
	 */
	@Pure
	public static <P1, P2, P3, P4, P5, P6> Procedure5<P2, P3, P4, P5, P6> curry(
			final Procedure6<? super P1, ? super P2, ? super P3, ? super P4, ? super P5, ? super P6> procedure, final P1 argument) {
		if (procedure == null)
			throw new NullPointerException("procedure");
		return new Procedure5<P2, P3, P4, P5, P6>() {
			@Override
			public void apply(P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) {
				procedure.apply(argument, p2, p3, p4, p5, p6);
			}
		};
	}
}