akkurate-core/dev.nesk.akkurate.validatables/Validatable

Validatable

class Validatable<out T>

Properties

epochSecond

val Validatable<Instant>.epochSecond: Validatable<Long>

nanos

val Validatable<Instant>.nanos: Validatable<Int>

Functions

and

infix fun <T> Validatable<T>.and(other: ValidatableCompound<T>): ValidatableCompound<T>

infix fun <T> Validatable<T>.and(other: Validatable<T>): ValidatableCompound<T>

component1

operator fun component1(): T

constrain

inline fun <T> Validatable<T>.constrain(block: (value: T) -> Boolean): Constraint

constrainIfNotNull

inline fun <T> Validatable<T?>.constrainIfNotNull(block: (value: T) -> Boolean): Constraint

each

inline fun <T> Validatable<Iterable<T>?>.each(block: Validatable<T>.() -> Unit)

Iterates over each element of this object and wraps them with a Validatable before passing them to the block.

equals

open operator override fun equals(other: Any?): Boolean

Indicates whether some other object is "equal to" this validatable.

first

fun <T> Validatable<Array<T>?>.first(): Validatable<T?>

fun <T> Validatable<Iterable<T>?>.first(): Validatable<T?>

Returns the first element, wrapped in Validatable.

get

operator fun <T> Validatable<Array<T>?>.get(index: Int): Validatable<T?>

operator fun <K, V> Validatable<Map<K, V>?>.get(index: K): Validatable<V?>

operator fun <T> Validatable<List<T>?>.get(index: Int): Validatable<T?>

Returns the element at the specified index in the list, wrapped in a Validatable.

hasFractionalCountEqualTo

@JvmName(name = "doubleHasFractionalCountEqualTo")

fun Validatable<Double?>.hasFractionalCountEqualTo(count: Int): Constraint

@JvmName(name = "floatHasFractionalCountEqualTo")

fun Validatable<Float?>.hasFractionalCountEqualTo(count: Int): Constraint

hashCode

open override fun hashCode(): Int

Returns a hash code value for the object.

hasIntegralCountEqualTo

@JvmName(name = "doubleHasIntegralCountEqualTo")

fun Validatable<Double?>.hasIntegralCountEqualTo(count: Int): Constraint

@JvmName(name = "floatHasIntegralCountEqualTo")

fun Validatable<Float?>.hasIntegralCountEqualTo(count: Int): Constraint

@JvmName(name = "intHasIntegralCountEqualTo")

fun Validatable<Int?>.hasIntegralCountEqualTo(count: Int): Constraint

@JvmName(name = "longHasIntegralCountEqualTo")

fun Validatable<Long?>.hasIntegralCountEqualTo(count: Int): Constraint

@JvmName(name = "shortHasIntegralCountEqualTo")

fun Validatable<Short?>.hasIntegralCountEqualTo(count: Int): Constraint

hasLengthBetween

fun Validatable<CharSequence?>.hasLengthBetween(range: IntRange): Constraint

hasLengthEqualTo

fun Validatable<CharSequence?>.hasLengthEqualTo(length: Int): Constraint

hasLengthGreaterThan

fun Validatable<CharSequence?>.hasLengthGreaterThan(length: Int): Constraint

hasLengthGreaterThanOrEqualTo

fun Validatable<CharSequence?>.hasLengthGreaterThanOrEqualTo(length: Int): Constraint

hasLengthLowerThan

fun Validatable<CharSequence?>.hasLengthLowerThan(length: Int): Constraint

hasLengthLowerThanOrEqualTo

fun Validatable<CharSequence?>.hasLengthLowerThanOrEqualTo(length: Int): Constraint

hasLengthNotEqualTo

fun Validatable<CharSequence?>.hasLengthNotEqualTo(length: Int): Constraint

hasNoDuplicates

fun <T> Validatable<Array<out T>?>.hasNoDuplicates(): Constraint

The validatable Array must contain unique elements when this constraint is applied.

fun <T> Validatable<Iterable<T>?>.hasNoDuplicates(): Constraint

The validatable Iterable must contain unique elements when this constraint is applied.

