javax.faces.validator.Validator Java Examples

@Override
protected Validator createValidator() throws JspException {
    DateValidator dateValidator = (DateValidator) super.createValidator();
    dateValidator.setFormat(getFormat());
    dateValidator.setStrict(getStrict());

    return dateValidator;
}
 

public static Validator resolveManagedValidator(Class<? extends Validator> validatorClass)
{
    if (JAVAX_FACES_VALIDATOR_PACKAGE_NAME.equals(validatorClass.getPackage().getName()))
    {
        return null;
    }

    return getContextualReference(BeanManagerProvider.getInstance().getBeanManager(), validatorClass);
}
 

private Validator managedOrDefaultValidator(Validator defaultResult)
{
    if (!this.containerManagedValidatorsEnabled)
    {
        return defaultResult;
    }
    if (defaultResult == null)
    {
        return null;
    }

    Validator result = ManagedArtifactResolver.resolveManagedValidator(defaultResult.getClass());

    if (result == null)
    {
        return defaultResult;
    }

    if (result instanceof DeltaSpikeProxy || ProxyUtils.isProxiedClass(result.getClass()))
    {
        return result;
    }
    else
    {
        return new ValidatorWrapper(result, this.fullStateSavingFallbackEnabled);
    }
}
 

@Override
protected Validator resolveInstanceForClass(FacesContext facesContext, Class<?> wrappedClass)
{
    FacesValidator facesValidator = wrappedClass.getAnnotation(FacesValidator.class);

    if (facesValidator == null)
    {
        return null;
    }

    return facesContext.getApplication().createValidator(facesValidator.value());
}
 

@Override
public Validator createValidator(String arg0) throws FacesException {
    throw new UnsupportedOperationException();
}
 

@Override
public void addValidator(Validator validator) {
    throw new UnsupportedOperationException();
}
 

@Override
public Validator[] getValidators() {
    throw new UnsupportedOperationException();
}
 

@Override
public void removeValidator(Validator validator) {
    throw new UnsupportedOperationException();
}
 

public DumpAccessor find(DumpContext dumpContext, Object o) {
    if(o instanceof ComponentParameters) {
        ComponentParameters c = (ComponentParameters)o;
        // The only access in 852 is through JSON
        try {
            JsonObject js = (JsonObject)JsonParser.fromJson(JsonJavaFactory.instanceEx,c.getAsJson());
            return new JavaScriptDumpFactory.Json(dumpContext,JsonJavaFactory.instanceEx,js);
        } catch(Throwable t) {
            return new JavaDumpFactory.ExceptionValue(dumpContext,t);
        }
    }
    // Use of JSF registry
	if(USE_JSF_REGISTRY) {
        if(    (o instanceof UIComponent) 
        	|| (o instanceof Converter)
        	|| (o instanceof Validator)
        	|| (o instanceof ValueBindingObject)) {
        	FacesDefinition def = XPagesDumpFactory.findDefinition(dumpContext, o);
        	if(def!=null) {
            	return new JSFRegistryValueMap(dumpContext, def, o);
        	}
        }
	}
	// Regular component as a bean
    if(o instanceof UIComponent) {
		return JavaDumpFactory.createJavaBean(dumpContext, o, new JavaDumpFactory.JavaBean.IFilter() {
			public boolean accept(PropertyDescriptor desc) {
				return true;
			}
		});
    }
    if(o instanceof HttpServletRequest) {
        return new HttpServletRequestMap(dumpContext,(HttpServletRequest)o);
    }
    if(o instanceof HttpSession) {
        return new HttpSessionMap(dumpContext,(HttpSession)o);
    }
    if(o instanceof Cookie) {
        return new CookieMap(dumpContext,(Cookie)o);
    }
    if(o instanceof SessionData) {
        return new SessionDataMap(dumpContext,(SessionData)o);
    }
    return null;
}
 

@Override
protected Validator createValidator() throws JspException {
    RegexValidator result = (RegexValidator) super.createValidator();
    result.setRegex(regex);
    return result;
}
 

@SuppressWarnings("UnusedDeclaration")
public <X> void findConverterAndValidatorsWhichNeedProxiesForDependencyInjectionSupport(
        @Observes ProcessAnnotatedType<X> pat, BeanManager beanManager)
{
    if (!this.isActivated)
    {
        return;
    }

    Class<X> beanClass = pat.getAnnotatedType().getJavaClass();

    if (!(Converter.class.isAssignableFrom(beanClass) || (Validator.class.isAssignableFrom(beanClass))))
    {
        return;
    }

    Bean<X> bean = new BeanBuilder<X>(beanManager).readFromType(pat.getAnnotatedType()).create();
    // veto normal converters/validators -> they will get excluded from the special handling later on
    if (!hasInjectionPoints(bean) && !hasNormalScopeAnnotation(bean, beanManager))
    {
        pat.veto();
        return;
    }

    // converters/validators without properties for tags, will be handled by the corresponding manual wrapper
    if (!hasPublicProperty(beanClass))
    {
        return;
    }

    if (!(Modifier.isFinal(beanClass.getModifiers())))
    {
        this.classesToProxy.add(beanClass);
        pat.veto();
    }
    else
    {
        LOG.warning("To use dependency-injection in converters/validators with properties, " +
                "you they aren't allowed to be 'final'.");
    }
}
 

@Override
public Validator createValidator(String validatorId) throws FacesException
{
    return managedOrDefaultValidator(this.wrapped.createValidator(validatorId));
}
 

public ValidatorWrapper(Validator wrapped, boolean fullStateSavingFallbackEnabled)
{
    super(wrapped, fullStateSavingFallbackEnabled);
}