CustomFunction.java

package pro.verron.officestamper.api;

import pro.verron.officestamper.utils.TriFunction;

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

/**
 * Represents a custom function encapsulating a name, parameter types, and a functional implementation.
 * This record provides a structure for defining and handling generic functions with dynamic argument types.
 *
 * @param name the name of the function
 * @param parameterTypes the parameter types expected by the function
 * @param function the implementation of the function that accepts a list of arguments and produces a result
 */
public record CustomFunction(
        String name,
        List<Class<?>> parameterTypes,
        Function<List<Object>, Object> function
) {
    /**
     * The NeedsFunctionImpl interface specifies a contract for classes that require the implementation
     * of a function that operates on a specific type and produces a result.
     *
     * @param <T> the type of the input to the function
     */
    public interface NeedsFunctionImpl<T> {
        /**
         * Sets a function implementation that operates on a specific input type and produces a result.
         *
         * @param function the function implementation to set; it takes an input of type {@code T} and returns a result.
         */
        void withImplementation(Function<T, ?> function);
    }

    /**
     * Represents a contract for classes that require the implementation of a BiFunction.
     * A BiFunction is a functional interface that accepts two input arguments of types T and U,
     * and produces a result.
     *
     * @param <T> the type of the first input to the BiFunction
     * @param <U> the type of the second input to the BiFunction
     */
    public interface NeedsBiFunctionImpl<T, U> {
        /**
         * Registers or sets a BiFunction implementation to be used by the client.
         * The BiFunction accepts two input arguments of types T and U,
         * and produces a result of an unspecified type.
         *
         * @param object the BiFunction implementation that defines the behavior for processing inputs of types T and U
         */
        void withImplementation(BiFunction<T, U, ?> object);
    }

    /**
     * Represents a contract for classes requiring the implementation of a TriFunction.
     * A TriFunction is a functional interface that accepts three input arguments of types T, U, and V,
     * and produces a result.
     *
     * @param <T> the type of the first input to the TriFunction
     * @param <U> the type of the second input to the TriFunction
     * @param <V> the type of the third input to the TriFunction
     */
    public interface NeedsTriFunctionImpl<T, U, V> {
        /**
         * Registers the implementation of a TriFunction that accepts three input arguments
         * of types T, U, and V and produces a result. This method allows the user to provide
         * a specific functional behavior to be executed with the given input arguments.
         *
         * @param function the implementation of a TriFunction that takes three inputs of
         *                 types T, U, and V, and produces a result
         */
        void withImplementation(TriFunction<T, U, V, ?> function);
    }
}