• Home
• io.github.nichetoolkit
• rest-toolkit-utils
• 1.1.0
• source code
• OptionalUtils.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.

io.github.nichetoolkit.rest.util.OptionalUtils Maven / Gradle / Ivy

package io.github.nichetoolkit.rest.util;

import io.github.nichetoolkit.rest.RestError;
import io.github.nichetoolkit.rest.RestException;
import io.github.nichetoolkit.rest.RestOptional;
import io.github.nichetoolkit.rest.actuator.*;
import io.github.nichetoolkit.rest.error.data.*;
import io.github.nichetoolkit.rest.error.often.FieldNullException;
import io.github.nichetoolkit.rest.error.often.FieldRepeatException;
import io.github.nichetoolkit.rest.error.often.IdentityNullException;
import io.github.nichetoolkit.rest.error.often.NameRepeatException;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.springframework.lang.NonNull;
import org.springframework.lang.Nullable;

import java.util.Objects;
import java.util.Optional;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * OptionalUtils
 * 
The optional utils class.
 * @author Cyan ([email protected])
 * @see lombok.extern.slf4j.Slf4j
 * @since Jdk1.8
 */
@Slf4j
public final class OptionalUtils {

    /**
     * xOfNull
     * 
The x of null method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @return X 
The x of null return object is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.util.function.Supplier
     * @see org.springframework.lang.NonNull
     */
    public static  X xOfNull(@Nullable T object, @NonNull Supplier supplier) {
        Objects.requireNonNull(supplier);
        X cause = null;
        if (GeneralUtils.isNull(object)) {
            cause = supplier.get();
        } else if (object instanceof Optional) {
            Optional optional = (Optional) object;
            if (optional.isPresent()) {
                cause = supplier.get();
            }
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isNullPresent()) {
                cause = supplier.get();
            }
        }
        return cause;
    }

    /**
     * xOfNullActuator
     * 
The x of null actuator method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.SupplierActuator} 
The actuator parameter is SupplierActuator type.
     * @return X 
The x of null actuator return object is X type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see io.github.nichetoolkit.rest.actuator.SupplierActuator
     * @see org.springframework.lang.NonNull
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  X xOfNullActuator(@Nullable T object, @NonNull SupplierActuator actuator) throws RestException {
        Objects.requireNonNull(actuator);
        X cause = null;
        if (GeneralUtils.isNull(object)) {
            cause = actuator.actuate();
        } else if (object instanceof Optional) {
            Optional optional = (Optional) object;
            if (!optional.isPresent()) {
                cause = actuator.actuate();
            }
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isNull()) {
                cause = actuator.actuate();
            }
        }
        return cause;
    }


    /**
     * xOfNull
     * 
The x of null method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @return X 
The x of null return object is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.Function
     * @see org.springframework.lang.NonNull
     */
    public static  X xOfNull(@Nullable T object, String message, @NonNull Function function) {
        Objects.requireNonNull(function);
        X cause = null;
        if (GeneralUtils.isNull(object)) {
            cause = function.apply(message);
        } else if (object instanceof Optional) {
            Optional optional = (Optional) object;
            if (!optional.isPresent()) {
                cause = function.apply(message);
            }
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isNull()) {
                cause = function.apply(message);
            }
        }
        return cause;
    }


    /**
     * xOfNullActuator
     * 
The x of null actuator method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.FunctionActuator} 
The actuator parameter is FunctionActuator type.
     * @return X 
The x of null actuator return object is X type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.FunctionActuator
     * @see org.springframework.lang.NonNull
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  X xOfNullActuator(@Nullable T object, String message, @NonNull FunctionActuator actuator) throws RestException {
        Objects.requireNonNull(actuator);
        X cause = null;
        if (GeneralUtils.isNull(object)) {
            cause = actuator.actuate(message);
        } else if (object instanceof Optional) {
            Optional optional = (Optional) object;
            if (!optional.isPresent()) {
                cause = actuator.actuate(message);
            }
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isNull()) {
                cause = actuator.actuate(message);
            }
        }
        return cause;
    }

    /**
     * xOfNull
     * 
The x of null method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @return X 
The x of null return object is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.BiFunction
     * @see org.springframework.lang.NonNull
     */
    public static  X xOfNull(@Nullable T object, String message, String resource, @NonNull BiFunction function) {
        Objects.requireNonNull(function);
        X cause = null;
        if (GeneralUtils.isNull(object)) {
            cause = function.apply(resource, message);
        } else if (object instanceof Optional) {
            Optional optional = (Optional) object;
            if (!optional.isPresent()) {
                cause = function.apply(resource, message);
            }
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isNull()) {
                cause = function.apply(resource, message);
            }
        }
        return cause;
    }

    /**
     * xOfNullActuator
     * 
The x of null actuator method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.BiFunctionActuator} 
The actuator parameter is BiFunctionActuator type.
     * @return X 
The x of null actuator return object is X type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.BiFunctionActuator
     * @see org.springframework.lang.NonNull
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  X xOfNullActuator(@Nullable T object, String message, String resource, @NonNull BiFunctionActuator actuator) throws RestException {
        Objects.requireNonNull(actuator);
        X cause = null;
        if (GeneralUtils.isNull(object)) {
            cause = actuator.actuate(resource, message);
        } else if (object instanceof Optional) {
            Optional optional = (Optional) object;
            if (!optional.isPresent()) {
                cause = actuator.actuate(resource, message);
            }
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isNull()) {
                cause = actuator.actuate(resource, message);
            }
        }
        return cause;
    }

    /**
     * xOfEmpty
     * 
The x of empty method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @return X 
The x of empty return object is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.util.function.Supplier
     * @see org.springframework.lang.NonNull
     */
    public static  X xOfEmpty(@Nullable T object, @NonNull Supplier supplier) {
        Objects.requireNonNull(supplier);
        X cause = null;
        if (GeneralUtils.isEmpty(object)) {
            cause = supplier.get();
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isEmpty()) {
                cause = supplier.get();
            }
        }
        return cause;
    }

    /**
     * xOfEmptyActuator
     * 
The x of empty actuator method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.SupplierActuator} 
The actuator parameter is SupplierActuator type.
     * @return X 
The x of empty actuator return object is X type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see io.github.nichetoolkit.rest.actuator.SupplierActuator
     * @see org.springframework.lang.NonNull
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  X xOfEmptyActuator(@Nullable T object, @NonNull SupplierActuator actuator) throws RestException {
        Objects.requireNonNull(actuator);
        X cause = null;
        if (GeneralUtils.isEmpty(object)) {
            cause = actuator.actuate();
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isEmpty()) {
                cause = actuator.actuate();
            }
        }
        return cause;
    }

    /**
     * xOfEmpty
     * 
The x of empty method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @return X 
The x of empty return object is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.Function
     * @see org.springframework.lang.NonNull
     */
    public static  X xOfEmpty(@Nullable T object, String message, @NonNull Function function) {
        Objects.requireNonNull(function);
        X cause = null;
        if (GeneralUtils.isEmpty(object)) {
            cause = function.apply(message);
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isEmpty()) {
                cause = function.apply(message);
            }
        }
        return cause;
    }

    /**
     * xOfEmptyActuator
     * 
The x of empty actuator method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.FunctionActuator} 
The actuator parameter is FunctionActuator type.
     * @return X 
The x of empty actuator return object is X type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.FunctionActuator
     * @see org.springframework.lang.NonNull
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  X xOfEmptyActuator(@Nullable T object, String message, @NonNull FunctionActuator actuator) throws RestException {
        Objects.requireNonNull(actuator);
        X cause = null;
        if (GeneralUtils.isEmpty(object)) {
            cause = actuator.actuate(message);
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isEmpty()) {
                cause = actuator.actuate(message);
            }
        }
        return cause;
    }

    /**
     * xOfEmpty
     * 
The x of empty method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @return X 
The x of empty return object is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.BiFunction
     * @see org.springframework.lang.NonNull
     */
    public static  X xOfEmpty(@Nullable T object, String message, String resource, @NonNull BiFunction function) {
        Objects.requireNonNull(function);
        X cause = null;
        if (GeneralUtils.isEmpty(object)) {
            cause = function.apply(resource, message);
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isEmpty()) {
                cause = function.apply(resource, message);
            }
        }
        return cause;
    }

    /**
     * xOfEmptyActuator
     * 
The x of empty actuator method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.BiFunctionActuator} 
The actuator parameter is BiFunctionActuator type.
     * @return X 
The x of empty actuator return object is X type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.BiFunctionActuator
     * @see org.springframework.lang.NonNull
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  X xOfEmptyActuator(@Nullable T object, String message, String resource, @NonNull BiFunctionActuator actuator) throws RestException {
        Objects.requireNonNull(actuator);
        X cause = null;
        if (GeneralUtils.isEmpty(object)) {
            cause = actuator.actuate(resource, message);
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isEmpty()) {
                cause = actuator.actuate(resource, message);
            }
        }
        return cause;
    }

    /**
     * xOfInvalid
     * 
The x of invalid method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @return X 
The x of invalid return object is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.util.function.Supplier
     * @see org.springframework.lang.NonNull
     */
    public static  X xOfInvalid(@Nullable T object, @NonNull Supplier supplier) {
        Objects.requireNonNull(supplier);
        X cause = null;
        if (GeneralUtils.isInvalid(object)) {
            cause = supplier.get();
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isInvalid()) {
                cause = supplier.get();
            }
        }
        return cause;
    }

    /**
     * xOfInvalidActuator
     * 
The x of invalid actuator method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.SupplierActuator} 
The actuator parameter is SupplierActuator type.
     * @return X 
The x of invalid actuator return object is X type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see io.github.nichetoolkit.rest.actuator.SupplierActuator
     * @see org.springframework.lang.NonNull
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  X xOfInvalidActuator(@Nullable T object, @NonNull SupplierActuator actuator) throws RestException {
        Objects.requireNonNull(actuator);
        X cause = null;
        if (GeneralUtils.isInvalid(object)) {
            cause = actuator.actuate();
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isInvalid()) {
                cause = actuator.actuate();
            }
        }
        return cause;
    }

    /**
     * xOfInvalid
     * 
The x of invalid method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @return X 
The x of invalid return object is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.Function
     * @see org.springframework.lang.NonNull
     */
    public static  X xOfInvalid(@Nullable T object, String message, @NonNull Function function) {
        Objects.requireNonNull(function);
        X cause = null;
        if (GeneralUtils.isInvalid(object)) {
            cause = function.apply(message);
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isInvalid()) {
                cause = function.apply(message);
            }
        }
        return cause;
    }

    /**
     * xOfInvalidActuator
     * 
The x of invalid actuator method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.FunctionActuator} 
The actuator parameter is FunctionActuator type.
     * @return X 
The x of invalid actuator return object is X type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.FunctionActuator
     * @see org.springframework.lang.NonNull
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  X xOfInvalidActuator(@Nullable T object, String message, @NonNull FunctionActuator actuator) throws RestException {
        Objects.requireNonNull(actuator);
        X cause = null;
        if (GeneralUtils.isInvalid(object)) {
            cause = actuator.actuate(message);
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isInvalid()) {
                cause = actuator.actuate(message);
            }
        }
        return cause;
    }

    /**
     * xOfInvalid
     * 
The x of invalid method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @return X 
The x of invalid return object is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.BiFunction
     * @see org.springframework.lang.NonNull
     */
    public static  X xOfInvalid(@Nullable T object, String message, String resource, @NonNull BiFunction function) {
        Objects.requireNonNull(function);
        X cause = null;
        if (GeneralUtils.isInvalid(object)) {
            cause = function.apply(resource, message);
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isInvalid()) {
                cause = function.apply(resource, message);
            }
        }
        return cause;
    }

    /**
     * xOfInvalidActuator
     * 
The x of invalid actuator method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.BiFunctionActuator} 
The actuator parameter is BiFunctionActuator type.
     * @return X 
The x of invalid actuator return object is X type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.BiFunctionActuator
     * @see org.springframework.lang.NonNull
     */
    public static  X xOfInvalidActuator(@Nullable T object, String message, String resource, @NonNull BiFunctionActuator actuator) throws RestException {
        Objects.requireNonNull(actuator);
        X cause = null;
        if (GeneralUtils.isInvalid(object)) {
            cause = actuator.actuate(resource, message);
        } else if (object instanceof RestOptional) {
            RestOptional optional = (RestOptional) object;
            if (optional.isInvalid()) {
                cause = actuator.actuate(resource, message);
            }
        }
        return cause;
    }

    /**
     * ofCauseThrow
     * 
The of cause throw method.
     * @param    {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param cause X 
The cause parameter is X type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     */
    public static  void ofCauseThrow(X cause) throws X {
        if (GeneralUtils.isNotNull(cause)) {
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofCauseThrow
     * 
The of cause throw method.
     * @param    {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param log   {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param cause X 
The cause parameter is X type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.slf4j.Logger
     */
    public static  void ofCauseThrow(Logger log, X cause) throws X {
        if (GeneralUtils.isNotNull(cause)) {
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofCauseThrowError
     * 
The of cause throw error method.
     * @param    {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param cause X 
The cause parameter is X type.
     * @see io.github.nichetoolkit.rest.RestError
     */
    public static  void ofCauseThrowError(X cause) {
        if (GeneralUtils.isNotNull(cause)) {
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofCauseThrowError
     * 
The of cause throw error method.
     * @param    {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param log   {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param cause X 
The cause parameter is X type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.slf4j.Logger
     */
    public static  void ofCauseThrowError(Logger log, X cause) {
        if (GeneralUtils.isNotNull(cause)) {
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofCauseThrowException
     * 
The of cause throw exception method.
     * @param    {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param cause {@link io.github.nichetoolkit.rest.RestException} 
The cause parameter is RestException type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofCauseThrowException(RestException cause) throws RestException {
        if (GeneralUtils.isNotNull(cause)) {
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofCauseThrowException
     * 
The of cause throw exception method.
     * @param    {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param log   {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param cause {@link io.github.nichetoolkit.rest.RestException} 
The cause parameter is RestException type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.slf4j.Logger
     */
    public static  void ofCauseThrowException(Logger log, RestException cause) throws RestException {
        if (GeneralUtils.isNotNull(cause)) {
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofTrueThrow
     * 
The of true throw method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.util.function.Supplier
     * @see X
     */
    public static  void ofTrueThrow(Boolean present, Supplier supplier) throws X {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = supplier.get();
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofTrueThrow
     * 
The of true throw method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see org.slf4j.Logger
     * @see java.util.function.Supplier
     * @see X
     */
    public static  void ofTrueThrow(Boolean present, Logger log, Supplier supplier) throws X {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = supplier.get();
            log.error(cause.getMessage());
            throw cause;
        }
    }


    /**
     * ofTrueThrowError
     * 
The of true throw error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.util.function.Supplier
     */
    public static  void ofTrueThrowError(Boolean present, Supplier supplier) {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = supplier.get();
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofTrueThrowError
     * 
The of true throw error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see org.slf4j.Logger
     * @see java.util.function.Supplier
     */
    public static  void ofTrueThrowError(Boolean present, Logger log, Supplier supplier) {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = supplier.get();
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofTrueThrowException
     * 
The of true throw exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.SupplierActuator} 
The actuator parameter is SupplierActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see io.github.nichetoolkit.rest.actuator.SupplierActuator
     */
    public static  void ofTrueThrowException(Boolean present, SupplierActuator actuator) throws RestException {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = actuator.actuate();
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofTrueThrowException
     * 
The of true throw exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.SupplierActuator} 
The actuator parameter is SupplierActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.SupplierActuator
     */
    public static  void ofTrueThrowException(Boolean present, Logger log, SupplierActuator actuator) throws RestException {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = actuator.actuate();
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofTrueThrow
     * 
The of true throw method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see java.util.function.Function
     * @see X
     */
    public static  void ofTrueThrow(Boolean present, String message, Function function) throws X {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = function.apply(message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofTrueThrow
     * 
The of true throw method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.Function
     * @see X
     */
    public static  void ofTrueThrow(Boolean present, String message, Logger log, Function function) throws X {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = function.apply(message);
            log.error(cause.getMessage());
            throw cause;
        }
    }


    /**
     * ofTrueThrowError
     * 
The of true throw error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see java.util.function.Function
     */
    public static  void ofTrueThrowError(Boolean present, String message, Function function) {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = function.apply(message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofTrueThrowError
     * 
The of true throw error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.Function
     */
    public static  void ofTrueThrowError(Boolean present, String message, Logger log, Function function) {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = function.apply(message);
            log.error(cause.getMessage());
            throw cause;
        }
    }


    /**
     * ofTrueThrowException
     * 
The of true throw exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.FunctionActuator} 
The actuator parameter is FunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.FunctionActuator
     */
    public static  void ofTrueThrowException(Boolean present, String message, FunctionActuator actuator) throws RestException {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = actuator.actuate(message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofTrueThrowException
     * 
The of true throw exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.FunctionActuator} 
The actuator parameter is FunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.FunctionActuator
     */
    public static  void ofTrueThrowException(Boolean present, String message, Logger log, FunctionActuator actuator) throws RestException {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = actuator.actuate(message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofTrueThrow
     * 
The of true throw method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see java.util.function.BiFunction
     * @see X
     */
    public static  void ofTrueThrow(Boolean present, String message, String resource, BiFunction function) throws X {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = function.apply(resource, message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofTrueThrow
     * 
The of true throw method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.BiFunction
     * @see X
     */
    public static  void ofTrueThrow(Boolean present, String message, String resource, Logger log, BiFunction function) throws X {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = function.apply(resource, message);
            log.error(cause.getMessage());
            throw cause;
        }
    }


    /**
     * ofTrueThrowError
     * 
The of true throw error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see java.util.function.BiFunction
     */
    public static  void ofTrueThrowError(Boolean present, String message, String resource, BiFunction function) {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = function.apply(resource, message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofTrueThrowError
     * 
The of true throw error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.BiFunction
     */
    public static  void ofTrueThrowError(Boolean present, String message, String resource, Logger log, BiFunction function) {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = function.apply(resource, message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofTrueThrowException
     * 
The of true throw exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.BiFunctionActuator} 
The actuator parameter is BiFunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.BiFunctionActuator
     */
    public static  void ofTrueThrowException(Boolean present, String message, String resource, BiFunctionActuator actuator) throws RestException {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = actuator.actuate(resource, message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofTrueThrowException
     * 
The of true throw exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.BiFunctionActuator} 
The actuator parameter is BiFunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.BiFunctionActuator
     */
    public static  void ofTrueThrowException(Boolean present, String message, String resource, Logger log, BiFunctionActuator actuator) throws RestException {
        if (GeneralUtils.isNotNull(present) && present) {
            X cause = actuator.actuate(resource, message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofFalseThrow
     * 
The of false throw method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.util.function.Supplier
     * @see X
     */
    public static  void ofFalseThrow(Boolean present, Supplier supplier) throws X {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = supplier.get();
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofFalseThrow
     * 
The of false throw method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see org.slf4j.Logger
     * @see java.util.function.Supplier
     * @see X
     */
    public static  void ofFalseThrow(Boolean present, Logger log, Supplier supplier) throws X {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = supplier.get();
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofFalseThrowError
     * 
The of false throw error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.util.function.Supplier
     */
    public static  void ofFalseThrowError(Boolean present, Supplier supplier) {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = supplier.get();
            log.error(cause.getMessage());
            throw cause;
        }
    }


    /**
     * ofFalseThrowError
     * 
The of false throw error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see org.slf4j.Logger
     * @see java.util.function.Supplier
     */
    public static  void ofFalseThrowError(Boolean present, Logger log, Supplier supplier) {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = supplier.get();
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofFalseThrowException
     * 
The of false throw exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.SupplierActuator} 
The actuator parameter is SupplierActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see io.github.nichetoolkit.rest.actuator.SupplierActuator
     */
    public static  void ofFalseThrowException(Boolean present, SupplierActuator actuator) throws RestException {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = actuator.actuate();
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofFalseThrowException
     * 
The of false throw exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.SupplierActuator} 
The actuator parameter is SupplierActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.SupplierActuator
     */
    public static  void ofFalseThrowException(Boolean present, Logger log, SupplierActuator actuator) throws RestException {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = actuator.actuate();
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofFalseThrow
     * 
The of false throw method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see java.util.function.Function
     * @see X
     */
    public static  void ofFalseThrow(Boolean present, String message, Function function) throws X {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = function.apply(message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofFalseThrow
     * 
The of false throw method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.Function
     * @see X
     */
    public static  void ofFalseThrow(Boolean present, String message, Logger log, Function function) throws X {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = function.apply(message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofFalseThrowError
     * 
The of false throw error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see java.util.function.Function
     */
    public static  void ofFalseThrowError(Boolean present, String message, Function function) {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = function.apply(message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofFalseThrowError
     * 
The of false throw error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.Function
     */
    public static  void ofFalseThrowError(Boolean present, String message, Logger log, Function function) {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = function.apply(message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofFalseThrowException
     * 
The of false throw exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.FunctionActuator} 
The actuator parameter is FunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.FunctionActuator
     */
    public static  void ofFalseThrowException(Boolean present, String message, FunctionActuator actuator) throws RestException {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = actuator.actuate(message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofFalseThrowException
     * 
The of false throw exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.FunctionActuator} 
The actuator parameter is FunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.FunctionActuator
     */
    public static  void ofFalseThrowException(Boolean present, String message, Logger log, FunctionActuator actuator) throws RestException {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = actuator.actuate(message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofFalseThrow
     * 
The of false throw method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see java.util.function.BiFunction
     * @see X
     */
    public static  void ofFalseThrow(Boolean present, String message, String resource, BiFunction function) throws X {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = function.apply(resource, message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofFalseThrow
     * 
The of false throw method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.BiFunction
     * @see X
     */
    public static  void ofFalseThrow(Boolean present, String message, String resource, Logger log, BiFunction function) throws X {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = function.apply(resource, message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofFalseThrowError
     * 
The of false throw error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see java.util.function.BiFunction
     */
    public static  void ofFalseThrowError(Boolean present, String message, String resource, BiFunction function) {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = function.apply(resource, message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofFalseThrowError
     * 
The of false throw error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.BiFunction
     */
    public static  void ofFalseThrowError(Boolean present, String message, String resource, Logger log, BiFunction function) {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = function.apply(resource, message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofFalseThrowException
     * 
The of false throw exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.BiFunctionActuator} 
The actuator parameter is BiFunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.BiFunctionActuator
     */
    public static  void ofFalseThrowException(Boolean present, String message, String resource, BiFunctionActuator actuator) throws RestException {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = actuator.actuate(resource, message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofFalseThrowException
     * 
The of false throw exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.BiFunctionActuator} 
The actuator parameter is BiFunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.BiFunctionActuator
     */
    public static  void ofFalseThrowException(Boolean present, String message, String resource, Logger log, BiFunctionActuator actuator) throws RestException {
        if (GeneralUtils.isNotNull(present) && !present) {
            X cause = actuator.actuate(resource, message);
            log.error(cause.getMessage());
            throw cause;
        }
    }

    /**
     * ofNull
     * 
The of null method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.util.function.Supplier
     * @see org.springframework.lang.NonNull
     * @see X
     */
    public static  void ofNull(@Nullable T object, @NonNull Supplier supplier) throws X {
        ofCauseThrow(xOfNull(object, supplier));
    }

    /**
     * ofNull
     * 
The of null method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see org.slf4j.Logger
     * @see java.util.function.Supplier
     * @see org.springframework.lang.NonNull
     * @see X
     */
    public static  void ofNull(@Nullable T object, Logger log, @NonNull Supplier supplier) throws X {
        ofCauseThrow(log, xOfNull(object, supplier));
    }

    /**
     * ofNullError
     * 
The of null error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see java.util.function.Supplier
     * @see org.springframework.lang.NonNull
     */
    public static  void ofNullError(@Nullable T object, @NonNull Supplier supplier) {
        ofCauseThrowError(xOfNull(object, supplier));
    }

    /**
     * ofNullError
     * 
The of null error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see org.slf4j.Logger
     * @see java.util.function.Supplier
     * @see org.springframework.lang.NonNull
     */
    public static  void ofNullError(@Nullable T object, Logger log, @NonNull Supplier supplier) {
        ofCauseThrowError(log, xOfNull(object, supplier));
    }

    /**
     * ofNullException
     * 
The of null exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.SupplierActuator} 
The actuator parameter is SupplierActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see io.github.nichetoolkit.rest.actuator.SupplierActuator
     * @see org.springframework.lang.NonNull
     */
    public static  void ofNullException(@Nullable T object, @NonNull SupplierActuator actuator) throws RestException {
        ofCauseThrowException(xOfNullActuator(object, actuator));
    }

    /**
     * ofNullException
     * 
The of null exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.SupplierActuator} 
The actuator parameter is SupplierActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.SupplierActuator
     * @see org.springframework.lang.NonNull
     */
    public static  void ofNullException(@Nullable T object, Logger log, @NonNull SupplierActuator actuator) throws RestException {
        ofCauseThrowException(log, xOfNullActuator(object, actuator));
    }

    /**
     * ofEmpty
     * 
The of empty method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.util.function.Supplier
     * @see org.springframework.lang.NonNull
     * @see X
     */
    public static  void ofEmpty(@Nullable T object, @NonNull Supplier supplier) throws X {
        ofCauseThrow(xOfEmpty(object, supplier));
    }

    /**
     * ofEmpty
     * 
The of empty method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see org.slf4j.Logger
     * @see java.util.function.Supplier
     * @see org.springframework.lang.NonNull
     * @see X
     */
    public static  void ofEmpty(@Nullable T object, Logger log, @NonNull Supplier supplier) throws X {
        ofCauseThrow(log, xOfEmpty(object, supplier));
    }

    /**
     * ofEmptyError
     * 
The of empty error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see java.util.function.Supplier
     * @see org.springframework.lang.NonNull
     */
    public static  void ofEmptyError(@Nullable T object, @NonNull Supplier supplier) {
        ofCauseThrowError(xOfEmpty(object, supplier));
    }

    /**
     * ofEmptyError
     * 
The of empty error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see org.slf4j.Logger
     * @see java.util.function.Supplier
     * @see org.springframework.lang.NonNull
     */
    public static  void ofEmptyError(@Nullable T object, Logger log, @NonNull Supplier supplier) {
        ofCauseThrowError(log, xOfEmpty(object, supplier));
    }

    /**
     * ofEmptyException
     * 
The of empty exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.SupplierActuator} 
The actuator parameter is SupplierActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see io.github.nichetoolkit.rest.actuator.SupplierActuator
     * @see org.springframework.lang.NonNull
     */
    public static  void ofEmptyException(@Nullable T object, @NonNull SupplierActuator actuator) throws RestException {
        ofCauseThrowException(xOfEmptyActuator(object, actuator));
    }

    /**
     * ofEmptyException
     * 
The of empty exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.SupplierActuator} 
The actuator parameter is SupplierActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.SupplierActuator
     * @see org.springframework.lang.NonNull
     */
    public static  void ofEmptyException(@Nullable T object, Logger log, @NonNull SupplierActuator actuator) throws RestException {
        ofCauseThrowException(log, xOfEmptyActuator(object, actuator));
    }

    /**
     * ofInvalid
     * 
The of invalid method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.util.function.Supplier
     * @see org.springframework.lang.NonNull
     * @see X
     */
    public static  void ofInvalid(@Nullable T object, @NonNull Supplier supplier) throws X {
        ofCauseThrow(xOfInvalid(object, supplier));
    }

    /**
     * ofInvalid
     * 
The of invalid method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see org.slf4j.Logger
     * @see java.util.function.Supplier
     * @see org.springframework.lang.NonNull
     * @see X
     */
    public static  void ofInvalid(@Nullable T object, Logger log, @NonNull Supplier supplier) throws X {
        ofCauseThrow(log, xOfInvalid(object, supplier));
    }

    /**
     * ofInvalidError
     * 
The of invalid error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see java.util.function.Supplier
     * @see org.springframework.lang.NonNull
     */
    public static  void ofInvalidError(@Nullable T object, @NonNull Supplier supplier) {
        ofCauseThrowError(xOfInvalid(object, supplier));
    }

    /**
     * ofInvalidError
     * 
The of invalid error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see org.slf4j.Logger
     * @see java.util.function.Supplier
     * @see org.springframework.lang.NonNull
     */
    public static  void ofInvalidError(@Nullable T object, Logger log, @NonNull Supplier supplier) {
        ofCauseThrowError(log, xOfInvalid(object, supplier));
    }

    /**
     * ofInvalidException
     * 
The of invalid exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.SupplierActuator} 
The actuator parameter is SupplierActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see io.github.nichetoolkit.rest.actuator.SupplierActuator
     * @see org.springframework.lang.NonNull
     */
    public static  void ofInvalidException(@Nullable T object, @NonNull SupplierActuator actuator) throws RestException {
        ofCauseThrowException(xOfInvalidActuator(object, actuator));
    }

    /**
     * ofInvalidException
     * 
The of invalid exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.SupplierActuator} 
The actuator parameter is SupplierActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.SupplierActuator
     * @see org.springframework.lang.NonNull
     */
    public static  void ofInvalidException(@Nullable T object, Logger log, @NonNull SupplierActuator actuator) throws RestException {
        ofCauseThrowException(log, xOfInvalidActuator(object, actuator));
    }

    /**
     * ofNull
     * 
The of null method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.Function
     * @see X
     */
    public static  void ofNull(@Nullable T object, String message, Function function) throws X {
        ofCauseThrow(xOfNull(object, message, function));
    }

    /**
     * ofNull
     * 
The of null method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.Function
     * @see X
     */
    public static  void ofNull(@Nullable T object, String message, Logger log, Function function) throws X {
        ofCauseThrow(log, xOfNull(object, message, function));
    }

    /**
     * ofNullError
     * 
The of null error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.Function
     */
    public static  void ofNullError(@Nullable T object, String message, Function function) {
        ofCauseThrowError(xOfNull(object, message, function));
    }

    /**
     * ofNullError
     * 
The of null error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.Function
     */
    public static  void ofNullError(@Nullable T object, String message, Logger log, Function function) {
        ofCauseThrowError(log, xOfNull(object, message, function));
    }

    /**
     * ofNullException
     * 
The of null exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.FunctionActuator} 
The actuator parameter is FunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.FunctionActuator
     */
    public static  void ofNullException(@Nullable T object, String message, FunctionActuator actuator) throws RestException {
        ofCauseThrowException(xOfNullActuator(object, message, actuator));
    }

    /**
     * ofNullException
     * 
The of null exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.FunctionActuator} 
The actuator parameter is FunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.FunctionActuator
     */
    public static  void ofNullException(@Nullable T object, String message, Logger log, FunctionActuator actuator) throws RestException {
        ofCauseThrowException(log, xOfNullActuator(object, message, actuator));
    }

    /**
     * ofEmpty
     * 
The of empty method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.Function
     * @see X
     */
    public static  void ofEmpty(@Nullable T object, String message, Function function) throws X {
        ofCauseThrow(xOfEmpty(object, message, function));
    }

    /**
     * ofEmpty
     * 
The of empty method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.Function
     * @see X
     */
    public static  void ofEmpty(@Nullable T object, String message, Logger log, Function function) throws X {
        ofCauseThrow(log, xOfEmpty(object, message, function));
    }

    /**
     * ofEmptyError
     * 
The of empty error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.Function
     */
    public static  void ofEmptyError(@Nullable T object, String message, Function function) {
        ofCauseThrowError(xOfEmpty(object, message, function));
    }

    /**
     * ofEmptyError
     * 
The of empty error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.Function
     */
    public static  void ofEmptyError(@Nullable T object, String message, Logger log, Function function) {
        ofCauseThrowError(log, xOfEmpty(object, message, function));
    }

    /**
     * ofEmptyException
     * 
The of empty exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.FunctionActuator} 
The actuator parameter is FunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.FunctionActuator
     */
    public static  void ofEmptyException(@Nullable T object, String message, FunctionActuator actuator) throws RestException {
        ofCauseThrowException(xOfEmptyActuator(object, message, actuator));
    }

    /**
     * ofEmptyException
     * 
The of empty exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.FunctionActuator} 
The actuator parameter is FunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.FunctionActuator
     */
    public static  void ofEmptyException(@Nullable T object, String message, Logger log, FunctionActuator actuator) throws RestException {
        ofCauseThrowException(log, xOfEmptyActuator(object, message, actuator));
    }

    /**
     * ofInvalid
     * 
The of invalid method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.Function
     * @see X
     */
    public static  void ofInvalid(@Nullable T object, String message, Function function) throws X {
        ofCauseThrow(xOfInvalid(object, message, function));
    }

    /**
     * ofInvalid
     * 
The of invalid method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.Function
     * @see X
     */
    public static  void ofInvalid(@Nullable T object, String message, Logger log, Function function) throws X {
        ofCauseThrow(log, xOfInvalid(object, message, function));
    }

    /**
     * ofInvalidError
     * 
The of invalid error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.Function
     */
    public static  void ofInvalidError(@Nullable T object, String message, Function function) {
        ofCauseThrowError(xOfInvalid(object, message, function));
    }

    /**
     * ofInvalidError
     * 
The of invalid error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.Function
     */
    public static  void ofInvalidError(@Nullable T object, String message, Logger log, Function function) {
        ofCauseThrowError(log, xOfInvalid(object, message, function));
    }

    /**
     * ofInvalidException
     * 
The of invalid exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.FunctionActuator} 
The actuator parameter is FunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.FunctionActuator
     */
    public static  void ofInvalidException(@Nullable T object, String message, FunctionActuator actuator) throws RestException {
        ofCauseThrowException(xOfInvalidActuator(object, message, actuator));
    }

    /**
     * ofInvalidException
     * 
The of invalid exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.FunctionActuator} 
The actuator parameter is FunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.FunctionActuator
     */
    public static  void ofInvalidException(@Nullable T object, String message, Logger log, FunctionActuator actuator) throws RestException {
        ofCauseThrowException(log, xOfInvalidActuator(object, message, actuator));
    }

    /**
     * ofNull
     * 
The of null method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.BiFunction
     * @see X
     */
    public static  void ofNull(@Nullable T object, String message, String resource, BiFunction function) throws X {
        ofCauseThrow(xOfNull(object, message, resource, function));
    }

    /**
     * ofNull
     * 
The of null method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.BiFunction
     * @see X
     */
    public static  void ofNull(@Nullable T object, String message, String resource, Logger log, BiFunction function) throws X {
        ofCauseThrow(log, xOfNull(object, message, resource, function));
    }

    /**
     * ofNullError
     * 
The of null error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.BiFunction
     */
    public static  void ofNullError(@Nullable T object, String message, String resource, BiFunction function) {
        ofCauseThrowError(xOfNull(object, message, resource, function));
    }

    /**
     * ofNullError
     * 
The of null error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.BiFunction
     */
    public static  void ofNullError(@Nullable T object, String message, String resource, Logger log, BiFunction function) {
        ofCauseThrowError(log, xOfNull(object, message, resource, function));
    }

    /**
     * ofNullException
     * 
The of null exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.BiFunctionActuator} 
The actuator parameter is BiFunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.BiFunctionActuator
     */
    public static  void ofNullException(@Nullable T object, String message, String resource, BiFunctionActuator actuator) throws RestException {
        ofCauseThrowException(xOfNullActuator(object, message, resource, actuator));
    }

    /**
     * ofNullException
     * 
The of null exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.BiFunctionActuator} 
The actuator parameter is BiFunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.BiFunctionActuator
     */
    public static  void ofNullException(@Nullable T object, String message, String resource, Logger log, BiFunctionActuator actuator) throws RestException {
        ofCauseThrowException(log, xOfNullActuator(object, message, resource, actuator));
    }

    /**
     * ofEmpty
     * 
The of empty method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.BiFunction
     * @see X
     */
    public static  void ofEmpty(@Nullable T object, String message, String resource, BiFunction function) throws X {
        ofCauseThrow(xOfEmpty(object, message, resource, function));
    }

    /**
     * ofEmpty
     * 
The of empty method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.BiFunction
     * @see X
     */
    public static  void ofEmpty(@Nullable T object, String message, String resource, Logger log, BiFunction function) throws X {
        ofCauseThrow(log, xOfEmpty(object, message, resource, function));
    }

    /**
     * ofEmptyError
     * 
The of empty error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.BiFunction
     */
    public static  void ofEmptyError(@Nullable T object, String message, String resource, BiFunction function) {
        ofCauseThrowError(xOfEmpty(object, message, resource, function));
    }

    /**
     * ofEmptyError
     * 
The of empty error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.BiFunction
     */
    public static  void ofEmptyError(@Nullable T object, String message, String resource, Logger log, BiFunction function) {
        ofCauseThrowError(log, xOfEmpty(object, message, resource, function));
    }

    /**
     * ofEmptyException
     * 
The of empty exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.BiFunctionActuator} 
The actuator parameter is BiFunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.BiFunctionActuator
     */
    public static  void ofEmptyException(@Nullable T object, String message, String resource, BiFunctionActuator actuator) throws RestException {
        ofCauseThrowException(xOfEmptyActuator(object, message, resource, actuator));
    }

    /**
     * ofEmptyException
     * 
The of empty exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.BiFunctionActuator} 
The actuator parameter is BiFunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.BiFunctionActuator
     */
    public static  void ofEmptyException(@Nullable T object, String message, String resource, Logger log, BiFunctionActuator actuator) throws RestException {
        ofCauseThrowException(log, xOfEmptyActuator(object, message, resource, actuator));
    }

    /**
     * ofInvalid
     * 
The of invalid method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.BiFunction
     * @see X
     */
    public static  void ofInvalid(@Nullable T object, String message, String resource, BiFunction function) throws X {
        ofCauseThrow(xOfInvalid(object, message, resource, function));
    }

    /**
     * ofInvalid
     * 
The of invalid method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.BiFunction
     * @see X
     */
    public static  void ofInvalid(@Nullable T object, String message, String resource, Logger log, BiFunction function) throws X {
        ofCauseThrow(log, xOfInvalid(object, message, resource, function));
    }

    /**
     * ofInvalidError
     * 
The of invalid error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see java.util.function.BiFunction
     */
    public static  void ofInvalidError(@Nullable T object, String message, String resource, BiFunction function) {
        ofCauseThrowError(xOfInvalid(object, message, resource, function));
    }

    /**
     * ofInvalidError
     * 
The of invalid error method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.BiFunction
     */
    public static  void ofInvalidError(@Nullable T object, String message, String resource, Logger log, BiFunction function) {
        ofCauseThrowError(log, xOfInvalid(object, message, resource, function));
    }

    /**
     * ofInvalidException
     * 
The of invalid exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.BiFunctionActuator} 
The actuator parameter is BiFunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.BiFunctionActuator
     */
    public static  void ofInvalidException(@Nullable T object, String message, String resource, BiFunctionActuator actuator) throws RestException {
        ofCauseThrowException(xOfInvalidActuator(object, message, resource, actuator));
    }

    /**
     * ofInvalidException
     * 
The of invalid exception method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param object   T 
The object parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.BiFunctionActuator} 
The actuator parameter is BiFunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see org.springframework.lang.Nullable
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.BiFunctionActuator
     */
    public static  void ofInvalidException(@Nullable T object, String message, String resource, Logger log, BiFunctionActuator actuator) throws RestException {
        ofCauseThrowException(log, xOfInvalidActuator(object, message, resource, actuator));
    }

    /**
     * ofTrue
     * 
The of true method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.util.function.Supplier
     * @see X
     */
    public static  void ofTrue(Boolean present, Supplier supplier) throws X {
        ofTrueThrow(present, supplier);
    }

    /**
     * ofTrue
     * 
The of true method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see org.slf4j.Logger
     * @see java.util.function.Supplier
     * @see X
     */
    public static  void ofTrue(Boolean present, Logger log, Supplier supplier) throws X {
        ofTrueThrow(present, log, supplier);
    }

    /**
     * ofTrueError
     * 
The of true error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.util.function.Supplier
     */
    public static  void ofTrueError(Boolean present, Supplier supplier) {
        ofTrueThrowError(present, supplier);
    }

    /**
     * ofTrueError
     * 
The of true error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see org.slf4j.Logger
     * @see java.util.function.Supplier
     */
    public static  void ofTrueError(Boolean present, Logger log, Supplier supplier) {
        ofTrueThrowError(present, log, supplier);
    }

    /**
     * ofTrueException
     * 
The of true exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.SupplierActuator} 
The actuator parameter is SupplierActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see io.github.nichetoolkit.rest.actuator.SupplierActuator
     */
    public static  void ofTrueException(Boolean present, SupplierActuator actuator) throws RestException {
        ofTrueThrowException(present, actuator);
    }

    /**
     * ofTrueException
     * 
The of true exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.SupplierActuator} 
The actuator parameter is SupplierActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.SupplierActuator
     */
    public static  void ofTrueException(Boolean present, Logger log, SupplierActuator actuator) throws RestException {
        ofTrueThrowException(present, log, actuator);
    }

    /**
     * ofTrue
     * 
The of true method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see java.util.function.Function
     * @see X
     */
    public static  void ofTrue(Boolean present, String message, Function function) throws X {
        ofTrueThrow(present, message, function);
    }

    /**
     * ofTrue
     * 
The of true method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.Function
     * @see X
     */
    public static  void ofTrue(Boolean present, String message, Logger log, Function function) throws X {
        ofTrueThrow(present, message, log, function);
    }

    /**
     * ofTrueError
     * 
The of true error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see java.util.function.Function
     */
    public static  void ofTrueError(Boolean present, String message, Function function) {
        ofTrueThrowError(present, message, function);
    }

    /**
     * ofTrueError
     * 
The of true error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.Function
     */
    public static  void ofTrueError(Boolean present, String message, Logger log, Function function) {
        ofTrueThrowError(present, message, log, function);
    }

    /**
     * ofTrueException
     * 
The of true exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.FunctionActuator} 
The actuator parameter is FunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.FunctionActuator
     */
    public static  void ofTrueException(Boolean present, String message, FunctionActuator actuator) throws RestException {
        ofTrueThrowException(present, message, actuator);
    }

    /**
     * ofTrueException
     * 
The of true exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.FunctionActuator} 
The actuator parameter is FunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.FunctionActuator
     */
    public static  void ofTrueException(Boolean present, String message, Logger log, FunctionActuator actuator) throws RestException {
        ofTrueThrowException(present, message, log, actuator);
    }

    /**
     * ofTrue
     * 
The of true method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see java.util.function.BiFunction
     * @see X
     */
    public static  void ofTrue(Boolean present, String message, String resource, BiFunction function) throws X {
        ofTrueThrow(present, message, resource, function);
    }

    /**
     * ofTrue
     * 
The of true method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.BiFunction
     * @see X
     */
    public static  void ofTrue(Boolean present, String message, String resource, Logger log, BiFunction function) throws X {
        ofTrueThrow(present, message, resource, log, function);
    }

    /**
     * ofTrueError
     * 
The of true error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see java.util.function.BiFunction
     */
    public static  void ofTrueError(Boolean present, String message, String resource, BiFunction function) {
        ofTrueThrowError(present, message, resource, function);
    }

    /**
     * ofTrueError
     * 
The of true error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.BiFunction
     */
    public static  void ofTrueError(Boolean present, String message, String resource, Logger log, BiFunction function) {
        ofTrueThrowError(present, message, resource, log, function);
    }

    /**
     * ofTrueException
     * 
The of true exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.BiFunctionActuator} 
The actuator parameter is BiFunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.BiFunctionActuator
     */
    public static  void ofTrueException(Boolean present, String message, String resource, BiFunctionActuator actuator) throws RestException {
        ofTrueThrowException(present, message, resource, actuator);
    }

    /**
     * ofTrueException
     * 
The of true exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.BiFunctionActuator} 
The actuator parameter is BiFunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.BiFunctionActuator
     */
    public static  void ofTrueException(Boolean present, String message, String resource, Logger log, BiFunctionActuator actuator) throws RestException {
        ofTrueThrowException(present, message, resource, log, actuator);
    }

    /**
     * ofFalse
     * 
The of false method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.util.function.Supplier
     * @see X
     */
    public static  void ofFalse(Boolean present, Supplier supplier) throws X {
        ofFalseThrow(present, supplier);
    }

    /**
     * ofFalse
     * 
The of false method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see org.slf4j.Logger
     * @see java.util.function.Supplier
     * @see X
     */
    public static  void ofFalse(Boolean present, Logger log, Supplier supplier) throws X {
        ofFalseThrow(present, log, supplier);
    }

    /**
     * ofFalseError
     * 
The of false error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.util.function.Supplier
     */
    public static  void ofFalseError(Boolean present, Supplier supplier) {
        ofFalseThrowError(present, supplier);
    }

    /**
     * ofFalseError
     * 
The of false error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param supplier {@link java.util.function.Supplier} 
The supplier parameter is Supplier type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see org.slf4j.Logger
     * @see java.util.function.Supplier
     */
    public static  void ofFalseError(Boolean present, Logger log, Supplier supplier) {
        ofFalseThrowError(present, log, supplier);
    }

    /**
     * ofFalseException
     * 
The of false exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.SupplierActuator} 
The actuator parameter is SupplierActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see io.github.nichetoolkit.rest.actuator.SupplierActuator
     */
    public static  void ofFalseException(Boolean present, SupplierActuator actuator) throws RestException {
        ofFalseThrowException(present, actuator);
    }

    /**
     * ofFalseException
     * 
The of false exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.SupplierActuator} 
The actuator parameter is SupplierActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.SupplierActuator
     */
    public static  void ofFalseException(Boolean present, Logger log, SupplierActuator actuator) throws RestException {
        ofFalseThrowException(present, log, actuator);
    }

    /**
     * ofFalse
     * 
The of false method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see java.util.function.Function
     * @see X
     */
    public static  void ofFalse(Boolean present, String message, Function function) throws X {
        ofFalseThrow(present, message, function);
    }

    /**
     * ofFalse
     * 
The of false method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.Function
     * @see X
     */
    public static  void ofFalse(Boolean present, String message, Logger log, Function function) throws X {
        ofFalseThrow(present, message, log, function);
    }

    /**
     * ofFalseError
     * 
The of false error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see java.util.function.Function
     */
    public static  void ofFalseError(Boolean present, String message, Function function) {
        ofFalseThrowError(present, message, function);
    }

    /**
     * ofFalseError
     * 
The of false error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.Function} 
The function parameter is Function type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.Function
     */
    public static  void ofFalseError(Boolean present, String message, Logger log, Function function) {
        ofFalseThrowError(present, message, log, function);
    }

    /**
     * ofFalseException
     * 
The of false exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.FunctionActuator} 
The actuator parameter is FunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.FunctionActuator
     */
    public static  void ofFalseException(Boolean present, String message, FunctionActuator actuator) throws RestException {
        ofFalseThrowException(present, message, actuator);
    }

    /**
     * ofFalseException
     * 
The of false exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.FunctionActuator} 
The actuator parameter is FunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.FunctionActuator
     */
    public static  void ofFalseException(Boolean present, String message, Logger log, FunctionActuator actuator) throws RestException {
        ofFalseThrowException(present, message, log, actuator);
    }

    /**
     * ofFalse
     * 
The of false method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see java.util.function.BiFunction
     * @see X
     */
    public static  void ofFalse(Boolean present, String message, String resource, BiFunction function) throws X {
        ofFalseThrow(present, message, resource, function);
    }

    /**
     * ofFalse
     * 
The of false method.
     * @param       {@link java.lang.Throwable} 
The generic parameter is Throwable type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @throws X X 
The x is X type.
     * @see java.lang.Throwable
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.BiFunction
     * @see X
     */
    public static  void ofFalse(Boolean present, String message, String resource, Logger log, BiFunction function) throws X {
        ofFalseThrow(present, message, resource, log, function);
    }

    /**
     * ofFalseError
     * 
The of false error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see java.util.function.BiFunction
     */
    public static  void ofFalseError(Boolean present, String message, String resource, BiFunction function) {
        ofFalseThrowError(present, message, resource, function);
    }

    /**
     * ofFalseError
     * 
The of false error method.
     * @param       {@link io.github.nichetoolkit.rest.RestError} 
The generic parameter is RestError type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param function {@link java.util.function.BiFunction} 
The function parameter is BiFunction type.
     * @see io.github.nichetoolkit.rest.RestError
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see java.util.function.BiFunction
     */
    public static  void ofFalseError(Boolean present, String message, String resource, Logger log, BiFunction function) {
        ofFalseThrowError(present, message, resource, log, function);
    }

    /**
     * ofFalseException
     * 
The of false exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.BiFunctionActuator} 
The actuator parameter is BiFunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.actuator.BiFunctionActuator
     */
    public static  void ofFalseException(Boolean present, String message, String resource, BiFunctionActuator actuator) throws RestException {
        ofFalseThrowException(present, message, resource, actuator);
    }

    /**
     * ofFalseException
     * 
The of false exception method.
     * @param       {@link io.github.nichetoolkit.rest.RestException} 
The generic parameter is RestException type.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @param actuator {@link io.github.nichetoolkit.rest.actuator.BiFunctionActuator} 
The actuator parameter is BiFunctionActuator type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.actuator.BiFunctionActuator
     */
    public static  void ofFalseException(Boolean present, String message, String resource, Logger log, BiFunctionActuator actuator) throws RestException {
        ofFalseThrowException(present, message, resource, log, actuator);
    }

    /**
     * ofFieldNull
     * 
The of field null method.
     * @param    {@link java.lang.Object} 
The parameter can be of any type.
     * @param field T 
The field parameter is T type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldNull(T field) throws RestException {
        ofNullException(field, FieldNullException::new);
    }

    /**
     * ofFieldNull
     * 
The of field null method.
     * @param    {@link java.lang.Object} 
The parameter can be of any type.
     * @param field T 
The field parameter is T type.
     * @param log   {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldNull(T field, Logger log) throws RestException {
        ofNullException(field, log, FieldNullException::new);
    }

    /**
     * ofFieldNull
     * 
The of field null method.
     * @param      {@link java.lang.Object} 
The parameter can be of any type.
     * @param field   T 
The field parameter is T type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldNull(T field, String message) throws RestException {
        ofNullException(field, message, FieldNullException::new);
    }

    /**
     * ofFieldNull
     * 
The of field null method.
     * @param      {@link java.lang.Object} 
The parameter can be of any type.
     * @param field   T 
The field parameter is T type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldNull(T field, String message, Logger log) throws RestException {
        ofNullException(field, message, log, FieldNullException::new);
    }

    /**
     * ofFieldNull
     * 
The of field null method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param field    T 
The field parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldNull(T field, String message, String resource) throws RestException {
        ofNullException(field, message, resource, FieldNullException::new);
    }

    /**
     * ofFieldNull
     * 
The of field null method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param field    T 
The field parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldNull(T field, String message, String resource, Logger log) throws RestException {
        ofNullException(field, message, resource, log, FieldNullException::new);
    }

    /**
     * ofFieldEmpty
     * 
The of field empty method.
     * @param    {@link java.lang.Object} 
The parameter can be of any type.
     * @param field T 
The field parameter is T type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldEmpty(T field) throws RestException {
        ofEmptyException(field, FieldNullException::new);
    }

    /**
     * ofFieldEmpty
     * 
The of field empty method.
     * @param    {@link java.lang.Object} 
The parameter can be of any type.
     * @param field T 
The field parameter is T type.
     * @param log   {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldEmpty(T field, Logger log) throws RestException {
        ofEmptyException(field, log, FieldNullException::new);
    }

    /**
     * ofFieldEmpty
     * 
The of field empty method.
     * @param      {@link java.lang.Object} 
The parameter can be of any type.
     * @param field   T 
The field parameter is T type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldEmpty(T field, String message) throws RestException {
        ofEmptyException(field, message, FieldNullException::new);
    }

    /**
     * ofFieldEmpty
     * 
The of field empty method.
     * @param      {@link java.lang.Object} 
The parameter can be of any type.
     * @param field   T 
The field parameter is T type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldEmpty(T field, String message, Logger log) throws RestException {
        ofEmptyException(field, message, log, FieldNullException::new);
    }

    /**
     * ofFieldEmpty
     * 
The of field empty method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param field    T 
The field parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldEmpty(T field, String message, String resource) throws RestException {
        ofEmptyException(field, message, resource, FieldNullException::new);
    }

    /**
     * ofFieldEmpty
     * 
The of field empty method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param field    T 
The field parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldEmpty(T field, String message, String resource, Logger log) throws RestException {
        ofEmptyException(field, message, resource, log, FieldNullException::new);
    }

    /**
     * ofFieldInvalid
     * 
The of field invalid method.
     * @param    {@link java.lang.Object} 
The parameter can be of any type.
     * @param field T 
The field parameter is T type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldInvalid(T field) throws RestException {
        ofInvalidException(field, FieldNullException::new);
    }

    /**
     * ofFieldInvalid
     * 
The of field invalid method.
     * @param    {@link java.lang.Object} 
The parameter can be of any type.
     * @param field T 
The field parameter is T type.
     * @param log   {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldInvalid(T field, Logger log) throws RestException {
        ofInvalidException(field, log, FieldNullException::new);
    }

    /**
     * ofFieldInvalid
     * 
The of field invalid method.
     * @param      {@link java.lang.Object} 
The parameter can be of any type.
     * @param field   T 
The field parameter is T type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldInvalid(T field, String message) throws RestException {
        ofInvalidException(field, message, FieldNullException::new);
    }

    /**
     * ofFieldInvalid
     * 
The of field invalid method.
     * @param      {@link java.lang.Object} 
The parameter can be of any type.
     * @param field   T 
The field parameter is T type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldInvalid(T field, String message, Logger log) throws RestException {
        ofInvalidException(field, message, log, FieldNullException::new);
    }

    /**
     * ofFieldInvalid
     * 
The of field invalid method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param field    T 
The field parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldInvalid(T field, String message, String resource) throws RestException {
        ofInvalidException(field, message, resource, FieldNullException::new);
    }

    /**
     * ofFieldInvalid
     * 
The of field invalid method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param field    T 
The field parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofFieldInvalid(T field, String message, String resource, Logger log) throws RestException {
        ofInvalidException(field, message, resource, log, FieldNullException::new);
    }

    /**
     * ofIdNull
     * 
The of id null method.
     * @param  {@link java.lang.Object} 
The parameter can be of any type.
     * @param id  T 
The id parameter is T type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdNull(T id) throws RestException {
        ofNullException(id, IdentityNullException::new);
    }

    /**
     * ofIdNull
     * 
The of id null method.
     * @param  {@link java.lang.Object} 
The parameter can be of any type.
     * @param id  T 
The id parameter is T type.
     * @param log {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdNull(T id, Logger log) throws RestException {
        ofNullException(id, log, IdentityNullException::new);
    }


    /**
     * ofIdNull
     * 
The of id null method.
     * @param      {@link java.lang.Object} 
The parameter can be of any type.
     * @param id      T 
The id parameter is T type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdNull(T id, String message) throws RestException {
        ofNullException(id, message, IdentityNullException::new);
    }

    /**
     * ofIdNull
     * 
The of id null method.
     * @param      {@link java.lang.Object} 
The parameter can be of any type.
     * @param id      T 
The id parameter is T type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdNull(T id, String message, Logger log) throws RestException {
        ofNullException(id, message, log, IdentityNullException::new);
    }

    /**
     * ofIdNull
     * 
The of id null method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param id       T 
The id parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdNull(T id, String message, String resource) throws RestException {
        ofNullException(id, message, resource, IdentityNullException::new);
    }

    /**
     * ofIdNull
     * 
The of id null method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param id       T 
The id parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdNull(T id, String message, String resource, Logger log) throws RestException {
        ofNullException(id, message, resource, log, IdentityNullException::new);
    }

    /**
     * ofIdEmpty
     * 
The of id empty method.
     * @param  {@link java.lang.Object} 
The parameter can be of any type.
     * @param id  T 
The id parameter is T type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdEmpty(T id) throws RestException {
        ofEmptyException(id, IdentityNullException::new);
    }

    /**
     * ofIdEmpty
     * 
The of id empty method.
     * @param  {@link java.lang.Object} 
The parameter can be of any type.
     * @param id  T 
The id parameter is T type.
     * @param log {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdEmpty(T id, Logger log) throws RestException {
        ofEmptyException(id, IdentityNullException::new);
    }

    /**
     * ofIdEmpty
     * 
The of id empty method.
     * @param      {@link java.lang.Object} 
The parameter can be of any type.
     * @param id      T 
The id parameter is T type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdEmpty(T id, String message) throws RestException {
        ofEmptyException(id, message, IdentityNullException::new);
    }

    /**
     * ofIdEmpty
     * 
The of id empty method.
     * @param      {@link java.lang.Object} 
The parameter can be of any type.
     * @param id      T 
The id parameter is T type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdEmpty(T id, String message, Logger log) throws RestException {
        ofEmptyException(id, message, log, IdentityNullException::new);
    }

    /**
     * ofIdEmpty
     * 
The of id empty method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param id       T 
The id parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdEmpty(T id, String message, String resource) throws RestException {
        ofEmptyException(id, message, resource, IdentityNullException::new);
    }

    /**
     * ofIdEmpty
     * 
The of id empty method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param id       T 
The id parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdEmpty(T id, String message, String resource, Logger log) throws RestException {
        ofEmptyException(id, message, resource, log, IdentityNullException::new);
    }

    /**
     * ofIdInvalid
     * 
The of id invalid method.
     * @param  {@link java.lang.Object} 
The parameter can be of any type.
     * @param id  T 
The id parameter is T type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdInvalid(T id) throws RestException {
        ofInvalidException(id, IdentityNullException::new);
    }

    /**
     * ofIdInvalid
     * 
The of id invalid method.
     * @param  {@link java.lang.Object} 
The parameter can be of any type.
     * @param id  T 
The id parameter is T type.
     * @param log {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdInvalid(T id, Logger log) throws RestException {
        ofInvalidException(id, log, IdentityNullException::new);
    }

    /**
     * ofIdInvalid
     * 
The of id invalid method.
     * @param      {@link java.lang.Object} 
The parameter can be of any type.
     * @param id      T 
The id parameter is T type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdInvalid(T id, String message) throws RestException {
        ofInvalidException(id, message, IdentityNullException::new);
    }

    /**
     * ofIdInvalid
     * 
The of id invalid method.
     * @param      {@link java.lang.Object} 
The parameter can be of any type.
     * @param id      T 
The id parameter is T type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdInvalid(T id, String message, Logger log) throws RestException {
        ofInvalidException(id, message, log, IdentityNullException::new);
    }

    /**
     * ofIdInvalid
     * 
The of id invalid method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param id       T 
The id parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdInvalid(T id, String message, String resource) throws RestException {
        ofInvalidException(id, message, resource, IdentityNullException::new);
    }

    /**
     * ofIdInvalid
     * 
The of id invalid method.
     * @param       {@link java.lang.Object} 
The parameter can be of any type.
     * @param id       T 
The id parameter is T type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static  void ofIdInvalid(T id, String message, String resource, Logger log) throws RestException {
        ofInvalidException(id, message, resource, log, IdentityNullException::new);
    }

    /**
     * ofCreate
     * 
The of create method.
     * @param result {@link java.lang.Integer} 
The result parameter is Integer type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofCreate(Integer result) throws RestException {
        ofInvalidException(result, DataCreateException::new);
    }

    /**
     * ofCreate
     * 
The of create method.
     * @param result {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param log    {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofCreate(Integer result, Logger log) throws RestException {
        ofInvalidException(result, log, DataCreateException::new);
    }

    /**
     * ofCreate
     * 
The of create method.
     * @param result  {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofCreate(Integer result, String message) throws RestException {
        ofInvalidException(result, message, DataCreateException::new);
    }

    /**
     * ofCreate
     * 
The of create method.
     * @param result  {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofCreate(Integer result, String message, Logger log) throws RestException {
        ofInvalidException(result, message, log, DataCreateException::new);
    }

    /**
     * ofCreate
     * 
The of create method.
     * @param result   {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofCreate(Integer result, String message, String resource) throws RestException {
        ofInvalidException(result, message, resource, DataCreateException::new);
    }

    /**
     * ofCreate
     * 
The of create method.
     * @param result   {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofCreate(Integer result, String message, String resource, Logger log) throws RestException {
        ofInvalidException(result, message, resource, log, DataCreateException::new);
    }

    /**
     * ofUpdate
     * 
The of update method.
     * @param result {@link java.lang.Integer} 
The result parameter is Integer type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdate(Integer result) throws RestException {
        ofInvalidException(result, DataUpdateException::new);
    }

    /**
     * ofUpdate
     * 
The of update method.
     * @param result {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param log    {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdate(Integer result, Logger log) throws RestException {
        ofInvalidException(result, log, DataUpdateException::new);
    }

    /**
     * ofUpdate
     * 
The of update method.
     * @param result  {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdate(Integer result, String message) throws RestException {
        ofInvalidException(result, message, DataUpdateException::new);
    }

    /**
     * ofUpdate
     * 
The of update method.
     * @param result  {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdate(Integer result, String message, Logger log) throws RestException {
        ofInvalidException(result, message, log, DataUpdateException::new);
    }

    /**
     * ofUpdate
     * 
The of update method.
     * @param result   {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdate(Integer result, String message, String resource) throws RestException {
        ofInvalidException(result, message, resource, DataUpdateException::new);
    }

    /**
     * ofUpdate
     * 
The of update method.
     * @param result   {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdate(Integer result, String message, String resource, Logger log) throws RestException {
        ofInvalidException(result, message, resource, log, DataUpdateException::new);
    }

    /**
     * ofSave
     * 
The of save method.
     * @param result {@link java.lang.Integer} 
The result parameter is Integer type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofSave(Integer result) throws RestException {
        ofInvalidException(result, DataSaveException::new);
    }

    /**
     * ofSave
     * 
The of save method.
     * @param result {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param log    {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofSave(Integer result, Logger log) throws RestException {
        ofInvalidException(result, log, DataSaveException::new);
    }

    /**
     * ofSave
     * 
The of save method.
     * @param result  {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofSave(Integer result, String message) throws RestException {
        ofInvalidException(result, message, DataSaveException::new);
    }

    /**
     * ofSave
     * 
The of save method.
     * @param result  {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofSave(Integer result, String message, Logger log) throws RestException {
        ofInvalidException(result, message, log, DataSaveException::new);
    }

    /**
     * ofSave
     * 
The of save method.
     * @param result   {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofSave(Integer result, String message, String resource) throws RestException {
        ofInvalidException(result, message, resource, DataSaveException::new);
    }

    /**
     * ofSave
     * 
The of save method.
     * @param result   {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofSave(Integer result, String message, String resource, Logger log) throws RestException {
        ofInvalidException(result, message, resource, log, DataSaveException::new);
    }

    /**
     * ofInsertAll
     * 
The of insert all method.
     * @param result {@link java.lang.Integer} 
The result parameter is Integer type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofInsertAll(Integer result) throws RestException {
        ofInvalidException(result, DataBatchInsertException::new);
    }

    /**
     * ofInsertAll
     * 
The of insert all method.
     * @param result {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param log    {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofInsertAll(Integer result, Logger log) throws RestException {
        ofInvalidException(result, log, DataBatchInsertException::new);
    }

    /**
     * ofInsertAll
     * 
The of insert all method.
     * @param result  {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofInsertAll(Integer result, String message) throws RestException {
        ofInvalidException(result, message, DataBatchInsertException::new);
    }

    /**
     * ofInsertAll
     * 
The of insert all method.
     * @param result  {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofInsertAll(Integer result, String message, Logger log) throws RestException {
        ofInvalidException(result, message, log, DataBatchInsertException::new);
    }

    /**
     * ofInsertAll
     * 
The of insert all method.
     * @param result   {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofInsertAll(Integer result, String message, String resource) throws RestException {
        ofInvalidException(result, message, resource, DataBatchInsertException::new);
    }

    /**
     * ofInsertAll
     * 
The of insert all method.
     * @param result   {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofInsertAll(Integer result, String message, String resource, Logger log) throws RestException {
        ofInvalidException(result, message, resource, log, DataBatchInsertException::new);
    }

    /**
     * ofInsertAll
     * 
The of insert all method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofInsertAll(Boolean present) throws RestException {
        ofFalseException(present, DataBatchInsertException::new);
    }

    /**
     * ofInsertAll
     * 
The of insert all method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofInsertAll(Boolean present, Logger log) throws RestException {
        ofFalseException(present, log, DataBatchInsertException::new);
    }

    /**
     * ofInsertAll
     * 
The of insert all method.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofInsertAll(Boolean present, String message, String resource) throws RestException {
        ofFalseException(present, message, resource, DataBatchInsertException::new);
    }

    /**
     * ofInsertAll
     * 
The of insert all method.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofInsertAll(Boolean present, String message, String resource, Logger log) throws RestException {
        ofFalseException(present, message, resource, log, DataBatchInsertException::new);
    }

    /**
     * ofInsertAll
     * 
The of insert all method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofInsertAll(Boolean present, String message) throws RestException {
        ofFalseException(present, message, DataBatchInsertException::new);
    }

    /**
     * ofInsertAll
     * 
The of insert all method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofInsertAll(Boolean present, String message, Logger log) throws RestException {
        ofFalseException(present, message, log, DataBatchInsertException::new);
    }

    /**
     * ofUpdateAll
     * 
The of update all method.
     * @param result {@link java.lang.Integer} 
The result parameter is Integer type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdateAll(Integer result) throws RestException {
        ofInvalidException(result, DataBatchUpdateException::new);
    }

    /**
     * ofUpdateAll
     * 
The of update all method.
     * @param result {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param log    {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdateAll(Integer result, Logger log) throws RestException {
        ofInvalidException(result, log, DataBatchUpdateException::new);
    }

    /**
     * ofUpdateAll
     * 
The of update all method.
     * @param result   {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdateAll(Integer result, String message, String resource) throws RestException {
        ofInvalidException(result, message, resource, DataBatchUpdateException::new);
    }

    /**
     * ofUpdateAll
     * 
The of update all method.
     * @param result   {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdateAll(Integer result, String message, String resource, Logger log) throws RestException {
        ofInvalidException(result, message, resource, log, DataBatchUpdateException::new);
    }

    /**
     * ofUpdateAll
     * 
The of update all method.
     * @param result  {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdateAll(Integer result, String message) throws RestException {
        ofInvalidException(result, message, DataBatchUpdateException::new);
    }

    /**
     * ofUpdateAll
     * 
The of update all method.
     * @param result  {@link java.lang.Integer} 
The result parameter is Integer type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Integer
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdateAll(Integer result, String message, Logger log) throws RestException {
        ofInvalidException(result, message, log, DataBatchUpdateException::new);
    }

    /**
     * ofUpdateAll
     * 
The of update all method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdateAll(Boolean present) throws RestException {
        ofFalseException(present, DataBatchUpdateException::new);
    }


    /**
     * ofUpdateAll
     * 
The of update all method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdateAll(Boolean present, Logger log) throws RestException {
        ofFalseException(present, log, DataBatchUpdateException::new);
    }

    /**
     * ofUpdateAll
     * 
The of update all method.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdateAll(Boolean present, String message, String resource) throws RestException {
        ofFalseException(present, message, resource, DataBatchUpdateException::new);
    }

    /**
     * ofUpdateAll
     * 
The of update all method.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdateAll(Boolean present, String message, String resource, Logger log) throws RestException {
        ofFalseException(present, message, resource, log, DataBatchUpdateException::new);
    }

    /**
     * ofUpdateAll
     * 
The of update all method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdateAll(Boolean present, String message) throws RestException {
        ofFalseException(present, message, DataBatchUpdateException::new);
    }

    /**
     * ofUpdateAll
     * 
The of update all method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofUpdateAll(Boolean present, String message, Logger log) throws RestException {
        ofFalseException(present, message, log, DataBatchUpdateException::new);
    }

    /**
     * ofSaveAll
     * 
The of save all method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofSaveAll(Boolean present) throws RestException {
        ofFalseException(present, DataBatchSaveException::new);
    }

    /**
     * ofSaveAll
     * 
The of save all method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofSaveAll(Boolean present, Logger log) throws RestException {
        ofFalseException(present, log, DataBatchSaveException::new);
    }

    /**
     * ofSaveAll
     * 
The of save all method.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofSaveAll(Boolean present, String message, String resource) throws RestException {
        ofFalseException(present, message, resource, DataBatchSaveException::new);
    }

    /**
     * ofSaveAll
     * 
The of save all method.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofSaveAll(Boolean present, String message, String resource, Logger log) throws RestException {
        ofFalseException(present, message, resource, log, DataBatchSaveException::new);
    }

    /**
     * ofSaveAll
     * 
The of save all method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofSaveAll(Boolean present, String message) throws RestException {
        ofFalseException(present, message, DataBatchSaveException::new);
    }

    /**
     * ofSaveAll
     * 
The of save all method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofSaveAll(Boolean present, String message, Logger log) throws RestException {
        ofFalseException(present, message, log, DataBatchSaveException::new);
    }

    /**
     * ofNameRepeat
     * 
The of name repeat method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofNameRepeat(Boolean present) throws RestException {
        ofTrueException(present, NameRepeatException::new);
    }

    /**
     * ofNameRepeat
     * 
The of name repeat method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofNameRepeat(Boolean present, Logger log) throws RestException {
        ofTrueException(present, log, NameRepeatException::new);
    }

    /**
     * ofNameRepeat
     * 
The of name repeat method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofNameRepeat(Boolean present, String message) throws RestException {
        ofTrueException(present, message, NameRepeatException::new);
    }

    /**
     * ofNameRepeat
     * 
The of name repeat method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofNameRepeat(Boolean present, String message, Logger log) throws RestException {
        ofTrueException(present, message, log, NameRepeatException::new);
    }

    /**
     * ofNameRepeat
     * 
The of name repeat method.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofNameRepeat(Boolean present, String message, String resource) throws RestException {
        ofTrueException(present, message, resource, (rse, msg) -> new NameRepeatException(rse, null, msg));
    }

    /**
     * ofNameRepeat
     * 
The of name repeat method.
     * @param present  {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param message  {@link java.lang.String} 
The message parameter is String type.
     * @param resource {@link java.lang.String} 
The resource parameter is String type.
     * @param log      {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofNameRepeat(Boolean present, String message, String resource, Logger log) throws RestException {
        ofTrueException(present, message, resource, log, (rse, msg) -> new NameRepeatException(rse, null, msg));
    }

    /**
     * ofFieldRepeat
     * 
The of field repeat method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofFieldRepeat(Boolean present) throws RestException {
        ofTrueException(present, FieldRepeatException::new);
    }

    /**
     * ofFieldRepeat
     * 
The of field repeat method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofFieldRepeat(Boolean present, Logger log) throws RestException {
        ofTrueException(present, log, FieldRepeatException::new);
    }

    /**
     * ofFieldRepeat
     * 
The of field repeat method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param field   {@link java.lang.String} 
The field parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofFieldRepeat(Boolean present, String field) throws RestException {
        ofTrueException(present, field, FieldRepeatException::new);
    }

    /**
     * ofFieldRepeat
     * 
The of field repeat method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param field   {@link java.lang.String} 
The field parameter is String type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofFieldRepeat(Boolean present, String field, Logger log) throws RestException {
        ofTrueException(present, field, log, FieldRepeatException::new);
    }

    /**
     * ofFieldRepeat
     * 
The of field repeat method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param field   {@link java.lang.String} 
The field parameter is String type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofFieldRepeat(Boolean present, String field, String message) throws RestException {
        ofTrueException(present, message, field, (fld, msg) -> new FieldRepeatException(fld, null, msg));
    }

    /**
     * ofFieldRepeat
     * 
The of field repeat method.
     * @param present {@link java.lang.Boolean} 
The present parameter is Boolean type.
     * @param field   {@link java.lang.String} 
The field parameter is String type.
     * @param message {@link java.lang.String} 
The message parameter is String type.
     * @param log     {@link org.slf4j.Logger} 
The log parameter is Logger type.
     * @throws RestException {@link io.github.nichetoolkit.rest.RestException} 
The rest exception is RestException type.
     * @see java.lang.Boolean
     * @see java.lang.String
     * @see org.slf4j.Logger
     * @see io.github.nichetoolkit.rest.RestException
     */
    public static void ofFieldRepeat(Boolean present, String field, String message, Logger log) throws RestException {
        ofTrueException(present, message, field, log, (fld, msg) -> new FieldRepeatException(fld, null, msg));
    }
}