BasicChecks (Fluent validation support. 4.0 API)

java.lang.Object
- fluent.validation.BasicChecks

```
public final class BasicChecks
extends Object
```
Factory of ready to use basic checks. These include: 1. General object checks 2. Logical operators (horizontal composition) 3. Transformation checks (vertical composition) 4. Exception checks 5. Value extractor

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Check<Object>`	`a(Class<?> expectedClass)` Alias of `instanceOf` which may be more readable in some context.
`static <D> Check<D>`	`allOf(Check<? super D>... operands)` General AND operator of multiple checks.
`static <D> Check<D>`	`allOf(Iterable<Check<? super D>> operands)` General AND operator of multiple checks.
`static Check<Object>`	`an(Class<?> expectedClass)` Alias of `instanceOf` which may be more readable in some context.
`static <D> Check<D>`	`anyOf(Check<? super D>... operands)` General OR operator of multiple checks.
`static <D> Check<D>`	`anyOf(Iterable<Check<? super D>> operands)` General OR operator of multiple checks.
`static Check<Object>`	`anything()` Check, that doesn't care of the tested value, and always returns true.
`static <V> TransformationBuilder<V,Check<V>>`	`as(Class<V> type)` Fluent builder of a check, that will assure, that provided object is instance of required class, and if yes, it will cast it to that class, and apply provided check on the required type.
`static <D,V> Check<D>`	`compose(String name, Transformation<? super D,V> transformation, Check<? super V> check)` Convenient composition using transformation of the original object, and check on the result.
`static <D,V> Check<D>`	`compose(Transformation<? super D,V> transformation, Check<? super V> check)` Simplified composition using transformation of the original object, and check on the result.
`static <D> Check<D>`	`createBuilder()`
`static <D> Check<D>`	`createBuilderWith(Check<D> check)`
`static <D> Check<D>`	`customResultFactory(Check<D> check, ResultFactory customResultFactory)`
`static <D> CheckBuilder<D>`	`dsl()`
`static <D> Check<D>`	`equalTo(D expectedValue)` Create a check, that checks if the tested value is equal to expected value.
`static <D,V> TransformationBuilder<V,Check<D>>`	`has(String name, Transformation<? super D,V> transformation)`
`static <D,V> TransformationBuilder<V,Check<D>>`	`has(Transformation<? super D,V> transformation)`
`static <D> Check<D>`	`check(Predicate<D> predicate, String expectationDescription)` Build a custom check using it's description and pure Java predicate.
`static Check<Object>`	`instanceOf(Class<?> expectedClass)` Check, that tested data is instance of provided class (either the class itself or any subclass).
`static <D> Check<D>`	`is(D expectedValue)` Alias for `equalTo`, which may be more readable in some constructions.
`static Check<Object>`	`isA(Class<?> expectedClass)` Alias of `instanceOf` which may be more readable in some context.
`static Check<Object>`	`isAn(Class<?> expectedClass)` Alias of `instanceOf` which may be more readable in some context.
`static Check<Object>`	`isNotNull()` Check, if tested data is not null.
`static Check<Object>`	`isNull()` Check, if tested data is null.
`static Check<Throwable>`	`message(Check<? super String> check)` Check of exception (throwable) message.
`static <D> Check<D>`	`not(D positiveValue)` Check, that provided positive value isn't equal to checked data.
`static <D> Check<D>`	`not(Check<D> positiveCheck)` Check, that provided positive check doesn't match checked data.
`static <D,V> TransformationBuilder<V,Check<D>>`	`nullableHas(String name, Transformation<? super D,V> transformation)`
`static <D,V> TransformationBuilder<V,Check<D>>`	`nullableHas(Transformation<? super D,V> transformation)`
`static <D> Check<D>`	`nullableCheck(Predicate<D> predicate, String expectationDescription)` Define a transparent check using provided predicate and string expectation description.
`static <D> Check<D>`	`oneOf(Collection<D> alternatives)` Create matcher, that matches, if tested object meets one of provided alternatives (or).
`static <D> Check<D>`	`oneOf(D... alternatives)` Create matcher, that matches, if tested object meets one of provided alternatives (or).
`static <D> Check<D>`	`require(Check<? super D> requirement, Check<? super D> check)` Require, that tested data meet provided requirement before application of a check.
`static <D> Check<D>`	`requireNotNull(Check<D> check)` Require, that tested value is not null, before application of the provided check on it.
`static Check<Object>`	`sameClass(Class<?> expectedClass)` Check, that tested data is exactly of the provided type, but not any subcalss of it.
`static <D> Check<D>`	`sameInstance(D expectedInstance)` Create a check, that checks if the tested value is exactly the same instance as expected.
`static <D> Check<D>`	`softCheck(Check<D> check)`
`static ThrowingCheck`	`throwing(Class<? extends Throwable> expectedType)` Check of a code, which should throw an exception (throwable) of expected type.
`static ThrowingCheck`	`throwing(Check<? super Throwable> check)` Check of a code, which should throw an exception (throwable).
`static <D,V> Check<D>`	`transform(Transformation<? super D,V> transformation, Check<? super V> check)` Lowest level transformation.
`static <D> Value<D>`	`value()`
`static <D> Check<D>`	`which(Check<D> check)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - nullableCheck
```
public static <D> Check<D> nullableCheck(Predicate<D> predicate,
                                         String expectationDescription)
```
    Define a transparent check using provided predicate and string expectation description.
    
    Type Parameters:
    
    D - Type of the data to be tested by the created expectation.
    
    Parameters:
    
    predicate - Predicate used to test the supplied data.
    
    expectationDescription - Function, that provides description of the expectation.
    
    Returns:
    
    New expectation.
  - require
