ConfigurationImpl (Red Hat JBoss Enterprise Application Platform 7.2.0.Beta public API)

java.lang.Object
- org.hibernate.validator.internal.engine.ConfigurationImpl

All Implemented Interfaces:

Configuration<HibernateValidatorConfiguration>, ConfigurationState, HibernateValidatorConfiguration
```
public class ConfigurationImpl
extends Object
implements HibernateValidatorConfiguration, ConfigurationState
```
Hibernate specific Configuration implementation.

Author:

Emmanuel Bernard, Hardy Ferentschik, Gunnar Morling, Kevin Pollet <kevin.pollet@serli.com> (C) 2011 SERLI, Chris Beckey <cbeckey@paypal.com>

Field Summary
- Fields inherited from interface org.hibernate.validator.HibernateValidatorConfiguration
  ALLOW_MULTIPLE_CASCADED_VALIDATION_ON_RESULT, ALLOW_PARALLEL_METHODS_DEFINE_PARAMETER_CONSTRAINTS, ALLOW_PARAMETER_CONSTRAINT_OVERRIDE, CONSTRAINT_MAPPING_CONTRIBUTOR, CONSTRAINT_MAPPING_CONTRIBUTORS, FAIL_FAST, TIME_PROVIDER, VALIDATED_VALUE_HANDLERS

Constructor Summary

Constructors
Constructor and Description

ConfigurationImpl(BootstrapState state)

ConfigurationImpl(ValidationProvider<?> provider)

