Open Source Repository

Home /spring/spring-web-servlet-3.0.5 | Repository Home


org/springframework/web/servlet/tags/TransformTag.java
/*
 * Copyright 2002-2007 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.web.servlet.tags;

import java.beans.PropertyEditor;
import java.io.IOException;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.TagSupport;

import org.springframework.web.util.ExpressionEvaluationUtils;
import org.springframework.web.util.HtmlUtils;
import org.springframework.web.util.TagUtils;

/**
 * Tag for transforming reference data values from form controllers and
 * other objects inside a <code>spring:bind</code> tag (or a data-bound
 * form element tag from Spring's form tag library).
 *
 <p>The BindTag has a PropertyEditor that it uses to transform properties of
 * a bean to a String, useable in HTML forms. This tag uses that PropertyEditor
 * to transform objects passed into this tag.
 *
 @author Alef Arendsen
 @author Juergen Hoeller
 @since 20.09.2003
 @see BindTag
 */
public class TransformTag extends HtmlEscapingAwareTag {

  /** the value to transform using the appropriate property editor */
  private Object value;

  /** the variable to put the result in */
  private String var;

  /** the scope of the variable the result will be put in */
  private String scope = TagUtils.SCOPE_PAGE;


  /**
   * Set the value to transform, using the appropriate PropertyEditor
   * from the enclosing BindTag.
   <p>The value can either be a plain value to transform (a hard-coded String
   * value in a JSP or a JSP expression), or a JSP EL expression to be evaluated
   * (transforming the result of the expression).
   <p>Like all of Spring's JSP tags, this tag is capable of parsing EL expressions
   * itself, on any JSP version. Note, however, that EL expressions in a JSP 2.0 page
   * will be evaluated by the JSP container, with the result getting passed in here.
   * For this reason, the type of this property is Object (accepting any result
   * object from a pre-evaluated expression) rather than String.
   */
  public void setValue(Object value) {
    this.value = value;
  }

  /**
   * Set PageContext attribute name under which to expose
   * a variable that contains the result of the transformation.
   @see #setScope
   @see javax.servlet.jsp.PageContext#setAttribute
   */
  public void setVar(String var) {
    this.var = var;
  }

  /**
   * Set the scope to export the variable to.
   * Default is SCOPE_PAGE ("page").
   @see #setVar
   @see org.springframework.web.util.TagUtils#SCOPE_PAGE
   @see javax.servlet.jsp.PageContext#setAttribute
   */
  public void setScope(String scope) {
    this.scope = scope;
  }


  @Override
  protected final int doStartTagInternal() throws JspException {
    Object resolvedValue = this.value;
    if (this.value instanceof String) {
      String strValue = (Stringthis.value;
      resolvedValue = ExpressionEvaluationUtils.evaluate("value", strValue, pageContext);
    }

    if (resolvedValue != null) {
      // Find the containing EditorAwareTag (e.g. BindTag), if applicable.
      EditorAwareTag tag = (EditorAwareTagTagSupport.findAncestorWithClass(this, EditorAwareTag.class);
      if (tag == null) {
        throw new JspException("TransformTag can only be used within EditorAwareTag (e.g. BindTag)");
      }

      // OK, let's obtain the editor...
      String result = null;
      PropertyEditor editor = tag.getEditor();
      if (editor != null) {
        // If an editor was found, edit the value.
        editor.setValue(resolvedValue);
        result = editor.getAsText();
      }
      else {
        // Else, just do a toString.
        result = resolvedValue.toString();
      }
      result = isHtmlEscape() ? HtmlUtils.htmlEscape(result: result;
      String resolvedVar = ExpressionEvaluationUtils.evaluateString("var"this.var, pageContext);
      if (resolvedVar != null) {
        String resolvedScope = ExpressionEvaluationUtils.evaluateString("scope"this.scope, pageContext);
        pageContext.setAttribute(resolvedVar, result, TagUtils.getScope(resolvedScope));
      }
      else {
        try {
          // Else, just print it out.
          pageContext.getOut().print(result);
        }
        catch (IOException ex) {
          throw new JspException(ex);
        }
      }
    }

    return SKIP_BODY;
  }

}