hasSizeBetween

@JvmName(name = "arrayHasSizeBetween")

fun <T> Validatable<Array<out T>?>.hasSizeBetween(range: IntRange): Constraint

The validatable Array must have a size within the provided range when this constraint is applied.

@JvmName(name = "collectionHasSizeBetween")

fun <T> Validatable<Collection<T>?>.hasSizeBetween(range: IntRange): Constraint

The validatable Collection must have a size within the provided range when this constraint is applied.

@JvmName(name = "mapHasSizeBetween")

fun <T> Validatable<Map<*, T>?>.hasSizeBetween(range: IntRange): Constraint

The validatable Map must have a size within the provided range when this constraint is applied.

hasSizeEqualTo

@JvmName(name = "arrayHasSizeEqualTo")

fun <T> Validatable<Array<out T>?>.hasSizeEqualTo(size: Int): Constraint

The validatable Array must have a size equal to size when this constraint is applied.

@JvmName(name = "collectionHasSizeEqualTo")

fun <T> Validatable<Collection<T>?>.hasSizeEqualTo(size: Int): Constraint

The validatable Collection must have a size equal to size when this constraint is applied.

@JvmName(name = "mapHasSizeEqualTo")

fun <T> Validatable<Map<*, T>?>.hasSizeEqualTo(size: Int): Constraint

The validatable Map must have a size equal to size when this constraint is applied.

hasSizeGreaterThan

@JvmName(name = "arrayHasSizeGreaterThan")

fun <T> Validatable<Array<out T>?>.hasSizeGreaterThan(size: Int): Constraint

The validatable Array must have a size greater than size when this constraint is applied.

@JvmName(name = "collectionHasSizeGreaterThan")

fun <T> Validatable<Collection<T>?>.hasSizeGreaterThan(size: Int): Constraint

The validatable Collection must have a size greater than size when this constraint is applied.

@JvmName(name = "mapHasSizeGreaterThan")

fun <T> Validatable<Map<*, T>?>.hasSizeGreaterThan(size: Int): Constraint

The validatable Map must have a size greater than size when this constraint is applied.

hasSizeGreaterThanOrEqualTo

@JvmName(name = "arrayHasSizeGreaterThanOrEqualTo")

fun <T> Validatable<Array<out T>?>.hasSizeGreaterThanOrEqualTo(size: Int): Constraint

The validatable Array must have a size greater than or equal to size when this constraint is applied.

@JvmName(name = "collectionHasSizeGreaterThanOrEqualTo")

fun <T> Validatable<Collection<T>?>.hasSizeGreaterThanOrEqualTo(size: Int): Constraint

The validatable Collection must have a size greater than or equal to size when this constraint is applied.

@JvmName(name = "mapHasSizeGreaterThanOrEqualTo")

fun <T> Validatable<Map<*, T>?>.hasSizeGreaterThanOrEqualTo(size: Int): Constraint

The validatable Map must have a size greater than or equal to size when this constraint is applied.

hasSizeLowerThan

@JvmName(name = "arrayHasSizeLowerThan")

fun <T> Validatable<Array<out T>?>.hasSizeLowerThan(size: Int): Constraint

The validatable Array must have a size lower than size when this constraint is applied.

@JvmName(name = "collectionHasSizeLowerThan")

fun <T> Validatable<Collection<T>?>.hasSizeLowerThan(size: Int): Constraint

The validatable Collection must have a size lower than size when this constraint is applied.

@JvmName(name = "mapHasSizeLowerThan")

fun <T> Validatable<Map<*, T>?>.hasSizeLowerThan(size: Int): Constraint

The validatable Map must have a size lower than size when this constraint is applied.

hasSizeLowerThanOrEqualTo

@JvmName(name = "arrayHasSizeLowerThanOrEqualTo")

fun <T> Validatable<Array<out T>?>.hasSizeLowerThanOrEqualTo(size: Int): Constraint

The validatable Array must have a size lower than or equal to size when this constraint is applied.

@JvmName(name = "collectionHasSizeLowerThanOrEqualTo")