Constructors
Constructor and Description
`ConfigurationImpl(BootstrapState state)`
`ConfigurationImpl(ValidationProvider<?> provider)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`HibernateValidatorConfiguration`	`addMapping(ConstraintMapping mapping)` Adds the specified `ConstraintMapping` instance to the configuration.
`HibernateValidatorConfiguration`	`addMapping(InputStream stream)` Add a stream describing constraint mapping in the Bean Validation XML format.
`HibernateValidatorConfiguration`	`addProperty(String name, String value)` Adds a provider specific property.
`HibernateValidatorConfiguration`	`addValidatedValueHandler(ValidatedValueUnwrapper<?> handler)` Registers the given validated value unwrapper with the bootstrapped validator factory.
`HibernateValidatorConfiguration`	`allowMultipleCascadedValidationOnReturnValues(boolean allow)` Define whether more than one constraint on a return value may be marked for cascading validation are allowed.
`HibernateValidatorConfiguration`	`allowOverridingMethodAlterParameterConstraint(boolean allow)` Define whether overriding methods that override constraints should throw a `ConstraintDefinitionException`.
`HibernateValidatorConfiguration`	`allowParallelMethodsDefineParameterConstraints(boolean allow)` Define whether parallel methods that define constraints should throw a `ConstraintDefinitionException`.
`ValidatorFactory`	`buildValidatorFactory()` Build a `ValidatorFactory` implementation.
`ConfigurationImpl`	`constraintValidatorFactory(ConstraintValidatorFactory constraintValidatorFactory)` Defines the constraint validator factory.
`DefaultConstraintMapping`	`createConstraintMapping()` Creates a new constraint mapping which can be used to programmatically configure the constraints for given types.
`HibernateValidatorConfiguration`	`externalClassLoader(ClassLoader externalClassLoader)` Sets the class loader to be used for loading user-provided resources: XML descriptors (`META-INF/validation.xml` as well as XML constraint mappings) classes specified by name in XML descriptors (e.g.
`HibernateValidatorConfiguration`	`failFast(boolean failFast)` En- or disables the fail fast mode.
`BootstrapConfiguration`	`getBootstrapConfiguration()` Returns configuration information stored in the `META-INF/validation.xml` file.
`ConstraintValidatorFactory`	`getConstraintValidatorFactory()` Returns the constraint validator factory of this configuration.
`ConstraintValidatorFactory`	`getDefaultConstraintValidatorFactory()` Returns an implementation of the `ConstraintValidatorFactory` interface following the default `ConstraintValidatorFactory` defined in the specification: uses the public no-arg constructor of the `ConstraintValidator`
`MessageInterpolator`	`getDefaultMessageInterpolator()` Returns an implementation of the `MessageInterpolator` interface following the default `MessageInterpolator` defined in the specification: use the `ValidationMessages` resource bundle to load keys use `Locale.getDefault()`
`ParameterNameProvider`	`getDefaultParameterNameProvider()` Returns an implementation of the `ParameterNameProvider` interface following the default `ParameterNameProvider` defined in the specification: returns the actual parameter names as provided in the validated executable’s definition, if the class file of the executable contains parameter name information otherwise returns names in the form `arg<PARAMETER_INDEX>`, where `PARAMETER_INDEX` starts at 0 for the first parameter, e.g.
`ResourceBundleLocator`	`getDefaultResourceBundleLocator()` Returns the `ResourceBundleLocator` used by the `default message interpolator` to load user-provided resource bundles.
`TraversableResolver`	`getDefaultTraversableResolver()` Returns an implementation of the `TraversableResolver` interface following the default `TraversableResolver` defined in the specification: if Java Persistence is available in the runtime environment, a property is considered reachable if Java Persistence considers the property as loaded if Java Persistence is not available in the runtime environment, all properties are considered reachable all properties are considered cascadable.
`ClassLoader`	`getExternalClassLoader()`
`boolean`	`getFailFast()`
`Set<InputStream>`	`getMappingStreams()` Returns a set of configuration streams.
`MessageInterpolator`	`getMessageInterpolator()` Returns the message interpolator of this configuration.
`MethodValidationConfiguration`	`getMethodValidationConfiguration()`
`ParameterNameProvider`	`getParameterNameProvider()` Returns the parameter name provider for this configuration.
`Set<DefaultConstraintMapping>`	`getProgrammaticMappings()`
`Map<String,String>`	`getProperties()` Returns a map of non type-safe custom properties.
`ConstraintMappingContributor`	`getServiceLoaderBasedConstraintMappingContributor()`
`TimeProvider`	`getTimeProvider()`
`TraversableResolver`	`getTraversableResolver()` Returns the traversable resolver for this configuration.
`List<ValidatedValueUnwrapper<?>>`	`getValidatedValueHandlers()`
`HibernateValidatorConfiguration`	`ignoreXmlConfiguration()` Ignores data from the `META-INF/validation.xml` file if this method is called.
`boolean`	`isAllowMultipleCascadedValidationOnReturnValues()`
`boolean`	`isAllowOverridingMethodAlterParameterConstraint()`
`boolean`	`isAllowParallelMethodsDefineParameterConstraints()`
`boolean`	`isIgnoreXmlConfiguration()` Returns `true` if `Configuration.ignoreXmlConfiguration()` has been called.
`ConfigurationImpl`	`messageInterpolator(MessageInterpolator interpolator)` Defines the message interpolator used.
`HibernateValidatorConfiguration`	`parameterNameProvider(ParameterNameProvider parameterNameProvider)` Defines the parameter name provider.
`HibernateValidatorConfiguration`	`timeProvider(TimeProvider timeProvider)` Registers the given time provider with the bootstrapped validator factory.
`ConfigurationImpl`	`traversableResolver(TraversableResolver resolver)` Defines the traversable resolver used.

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

Methods inherited from interface javax.validation.Configuration
addValueExtractor, clockProvider, getDefaultClockProvider

Methods inherited from interface javax.validation.spi.ConfigurationState
getClockProvider, getValueExtractors

- Constructor Detail
  - ConfigurationImpl
```
public ConfigurationImpl(BootstrapState state)
```
  - ConfigurationImpl
```
public ConfigurationImpl(ValidationProvider<?> provider)
```
- Method Detail
  - ignoreXmlConfiguration
```
public final HibernateValidatorConfiguration ignoreXmlConfiguration()
```
    Description copied from interface: Configuration
    
    Ignores data from the META-INF/validation.xml file if this method is called.
    This method is typically useful for containers that parse META-INF/validation.xml themselves and pass the information via the Configuration methods.
    
    Specified by:
    
    ignoreXmlConfiguration in interface Configuration<HibernateValidatorConfiguration>
    
    Returns:
    
    this following the chaining method pattern.
  - messageInterpolator
```
public final ConfigurationImpl messageInterpolator(MessageInterpolator interpolator)
```
    Description copied from interface: Configuration
    
    Defines the message interpolator used. Has priority over the configuration based message interpolator.
    If null is passed, the default message interpolator is used (defined in XML or the specification default).
    
    Specified by:
    
    messageInterpolator in interface Configuration<HibernateValidatorConfiguration>
    
    Parameters:
    
    interpolator - message interpolator implementation
    
    Returns:
    
    this following the chaining method pattern
  - traversableResolver
```
public final ConfigurationImpl traversableResolver(TraversableResolver resolver)
```
    Description copied from interface: Configuration
    
    Defines the traversable resolver used. Has priority over the configuration based traversable resolver.
    If null is passed, the default traversable resolver is used (defined in XML or the specification default).
    
    Specified by:
    
    traversableResolver in interface Configuration<HibernateValidatorConfiguration>
    
    Parameters:
    
    resolver - traversable resolver implementation
    
    Returns:
    
    this following the chaining method pattern
  - constraintValidatorFactory
```
public final ConfigurationImpl constraintValidatorFactory(ConstraintValidatorFactory constraintValidatorFactory)
```
    Description copied from interface: Configuration
    
    Defines the constraint validator factory. Has priority over the configuration based constraint factory.
    If null is passed, the default constraint validator factory is used (defined in XML or the specification default).
    
    Specified by:
    
    constraintValidatorFactory in interface Configuration<HibernateValidatorConfiguration>
    
    Parameters:
    
    constraintValidatorFactory - constraint factory implementation
    
    Returns:
    
    this following the chaining method pattern
  - parameterNameProvider
```
public HibernateValidatorConfiguration parameterNameProvider(ParameterNameProvider parameterNameProvider)
```
    Description copied from interface: Configuration
    
    Defines the parameter name provider. Has priority over the configuration based provider.
    If null is passed, the default parameter name provider is used (defined in XML or the specification default).
    
    Specified by:
    
    parameterNameProvider in interface Configuration<HibernateValidatorConfiguration>
    
    Parameters:
    
    parameterNameProvider - parameter name provider implementation
    
    Returns:
    
    this following the chaining method pattern.
  - addMapping
```
public final HibernateValidatorConfiguration addMapping(InputStream stream)
```
    Description copied from interface: Configuration
    
    Add a stream describing constraint mapping in the Bean Validation XML format.
    The stream should be closed by the client API after the ValidatorFactory has been built. The Bean Validation provider must not close the stream.
    
    Specified by:
    
    addMapping in interface Configuration<HibernateValidatorConfiguration>
    
    Parameters:
    
    stream - XML mapping stream; the given stream should support the mark/reset contract (see InputStream.markSupported()); if it doesn't, it will be wrapped into a stream supporting the mark/reset contract by the Bean Validation provider
    
    Returns:
    
    this following the chaining method pattern
  - failFast
```
public final HibernateValidatorConfiguration failFast(boolean failFast)
```
    Description copied from interface: HibernateValidatorConfiguration
    
    En- or disables the fail fast mode. When fail fast is enabled the validation will stop on the first constraint violation detected.
    
    Specified by:
    
    failFast in interface HibernateValidatorConfiguration
    
    Parameters:
    
    failFast - true to enable fail fast, false otherwise.
    
    Returns:
    
    this following the chaining method pattern
  - allowOverridingMethodAlterParameterConstraint
```
public HibernateValidatorConfiguration allowOverridingMethodAlterParameterConstraint(boolean allow)
```
    Description copied from interface: HibernateValidatorConfiguration
    Define whether overriding methods that override constraints should throw a ConstraintDefinitionException. The default value is false, i.e. do not allow.
    See Section 4.5.5 of the JSR 349 specification, specifically
```
 "In sub types (be it sub classes/interfaces or interface implementations), no parameter constraints may
 be declared on overridden or implemented methods, nor may parameters be marked for cascaded validation.
 This would pose a strengthening of preconditions to be fulfilled by the caller."
 