```
public static <D> Check<D> require(Check<? super D> requirement,
                                   Check<? super D> check)
```
    Require, that tested data meet provided requirement before application of a check. If the requirement is not met, composed check returns false, and the "actual" check is not evaluated. If the requirement is met, then "actual" check is evaluated, and the result is returned. Error description: If requirement is not met, then error contains description of it's mismatch. If requirement is met, then error contains only mismatch of the "actual" check, while requirement stays silent. The behavior is like Java's and operator, which doesn't evaluate second operand if first one is false. The and() operator check as opposed to this one, evaluates always both operands to get mismatch details from both of them. Keep that in mind and properly decide, in which situation to use which operator.
    
    Type Parameters:
    
    D - Type of the data to be tested by the created check.
    
    Parameters:
    
    requirement - Check, that must return true in order to evaluate the "actual" one.
    
    check - "Actual" check to be evaluated on tested data, if requirement is met.
    
    Returns:
    
    Composed check.
  - requireNotNull
```
public static <D> Check<D> requireNotNull(Check<D> check)
```
    Require, that tested value is not null, before application of the provided check on it. If the tested value is null, then it returns false without evaluating the check. If the tested value is not null, then the provided check is applied, and result is returned.
    
    Type Parameters:
    
    D - Type of the data to be tested by the created check.
    
    Parameters:
    
    check - Check to apply on the value, if it's not null.
    
    Returns:
    
    Composed check.
  - check
```
public static <D> Check<D> check(Predicate<D> predicate,
                                 String expectationDescription)
```
    Build a custom check using it's description and pure Java predicate. As the Predicate doesn't provide any transparency, it's enriched with the description.
    
    Type Parameters:
    
    D - Type of the data to be checked.
    
    Parameters:
    
    predicate - Implementation of the check logic.
    
    expectationDescription - Description of the expectation represented by this check.
    
    Returns:
    
    Custom check.
  - sameInstance
```
public static <D> Check<D> sameInstance(D expectedInstance)
```
    Create a check, that checks if the tested value is exactly the same instance as expected. This check doesn't use `equals()` method, but reference comparison operator ==.
    
    Type Parameters:
    
    D - Type of the tested data.
    
    Parameters:
    
    expectedInstance - Expected instance.
    
    Returns:
    
    New check.
  - equalTo
```
public static <D> Check<D> equalTo(D expectedValue)
```
    Create a check, that checks if the tested value is equal to expected value. It will return true as long as the equals() method does.
    
    Type Parameters:
    
    D - Type of the tested data.
    
    Parameters:
    
    expectedValue - Expected value.
    
    Returns:
    
    New check.
  - is
```
public static <D> Check<D> is(D expectedValue)
```
    Alias for `equalTo`, which may be more readable in some constructions.
    
    Type Parameters:
    
    D - Type of the tested data.
    
    Parameters:
    
    expectedValue - Expected value.
    
    Returns:
    
    New check.
    
    See Also:
    
    equalTo(Object)
  - isNull
```
public static Check<Object> isNull()
```
    Check, if tested data is null.
    
    Returns:
    
    New check.
  - isNotNull
```
public static Check<Object> isNotNull()
```
    Check, if tested data is not null.
    
    Returns:
    
    New check.
  - anything
```
public static Check<Object> anything()
```
    Check, that doesn't care of the tested value, and always returns true.
    
    Returns:
    
    New check.
  - instanceOf
```
public static Check<Object> instanceOf(Class<?> expectedClass)
```
    Check, that tested data is instance of provided class (either the class itself or any subclass).
    
    Parameters:
    
    expectedClass - Expected class.
    
    Returns:
    
    New check.
  - isA
