// 
// Decompiled by Procyon v0.6.0
// 

package com.hypixel.hytale.codec.validation;

import com.hypixel.hytale.codec.validation.validator.ListValidator;
import java.util.List;
import com.hypixel.hytale.codec.validation.validator.OrValidator;
import com.hypixel.hytale.codec.validation.validator.SequentialDoubleArrayValidator;
import com.hypixel.hytale.codec.validation.validator.NonEmptyFloatArrayValidator;
import com.hypixel.hytale.codec.validation.validator.NonEmptyDoubleArrayValidator;
import com.hypixel.hytale.codec.validation.validator.NotEqualValidator;
import com.hypixel.hytale.codec.validation.validator.EqualValidator;
import com.hypixel.hytale.codec.validation.validator.DoubleArraySizeValidator;
import com.hypixel.hytale.codec.validation.validator.IntArraySizeValidator;
import com.hypixel.hytale.codec.validation.validator.ArraySizeValidator;
import com.hypixel.hytale.codec.validation.validator.ArraySizeRangeValidator;
import com.hypixel.hytale.codec.validation.validator.RangeValidator;
import com.hypixel.hytale.codec.validation.validator.RequiredMapKeysValidator;
import com.hypixel.hytale.codec.validation.validator.UniqueInArrayValidator;
import com.hypixel.hytale.codec.validation.validator.NonEmptyMapValidator;
import java.util.Map;
import com.hypixel.hytale.codec.validation.validator.NonEmptyArrayValidator;
import com.hypixel.hytale.codec.validation.validator.NonEmptyStringValidator;
import com.hypixel.hytale.codec.validation.validator.ArrayValidator;
import com.hypixel.hytale.codec.validation.validator.NonNullValidator;
import javax.annotation.Nonnull;
import com.hypixel.hytale.codec.validation.validator.DeprecatedValidator;

public class Validators
{
    @Nonnull
    public static <T> DeprecatedValidator<T> deprecated() {
        return (DeprecatedValidator<T>)DeprecatedValidator.INSTANCE;
    }
    
    @Nonnull
    public static <T> Validator<T> nonNull() {
        return (Validator<T>)NonNullValidator.INSTANCE;
    }
    
    @Nonnull
    public static <T> ArrayValidator<T> nonNullArrayElements() {
        return new ArrayValidator<T>(nonNull());
    }
    
    @Nonnull
    public static Validator<String> nonEmptyString() {
        return NonEmptyStringValidator.INSTANCE;
    }
    
    @Nonnull
    public static <T> Validator<T[]> nonEmptyArray() {
        return (Validator<T[]>)NonEmptyArrayValidator.INSTANCE;
    }
    
    @Nonnull
    public static <K, V> Validator<Map<K, V>> nonEmptyMap() {
        return (Validator<Map<K, V>>)NonEmptyMapValidator.INSTANCE;
    }
    
    @Nonnull
    public static <T> Validator<T[]> uniqueInArray() {
        return (Validator<T[]>)UniqueInArrayValidator.INSTANCE;
    }
    
    @Nonnull
    public static <T> Validator<Map<T, ?>> requiredMapKeysValidator(final T[] array) {
        return new RequiredMapKeysValidator<T>(array);
    }
    
    @Nonnull
    public static <T extends Comparable<T>> Validator<T> greaterThan(final T greaterThan) {
        return new RangeValidator<T>(greaterThan, null, false);
    }
    
    @Nonnull
    public static <T extends Comparable<T>> Validator<T> greaterThanOrEqual(final T greaterThan) {
        return new RangeValidator<T>(greaterThan, null, true);
    }
    
    @Nonnull
    public static <T extends Comparable<T>> Validator<T> lessThan(final T lessThan) {
        return new RangeValidator<T>(null, lessThan, false);
    }
    
    @Nonnull
    public static <T extends Comparable<T>> Validator<T> insideRange(final T greaterthan, final T lessThan) {
        return new RangeValidator<T>(greaterthan, lessThan, false);
    }
    
    @Nonnull
    public static <T extends Comparable<T>> Validator<T> min(final T min) {
        return new RangeValidator<T>(min, null, true);
    }
    
    @Nonnull
    public static <T extends Comparable<T>> Validator<T> max(final T max) {
        return new RangeValidator<T>(null, max, true);
    }
    
    @Nonnull
    public static <T extends Comparable<T>> Validator<T> range(final T min, final T max) {
        return new RangeValidator<T>(min, max, true);
    }
    
    @Nonnull
    public static <T> Validator<T[]> arraySizeRange(final int min, final int max) {
        return new ArraySizeRangeValidator<T>(min, max);
    }
    
    @Nonnull
    public static <T> Validator<T[]> arraySize(final int size) {
        return new ArraySizeValidator<T>(size);
    }
    
    @Nonnull
    public static Validator<int[]> intArraySize(final int size) {
        return new IntArraySizeValidator(size);
    }
    
    @Nonnull
    public static Validator<double[]> doubleArraySize(final int size) {
        return new DoubleArraySizeValidator(size);
    }
    
    @Nonnull
    public static <T extends Comparable<T>> Validator<T> equal(@Nonnull final T value) {
        return new EqualValidator<T>(value);
    }
    
    @Nonnull
    public static <T extends Comparable<T>> Validator<T> notEqual(@Nonnull final T value) {
        return new NotEqualValidator<T>(value);
    }
    
    @Nonnull
    public static Validator<double[]> nonEmptyDoubleArray() {
        return NonEmptyDoubleArrayValidator.INSTANCE;
    }
    
    @Nonnull
    public static Validator<float[]> nonEmptyFloatArray() {
        return NonEmptyFloatArrayValidator.INSTANCE;
    }
    
    @Nonnull
    public static Validator<double[]> monotonicSequentialDoubleArrayValidator() {
        return SequentialDoubleArrayValidator.NEQ_INSTANCE;
    }
    
    @Nonnull
    public static Validator<double[]> weaklyMonotonicSequentialDoubleArrayValidator() {
        return SequentialDoubleArrayValidator.ALLOW_EQ_INSTANCE;
    }
    
    @Nonnull
    public static <T> Validator<T> or(final Validator<T>... validators) {
        return new OrValidator<T>(validators);
    }
    
    @Nonnull
    public static <T> Validator<List<T>> listItem(final Validator<T> validator) {
        return new ListValidator<T>(validator);
    }
}