fun <T> Validatable<Collection<T>?>.hasSizeLowerThanOrEqualTo(size: Int): Constraint

The validatable Collection must have a size lower than or equal to size when this constraint is applied.

@JvmName(name = "mapHasSizeLowerThanOrEqualTo")

fun <T> Validatable<Map<*, T>?>.hasSizeLowerThanOrEqualTo(size: Int): Constraint

The validatable Map must have a size lower than or equal to size when this constraint is applied.

hasSizeNotEqualTo

@JvmName(name = "arrayHasSizeNotEqualTo")

fun <T> Validatable<Array<out T>?>.hasSizeNotEqualTo(size: Int): Constraint

The validatable Array must have a size different from size when this constraint is applied.

@JvmName(name = "collectionHasSizeNotEqualTo")

fun <T> Validatable<Collection<T>?>.hasSizeNotEqualTo(size: Int): Constraint

The validatable Collection must have a size different from size when this constraint is applied.

@JvmName(name = "mapHasSizeNotEqualTo")

fun <T> Validatable<Map<*, T>?>.hasSizeNotEqualTo(size: Int): Constraint

The validatable Map must have a size different from size when this constraint is applied.

invoke

inline operator fun invoke(block: Validatable<T>.() -> Unit)

isAfter

fun Validatable<Instant?>.isAfter(other: Instant): Constraint

fun Validatable<LocalDate?>.isAfter(other: LocalDate): Constraint

fun Validatable<LocalDateTime?>.isAfter(other: LocalDateTime): Constraint

fun Validatable<ZonedDateTime?>.isAfter(other: ZonedDateTime): Constraint

isAfterOrEqualTo

fun Validatable<Instant?>.isAfterOrEqualTo(other: Instant): Constraint

fun Validatable<LocalDate?>.isAfterOrEqualTo(other: LocalDate): Constraint

fun Validatable<LocalDateTime?>.isAfterOrEqualTo(other: LocalDateTime): Constraint

fun Validatable<ZonedDateTime?>.isAfterOrEqualTo(other: ZonedDateTime): Constraint

isBefore

fun Validatable<Instant?>.isBefore(other: Instant): Constraint

fun Validatable<LocalDate?>.isBefore(other: LocalDate): Constraint

fun Validatable<LocalDateTime?>.isBefore(other: LocalDateTime): Constraint

fun Validatable<ZonedDateTime?>.isBefore(other: ZonedDateTime): Constraint

isBeforeOrEqualTo

fun Validatable<Instant?>.isBeforeOrEqualTo(other: Instant): Constraint

fun Validatable<LocalDate?>.isBeforeOrEqualTo(other: LocalDate): Constraint

fun Validatable<LocalDateTime?>.isBeforeOrEqualTo(other: LocalDateTime): Constraint

fun Validatable<ZonedDateTime?>.isBeforeOrEqualTo(other: ZonedDateTime): Constraint

isBetween

fun Validatable<Duration?>.isBetween(range: ClosedRange<Duration>): Constraint

fun Validatable<Duration?>.isBetween(range: OpenEndRange<Duration>): Constraint

@JvmName(name = "closedDoubleIsBetween")

fun Validatable<Double?>.isBetween(range: ClosedFloatingPointRange<Double>): Constraint

@JvmName(name = "openDoubleIsBetween")

fun Validatable<Double?>.isBetween(range: OpenEndRange<Double>): Constraint

@JvmName(name = "closedFloatIsBetween")

fun Validatable<Float?>.isBetween(range: ClosedFloatingPointRange<Float>): Constraint

@JvmName(name = "openFloatIsBetween")

fun Validatable<Float?>.isBetween(range: OpenEndRange<Float>): Constraint

fun Validatable<Int?>.isBetween(range: IntRange): Constraint

fun Validatable<Long?>.isBetween(range: LongRange): Constraint

@JvmName(name = "shortIsBetween")

fun Validatable<Short?>.isBetween(range: IntRange): Constraint

isBlank

fun Validatable<CharSequence?>.isBlank(): Constraint

isContaining

@JvmName(name = "arrayIsContaining")

