uiinput.java

RESIN 3.2 最新源码

      try {
	updateModel(context);
      } catch (RuntimeException e) {
	context.renderResponse();
      
	throw e;
      }

      if (! isValid())
	context.renderResponse();
    }
  }

  public void updateModel(FacesContext context)
  {
    if (! isValid())
      return;

    if (! isLocalValueSet())
      return;

    if (_valueExpr == null)
      return;

    try {
      _valueExpr.setValue(context.getELContext(), getLocalValue());

      setValue(null);
      setLocalValueSet(false);
    } catch (RuntimeException e) {
      log.log(Level.FINE, e.toString(), e);
      
      setValid(false);
      
      String summary = Util.l10n(context, UPDATE_MESSAGE_ID,
				 "{0}: An error occurred while processing your submitted information.",
				 Util.getLabel(context, this));

      String detail = summary;

      FacesMessage msg = new FacesMessage(summary, detail);

      context.addMessage(getClientId(context), msg);

      // jsf/5011
      // if the spec lets us throw this, it's useful for development
      throw new FacesException("id=" + getClientId(context)
			       + " " + e.toString(), e);
    }
  }

  @Override
  public void processValidators(FacesContext context)
  {
    if (isRendered()) {
      super.processValidators(context);

      try {
	if (! isImmediate())
	  validate(context);

	if (! isValid())
	  context.renderResponse();
      } catch (RuntimeException e) {
	context.renderResponse();
      
	throw e;
      }
    }
  }

  public void validate(FacesContext context)
  {
    Object submittedValue = getSubmittedValue();
    if (submittedValue == null)
      return;

    Object value;

    try {
      value = getConvertedValue(context, submittedValue);

      validateValue(context, value);

      if (! isValid()) {
	context.renderResponse();
	return;
      }
    } catch (ConverterException e) {
      log.log(Level.FINE, e.toString(), e);
      setValid(false);
      context.renderResponse();

      final String converterMessage = getConverterMessage();

      FacesMessage msg = e.getFacesMessage();

      if (msg == null) {
	String summary = null;

	if (converterMessage != null)
	  summary = converterMessage;
	else
	  summary = Util.l10n(context, CONVERSION_MESSAGE_ID,
			      "{0}: Conversion error occurred.",
			      Util.getLabel(context, this));

	String detail = summary;

        msg = new FacesMessage(FacesMessage.SEVERITY_ERROR, summary, detail);
      }
      else if (converterMessage != null) {
	msg.setSummary(converterMessage);
	msg.setDetail(converterMessage);
      }

      context.addMessage(getClientId(context), msg);

      return;
    }
    
    Object oldValue = getValue();
    setValue(value);
    setSubmittedValue(null);

    if (compareValues(oldValue, value)
	&& getFacesListeners(FacesListener.class).length > 0) {
      ValueChangeEvent event = new ValueChangeEvent(this, oldValue, value);

      broadcast(event);
    }
  }

  protected Object getConvertedValue(FacesContext context,
				     Object submittedValue)
    throws ConverterException
  {
    Renderer renderer = getRenderer(context);

    if (renderer != null)
      return renderer.getConvertedValue(context, this, submittedValue);
    else if (submittedValue instanceof String) {
      Converter converter = getConverter();

      if (converter != null)
	return converter.getAsObject(context, this, (String) submittedValue);

      if (_valueExpr != null) {
	Class type = _valueExpr.getType(context.getELContext());

	if (type != null) {
	  converter = context.getApplication().createConverter(type);

	  if (converter != null) {
	    return converter.getAsObject(context,
					 this,
					 (String) submittedValue);
	  }
	}
      }
    }

    return submittedValue;
  }
  
  protected boolean compareValues(Object oldValue, Object newValue)
  {
    if (oldValue == newValue)
      return false;
    else if (oldValue == null || newValue == null)
      return true;
    else
      return ! oldValue.equals(newValue);
  }

  public void validateValue(FacesContext context, Object value)
  {
    if (! isValid()) {
    }
    else if (value != null &&
             ! "".equals(value) &&
             ! (value.getClass().isArray() &&
               java.lang.reflect.Array.getLength(value) == 0)) {
      for (Validator validator : getValidators()) {
	try {
	  validator.validate(context, this, value);
	} catch (ValidatorException e) {
	  log.log(Level.FINER, e.toString(), e);

	  FacesMessage msg = e.getFacesMessage();

	  String validatorMessage = getValidatorMessage();

	  if (msg == null) {
	    final String summary;
	    final String detail;

	    if (validatorMessage != null) {
	      summary = validatorMessage;
	      detail = validatorMessage;
	    }
	    else {
	      summary = e.getMessage();
	      detail = e.toString();
	    }

            msg = new FacesMessage(FacesMessage.SEVERITY_ERROR,
                                   summary,
                                   detail);
	  }
	  else {
	    if (validatorMessage != null) {
	      msg.setSummary(validatorMessage);
	      msg.setDetail(validatorMessage);
	    }
	  }
	  
	  context.addMessage(getClientId(context), msg);
	  setValid(false);
	}
      }
    }
    else if (isRequired()) {
      final FacesMessage msg;

      String requiredMessage = getRequiredMessage();

      if (requiredMessage != null)
        msg = new FacesMessage(FacesMessage.SEVERITY_ERROR,
                               requiredMessage,
                               requiredMessage);
      else {
	String summary = Util.l10n(context,
				   REQUIRED_MESSAGE_ID,
				   "{0}: UIInput validation Error: Value is required.",
				   Util.getLabel(context, this));

	String detail = summary;
	msg = new FacesMessage(FacesMessage.SEVERITY_ERROR, summary, detail);
      }

      context.addMessage(getClientId(context), msg);

      setValid(false);
      return;
    }

  }

  //
  // state
  //

  public Object saveState(FacesContext context)
  {
    int offset = 6;
    
    Object []state = new Object[offset + 2 * _validators.length];
    
    state[0] = super.saveState(context);
    state[1] = _immediate;
    state[2] = _required;
    state[3] = _requiredMessage;
    state[4] = _converterMessage;
    state[5] = _validatorMessage;

    if (_validators.length > 0) {
      for (int i = 0; i < _validators.length; i++) {
	Validator validator = _validators[i];

	int index = offset + 2 * i;
	
	state[index] = validator.getClass();

	if (validator instanceof StateHolder) {
	  StateHolder holder = (StateHolder) validator;
	  
	  state[index + 1] = holder.saveState(context);
	}
      }
    }

    return state;
  }

  public void restoreState(FacesContext context, Object value)
  {
    Object []state = (Object []) value;

    super.restoreState(context, state[0]);

    _immediate = (Boolean) state[1];
    _required = (Boolean) state[2];
    _requiredMessage = (String) state[3];
    _converterMessage = (String) state[4];
    _validatorMessage = (String) state[5];
    
    _valueExpr = super.getValueExpression("value");

    int offset = 6;

    if (offset < state.length) {
      _validators = new Validator[(state.length - offset) / 2];

      for (int i = 0; i < _validators.length; i++) {
	int index = offset + 2 * i;
	
	Class cl = (Class) state[index];

	try {
	  Validator validator = (Validator) cl.newInstance();

	  if (validator instanceof StateHolder) {
	    StateHolder holder = (StateHolder) validator;

	    holder.restoreState(context, state[index + 1]);
	  }

	  _validators[i] = validator;
	} catch (Exception e) {
	  throw new FacesException(e);
	}
      }
    }
  }

  //
  // private helpers
  //

  private static enum PropEnum {
    IMMEDIATE,
    REQUIRED,
    VALUE,
    REQUIRED_MESSAGE,
    CONVERTER_MESSAGE,
    VALIDATOR_MESSAGE,
  }

  private static class ValueChangeListenerAdapter
    implements ValueChangeListener, StateHolder
  {
    private MethodBinding _binding;
    
    private boolean _transient;

    public ValueChangeListenerAdapter()
    {
    }

    public ValueChangeListenerAdapter(MethodBinding binding)
    {
      _binding = binding;
    }

    MethodBinding getBinding()
    {
      return _binding;
    }

    public void processValueChange(ValueChangeEvent event)
      throws AbortProcessingException
    {
      FacesContext facesContext = FacesContext.getCurrentInstance();

      _binding.invoke(facesContext, new Object[] { event }); 
    }

    public Object saveState(FacesContext context)
    {
      return _binding;
    }

    public void restoreState(FacesContext context, Object state)
    {
      _binding = (MethodBinding) state;
    }

    public boolean isTransient()
    {
      return _transient;
    }

    public void setTransient(boolean isTransient)
    {
      _transient = isTransient;
    }

    public String toString()
    {
      return "ValueChangeListenerAdapter[" + _binding + "]";
    }
  }

  private static class ValidatorAdapter
    implements Validator, StateHolder
  {
    private MethodBinding _binding;
    
    private boolean _transient;

    public ValidatorAdapter()
    {
    }

    public ValidatorAdapter(MethodBinding binding)
    {
      _binding = binding;
    }

    MethodBinding getBinding()
    {
      return _binding;
    }

    public void validate(FacesContext context,
			 UIComponent component,
			 Object value)
      throws ValidatorException
    {
      try {
	FacesContext facesContext = FacesContext.getCurrentInstance();

	_binding.invoke(facesContext, new Object[] { context, component, value });
      } catch (EvaluationException e) {
	if (e.getCause() instanceof ValidatorException)
	  throw (ValidatorException) e.getCause();
	else if (e.getCause() instanceof RuntimeException)
	  throw (RuntimeException) e.getCause();
	else
	  throw e;
      }
    }

    public Object saveState(FacesContext context)
    {
      return _binding;
    }

    public void restoreState(FacesContext context, Object state)
    {
      _binding = (MethodBinding) state;
    }

    public boolean isTransient()
    {
      return _transient;
    }

    public void setTransient(boolean isTransient)
    {
      _transient = isTransient;
    }

    public String toString()
    {
      return "ValueChangeListenerAdapter[" + _binding + "]";
    }
  }

  static {
    _propMap.put("value", PropEnum.VALUE);
    _propMap.put("immediate", PropEnum.IMMEDIATE);
    _propMap.put("required", PropEnum.REQUIRED);
    _propMap.put("requiredMessage", PropEnum.REQUIRED_MESSAGE);
    _propMap.put("converterMessage", PropEnum.CONVERTER_MESSAGE);
    _propMap.put("validatorMessage", PropEnum.VALIDATOR_MESSAGE);
  }
}