```
public static Check<Object> isA(Class<?> expectedClass)
```
    Alias of `instanceOf` which may be more readable in some context.
    
    Parameters:
    
    expectedClass - Expected class.
    
    Returns:
    
    New check.
  - isAn
```
public static Check<Object> isAn(Class<?> expectedClass)
```
    Alias of `instanceOf` which may be more readable in some context.
    
    Parameters:
    
    expectedClass - Expected class.
    
    Returns:
    
    New check.
  - a
```
public static Check<Object> a(Class<?> expectedClass)
```
    Alias of `instanceOf` which may be more readable in some context.
    
    Parameters:
    
    expectedClass - Expected class.
    
    Returns:
    
    New check.
  - an
```
public static Check<Object> an(Class<?> expectedClass)
```
    Alias of `instanceOf` which may be more readable in some context.
    
    Parameters:
    
    expectedClass - Expected class.
    
    Returns:
    
    New check.
  - sameClass
```
public static Check<Object> sameClass(Class<?> expectedClass)
```
    Check, that tested data is exactly of the provided type, but not any subcalss of it.
    
    Parameters:
    
    expectedClass - Expected class.
    
    Returns:
    
    New check.
  - not
```
public static <D> Check<D> not(Check<D> positiveCheck)
```
    Check, that provided positive check doesn't match checked data.
    
    Type Parameters:
    
    D - Type of the data to be tested by the created check.
    
    Parameters:
    
    positiveCheck - Positive check to evaluate, what shouldn't match.
    
    Returns:
    
    Negated expectation.
  - not
```
public static <D> Check<D> not(D positiveValue)
```
    Check, that provided positive value isn't equal to checked data.
    
    Type Parameters:
    
    D - Type of the data to be tested by the created check.
    
    Parameters:
    
    positiveValue - Positive value, which shouldn't be equal to checked data.
    
    Returns:
    
    Negated expectation.
  - oneOf
```
public static <D> Check<D> oneOf(Collection<D> alternatives)
```
    Create matcher, that matches, if tested object meets one of provided alternatives (or).
    
    Type Parameters:
    
    D - Type of the data to test using this expectation.
    
    Parameters:
    
    alternatives - Expected alternatives.
    
    Returns:
    
    Expectation with alternatives.
  - oneOf
```
@SafeVarargs
public static <D> Check<D> oneOf(D... alternatives)
```
    Create matcher, that matches, if tested object meets one of provided alternatives (or).
    
    Type Parameters:
    
    D - Type of the data to test using this expectation.
    
    Parameters:
    
    alternatives - Expected alternatives.
    
    Returns:
    
    Expectation with alternatives.
  - anyOf
```
public static <D> Check<D> anyOf(Iterable<Check<? super D>> operands)
```
    General OR operator of multiple checks. The created check returns true if any of the provided operands (checks) returns true on the tested data, and only if none of the operands returns true, then the resulting check returns false. Corner case: If no operands are provided, then it returns false (as none of them evaluated to true).
    
    Type Parameters:
    
    D - Type of the tested data.
    
    Parameters:
    
    operands - Individual checks to evaluate and apply logical or on their results.
    
    Returns:
    
    New check with the described logic.
  - anyOf
```
@SafeVarargs
public static <D> Check<D> anyOf(Check<? super D>... operands)
```
    General OR operator of multiple checks. The created check returns true if any of the provided operands (checks) returns true on the tested data, and only if none of the operands returns true, then the resulting check returns false. Corner case: If no operands are provided, then it returns false (as none of them evaluated to true).
    
    Type Parameters:
    
    D - Type of the tested data.
    
    Parameters:
    
    operands - Individual checks to evaluate and apply logical or on their results.
    
    Returns:
    
    New check with the described logic.
  - allOf
```
public static <D> Check<D> allOf(Iterable<Check<? super D>> operands)
```
    General AND operator of multiple checks. The created check returns true if all the provided operands (checks) return true on the tested data, and if any of the operands returns false, then the resulting check returns false. Corner case: If no operands are provided, then it returns true (as none of them evaluated to false).
    
    Type Parameters:
    
    D - Type of the tested data.
    
    Parameters:
    
    operands - Individual checks to evaluate and apply logical and on their results.
    
    Returns:
    
    New check with the described logic.
  - allOf
```
@SafeVarargs
public static <D> Check<D> allOf(Check<? super D>... operands)
```
    General AND operator of multiple checks. The created check returns true if all the provided operands (checks) return true on the tested data, and if any of the operands returns false, then the resulting check returns false. Corner case: If no operands are provided, then it returns true (as none of them evaluated to false).
    
    Type Parameters:
    
    D - Type of the tested data.
    
    Parameters:
    
    operands - Individual checks to evaluate and apply logical and on their results.
    
    Returns:
    
    New check with the described logic.
  - transform
