jsonvalues.spec.Functions Maven / Gradle / Ivy

Go to download
package jsonvalues.spec;

import jsonvalues.JsArray;
import jsonvalues.JsValue;

import java.util.Optional;
import java.util.function.Function;
import java.util.function.Predicate;

import static jsonvalues.spec.ERROR_CODE.*;

class Functions {
    static Function> testElem(final Predicate elemCondition,
                                                       final ERROR_CODE errorCode,
                                                       final boolean required,
                                                       final boolean nullable
                                                      ) {

        return value ->
        {
            final Optional error = testFlags(required,
                                                    nullable
                                                   ).apply(value);
            if (error.isPresent() || value.isNull()) return error;
            if (!elemCondition.test(value)) return Optional.of(new Error(value,
                                                                         errorCode
                                                               )
                                                              );
            return Optional.empty();
        };
    }

    private static Function> testFlags(boolean required,
                                                                boolean nullable
                                                               ) {
        return value ->
        {
            if (value.isNothing() && required) return Optional.of(new Error(value,
                                                                            REQUIRED
                                                                  )
                                                                 );
            if (value.isNull() && !nullable) return Optional.of(new Error(value,
                                                                          NULL
                                                                )
                                                               );
            return Optional.empty();
        };
    }

    static Function> testArrayOfTestedValue(final Function> elemCondition,
                                                                     final boolean required,
                                                                     final boolean nullable
                                                                    ) {

        return testArrayPredicate(required,
                                  nullable,
                                  array ->
                                  {
                                      for (final JsValue next : array) {
                                          final Optional result = elemCondition.apply(next);
                                          if (result.isPresent()) return result;
                                      }
                                      return Optional.empty();
                                  }
                                 );
    }

    private static Function> testArrayPredicate(final boolean required,
                                                                         final boolean nullable,
                                                                         final Function> validation
                                                                        ) {
        return value ->
        {
            final Optional errors = testArray(required,
                                                     nullable
                                                    ).apply(value);
            if (errors.isPresent() || value.isNull()) return errors;
            return validation.apply(value.toJsArray());
        };
    }

    static Function> testArray(boolean required,
                                                        boolean nullable
                                                       ) {
        return value ->
        {
            final Optional error = testFlags(required,
                                                    nullable
                                                   ).apply(value);
            if (error.isPresent()) return error;
            return value.isNull() || value.isArray() ? Optional.empty() : Optional.of(new Error(value,
                                                                                                ARRAY_EXPECTED
            ));
        };

    }


}