fun <T> Validatable<Array<out T>?>.isContaining(element: T): Constraint

The validatable Array must contain element when this constraint is applied.

fun Validatable<CharSequence?>.isContaining(other: CharSequence): Constraint

@JvmName(name = "iterableIsContaining")

fun <T> Validatable<Iterable<T>?>.isContaining(element: T): Constraint

The validatable Iterable must contain element when this constraint is applied.

isContainingKey

fun <K> Validatable<Map<out K, *>?>.isContainingKey(key: K): Constraint

The validatable Map must contain the provided key when this constraint is applied.

isContainingValue

fun <V> Validatable<Map<*, V>?>.isContainingValue(value: V): Constraint

The validatable Map must contain the provided value when this constraint is applied.

isEmpty

@JvmName(name = "arrayIsEmpty")

fun <T> Validatable<Array<out T>?>.isEmpty(): Constraint

The validatable Array must be empty when this constraint is applied.

fun Validatable<CharSequence?>.isEmpty(): Constraint

@JvmName(name = "collectionIsEmpty")

fun <T> Validatable<Collection<T>?>.isEmpty(): Constraint

The validatable Collection must be empty when this constraint is applied.

@JvmName(name = "mapIsEmpty")

fun <T> Validatable<Map<*, T>?>.isEmpty(): Constraint

The validatable Map must be empty when this constraint is applied.

isEndingWith

fun Validatable<CharSequence?>.isEndingWith(suffix: CharSequence): Constraint

isEqualTo

fun <T> Validatable<T?>.isEqualTo(other: T?): Constraint

fun <T> Validatable<T?>.isEqualTo(other: Validatable<T>): Constraint

The validatable value must be equal to other when this constraint is applied.

isFalse

fun Validatable<Boolean?>.isFalse(): Constraint

isFinite

@JvmName(name = "doubleIsFinite")

fun Validatable<Double?>.isFinite(): Constraint

@JvmName(name = "floatIsFinite")

fun Validatable<Float?>.isFinite(): Constraint

isGreaterThan

fun Validatable<Duration?>.isGreaterThan(value: Duration): Constraint

fun Validatable<Double?>.isGreaterThan(value: Double): Constraint

fun Validatable<Float?>.isGreaterThan(value: Float): Constraint

fun Validatable<Int?>.isGreaterThan(value: Int): Constraint

fun Validatable<Long?>.isGreaterThan(value: Long): Constraint

fun Validatable<Short?>.isGreaterThan(value: Short): Constraint

isGreaterThanOrEqualTo

fun Validatable<Duration?>.isGreaterThanOrEqualTo(value: Duration): Constraint

fun Validatable<Double?>.isGreaterThanOrEqualTo(value: Double): Constraint

fun Validatable<Float?>.isGreaterThanOrEqualTo(value: Float): Constraint

fun Validatable<Int?>.isGreaterThanOrEqualTo(value: Int): Constraint

fun Validatable<Long?>.isGreaterThanOrEqualTo(value: Long): Constraint

fun Validatable<Short?>.isGreaterThanOrEqualTo(value: Short): Constraint

isIdenticalTo

fun <T> Validatable<T?>.isIdenticalTo(other: T?): Constraint

The validatable value must be identical to other when this constraint is applied.

isInfinite

@JvmName(name = "doubleIsInfinite")

fun Validatable<Double?>.isInfinite(): Constraint

@JvmName(name = "floatIsInfinite")

fun Validatable<Float?>.isInfinite(): Constraint

isInFuture

@JvmName(name = "instantFuture")

fun Validatable<Instant?>.isInFuture(): Constraint

@JvmName(name = "localDateFuture")

fun Validatable<LocalDate?>.isInFuture(): Constraint

@JvmName(name = "localDateTimeFuture")

fun Validatable<LocalDateTime?>.isInFuture(): Constraint

@JvmName(name = "zonedDateTimeFuture")

fun Validatable<ZonedDateTime?>.isInFuture(): Constraint

isInFutureOrIsPresent

@JvmName(name = "instantIsInFutureOrIsPresent")