```
    Specified by:
    
    allowOverridingMethodAlterParameterConstraint in interface HibernateValidatorConfiguration
    
    Parameters:
    
    allow - flag determining whether validation will allow overriding to alter parameter constraints.
    
    Returns:
    
    this following the chaining method pattern
  - isAllowOverridingMethodAlterParameterConstraint
```
public boolean isAllowOverridingMethodAlterParameterConstraint()
```
  - allowMultipleCascadedValidationOnReturnValues
```
public HibernateValidatorConfiguration allowMultipleCascadedValidationOnReturnValues(boolean allow)
```
    Description copied from interface: HibernateValidatorConfiguration
    Define whether more than one constraint on a return value may be marked for cascading validation are allowed. The default value is false, i.e. do not allow.
    See Section 4.5.5 of the JSR 349 specification, specifically
```
 "One must not mark a method return value for cascaded validation more than once in a line of a class hierarchy.
 In other words, overriding methods on sub types (be it sub classes/interfaces or interface implementations)
 cannot mark the return value for cascaded validation if the return value has already been marked on the
 overridden method of the super type or interface."
 
```
    Specified by:
    
    allowMultipleCascadedValidationOnReturnValues in interface HibernateValidatorConfiguration
    
    Parameters:
    
    allow - flag determining whether validation will allow multiple cascaded validation on return values.
    
    Returns:
    
    this following the chaining method pattern
  - isAllowMultipleCascadedValidationOnReturnValues
```
public boolean isAllowMultipleCascadedValidationOnReturnValues()
```
  - allowParallelMethodsDefineParameterConstraints
```
public HibernateValidatorConfiguration allowParallelMethodsDefineParameterConstraints(boolean allow)
```
    Description copied from interface: HibernateValidatorConfiguration
    Define whether parallel methods that define constraints should throw a ConstraintDefinitionException. The default value is false, i.e. do not allow.
    See Section 4.5.5 of the JSR 349 specification, specifically
```
 "If a sub type overrides/implements a method originally defined in several parallel types of the hierarchy
 (e.g. two interfaces not extending each other, or a class and an interface not implemented by said class),
 no parameter constraints may be declared for that method at all nor parameters be marked for cascaded validation.
 This again is to avoid an unexpected strengthening of preconditions to be fulfilled by the caller."
 