```
public static <D,V> Check<D> transform(Transformation<? super D,V> transformation,
                                       Check<? super V> check)
```
    Lowest level transformation. Create a new check using transformation of the original object, e.g. by accessing it's field, and partial check applied on the result of the transformation.
    
    Type Parameters:
    
    D - Type of the original tested object.
    
    V - Type of the transformation result.
    
    Parameters:
    
    transformation - Function transforming the original object.
    
    check - Check to apply on the result of the transformation.
    
    Returns:
    
    Composed check applicable on the original (whole) object.
  - compose
```
public static <D,V> Check<D> compose(String name,
                                     Transformation<? super D,V> transformation,
                                     Check<? super V> check)
```
    Convenient composition using transformation of the original object, and check on the result.
    
    Type Parameters:
    
    D - Type of the original tested object.
    
    V - Type of the transformation result.
    
    Parameters:
    
    name - Name (description) of the transformation.
    
    transformation - Function transforming the original object.
    
    check - Check to apply on the result of the transformation.
    
    Returns:
    
    Composed check applicable on the original (whole) object.
  - compose
```
public static <D,V> Check<D> compose(Transformation<? super D,V> transformation,
                                     Check<? super V> check)
```
    Simplified composition using transformation of the original object, and check on the result.
    
    Type Parameters:
    
    D - Type of the original tested object.
    
    V - Type of the transformation result.
    
    Parameters:
    
    transformation - Function transforming the original object.
    
    check - Check to apply on the result of the transformation.
    
    Returns:
    
    Composed check applicable on the original (whole) object.
  - has
```
public static <D,V> TransformationBuilder<V,Check<D>> has(String name,
                                                          Transformation<? super D,V> transformation)
```
  - has
```
public static <D,V> TransformationBuilder<V,Check<D>> has(Transformation<? super D,V> transformation)
```
  - nullableHas
```
public static <D,V> TransformationBuilder<V,Check<D>> nullableHas(String name,
                                                                  Transformation<? super D,V> transformation)
```
  - nullableHas
```
public static <D,V> TransformationBuilder<V,Check<D>> nullableHas(Transformation<? super D,V> transformation)
```
  - as
```
public static <V> TransformationBuilder<V,Check<V>> as(Class<V> type)
```
    Fluent builder of a check, that will assure, that provided object is instance of required class, and if yes, it will cast it to that class, and apply provided check on the required type.
    
    Type Parameters:
    
    V - Type to check, and cast to.
    
    Parameters:
    
    type - Required Java class / type
    
    Returns:
    
    Builder of a object check, that accepts check on the required type.
  - message
```
public static Check<Throwable> message(Check<? super String> check)
```
    Check of exception (throwable) message.
    
    Parameters:
    
    check - String check of the message content.
    
    Returns:
    
    Check on Throwable.
  - throwing
```
public static ThrowingCheck throwing(Check<? super Throwable> check)
```
    Check of a code, which should throw an exception (throwable). The created check will actually run the code passed to test, and return true if the code throws exception, which matches specified criteria.
    
    Parameters:
    
    check - Check on the throwable.
    
    Returns:
    
    ThrowingCheck applicable on provided code, allowing to build further criteria.
  - throwing
```
public static ThrowingCheck throwing(Class<? extends Throwable> expectedType)
```
    Check of a code, which should throw an exception (throwable) of expected type. The created check will actually run the code passed to test, and return true if the code throws exception of the required type.
    
    Parameters:
    
    expectedType - Expected type of the thrown exception.
    
    Returns:
    
    ThrowingCheck applicable on provided code, allowing to build further criteria.
  - createBuilder
```
public static <D> Check<D> createBuilder()
```
  - createBuilderWith
```
public static <D> Check<D> createBuilderWith(Check<D> check)
```
  - which
```
public static <D> Check<D> which(Check<D> check)
```
  - dsl
```
public static <D> CheckBuilder<D> dsl()
```
  - value
```
public static <D> Value<D> value()
```
  - softCheck
```
public static <D> Check<D> softCheck(Check<D> check)
```
  - customResultFactory
```
public static <D> Check<D> customResultFactory(Check<D> check,
                                               ResultFactory customResultFactory)
```

Class BasicChecks

Method Summary

Methods inherited from class java.lang.Object

Method Detail

nullableCheck

require

requireNotNull

check

sameInstance

equalTo

is

isNull

isNotNull

anything

instanceOf

isA

isAn

a

an

sameClass

not

not

oneOf

oneOf

anyOf

anyOf

allOf

allOf

transform

compose

compose

has

has

nullableHas

nullableHas

as

message

throwing

throwing

createBuilder

createBuilderWith

which

dsl

value

softCheck

customResultFactory