How to use

Log

in

org.hibernate.validator.internal.util.logging

  private void validateParameters() {
    if ( maxIntegerLength < 0 ) {
      throw log.getInvalidLengthForIntegerPartException();
    }
    if ( maxFractionLength < 0 ) {
      throw log.getInvalidLengthForFractionPartException();
    }
  }
}

  private void validateParameters() {
    if ( min < 0 ) {
      throw LOG.getMinCannotBeNegativeException();
    }
    if ( max < 0 ) {
      throw LOG.getMaxCannotBeNegativeException();
    }
    if ( max < min ) {
      throw LOG.getLengthCannotBeNegativeException();
    }
  }
}

@Override
public final ConfigurationImpl messageInterpolator(MessageInterpolator interpolator) {
  if ( LOG.isDebugEnabled() ) {
    if ( interpolator != null ) {
      LOG.debug( "Setting custom MessageInterpolator of type " + interpolator.getClass().getName() );
    }
  }
  this.validationBootstrapParameters.setMessageInterpolator( interpolator );
  return this;
}

  private void validateParameters() {
    if ( min < 0 ) {
      throw LOG.getMaxCannotBeNegativeException();
    }
    if ( max < 0 ) {
      throw LOG.getMaxCannotBeNegativeException();
    }
    if ( max < min ) {
      throw LOG.getLengthCannotBeNegativeException();
    }
  }
}

@Override
public boolean areClassLevelConstraintsIgnoredFor(Class<?> clazz) {
  boolean ignoreAnnotation;
  if ( annotationIgnoresForClasses.containsKey( clazz ) ) {
    ignoreAnnotation = annotationIgnoresForClasses.get( clazz );
  }
  else {
    ignoreAnnotation = areAllConstraintAnnotationsIgnoredFor( clazz );
  }
  if ( LOG.isDebugEnabled() && ignoreAnnotation ) {
    LOG.debugf( "Class level annotation are getting ignored for %s.", clazz.getName() );
  }
  return ignoreAnnotation;
}

public void initialize(ReversePattern parameters) {
  ReversePattern.Flag[] flags = parameters.flags();
  int intFlag = 0;
  for (ReversePattern.Flag flag : flags) {
    intFlag = intFlag | flag.getValue();
  }
  try {
    pattern = java.util.regex.Pattern.compile(parameters.regexp(), intFlag);
  } catch (PatternSyntaxException e) {
    throw LOG.getInvalidRegularExpressionException(e);
  }
}

@Override
public String interpolate(MessageInterpolator.Context context, String expression) {
  String resolvedExpression = expression;
  SimpleELContext elContext = new SimpleELContext( expressionFactory );
  try {
    ValueExpression valueExpression = bindContextValues( expression, context, elContext );
    resolvedExpression = (String) valueExpression.getValue( elContext );
  }
  catch (PropertyNotFoundException pnfe) {
    LOG.unknownPropertyInExpressionLanguage( expression, pnfe );
  }
  catch (ELException e) {
    LOG.errorInExpressionLanguage( expression, e );
  }
  catch (Exception e) {
    LOG.evaluatingExpressionLanguageExpressionCausedException( expression, e );
  }
  return resolvedExpression;
}

@Override
public HibernateValidatorConfiguration addValueExtractor(ValueExtractor<?> extractor) {
  Contracts.assertNotNull( extractor, MESSAGES.parameterMustNotBeNull( "extractor" ) );
  ValueExtractorDescriptor descriptor = new ValueExtractorDescriptor( extractor );
  ValueExtractorDescriptor previous = valueExtractorDescriptors.put( descriptor.getKey(), descriptor );
  if ( previous != null ) {
    throw LOG.getValueExtractorForTypeAndTypeUseAlreadyPresentException( extractor, previous.getValueExtractor() );
  }
  if ( LOG.isDebugEnabled() ) {
    LOG.debug( "Adding value extractor " + extractor );
  }
  return this;
}