```
    Specified by:
    
    allowParallelMethodsDefineParameterConstraints in interface HibernateValidatorConfiguration
    
    Parameters:
    
    allow - flag determining whether validation will allow parameter constraints in parallel hierarchies
    
    Returns:
    
    this following the chaining method pattern
  - isAllowParallelMethodsDefineParameterConstraints
```
public boolean isAllowParallelMethodsDefineParameterConstraints()
```
  - getMethodValidationConfiguration
```
public MethodValidationConfiguration getMethodValidationConfiguration()
```
  - createConstraintMapping
```
public final DefaultConstraintMapping createConstraintMapping()
```
    Description copied from interface: HibernateValidatorConfiguration
    
    Creates a new constraint mapping which can be used to programmatically configure the constraints for given types. After the mapping has been set up, it must be added to this configuration via HibernateValidatorConfiguration.addMapping(ConstraintMapping).
    
    Specified by:
    
    createConstraintMapping in interface HibernateValidatorConfiguration
    
    Returns:
    
    A new constraint mapping.
  - addMapping
```
public final HibernateValidatorConfiguration addMapping(ConstraintMapping mapping)
```
    Description copied from interface: HibernateValidatorConfiguration
    
    Adds the specified ConstraintMapping instance to the configuration. Constraints configured in mapping will be added to the constraints configured via annotations and/or xml.
    
    Specified by:
    
    addMapping in interface HibernateValidatorConfiguration
    
    Parameters:
    
    mapping - ConstraintMapping instance containing programmatic configured constraints
    
    Returns:
    
    this following the chaining method pattern
  - addProperty
```
public final HibernateValidatorConfiguration addProperty(String name,
                                                         String value)
```
    Description copied from interface: Configuration
    Adds a provider specific property. This property is equivalent to XML configuration properties. If the underlying provider does not know how to handle the property, it must silently ignore it.
    Note: Using this non type-safe method is generally not recommended.
    It is more appropriate to use, if available, the type-safe equivalent provided by a specific provider via its Configuration subclass.
```
 ValidatorFactory factory = Validation.byProvider(ACMEProvider.class)
     .configure()
         .providerSpecificProperty(ACMEState.FAST)
     .buildValidatorFactory();
 
