/** @param theMessageInterpolator */
 public GPI18NValidator(IGPI18NMessageInterpolator theMessageInterpolator) {
   Preconditions.checkArgument(
       theMessageInterpolator != null, "The Parameter MessageInterpoletor must " + "not be null.");
   this.messageInterpolator = theMessageInterpolator;
   Configuration<?> configuration = Validation.byDefaultProvider().configure();
   this.validator =
       configuration
           .messageInterpolator(this.messageInterpolator)
           .buildValidatorFactory()
           .getValidator();
 }
  @Override
  @SuppressWarnings("unchecked")
  public void afterPropertiesSet() {
    @SuppressWarnings("rawtypes")
    Configuration configuration =
        (this.providerClass != null
            ? Validation.byProvider(this.providerClass).configure()
            : Validation.byDefaultProvider().configure());

    MessageInterpolator targetInterpolator = this.messageInterpolator;
    if (targetInterpolator == null) {
      targetInterpolator = configuration.getDefaultMessageInterpolator();
    }
    configuration.messageInterpolator(new LocaleContextMessageInterpolator(targetInterpolator));

    if (this.traversableResolver != null) {
      configuration.traversableResolver(this.traversableResolver);
    }

    ConstraintValidatorFactory targetConstraintValidatorFactory = this.constraintValidatorFactory;
    if (targetConstraintValidatorFactory == null && this.applicationContext != null) {
      targetConstraintValidatorFactory =
          new SpringConstraintValidatorFactory(
              this.applicationContext.getAutowireCapableBeanFactory());
    }
    if (targetConstraintValidatorFactory != null) {
      configuration.constraintValidatorFactory(targetConstraintValidatorFactory);
    }

    configureParameterNameProviderIfPossible(configuration);

    if (this.mappingLocations != null) {
      for (Resource location : this.mappingLocations) {
        try {
          configuration.addMapping(location.getInputStream());
        } catch (IOException ex) {
          throw new IllegalStateException("Cannot read mapping resource: " + location);
        }
      }
    }

    for (Map.Entry<String, String> entry : this.validationPropertyMap.entrySet()) {
      configuration.addProperty(entry.getKey(), entry.getValue());
    }

    // Allow for custom post-processing before we actually build the ValidatorFactory.
    postProcessConfiguration(configuration);

    this.validatorFactory = configuration.buildValidatorFactory();
    setTargetValidator(this.validatorFactory.getValidator());
  }
  // For tests
  public ValidatorFactory create() throws Exception {
    Configuration<?> configuration = Validation.byDefaultProvider().configure();
    final Map<Locale, ResourceBundle> resourceBundles = readUserResourceBundles();
    ResourceBundleLocator resourceBundleLocator =
        new ResourceBundleLocator() {
          @Override
          public ResourceBundle getResourceBundle(Locale locale) {
            if (!resourceBundles.containsKey(locale))
              return resourceBundles.values().iterator().next();
            return resourceBundles.get(locale);
          }
        };
    MessageInterpolator messageInterpolator =
        new ResourceBundleMessageInterpolator(resourceBundleLocator);

    return configuration
        .messageInterpolator(new LocaleContextMessageInterpolator(messageInterpolator))
        .buildValidatorFactory();
  }
  @Override
  protected void configure(Configuration cfg) {
    super.configure(cfg);
    final MessageInterpolator messageInterpolator =
        new MessageInterpolator() {

          public String interpolate(String s, Context context) {
            return "Oops";
          }

          public String interpolate(String s, Context context, Locale locale) {
            return interpolate(s, context);
          }
        };
    final javax.validation.Configuration<?> configuration =
        Validation.byDefaultProvider().configure();
    configuration.messageInterpolator(messageInterpolator);
    ValidatorFactory vf = configuration.buildValidatorFactory();
    cfg.getProperties().put("javax.persistence.validation.factory", vf);
    cfg.setProperty("javax.persistence.validation.mode", "AUTO");
  }
  private ValidatorFactory() {
    Configuration<?> config = Validation.byDefaultProvider().configure();
    final MessageInterpolator defaultMessageInterpolator = config.getDefaultMessageInterpolator();

    config.messageInterpolator(
        new MessageInterpolator() {
          @Override
          public String interpolate(String messageTemplate, Context context) {
            String message;
            if (context.getConstraintDescriptor().getPayload() != null
                && context.getConstraintDescriptor().getPayload().contains(Localized.class)) {
              // Retrieve message from message library
              message = MessageUtility.getLocalizedMessage(messageTemplate).getMessage();
            } else {
              message = defaultMessageInterpolator.interpolate(messageTemplate, context);
            }
            return message;
          }

          @Override
          public String interpolate(String messageTemplate, Context context, Locale locale) {
            String message;
            if (context.getConstraintDescriptor().getPayload() != null
                && context.getConstraintDescriptor().getPayload().contains(Localized.class)) {
              // Retrieve message from message library
              message = MessageUtility.getLocalizedMessage(messageTemplate, locale).getMessage();
            } else {
              message = defaultMessageInterpolator.interpolate(messageTemplate, context);
            }
            return message;
          }
        });

    // Stop validation if Entity action is DELETE
    config.traversableResolver(
        new TraversableResolver() {

          @Override
          public boolean isReachable(
              Object traversableObject,
              Node traversableProperty,
              Class<?> rootBeanType,
              Path pathToTraversableObject,
              ElementType elementType) {
            if (traversableObject != null
                && AbstractBindingBean.class.isAssignableFrom(traversableObject.getClass())) {
              AbstractBindingBean bean = (AbstractBindingBean) traversableObject;
              if (bean.getEntityAction() != null && bean.getEntityAction() == EntityAction.DELETE) {
                return false;
              }
            }
            return true;
          }

          @Override
          public boolean isCascadable(
              Object traversableObject,
              Node traversableProperty,
              Class<?> rootBeanType,
              Path pathToTraversableObject,
              ElementType elementType) {
            return true;
          }
        });

    javax.validation.ValidatorFactory factory = config.buildValidatorFactory();
    validator = factory.getValidator();
  }
 @Override
 public T messageInterpolator(final MessageInterpolator interpolator) {
   return delegate.messageInterpolator(interpolator);
 }
  @SuppressWarnings("unchecked")
  private static Configuration<?> getConfig(final ValidationInfo info) {
    Configuration<?> target = null;
    final Thread thread = Thread.currentThread();
    final ClassLoader classLoader = thread.getContextClassLoader();

    String providerClassName = info.providerClassName;
    if (providerClassName == null) {
      providerClassName =
          SystemInstance.get().getOptions().get(VALIDATION_PROVIDER_KEY, (String) null);
    }

    if (providerClassName != null) {
      try {
        @SuppressWarnings({"unchecked", "rawtypes"})
        final Class clazz = classLoader.loadClass(providerClassName);
        target = Validation.byProvider(clazz).configure();
        logger.info("Using " + providerClassName + " as validation provider.");
      } catch (final ClassNotFoundException e) {
        logger.warning("Unable to load provider class " + providerClassName, e);
      } catch (final ValidationException ve) {
        logger.warning(
            "Unable create validator factory with provider "
                + providerClassName
                + " ("
                + ve.getMessage()
                + ")."
                + " Default one will be used.");
      }
    }
    if (target == null) {
      // force to use container provider to ignore any conflicting configuration
      thread.setContextClassLoader(ValidatorBuilder.class.getClassLoader());
      target = Validation.byDefaultProvider().configure();
      thread.setContextClassLoader(classLoader);
    }

    final Set<ExecutableType> types = new HashSet<>();
    for (final String type : info.validatedTypes) {
      types.add(ExecutableType.valueOf(type));
    }

    final Map<String, String> props = new HashMap<>();
    for (final Map.Entry<Object, Object> entry : info.propertyTypes.entrySet()) {
      final PropertyType property = new PropertyType();
      property.setName((String) entry.getKey());
      property.setValue((String) entry.getValue());

      props.put(property.getName(), property.getValue());
      if (logger.isDebugEnabled()) {
        logger.debug(
            "Found property '" + property.getName() + "' with value '" + property.getValue());
      }
      target.addProperty(property.getName(), property.getValue());
    }

    final OpenEjbBootstrapConfig bootstrapConfig =
        new OpenEjbBootstrapConfig(
            providerClassName,
            info.constraintFactoryClass,
            info.messageInterpolatorClass,
            info.traversableResolverClass,
            info.parameterNameProviderClass,
            new HashSet<>(info.constraintMappings),
            info.executableValidationEnabled,
            types,
            props);
    final OpenEjbConfig config = new OpenEjbConfig(bootstrapConfig, target);

    target.ignoreXmlConfiguration();

    final String messageInterpolatorClass = info.messageInterpolatorClass;
    if (messageInterpolatorClass != null) {
      try {
        @SuppressWarnings("unchecked")
        final Class<MessageInterpolator> clazz =
            (Class<MessageInterpolator>) classLoader.loadClass(messageInterpolatorClass);
        target.messageInterpolator(newInstance(config, clazz));
      } catch (final Exception e) {
        logger.warning(
            "Unable to set " + messageInterpolatorClass + " as message interpolator.", e);
      }
      logger.info("Using " + messageInterpolatorClass + " as message interpolator.");
    }
    final String traversableResolverClass = info.traversableResolverClass;
    if (traversableResolverClass != null) {
      try {
        @SuppressWarnings("unchecked")
        final Class<TraversableResolver> clazz =
            (Class<TraversableResolver>) classLoader.loadClass(traversableResolverClass);
        target.traversableResolver(newInstance(config, clazz));
      } catch (final Exception e) {
        logger.warning(
            "Unable to set " + traversableResolverClass + " as traversable resolver.", e);
      }
      logger.info("Using " + traversableResolverClass + " as traversable resolver.");
    }
    final String constraintFactoryClass = info.constraintFactoryClass;
    if (constraintFactoryClass != null) {
      try {
        @SuppressWarnings("unchecked")
        final Class<ConstraintValidatorFactory> clazz =
            (Class<ConstraintValidatorFactory>) classLoader.loadClass(constraintFactoryClass);
        target.constraintValidatorFactory(newInstance(config, clazz));
      } catch (final Exception e) {
        logger.warning("Unable to set " + constraintFactoryClass + " as constraint factory.", e);
      }
      logger.info("Using " + constraintFactoryClass + " as constraint factory.");
    }
    for (final String mappingFileName : info.constraintMappings) {
      if (logger.isDebugEnabled()) {
        logger.debug("Opening input stream for " + mappingFileName);
      }
      final InputStream in = classLoader.getResourceAsStream(mappingFileName);
      if (in == null) {
        logger.warning(
            "Unable to open input stream for mapping file "
                + mappingFileName
                + ". It will be ignored");
      } else {
        target.addMapping(in);
      }
    }
    if (info.parameterNameProviderClass != null) {
      try {
        final Class<ParameterNameProvider> clazz =
            (Class<ParameterNameProvider>) classLoader.loadClass(info.parameterNameProviderClass);
        target.parameterNameProvider(newInstance(config, clazz));
      } catch (final Exception e) {
        logger.warning(
            "Unable to set " + info.parameterNameProviderClass + " as parameter name provider.", e);
      }
      logger.info("Using " + info.parameterNameProviderClass + " as parameter name provider.");
    }

    return config;
  }
 @SuppressWarnings("unchecked")
 @Override
 public T messageInterpolator(MessageInterpolator interpolator) {
   configuration = configuration.messageInterpolator(interpolator);
   return (T) this;
 }