fun Validatable<Instant?>.isInFutureOrIsPresent(): Constraint

@JvmName(name = "localDateIsInFutureOrIsPresent")

fun Validatable<LocalDate?>.isInFutureOrIsPresent(): Constraint

@JvmName(name = "localDateTimeIsInFutureOrIsPresent")

fun Validatable<LocalDateTime?>.isInFutureOrIsPresent(): Constraint

@JvmName(name = "zonedDateTimeIsInFutureOrIsPresent")

fun Validatable<ZonedDateTime?>.isInFutureOrIsPresent(): Constraint

isInPast

@JvmName(name = "instantIsInPast")

fun Validatable<Instant?>.isInPast(): Constraint

@JvmName(name = "localDateIsInPast")

fun Validatable<LocalDate?>.isInPast(): Constraint

@JvmName(name = "localDateTimeIsInPast")

fun Validatable<LocalDateTime?>.isInPast(): Constraint

@JvmName(name = "zonedDateTimeIsInPast")

fun Validatable<ZonedDateTime?>.isInPast(): Constraint

isInPastOrIsPresent

@JvmName(name = "instantIsInPastOrIsPresent")

fun Validatable<Instant?>.isInPastOrIsPresent(): Constraint

@JvmName(name = "localDateIsInPastOrIsPresent")

fun Validatable<LocalDate?>.isInPastOrIsPresent(): Constraint

@JvmName(name = "localDateTimeIsInPastOrIsPresent")

fun Validatable<LocalDateTime?>.isInPastOrIsPresent(): Constraint

@JvmName(name = "zonedDateTimeIsInPastOrIsPresent")

fun Validatable<ZonedDateTime?>.isInPastOrIsPresent(): Constraint

isInstanceOf

inline fun <T> Validatable<*>.isInstanceOf(): Constraint

The validatable value must be an instance of type parameter R when this constraint is applied.

isLowerThan

fun Validatable<Duration?>.isLowerThan(value: Duration): Constraint

fun Validatable<Double?>.isLowerThan(value: Double): Constraint

fun Validatable<Float?>.isLowerThan(value: Float): Constraint

fun Validatable<Int?>.isLowerThan(value: Int): Constraint

fun Validatable<Long?>.isLowerThan(value: Long): Constraint

fun Validatable<Short?>.isLowerThan(value: Short): Constraint

isLowerThanOrEqualTo

fun Validatable<Duration?>.isLowerThanOrEqualTo(value: Duration): Constraint

fun Validatable<Double?>.isLowerThanOrEqualTo(value: Double): Constraint

fun Validatable<Float?>.isLowerThanOrEqualTo(value: Float): Constraint

fun Validatable<Int?>.isLowerThanOrEqualTo(value: Int): Constraint

fun Validatable<Long?>.isLowerThanOrEqualTo(value: Long): Constraint

fun Validatable<Short?>.isLowerThanOrEqualTo(value: Short): Constraint

isMatching

fun Validatable<CharSequence?>.isMatching(regex: Regex): Constraint

isNegative

@JvmName(name = "durationIsNegative")

fun Validatable<Duration?>.isNegative(): Constraint

@JvmName(name = "periodIsNegative")

fun Validatable<Period?>.isNegative(): Constraint

@JvmName(name = "doubleIsNegative")

fun Validatable<Double?>.isNegative(): Constraint

@JvmName(name = "floatIsNegative")

fun Validatable<Float?>.isNegative(): Constraint

@JvmName(name = "intIsNegative")

fun Validatable<Int?>.isNegative(): Constraint

@JvmName(name = "longIsNegative")

fun Validatable<Long?>.isNegative(): Constraint

@JvmName(name = "shortIsNegative")

fun Validatable<Short?>.isNegative(): Constraint

isNegativeOrZero

@JvmName(name = "durationIsNegativeOrZero")

fun Validatable<Duration?>.isNegativeOrZero(): Constraint

@JvmName(name = "periodIsNegativeOrZero")

fun Validatable<Period?>.isNegativeOrZero(): Constraint

@JvmName(name = "doubleIsNegativeOrZero")