```
    This method is typically used by containers parsing META-INF/validation.xml themselves and injecting the state to the Configuration object.
    If a property with a given name is defined both via this method and in the XML configuration, the value set programmatically has priority.
    If null is passed as a value, the value defined in XML is used. If no value is defined in XML, the property is considered unset.
    Specified by:
    
    addProperty in interface Configuration<HibernateValidatorConfiguration>
    
    Parameters:
    
    name - property name
    
    value - property value
    
    Returns:
    
    this following the chaining method pattern
  - addValidatedValueHandler
```
public HibernateValidatorConfiguration addValidatedValueHandler(ValidatedValueUnwrapper<?> handler)
```
    Description copied from interface: HibernateValidatorConfiguration
    
    Registers the given validated value unwrapper with the bootstrapped validator factory. When validating an element which is of a type supported by the unwrapper and which is annotated with UnwrapValidatedValue, the unwrapper will be applied to retrieve the value to validate.
    
    Specified by:
    
    addValidatedValueHandler in interface HibernateValidatorConfiguration
    
    Parameters:
    
    handler - the unwrapper to register
    
    Returns:
    
    this following the chaining method pattern
  - getServiceLoaderBasedConstraintMappingContributor
```
public final ConstraintMappingContributor getServiceLoaderBasedConstraintMappingContributor()
```
  - externalClassLoader
```
public HibernateValidatorConfiguration externalClassLoader(ClassLoader externalClassLoader)
```
    Description copied from interface: HibernateValidatorConfiguration
    Sets the class loader to be used for loading user-provided resources:
    - XML descriptors (META-INF/validation.xml as well as XML constraint mappings)
    - classes specified by name in XML descriptors (e.g. custom message interpolators etc.)
    - the ValidationMessages resource bundle
    If no class loader is given, these resources will be obtained through the thread context class loader and as a last fallback through Hibernate Validator's own class loader.
    Specified by:
    
    externalClassLoader in interface HibernateValidatorConfiguration
    
    Parameters:
    
    externalClassLoader - The class loader for loading user-provided resources.
    
    Returns:
    
    this following the chaining method pattern
  - timeProvider
```
public HibernateValidatorConfiguration timeProvider(TimeProvider timeProvider)
```
    Description copied from interface: HibernateValidatorConfiguration
    
    Registers the given time provider with the bootstrapped validator factory. This provider will be used to obtain the current time when validating @Future and @Past constraints. By default the current system time and the current default time zone will be used when validating these constraints.
    
    Specified by:
    
    timeProvider in interface HibernateValidatorConfiguration
    
    Parameters:
    
    timeProvider - the time provider to register. Must not be null
    
    Returns:
    
    this following the chaining method pattern
  - buildValidatorFactory
```
public final ValidatorFactory buildValidatorFactory()
```
    Description copied from interface: Configuration
    
    Build a ValidatorFactory implementation.
    
    Specified by:
    
    buildValidatorFactory in interface Configuration<HibernateValidatorConfiguration>
    
    Returns:
    
    the ValidatorFactory
  - isIgnoreXmlConfiguration
```
public final boolean isIgnoreXmlConfiguration()
```
    Description copied from interface: ConfigurationState
    
    Returns true if Configuration.ignoreXmlConfiguration() has been called.
    In this case, the ValidatorFactory must ignore META-INF/validation.xml.
    
    Specified by:
    
    isIgnoreXmlConfiguration in interface ConfigurationState
    
    Returns:
    
    true if META-INF/validation.xml should be ignored
  - getMessageInterpolator
```
public final MessageInterpolator getMessageInterpolator()
```
    Description copied from interface: ConfigurationState
    Returns the message interpolator of this configuration.
    Message interpolator is defined in the following decreasing priority:
    - set via the Configuration programmatic API
    - defined in META-INF/validation.xml provided that ignoreXmlConfiguration is false. In this case the instance is created via its no-arg constructor.
    - null if undefined.
    Specified by:
    
    getMessageInterpolator in interface ConfigurationState
    
    Returns:
    
    message interpolator instance or null if not defined
  - getMappingStreams
```
public final Set<InputStream> getMappingStreams()
```
    Description copied from interface: ConfigurationState
    Returns a set of configuration streams.
    The streams are defined by:
    - mapping XML streams passed programmatically in Configuration
    - mapping XML streams located in the resources defined in META-INF/validation.xml (constraint-mapping element)
    Streams represented in the XML configuration and opened by the Configuration implementation must be closed by the Configuration implementation after the ValidatorFactory creation (or if an exception occurs). All streams are guaranteed to adhere to the mark/reset contract (see InputStream.markSupported() by the Bean Validation provider.
    Specified by:
    
    getMappingStreams in interface ConfigurationState
    
    Returns:
    
    set of input stream
  - getFailFast
```
public final boolean getFailFast()
```
  - getConstraintValidatorFactory
```
public final ConstraintValidatorFactory getConstraintValidatorFactory()
```
    Description copied from interface: ConfigurationState
    Returns the constraint validator factory of this configuration.
    The ConstraintValidatorFactory implementation is defined in the following decreasing priority:
    - set via the Configuration programmatic API
    - defined in META-INF/validation.xml provided that ignoredXmlConfiguration is false. In this case the instance is created via its no-arg constructor.
    - null if undefined.
    Specified by:
    
    getConstraintValidatorFactory in interface ConfigurationState
    
    Returns:
    
    factory instance or null if not defined
  - getTraversableResolver
```
public final TraversableResolver getTraversableResolver()
```
    Description copied from interface: ConfigurationState
    Returns the traversable resolver for this configuration.
    TraversableResolver is defined in the following decreasing priority:
    - set via the Configuration programmatic API
    - defined in META-INF/validation.xml provided that ignoredXmlConfiguration is false. In this case the instance is created via its no-arg constructor.
    - null if undefined.
    Specified by:
    
    getTraversableResolver in interface ConfigurationState
    
    Returns:
    
    traversable resolver instance or null if not defined
  - getBootstrapConfiguration
```
public BootstrapConfiguration getBootstrapConfiguration()
```
    Description copied from interface: Configuration
    
    Returns configuration information stored in the META-INF/validation.xml file.
    Note:
    Implementations are encouraged to lazily build this object to delay parsing.
    
    Specified by:
    
    getBootstrapConfiguration in interface Configuration<HibernateValidatorConfiguration>
    
    Returns:
    
    returns an instance of BootstrapConfiguration; this method never returns null; if there is no META-INF/validation.xml the different getters of the returned instance will return null respectively an empty set or map
  - getParameterNameProvider
```
public ParameterNameProvider getParameterNameProvider()
```
    Description copied from interface: ConfigurationState
    Returns the parameter name provider for this configuration.
    ParameterNameProvider is defined in the following decreasing priority:
    - set via the Configuration programmatic API
    - defined in META-INF/validation.xml provided that ignoreXmlConfiguration is false. In this case the instance is created via its no-arg constructor.
    - null if undefined.
    Specified by:
    
    getParameterNameProvider in interface ConfigurationState
    
    Returns:
    
    parameter name provider instance or null if not defined
  - getValidatedValueHandlers
```
public List<ValidatedValueUnwrapper<?>> getValidatedValueHandlers()
```
  - getTimeProvider
```
public TimeProvider getTimeProvider()
```
  - getProperties
```
public final Map<String,String> getProperties()
```
    Description copied from interface: ConfigurationState
    Returns a map of non type-safe custom properties.
    Properties defined via:
    - Configuration.addProperty(String, String)
    - META-INF/validation.xml provided that ignoreXmlConfiguration is false.
    If a property is defined both programmatically and in XML, the value defined programmatically has priority.
    Specified by:
    
    getProperties in interface ConfigurationState
    
    Returns:
    
    Map whose key is the property key and the value the property value
  - getExternalClassLoader
```
public ClassLoader getExternalClassLoader()
```
  - getDefaultMessageInterpolator
```
public final MessageInterpolator getDefaultMessageInterpolator()
```
    Description copied from interface: Configuration
    Returns an implementation of the MessageInterpolator interface following the default MessageInterpolator defined in the specification:
    - use the ValidationMessages resource bundle to load keys
    - use Locale.getDefault()
    Specified by:
    
    getDefaultMessageInterpolator in interface Configuration<HibernateValidatorConfiguration>
    
    Returns:
    
    default MessageInterpolator implementation compliant with the specification
  - getDefaultTraversableResolver
```
public final TraversableResolver getDefaultTraversableResolver()
```
    Description copied from interface: Configuration
    Returns an implementation of the TraversableResolver interface following the default TraversableResolver defined in the specification:
    - if Java Persistence is available in the runtime environment, a property is considered reachable if Java Persistence considers the property as loaded
    - if Java Persistence is not available in the runtime environment, all properties are considered reachable
    - all properties are considered cascadable.
    Specified by:
    
    getDefaultTraversableResolver in interface Configuration<HibernateValidatorConfiguration>
    
    Returns:
    
    default TraversableResolver implementation compliant with the specification
  - getDefaultConstraintValidatorFactory
```
public final ConstraintValidatorFactory getDefaultConstraintValidatorFactory()
```
    Description copied from interface: Configuration
    Returns an implementation of the ConstraintValidatorFactory interface following the default ConstraintValidatorFactory defined in the specification:
    - uses the public no-arg constructor of the ConstraintValidator
    Specified by:
    
    getDefaultConstraintValidatorFactory in interface Configuration<HibernateValidatorConfiguration>
    
    Returns:
    
    default ConstraintValidatorFactory implementation compliant with the specification
  - getDefaultResourceBundleLocator
```
public final ResourceBundleLocator getDefaultResourceBundleLocator()
```
    Description copied from interface: HibernateValidatorConfiguration
    Returns the ResourceBundleLocator used by the default message interpolator to load user-provided resource bundles. In conformance with the specification this default locator retrieves the bundle "ValidationMessages".
    
    This locator can be used as delegate for custom locators when setting a customized ResourceBundleMessageInterpolator:
```
 
 	HibernateValidatorConfiguration configure =
    Validation.byProvider(HibernateValidator.class).configure();

  ResourceBundleLocator defaultResourceBundleLocator =
    configure.getDefaultBundleLocator();
  ResourceBundleLocator myResourceBundleLocator =
    new MyResourceBundleLocator(defaultResourceBundleLocator);

  configure.messageInterpolator(
    new ResourceBundleMessageInterpolator(myResourceBundleLocator));
 
 