private void setMappingStreams(Set<String> mappingFileNames, ClassLoader externalClassLoader) {
  for ( String mappingFileName : mappingFileNames ) {
    log.debugf( "Trying to open input stream for %s.", mappingFileName );
    InputStream in = ResourceLoaderHelper.getResettableInputStreamForPath( mappingFileName, externalClassLoader );
    if ( in == null ) {
      throw log.getUnableToOpenInputStreamForMappingFileException( mappingFileName );
    }
    mappings.add( in );
  }
}

  LOG.debug( "Loaded expression factory via original TCCL" );
  return expressionFactory;
    LOG.debug( "Loaded expression factory via HV classloader" );
    return expressionFactory;
  if ( canLoadExpressionFactory() ) {
    ExpressionFactory expressionFactory = ELManager.getExpressionFactory();
    LOG.debug( "Loaded expression factory via EL classloader" );
    return expressionFactory;
  throw LOG.getUnableToInitializeELExpressionFactoryException( e );
throw LOG.getUnableToInitializeELExpressionFactoryException( null );

      log.debug( "Unable to reset input stream." );
throw log.getErrorParsingMappingFileException( e );

private InputStream getValidationXmlInputStream() {
  LOG.debugf( "Trying to load %s for XML based Validator configuration.", VALIDATION_XML_FILE );
  InputStream inputStream = ResourceLoaderHelper.getResettableInputStreamForPath( VALIDATION_XML_FILE, externalClassLoader );
  if ( inputStream != null ) {
    return inputStream;
  }
  else {
    LOG.debugf( "No %s found. Using annotation based configuration only.", VALIDATION_XML_FILE );
    return null;
  }
}

LOG.debug( "Trying to load " + path + " via user class loader" );
inputStream = externalClassLoader.getResourceAsStream( inputPath );
ClassLoader loader = run( GetClassLoader.fromContext() );
if ( loader != null ) {
  LOG.debug( "Trying to load " + path + " via TCCL" );
  inputStream = loader.getResourceAsStream( inputPath );
LOG.debug( "Trying to load " + path + " via Hibernate Validator's class loader" );
ClassLoader loader = ResourceLoaderHelper.class.getClassLoader();
inputStream = loader.getResourceAsStream( inputPath );

if ( composingConstraintLocations.containsKey( declaredAnnotationType )
    && !ComposingConstraintAnnotationLocation.DIRECT.equals( composingConstraintLocations.get( declaredAnnotationType ) ) ) {
  throw LOG.getCannotMixDirectAnnotationAndListContainerOnComposedConstraintException( annotationDescriptor.getType(), declaredAnnotationType );
composingConstraintsSet.add( descriptor );
composingConstraintLocations.put( declaredAnnotationType, ComposingConstraintAnnotationLocation.DIRECT );
LOG.debugf( "Adding composing constraint: %s.", descriptor );
  if ( composingConstraintLocations.containsKey( constraintAnnotation.annotationType() )
      && !ComposingConstraintAnnotationLocation.IN_CONTAINER.equals( composingConstraintLocations.get( constraintAnnotation.annotationType() ) ) ) {
    throw LOG.getCannotMixDirectAnnotationAndListContainerOnComposedConstraintException( annotationDescriptor.getType(),
        constraintAnnotation.annotationType() );
  composingConstraintsSet.add( descriptor );
  composingConstraintLocations.put( constraintAnnotation.annotationType(), ComposingConstraintAnnotationLocation.IN_CONTAINER );
  LOG.debugf( "Adding composing constraint: %s.", descriptor );
  index++;

  LOG.debugf(
      "Cannot find %s on classpath. Assuming non JPA 2 environment. All properties will per default be traversable.",
      PERSISTENCE_CLASS_NAME
  LOG.debugf(
      "Found %s on classpath, but no method '%s'. Assuming JPA 1 environment. All properties will per default be traversable.",
      PERSISTENCE_CLASS_NAME,
  LOG.debugf(
      "Unable to invoke %s.%s. Inconsistent JPA environment. All properties will per default be traversable.",
      PERSISTENCE_CLASS_NAME,
LOG.debugf(
    "Found %s on classpath containing '%s'. Assuming JPA 2 environment. Trying to instantiate JPA aware TraversableResolver",
    PERSISTENCE_CLASS_NAME,
  Class<? extends TraversableResolver> jpaAwareResolverClass = (Class<? extends TraversableResolver>)
      run( LoadClass.action( JPA_AWARE_TRAVERSABLE_RESOLVER_CLASS_NAME, TraversableResolvers.class.getClassLoader() ) );
  LOG.debugf(
      "Instantiated JPA aware TraversableResolver of type %s.", JPA_AWARE_TRAVERSABLE_RESOLVER_CLASS_NAME
  );
  LOG.logUnableToLoadOrInstantiateJPAAwareResolver( JPA_AWARE_TRAVERSABLE_RESOLVER_CLASS_NAME );
  return getTraverseAllTraversableResolver();

@Override
public boolean areClassLevelConstraintsIgnoredFor(Class<?> clazz) {
  boolean ignoreAnnotation;
  if ( annotationIgnoresForClasses.containsKey( clazz ) ) {
    ignoreAnnotation = annotationIgnoresForClasses.get( clazz );
  }
  else {
    ignoreAnnotation = areAllConstraintAnnotationsIgnoredFor( clazz );
  }
  if ( log.isDebugEnabled() && ignoreAnnotation ) {
    log.debugf( "Class level annotation are getting ignored for %s.", clazz.getName() );
  }
  return ignoreAnnotation;
}

public void initialize(ReversePattern parameters) {
  ReversePattern.Flag[] flags = parameters.flags();
  int intFlag = 0;
  for (ReversePattern.Flag flag : flags) {
    intFlag = intFlag | flag.getValue();
  }
  try {
    pattern = java.util.regex.Pattern.compile(parameters.regexp(), intFlag);
  } catch (PatternSyntaxException e) {
    throw LOG.getInvalidRegularExpressionException(e);
  }
}

  private void validateParameters() {
    if ( min < 0 ) {
      throw log.getMaxCannotBeNegativeException();
    }
    if ( max < 0 ) {
      throw log.getMaxCannotBeNegativeException();
    }
    if ( max < min ) {
      throw log.getLengthCannotBeNegativeException();
    }
  }
}

@Override
public String interpolate(MessageInterpolator.Context context, String expression) {
  String resolvedExpression = expression;
  SimpleELContext elContext = new SimpleELContext( expressionFactory );
  try {
    ValueExpression valueExpression = bindContextValues( expression, context, elContext );
    resolvedExpression = (String) valueExpression.getValue( elContext );
  }
  catch (PropertyNotFoundException pnfe) {
    log.unknownPropertyInExpressionLanguage( expression, pnfe );
  }
  catch (ELException e) {
    log.errorInExpressionLanguage( expression, e );
  }
  catch (Exception e) {
    log.evaluatingExpressionLanguageExpressionCausedException( expression, e );
  }
  return resolvedExpression;
}

private void setMappingStreams(Set<String> mappingFileNames, ClassLoader externalClassLoader) {
  for ( String mappingFileName : mappingFileNames ) {
    LOG.debugf( "Trying to open input stream for %s.", mappingFileName );
    InputStream in = ResourceLoaderHelper.getResettableInputStreamForPath( mappingFileName, externalClassLoader );
    if ( in == null ) {
      throw LOG.getUnableToOpenInputStreamForMappingFileException( mappingFileName );
    }
    mappings.add( in );
  }
}