fun Validatable<Double?>.isNegativeOrZero(): Constraint

@JvmName(name = "floatIsNegativeOrZero")

fun Validatable<Float?>.isNegativeOrZero(): Constraint

@JvmName(name = "intIsNegativeOrZero")

fun Validatable<Int?>.isNegativeOrZero(): Constraint

@JvmName(name = "longIsNegativeOrZero")

fun Validatable<Long?>.isNegativeOrZero(): Constraint

@JvmName(name = "shortIsNegativeOrZero")

fun Validatable<Short?>.isNegativeOrZero(): Constraint

isNotBlank

fun Validatable<CharSequence?>.isNotBlank(): Constraint

isNotContaining

@JvmName(name = "arrayIsNotContaining")

fun <T> Validatable<Array<out T>?>.isNotContaining(element: T): Constraint

The validatable Array must not contain element when this constraint is applied.

fun Validatable<CharSequence?>.isNotContaining(other: CharSequence): Constraint

@JvmName(name = "iterableIsNotContaining")

fun <T> Validatable<Iterable<T>?>.isNotContaining(element: T): Constraint

The validatable Iterable must not contain element when this constraint is applied.

isNotContainingKey

fun <K> Validatable<Map<out K, *>?>.isNotContainingKey(key: K): Constraint

The validatable Map must not contain the provided key when this constraint is applied.

isNotContainingValue

fun <V> Validatable<Map<*, V>?>.isNotContainingValue(value: V): Constraint

The validatable Map must not contain the provided value when this constraint is applied.

isNotEmpty

@JvmName(name = "arrayIsNotEmpty")

fun <T> Validatable<Array<out T>?>.isNotEmpty(): Constraint

The validatable Array must not be empty when this constraint is applied.

fun Validatable<CharSequence?>.isNotEmpty(): Constraint

@JvmName(name = "collectionIsNotEmpty")

fun <T> Validatable<Collection<T>?>.isNotEmpty(): Constraint

The validatable Collection must not be empty when this constraint is applied.

@JvmName(name = "mapIsNotEmpty")

fun <T> Validatable<Map<*, T>?>.isNotEmpty(): Constraint

The validatable Map must not be empty when this constraint is applied.

isNotEndingWith

fun Validatable<CharSequence?>.isNotEndingWith(suffix: CharSequence): Constraint

isNotEqualTo

fun <T> Validatable<T?>.isNotEqualTo(other: T?): Constraint

fun <T> Validatable<T?>.isNotEqualTo(other: Validatable<T>): Constraint

The validatable value must be different from other when this constraint is applied.

isNotFalse

fun Validatable<Boolean?>.isNotFalse(): Constraint

isNotIdenticalTo

fun <T> Validatable<T?>.isNotIdenticalTo(other: T?): Constraint

The validatable value must not be identical to other when this constraint is applied.

isNotInstanceOf

inline fun <T> Validatable<*>.isNotInstanceOf(): Constraint

The validatable value must not be an instance of type parameter R when this constraint is applied.

isNotMatching

fun Validatable<CharSequence?>.isNotMatching(regex: Regex): Constraint

isNotNaN

@JvmName(name = "doubleIsNotNaN")

fun Validatable<Double?>.isNotNaN(): Constraint

@JvmName(name = "floatIsNotNaN")

fun Validatable<Float?>.isNotNaN(): Constraint

isNotNull

fun <T> Validatable<T?>.isNotNull(): Constraint

The validatable value must not be null when this constraint is applied.

isNotStartingWith

fun Validatable<CharSequence?>.isNotStartingWith(prefix: CharSequence): Constraint

isNotTrue

fun Validatable<Boolean?>.isNotTrue(): Constraint

isNull

fun <T> Validatable<T?>.isNull(): Constraint

The validatable value must be null when this constraint is applied.

isPositive

@JvmName(name = "durationIsPositive")

fun Validatable<Duration?>.isPositive(): Constraint

@JvmName(name = "periodIsPositive")

fun Validatable<Period?>.isPositive(): Constraint

@JvmName(name = "doubleIsPositive")

