ConfigurationImpl (Red Hat JBoss Enterprise Application Platform 7.4.0.GA 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, ENABLE_TRAVERSABLE_RESOLVER_RESULT_CACHE, FAIL_FAST, SCRIPT_EVALUATOR_FACTORY_CLASSNAME, TEMPORAL_VALIDATION_TOLERANCE

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 Jakarta Bean Validation XML format.
`HibernateValidatorConfiguration`	`addProperty(String name, String value)` Adds a provider specific property.
`HibernateValidatorConfiguration`	`addValueExtractor(ValueExtractor<?> extractor)` Adds a value extractor.
`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`.
`HibernateValidatorConfiguration`	`beanMetaDataClassNormalizer(BeanMetaDataClassNormalizer beanMetaDataClassNormalizer)` Allows to set a `BeanMetaDataClassNormalizer` that will be used to normalize the class before accessing the metadata.
`ValidatorFactory`	`buildValidatorFactory()` Build a `ValidatorFactory` implementation.
`HibernateValidatorConfiguration`	`clockProvider(ClockProvider clockProvider)` Defines the clock provider.
`ConfigurationImpl`	`constraintValidatorFactory(ConstraintValidatorFactory constraintValidatorFactory)` Defines the constraint validator factory.
`HibernateValidatorConfiguration`	`constraintValidatorPayload(Object constraintValidatorPayload)` Allows to set a payload which will be passed to the constraint validators.
`DefaultConstraintMapping`	`createConstraintMapping()` Creates a new constraint mapping which can be used to programmatically configure the constraints for given types.
`ConfigurationImpl`	`enableTraversableResolverResultCache(boolean enabled)` Define whether the per validation call caching of `TraversableResolver` results is enabled.
`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.
`BeanMetaDataClassNormalizer`	`getBeanMetaDataClassNormalizer()`
`BootstrapConfiguration`	`getBootstrapConfiguration()` Returns configuration information stored in the `META-INF/validation.xml` file.
`ClockProvider`	`getClockProvider()` Returns the clock provider for this configuration.
`ConstraintValidatorFactory`	`getConstraintValidatorFactory()` Returns the constraint validator factory of this configuration.
`Object`	`getConstraintValidatorPayload()`
`ClockProvider`	`getDefaultClockProvider()` Returns an implementation of the `ClockProvider` interface following the default `ClockProvider` defined in the specification: returns a clock representing the current system time and default time zone.
`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.
`Set<ValueExtractor<?>>`	`getDefaultValueExtractors()` Returns the default `ValueExtractor` implementations as per the specification.
`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.
`ScriptEvaluatorFactory`	`getScriptEvaluatorFactory()`
`Duration`	`getTemporalValidationTolerance()`
`TraversableResolver`	`getTraversableResolver()` Returns the traversable resolver for this configuration.
`Set<ValueExtractor<?>>`	`getValueExtractors()` Returns a set of value extractors.
`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.
`boolean`	`isTraversableResolverResultCacheEnabled()`
`ConfigurationImpl`	`messageInterpolator(MessageInterpolator interpolator)` Defines the message interpolator used.
`HibernateValidatorConfiguration`	`parameterNameProvider(ParameterNameProvider parameterNameProvider)` Defines the parameter name provider.
`HibernateValidatorConfiguration`	`scriptEvaluatorFactory(ScriptEvaluatorFactory scriptEvaluatorFactory)` Allows to specify a custom `ScriptEvaluatorFactory` responsible for creating `ScriptEvaluator`s used to evaluate script expressions for `ScriptAssert` and `ParameterScriptAssert` constraints.
`HibernateValidatorConfiguration`	`temporalValidationTolerance(Duration temporalValidationTolerance)` Allows to set the acceptable margin of error when comparing date/time in temporal constraints such as `Past`/`PastOrPresent` and `Future`/`FutureOrPresent`.
`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

- 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
  - enableTraversableResolverResultCache
```
public final ConfigurationImpl enableTraversableResolverResultCache(boolean enabled)
```
    Description copied from interface: HibernateValidatorConfiguration
    
    Define whether the per validation call caching of TraversableResolver results is enabled. The default value is true, i.e. the caching is enabled.
    This behavior was initially introduced to cache the JPATraversableResolver results but the map lookups it introduces can be counterproductive when the TraversableResolver calls are very fast.
    
    Specified by:
    
    enableTraversableResolverResultCache in interface HibernateValidatorConfiguration
    
    Parameters:
    
    enabled - flag determining whether per validation call caching is enabled for TraversableResolver results.
    
    Returns:
    
    this following the chaining method pattern
  - isTraversableResolverResultCacheEnabled
```
public final boolean isTraversableResolverResultCacheEnabled()
```
  - 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.
  - clockProvider
```
public HibernateValidatorConfiguration clockProvider(ClockProvider clockProvider)
```
    Description copied from interface: Configuration
    
    Defines the clock provider. Has priority over the configuration based provider.
    If null is passed, the default clock provider is used (defined in XML or the specification default).
    
    Specified by:
    
    clockProvider in interface Configuration<HibernateValidatorConfiguration>
    
    Parameters:
    
    clockProvider - clock provider implementation
    
    Returns:
    
    this following the chaining method pattern.
  - addValueExtractor
```
public HibernateValidatorConfiguration addValueExtractor(ValueExtractor<?> extractor)
```
    Description copied from interface: Configuration
    
    Adds a value extractor. Has priority over any extractor for the same type and type parameter detected through the service loader or given in the XML configuration.
    
    Specified by:
    
    addValueExtractor in interface Configuration<HibernateValidatorConfiguration>
    
    Parameters:
    
    extractor - value extractor 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 Jakarta Bean Validation XML format.
    The stream should be closed by the client API after the ValidatorFactory has been built. The Jakarta 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 Jakarta 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 380 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 380 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 380 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
  - scriptEvaluatorFactory
```
public HibernateValidatorConfiguration scriptEvaluatorFactory(ScriptEvaluatorFactory scriptEvaluatorFactory)
```
    Description copied from interface: HibernateValidatorConfiguration
    
    Allows to specify a custom ScriptEvaluatorFactory responsible for creating ScriptEvaluators used to evaluate script expressions for ScriptAssert and ParameterScriptAssert constraints.
    
    Specified by:
    
    scriptEvaluatorFactory in interface HibernateValidatorConfiguration
    
    Parameters:
    
    scriptEvaluatorFactory - the ScriptEvaluatorFactory to be used
    
    Returns:
    
    this following the chaining method pattern
  - temporalValidationTolerance
```
public HibernateValidatorConfiguration temporalValidationTolerance(Duration temporalValidationTolerance)
```
    Description copied from interface: HibernateValidatorConfiguration
    
    Allows to set the acceptable margin of error when comparing date/time in temporal constraints such as Past/PastOrPresent and Future/FutureOrPresent.
    
    Specified by:
    
    temporalValidationTolerance in interface HibernateValidatorConfiguration
    
    Parameters:
    
    temporalValidationTolerance - the acceptable tolerance
    
    Returns:
    
    this following the chaining method pattern
  - constraintValidatorPayload
```
public HibernateValidatorConfiguration constraintValidatorPayload(Object constraintValidatorPayload)
```
    Description copied from interface: HibernateValidatorConfiguration
    
    Allows to set a payload which will be passed to the constraint validators. If the method is called multiple times, only the payload passed last will be propagated.
    
    Specified by:
    
    constraintValidatorPayload in interface HibernateValidatorConfiguration
    
    Parameters:
    
    constraintValidatorPayload - the payload passed to constraint validators
    
    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
  - 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
  - beanMetaDataClassNormalizer
```
public HibernateValidatorConfiguration beanMetaDataClassNormalizer(BeanMetaDataClassNormalizer beanMetaDataClassNormalizer)
```
    Description copied from interface: HibernateValidatorConfiguration
    
    Allows to set a BeanMetaDataClassNormalizer that will be used to normalize the class before accessing the metadata.
    
    Specified by:
    
    beanMetaDataClassNormalizer in interface HibernateValidatorConfiguration
    
    Parameters:
    
    beanMetaDataClassNormalizer - the BeanMetaDataClassNormalizer to use
    
    Returns:
    
    this following the chaining method pattern
  - getBeanMetaDataClassNormalizer
```
public BeanMetaDataClassNormalizer getBeanMetaDataClassNormalizer()
```
  - 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 Jakarta 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
  - getClockProvider
```
public ClockProvider getClockProvider()
```
    Description copied from interface: ConfigurationState
    Returns the clock provider for this configuration.
    ClockProvider 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:
    
    getClockProvider in interface ConfigurationState
    
    Returns:
    
    clock provider instance or null if not defined
  - getScriptEvaluatorFactory
```
public ScriptEvaluatorFactory getScriptEvaluatorFactory()
```
  - getTemporalValidationTolerance
```
public Duration getTemporalValidationTolerance()
```
  - getConstraintValidatorPayload
```
public Object getConstraintValidatorPayload()
```
  - getValueExtractors
```
public Set<ValueExtractor<?>> getValueExtractors()
```
    Description copied from interface: ConfigurationState
    Returns a set of value extractors.
    The extractors are retrieved from the following sources in decreasing order:
    - extractors passed programmatically to Configuration
    - extractors defined in META-INF/validation.xml provided that ignoredXmlConfiguration is false
    - extractors loaded through the Java service loader
    An extractor for a given type and type parameter passed in programmatically takes precedence over any extractor for the same type and type parameter defined in META-INF/validation.xml or loaded through the service loader. Extractors defined in META-INF/validation.xml take precedence over any extractor for the same type and type parameter loaded through the service loader.
    Extractors defined in META-INF/validation.xml or loaded through the service loader are instantiated using their no-arg constructor.
    Specified by:
    
    getValueExtractors in interface ConfigurationState
    
    Returns:
    
    set of value extractors; may be empty but never null
  - 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
  - getDefaultClockProvider
```
public ClockProvider getDefaultClockProvider()
```
    Description copied from interface: Configuration
    Returns an implementation of the ClockProvider interface following the default ClockProvider defined in the specification:
    - returns a clock representing the current system time and default time zone.
    Specified by:
    
    getDefaultClockProvider in interface Configuration<HibernateValidatorConfiguration>
    
    Returns:
    
    default ClockProvider implementation compliant with the specification
  - getDefaultValueExtractors
```
public Set<ValueExtractor<?>> getDefaultValueExtractors()
```
    Description copied from interface: HibernateValidatorConfiguration
    
    Returns the default ValueExtractor implementations as per the specification.
    
    Specified by:
    
    getDefaultValueExtractors in interface HibernateValidatorConfiguration
    
    Returns:
    
    the default ValueExtractor implementations 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

Constructor Detail

ConfigurationImpl

ConfigurationImpl

Method Detail

ignoreXmlConfiguration

messageInterpolator

traversableResolver

enableTraversableResolverResultCache

isTraversableResolverResultCacheEnabled

constraintValidatorFactory

parameterNameProvider

clockProvider

addValueExtractor

addMapping

failFast

allowOverridingMethodAlterParameterConstraint

isAllowOverridingMethodAlterParameterConstraint

allowMultipleCascadedValidationOnReturnValues

isAllowMultipleCascadedValidationOnReturnValues

allowParallelMethodsDefineParameterConstraints

scriptEvaluatorFactory

temporalValidationTolerance

constraintValidatorPayload

isAllowParallelMethodsDefineParameterConstraints

getMethodValidationConfiguration

createConstraintMapping

addMapping

addProperty

externalClassLoader

beanMetaDataClassNormalizer

getBeanMetaDataClassNormalizer

buildValidatorFactory

isIgnoreXmlConfiguration

getMessageInterpolator

getMappingStreams

getFailFast

getConstraintValidatorFactory

getTraversableResolver

getBootstrapConfiguration

getParameterNameProvider

getClockProvider

getScriptEvaluatorFactory

getTemporalValidationTolerance

getConstraintValidatorPayload

getValueExtractors

getProperties

getExternalClassLoader

getDefaultMessageInterpolator

getDefaultTraversableResolver

getDefaultConstraintValidatorFactory

getDefaultResourceBundleLocator

getDefaultParameterNameProvider

getDefaultClockProvider

getDefaultValueExtractors

getProgrammaticMappings