public ClassValidator(Class beanClass) 
{
	        	 
		this( beanClass, (ResourceBundle) null );
}

create the validator engine for this bean type

 public ClassValidator(Class beanClass,
    ResourceBundle resourceBundle) 
{
		this( beanClass, resourceBundle, null, new HashMap< XClass, ClassValidator >(), null );
}

create the validator engine for a particular bean class, using a resource bundle for message rendering on violation

 public ClassValidator(Class beanClass,
    MessageInterpolator interpolator) 
{
		this( beanClass, null, interpolator, new HashMap< XClass, ClassValidator >(), null );
}

create the validator engine for a particular bean class, using a custom message interpolator for message rendering on violation

 public ClassValidator(Class beanClass,
    ResourceBundle resourceBundle,
    MessageInterpolator interpolator,
    Map childClassValidators,
    ReflectionManager reflectionManager) 
{
        this.reflectionManager = reflectionManager != null ? reflectionManager : new JavaReflectionManager();
        XClass beanXClass = this.reflectionManager.toXClass( beanClass );
		this.beanClass = beanClass;
		this.messageBundle = resourceBundle == null ?
				getDefaultResourceBundle() :
				resourceBundle;
		this.defaultMessageBundle = ResourceBundle.getBundle( DEFAULT_VALIDATOR_MESSAGE );
		this.userInterpolator = interpolator;
		this.childClassValidators = childClassValidators != null ?
                childClassValidators :
                new HashMap< XClass, ClassValidator >();
		initValidator( beanXClass, this.childClassValidators );
}

Not a public API

 protected ClassValidator(XClass beanXClass,
    ResourceBundle resourceBundle,
    MessageInterpolator userInterpolator,
    Map childClassValidators,
    ReflectionManager reflectionManager) 
{
		this.reflectionManager = reflectionManager;
		this.beanClass = reflectionManager.toClass( beanXClass );
		this.messageBundle = resourceBundle == null ?
				getDefaultResourceBundle() :
				resourceBundle;
		this.defaultMessageBundle = ResourceBundle.getBundle( DEFAULT_VALIDATOR_MESSAGE );
		this.userInterpolator = userInterpolator;
		this.childClassValidators = childClassValidators;
		initValidator( beanXClass, childClassValidators );
}

 public  void apply(PersistentClass persistentClass) 
{
		for ( Validator validator : beanValidators ) {
			if ( validator instanceof PersistentClassConstraint ) {
				( (PersistentClassConstraint) validator ).apply( persistentClass );
			}
		}
		Iterator< Validator > validators = memberValidators.iterator();
		Iterator< XMember > getters = memberGetters.iterator();
		while ( validators.hasNext() ) {
			Validator validator = validators.next();
			String propertyName = getPropertyName( getters.next() );
			if ( validator instanceof PropertyConstraint ) {
				try {
					Property property = findPropertyByName(persistentClass, propertyName);
					if (property != null) {
						( (PropertyConstraint) validator ).apply( property );
					}
				}
				catch (MappingException pnfe) {
					//do nothing
				}
			}
		}
}

apply the registred constraints rules on the hibernate metadata (to be applied on DB schema...)

 public  void assertValid(T bean) 
{
		InvalidValue[] values = getInvalidValues( bean );
		if ( values.length  > 0 ) {
			throw new InvalidStateException( values );
		}
}

 public static Property findPropertyByName(PersistentClass associatedClass,
    String propertyName) 
{
		Property property = null;
		Property idProperty = associatedClass.getIdentifierProperty();
		String idName = idProperty != null ? idProperty.getName() : null;
		try {
			if ( propertyName == null
					|| propertyName.length() == 0
					|| propertyName.equals( idName ) ) {
				//default to id
				property = idProperty;
			}
			else {
				if ( propertyName.indexOf( idName + "." ) == 0 ) {
					property = idProperty;
					propertyName = propertyName.substring( idName.length() + 1 );
				}
				StringTokenizer st = new StringTokenizer( propertyName, ".", false );
				while ( st.hasMoreElements() ) {
					String element = (String) st.nextElement();
					if ( property == null ) {
						property = associatedClass.getProperty( element );
					}
					else {
						if ( ! property.isComposite() ) return null;
						property = ( (Component) property.getValue() ).getProperty( element );
					}
				}
			}
		}
		catch (MappingException e) {
			try {
				//if we do not find it try to check the identifier mapper
				if ( associatedClass.getIdentifierMapper() == null ) return null;
				StringTokenizer st = new StringTokenizer( propertyName, ".", false );
				while ( st.hasMoreElements() ) {
					String element = (String) st.nextElement();
					if ( property == null ) {
						property = associatedClass.getIdentifierMapper().getProperty( element );
					}
					else {
						if ( ! property.isComposite() ) return null;
						property = ( (Component) property.getValue() ).getProperty( element );
					}
				}
			}
			catch (MappingException ee) {
				return null;
			}
		}
		return property;
}

Retrieve the property by path in a recursive way, including IndetifierProperty in the loop If propertyName is null or empty, the IdentifierProperty is returned

 public InvalidValue[] getInvalidValues(T bean) 
{
		return this.getInvalidValues( bean, new IdentitySet() );
}