fun Validatable<Double?>.isPositive(): Constraint

@JvmName(name = "floatIsPositive")

fun Validatable<Float?>.isPositive(): Constraint

@JvmName(name = "intIsPositive")

fun Validatable<Int?>.isPositive(): Constraint

@JvmName(name = "longIsPositive")

fun Validatable<Long?>.isPositive(): Constraint

@JvmName(name = "shortIsPositive")

fun Validatable<Short?>.isPositive(): Constraint

isPositiveOrZero

@JvmName(name = "durationIsPositiveOrZero")

fun Validatable<Duration?>.isPositiveOrZero(): Constraint

@JvmName(name = "periodIsPositiveOrZero")

fun Validatable<Period?>.isPositiveOrZero(): Constraint

@JvmName(name = "doubleIsPositiveOrZero")

fun Validatable<Double?>.isPositiveOrZero(): Constraint

@JvmName(name = "floatIsPositiveOrZero")

fun Validatable<Float?>.isPositiveOrZero(): Constraint

@JvmName(name = "intIsPositiveOrZero")

fun Validatable<Int?>.isPositiveOrZero(): Constraint

@JvmName(name = "longIsPositiveOrZero")

fun Validatable<Long?>.isPositiveOrZero(): Constraint

@JvmName(name = "shortIsPositiveOrZero")

fun Validatable<Short?>.isPositiveOrZero(): Constraint

isStartingWith

fun Validatable<CharSequence?>.isStartingWith(prefix: CharSequence): Constraint

isTrue

fun Validatable<Boolean?>.isTrue(): Constraint

iterator

operator fun <T> Validatable<Iterable<T>?>.iterator(): Iterator<Validatable<T>>

Returns an iterator over the elements of this object. Each element is wrapped with a Validatable.

last

fun <T> Validatable<Array<T>?>.last(): Validatable<T?>

fun <T> Validatable<Iterable<T>?>.last(): Validatable<T?>

Returns the last element, wrapped in Validatable.

map

inline fun <T, R> Validatable<T>.map(transform: (T) -> R): Validatable<R>

Returns a Validatable wrapping the result of the given transform function. The latter is applied to the wrapped value of the Validatable receiver.

path

fun path(): Path

path

fun Validatable<*>.path(block: PathBuilder.() -> Path): Path

registerConstraint

fun registerConstraint(constraint: Constraint)

Registers the provided constraint if it's unsatisfied.

fun registerConstraint(constraint: ConstraintViolation)

Registers the provided constraint violation.

runChecksBeforeConstraintRegistration

fun runChecksBeforeConstraintRegistration()

Runs all the necessary checks before registering a constraint.

toString

open override fun toString(): String

unwrap

fun unwrap(): T

validatableOf

@JvmName(name = "nullableValidatableOfFunction")

fun <T, V> Validatable<T>.validatableOf(getter: (T & Any) -> V): Validatable<V?>

@JvmName(name = "nullableValidatableOfProperty")

fun <T, V> Validatable<T>.validatableOf(getter: KProperty1<T & Any, V>): Validatable<V?>

fun <T : Any, V> Validatable<T>.validatableOf(getter: (T) -> V): Validatable<V>

fun <T : Any, V> Validatable<T>.validatableOf(getter: KProperty1<T, V>): Validatable<V>

validateWith

fun <ValueType> Validatable<ValueType>.validateWith(validator: Validator.Runner<ValueType>)

suspend fun <ValueType> Validatable<ValueType>.validateWith(validator: Validator.SuspendableRunner<ValueType>)

fun <ContextType, ValueType> Validatable<ValueType>.validateWith(validator: Validator.Runner.WithContext<ContextType, ValueType>, context: ContextType)

suspend fun <ContextType, ValueType> Validatable<ValueType>.validateWith(validator: Validator.SuspendableRunner.WithContext<ContextType, ValueType>, context: ContextType)

withValue

fun <NEW_TYPE> withValue(value: NEW_TYPE): Validatable<NEW_TYPE>

Duplicates the Validatable with the new provided value. The path remains the same.