```
    Specified by:
    
    getDefaultResourceBundleLocator in interface HibernateValidatorConfiguration
    
    Returns:
    
    The default ResourceBundleLocator. Never null.
  - getDefaultParameterNameProvider
```
public ParameterNameProvider getDefaultParameterNameProvider()
```
    Description copied from interface: Configuration
    Returns an implementation of the ParameterNameProvider interface following the default ParameterNameProvider defined in the specification:
    - returns the actual parameter names as provided in the validated executable’s definition, if the class file of the executable contains parameter name information
    - otherwise returns names in the form arg<PARAMETER_INDEX>, where PARAMETER_INDEX starts at 0 for the first parameter, e.g. arg0, arg1 etc.
    Specified by:
    
    getDefaultParameterNameProvider in interface Configuration<HibernateValidatorConfiguration>
    
    Returns:
    
    default ParameterNameProvider implementation compliant with the specification
  - getProgrammaticMappings
```
public final Set<DefaultConstraintMapping> getProgrammaticMappings()
```

Class ConfigurationImpl

Field Summary

Fields inherited from interface org.hibernate.validator.HibernateValidatorConfiguration

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface javax.validation.Configuration

Methods inherited from interface javax.validation.spi.ConfigurationState

Constructor Detail

ConfigurationImpl

ConfigurationImpl

Method Detail

ignoreXmlConfiguration

messageInterpolator

traversableResolver

constraintValidatorFactory

parameterNameProvider

addMapping

failFast

allowOverridingMethodAlterParameterConstraint

isAllowOverridingMethodAlterParameterConstraint

allowMultipleCascadedValidationOnReturnValues

isAllowMultipleCascadedValidationOnReturnValues

allowParallelMethodsDefineParameterConstraints

isAllowParallelMethodsDefineParameterConstraints

getMethodValidationConfiguration

createConstraintMapping

addMapping

addProperty

addValidatedValueHandler

getServiceLoaderBasedConstraintMappingContributor

externalClassLoader

timeProvider

buildValidatorFactory

isIgnoreXmlConfiguration

getMessageInterpolator

getMappingStreams

getFailFast

getConstraintValidatorFactory

getTraversableResolver

getBootstrapConfiguration

getParameterNameProvider

getValidatedValueHandlers

getTimeProvider

getProperties

getExternalClassLoader

getDefaultMessageInterpolator

getDefaultTraversableResolver

getDefaultConstraintValidatorFactory

getDefaultResourceBundleLocator

getDefaultParameterNameProvider

getProgrammaticMappings