apply constraints on a bean instance and return all the failures. if bean is null, an empty array is returned

 protected InvalidValue[] getInvalidValues(T bean,
    Set circularityState) 
{
		if ( bean == null || circularityState.contains( bean ) ) {
			return EMPTY_INVALID_VALUE_ARRAY; //Avoid circularity
		}
		else {
			circularityState.add( bean );
		}
		if ( !beanClass.isInstance( bean ) ) {
			throw new IllegalArgumentException( "not an instance of: " + bean.getClass() );
		}
		List< InvalidValue > results = new ArrayList< InvalidValue >();
		for ( int i = 0; i <  beanValidators.size() ; i++ ) {
			Validator validator = beanValidators.get( i );
			if ( !validator.isValid( bean ) ) {
				results.add( new InvalidValue( interpolate(validator), beanClass, null, bean, bean ) );
			}
		}
		for ( int i = 0; i <  memberValidators.size() ; i++ ) {
			XMember getter = memberGetters.get( i );
			if ( Hibernate.isPropertyInitialized( bean, getPropertyName( getter ) ) ) {
				Object value = getMemberValue( bean, getter );
				Validator validator = memberValidators.get( i );
				if ( !validator.isValid( value ) ) {
					String propertyName = getPropertyName( getter );
					results.add( new InvalidValue( interpolate(validator), beanClass, propertyName, value, bean ) );
				}
			}
		}
		for ( int i = 0; i <  childGetters.size() ; i++ ) {
			XMember getter = childGetters.get( i );
			if ( Hibernate.isPropertyInitialized( bean, getPropertyName( getter ) ) ) {
				Object value = getMemberValue( bean, getter );
				if ( value != null && Hibernate.isInitialized( value ) ) {
					String propertyName = getPropertyName( getter );
					if ( getter.isCollection() ) {
						int index = 0;
						boolean isIterable = value instanceof Iterable;
						Map map = ! isIterable ? (Map) value : null;
						Iterable elements = isIterable ?
								(Iterable) value :
								map.keySet();
						for ( Object element : elements ) {
							Object actualElement = isIterable ? element : map.get( element );
							if ( actualElement == null ) {
								index++;
								continue;
							}
							InvalidValue[] invalidValues = getClassValidator( actualElement )
									.getInvalidValues( actualElement, circularityState );
							String indexedPropName = MessageFormat.format(
									"{0}[{1}]",
									propertyName,
									INDEXABLE_CLASS.contains( element.getClass() ) ?
											( "'" + element + "'" ) :
											index
							);
							index++;
							for ( InvalidValue invalidValue : invalidValues ) {
								invalidValue.addParentBean( bean, indexedPropName );
								results.add( invalidValue );
							}
						}
					}
					if ( getter.isArray() ) {
						int index = 0;
						for ( Object element : (Object[]) value ) {
							if ( element == null ) {
								index++;
								continue;
							}
							InvalidValue[] invalidValues = getClassValidator( element )
									.getInvalidValues( element, circularityState );
							String indexedPropName = MessageFormat.format(
									"{0}[{1}]",
									propertyName,
									index
							);
							index++;
							for ( InvalidValue invalidValue : invalidValues ) {
								invalidValue.addParentBean( bean, indexedPropName );
								results.add( invalidValue );
							}
						}
					}
					else {
						InvalidValue[] invalidValues = getClassValidator( value )
								.getInvalidValues( value, circularityState );
						for ( InvalidValue invalidValue : invalidValues ) {
							invalidValue.addParentBean( bean, propertyName );
							results.add( invalidValue );
						}
					}
				}
			}
		}
		return results.toArray( new InvalidValue[results.size()] );
}

apply constraints on a bean instance and return all the failures. if bean is null, an empty array is returned

 public InvalidValue[] getInvalidValues(T bean,
    String propertyName) 
{
		List< InvalidValue > results = new ArrayList< InvalidValue >();
		for ( int i = 0; i <  memberValidators.size() ; i++ ) {
			XMember getter = memberGetters.get( i );
			if ( getPropertyName( getter ).equals( propertyName ) ) {
				Object value = getMemberValue( bean, getter );
				Validator validator = memberValidators.get( i );
				if ( !validator.isValid( value ) ) {
					results.add( new InvalidValue( interpolate(validator), beanClass, propertyName, value, bean ) );
				}
			}
		}
		return results.toArray( new InvalidValue[results.size()] );
}

Apply constraints of a particular property on a bean instance and return all the failures. Note this is not recursive.

 public InvalidValue[] getPotentialInvalidValues(String propertyName,
    Object value) 
{
		List< InvalidValue > results = new ArrayList< InvalidValue >();
		for ( int i = 0; i <  memberValidators.size() ; i++ ) {
			XMember getter = memberGetters.get( i );
			if ( getPropertyName( getter ).equals( propertyName ) ) {
				Validator validator = memberValidators.get( i );
				if ( !validator.isValid( value ) ) {
					results.add( new InvalidValue( interpolate(validator), beanClass, propertyName, value, null ) );
				}
			}
		}
		return results.toArray( new InvalidValue[results.size()] );
}

Apply constraints of a particular property value of a bean type and return all the failures. The InvalidValue objects returns return null for InvalidValue#getBean() and InvalidValue#getRootBean() Note this is not recursive.

 public boolean hasValidationRules() 
{
		return beanValidators.size() != 0 || memberValidators.size() != 0;
}