Eg. if we have nested Visitor AddressVisitor nested inside PersonVisitor, when using the normal #getFullFieldName, we will get "address.somefield", we lost the parent, with this wrapper, we will get "person.address.somefield". This is so that the key is used to register errors, so that we don't screw up short-curcuit feature when using nested visitor. See XW-571 (nested visitor validators break short-circuit functionality) at http://jira.opensymphony.com/browse/XW-571 

 protected List<ValidatorConfig> buildClassValidatorConfigs(Class aClass,
    boolean checkFile) 
{
        String fileName = aClass.getName().replace('.', '/') + VALIDATION_CONFIG_SUFFIX;
        List< ValidatorConfig > result = new ArrayList< ValidatorConfig >(loadFile(fileName, aClass, checkFile));
        AnnotationValidationConfigurationBuilder builder = new AnnotationValidationConfigurationBuilder(validatorFactory);
        List< ValidatorConfig > annotationResult = new ArrayList< ValidatorConfig >(builder.buildAnnotationClassValidatorConfigs(aClass));
        result.addAll(annotationResult);
        return result;
}

 protected static String buildValidatorKey(Class clazz) 
{
        ActionInvocation invocation = ActionContext.getContext().getActionInvocation();
        ActionProxy proxy = invocation.getProxy();
        //the key needs to use the name of the action from the config file,
        //instead of the url, so wild card actions will have the same validator
        //see WW-2996
        StringBuilder sb = new StringBuilder(clazz.getName());
        sb.append("/");
        sb.append(proxy.getConfig().getName());
        sb.append("|");
        sb.append(proxy.getMethod());
        return sb.toString();
}

Builds a key for validators - used when caching validators.

 public synchronized List<Validator> getValidators(Class clazz,
    String context) 
{
        return getValidators(clazz, context, null);
}

 public synchronized List<Validator> getValidators(Class clazz,
    String context,
    String method) 
{
        final String validatorKey = buildValidatorKey(clazz);
        if (validatorCache.containsKey(validatorKey)) {
            if (FileManager.isReloadingConfigs()) {
                validatorCache.put(validatorKey, buildValidatorConfigs(clazz, context, true, null));
            }
        } else {
            validatorCache.put(validatorKey, buildValidatorConfigs(clazz, context, false, null));
        }
        // get the set of validator configs
        List< ValidatorConfig > cfgs = validatorCache.get(validatorKey);
        ValueStack stack = ActionContext.getContext().getValueStack();
        // create clean instances of the validators for the caller's use
        ArrayList< Validator > validators = new ArrayList< Validator >(cfgs.size());
        for (ValidatorConfig cfg : cfgs) {
            if (method == null || method.equals(cfg.getParams().get("methodName"))) {
                Validator validator = validatorFactory.getValidator(
                        new ValidatorConfig.Builder(cfg)
                            .removeParam("methodName")
                            .build());
                validator.setValidatorType(cfg.getType());
                validator.setValueStack(stack);
                validators.add(validator);
            }
        }
        return validators;
}

 public  void setValidatorFactory(ValidatorFactory fac) 
{
        this.validatorFactory = fac;
}

 public  void setValidatorFileParser(ValidatorFileParser parser) 
{
        this.validatorFileParser = parser;
}

 public  void validate(Object object,
    String context) throws ValidationException 
{
        validate(object, context, (String) null);
}

 public  void validate(Object object,
    String context,
    String method) throws ValidationException 
{
        ValidatorContext validatorContext = new DelegatingValidatorContext(object);
        validate(object, context, validatorContext, method);
}

 public  void validate(Object object,
    String context,
    ValidatorContext validatorContext) throws ValidationException 
{
        validate(object, context, validatorContext, null);
}

 public  void validate(Object object,
    String context,
    ValidatorContext validatorContext,
    String method) throws ValidationException 
{
        List< Validator > validators = getValidators(object.getClass(), context, method);
        Set< String > shortcircuitedFields = null;
        for (final Validator validator: validators) {
            try {
                validator.setValidatorContext(validatorContext);
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Running validator: " + validator + " for object " + object + " and method " + method);
                }
                FieldValidator fValidator = null;
                String fullFieldName = null;
                if (validator instanceof FieldValidator) {
                    fValidator = (FieldValidator) validator;
                    fullFieldName = new InternalValidatorContextWrapper(fValidator.getValidatorContext()).getFullFieldName(fValidator.getFieldName());
                    if ((shortcircuitedFields != null) && shortcircuitedFields.contains(fullFieldName)) {
                        if (LOG.isDebugEnabled()) {
                            LOG.debug("Short-circuited, skipping");
                        }
                        continue;
                    }
                }
                if (validator instanceof ShortCircuitableValidator && ((ShortCircuitableValidator) validator).isShortCircuit())
                {
                    // get number of existing errors
                    List< String > errs = null;
                    if (fValidator != null) {
                        if (validatorContext.hasFieldErrors()) {
                            Collection< String > fieldErrors = validatorContext.getFieldErrors().get(fullFieldName);
                            if (fieldErrors != null) {
                                errs = new ArrayList< String >(fieldErrors);
                            }
                        }
                    } else if (validatorContext.hasActionErrors()) {
                        Collection< String > actionErrors = validatorContext.getActionErrors();
                        if (actionErrors != null) {
                            errs = new ArrayList< String >(actionErrors);
                        }
                    }
                    validator.validate(object);
                    if (fValidator != null) {
                        if (validatorContext.hasFieldErrors()) {
                            Collection< String > errCol = validatorContext.getFieldErrors().get(fullFieldName);
                            if ((errCol != null) && !errCol.equals(errs)) {
                                if (LOG.isDebugEnabled()) {
                                    LOG.debug("Short-circuiting on field validation");
                                }
                                if (shortcircuitedFields == null) {
                                    shortcircuitedFields = new TreeSet< String >();
                                }
                                shortcircuitedFields.add(fullFieldName);
                            }
                        }
                    } else if (validatorContext.hasActionErrors()) {
                        Collection< String > errCol = validatorContext.getActionErrors();
                        if ((errCol != null) && !errCol.equals(errs)) {
                            if (LOG.isDebugEnabled()) {
                                LOG.debug("Short-circuiting");
                            }
                            break;
                        }
                    }
                    continue;
                }
                validator.validate(object);
            } finally {
                validator.setValidatorContext( null );
            }
        }
}