jakarta-taglibs-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pier...@apache.org
Subject cvs commit: jakarta-taglibs/jsptl/doc/web Conditionals_FunctionalDescription_1_EA1.html ExpressionLanguageSupport_FunctionalDescription_2_EA1.html ExpressionTags_FunctionalDescription_1_EA1.html IteratorTag_FunctionalDescription_2_EAI.html Overview.html
Date Tue, 20 Nov 2001 12:21:47 GMT
pierred     01/11/20 04:21:47

  Modified:    jsptl/doc/web Conditionals_FunctionalDescription_1_EA1.html
                        ExpressionLanguageSupport_FunctionalDescription_2_EA1.html
                        ExpressionTags_FunctionalDescription_1_EA1.html
                        IteratorTag_FunctionalDescription_2_EAI.html
                        Overview.html
  Log:
  Updated these documents in the context of EA2, namely
  prefix changed from "jx" to "c".
  
  Revision  Changes    Path
  1.2       +9 -9      jakarta-taglibs/jsptl/doc/web/Conditionals_FunctionalDescription_1_EA1.html
  
  Index: Conditionals_FunctionalDescription_1_EA1.html
  ===================================================================
  RCS file: /home/cvs/jakarta-taglibs/jsptl/doc/web/Conditionals_FunctionalDescription_1_EA1.html,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- Conditionals_FunctionalDescription_1_EA1.html	2001/07/08 16:27:32	1.1
  +++ Conditionals_FunctionalDescription_1_EA1.html	2001/11/20 12:21:46	1.2
  @@ -20,35 +20,35 @@
   <hr WIDTH="100%" noshade>
   <h3>
   1. Introduction</h3>
  -The set of JSPTL conditional tags are designed to support the two most
  +The set of JSTL conditional tags are designed to support the two most
   common usage patterns associated with conditional processing: <i>simple</i>
   conditional execution and <i>mutually exclusive</i> conditional execution.
  -The JSPTL conditional tags are similar to the XSLT instructions for conditional
  +The JSTL conditional tags are similar to the XSLT instructions for conditional
   processing (<tt>&lt;xsl:if></tt> and <tt>&lt;xsl:choose></tt>).
   <p>A simple conditional execution tag evaluates its body content only if
   the test condition associated with it is true. In the following example,
   a special greeting is displayed only if this is a customer's first visit
   to the site.
  -<p><tt>&nbsp; &lt;jx:if test="$user.visitCount == 1"></tt> <br>
  +<p><tt>&nbsp; &lt;c:if test="$user.visitCount == 1"></tt> <br>
     <tt>&nbsp;&nbsp;&nbsp;&nbsp; This is your first visit. Welcome to the
   site!</tt>
   <br>
  -  <tt>&nbsp; &lt;/jx:if></tt> 
  +  <tt>&nbsp; &lt;/c:if></tt> 
   <p>With mutually exclusive conditional execution, only one among a number
   of possible alternative tags gets its body content evaluated. In the example
   below, the information displayed for a specific product depends on the
   verbosity level selected.
   <p><tt>&nbsp; &lt;choose></tt> <br>
     <tt>&nbsp;&nbsp;&nbsp; &lt;when test="$verbosityLevel == 'short'></tt> <br>
  -  <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;jx:expr value=&quot;$product.shortDescription&quot;/&gt;</tt> 
  +  <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;c:expr value=&quot;$product.shortDescription&quot;/&gt;</tt> 
     <br>
     <tt>&nbsp;&nbsp;&nbsp; &lt;/when></tt> <br>
     <tt>&nbsp;&nbsp;&nbsp; &lt;when test="$verbosityLevel == 'medium'></tt> <br>
  -  <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;jx:expr value=&quot;$product.mediumDescription&quot;/&gt;</tt> 
  +  <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;c:expr value=&quot;$product.mediumDescription&quot;/&gt;</tt> 
     <br>
     <tt>&nbsp;&nbsp;&nbsp; &lt;/when></tt><br>
     <tt>&nbsp;&nbsp;&nbsp; &lt;otherwise></tt> <br>
  -  <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;jx:expr value=&quot;$product.longDescription&quot;/&gt;</tt> 
  +  <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;c:expr value=&quot;$product.longDescription&quot;/&gt;</tt> 
     <br>
     <tt>&nbsp;&nbsp;&nbsp; &lt;/otherwise></tt> <br>
     <tt>&nbsp; &lt;/choose></tt> 
  @@ -67,7 +67,7 @@
       <td>expr</td>
       <td>The test condition to be evaluated. The value returned by the attribute 
         must either be a <tt>boolean</tt> primitive or a <tt>Boolean</tt> object 
  -      (jx library). Must be a Boolean object in the jr library.</td>
  +      (EL library). Must be a Boolean object in the RT library.</td>
     </tr>
     <tr> 
       <td><tt>var</tt></td>
  @@ -109,7 +109,7 @@
   
       <td>The test condition to be evaluated. The value returned by the attribute 
         must either be a <tt>boolean</tt> primitive or a <tt>Boolean</tt> object 
  -      (jx library). Must be a Boolean object in the jr library. </td>
  +      (EL library). Must be a Boolean object in the RT library. </td>
   </tr>
   </table>
   
  
  
  
  1.2       +45 -48    jakarta-taglibs/jsptl/doc/web/ExpressionLanguageSupport_FunctionalDescription_2_EA1.html
  
  Index: ExpressionLanguageSupport_FunctionalDescription_2_EA1.html
  ===================================================================
  RCS file: /home/cvs/jakarta-taglibs/jsptl/doc/web/ExpressionLanguageSupport_FunctionalDescription_2_EA1.html,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- ExpressionLanguageSupport_FunctionalDescription_2_EA1.html	2001/07/08 16:27:32	1.1
  +++ ExpressionLanguageSupport_FunctionalDescription_2_EA1.html	2001/11/20 12:21:46	1.2
  @@ -15,12 +15,11 @@
   <hr width="100%" noshade>
   <h3>
   1. Introduction</h3>
  -Support for an Expression Language (EL) is a clear requirement for JSPTL1.0.
  -We need to address this requirement even though it is utimately the responsibility
  -of the JSR053 expert group to specify how an EL can be seamlessly integrated
  -in JSP, as well as which expression language(s) is/are to be supported
  -by JSP containers.
  -<p>In our quest for an interim solution, JSPTL is constrained by the fact
  +Support for an Expression Language (EL) is a clear requirement for JSTL1.0. We 
  +need to address this requirement even though it is utimately the responsibility 
  +of the JSR152 expert group to specify how an EL can be seamlessly integrated in 
  +JSP, as well as which expression language(s) is/are to be supported by JSP containers. 
  +<p>In our quest for an interim solution, JSTL is constrained by the fact
   that this solution must work in the context of JSP1.2, without requiring
   any change to the spec, and that it should integrate seamlessly with JSP.next
   (where an EL would be supported natively). It is also important to consider
  @@ -30,14 +29,14 @@
   <p>Our strategy therefore consists in allowing the easy integration, selection,
   and use of a variety of expression languages via an Expression Language
   Integration API, a set of tags, as well as conventions used throughout
  -JSPTL. We won't rule on any specific EL immediately. Rather we will allow
  +JSTL. We won't rule on any specific EL immediately. Rather we will allow
   various implementations of Expression Languages to all play in our sandbox.
   The hope is that through experimentation, it will be much easier to evaluate
   the merits of each approach, paving the way for the selection of a single
  -or limited number of Expression Language(s) for the final draft of JSPTL.
  +or limited number of Expression Language(s) for the final draft of JSTL.
   <h3>
  -2. Integration of an Expression Language in JSPTL1.0</h3>
  -An important requirement for support of an Expression Language within JSPTL
  +2. Integration of an Expression Language in JSTL1.0</h3>
  +An important requirement for support of an Expression Language within JSTL
   was that a single attribute should support a value specified in any of
   the following 3 forms:
   <p><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; a. String literal&nbsp;&nbsp;&nbsp;
  @@ -78,37 +77,35 @@
   <h3>
   2. Twin Tag Libraries to support the Expression Language</h3>
   Among the mechanisms that are now available in JSP1.2 is the ability to deliver 
  -more than one taglib in the same JAR file. The JSPTL tag library therefore comes 
  -in two flavors: <b>RT</b> (<b>rt</b>exprvalues) and <b>EL</b> (<b>el</b>exprvalues). 
  -They only differ in the way they support expressions for attribute values. 
  -<p>In the JSPTL-RT tag library, attributes that support expressions support them 
  -  as 'rtexprvalues'; i.e. as expressions specified in the page's scripting language 
  -  (and evaluated at runtime). This is exactly how things currently work in tag 
  -  libraries. 
  -<p>In the JSPTL-EL tag library, attributes that support expressions support them 
  -  as 'elexprvalues'; i.e. as expressions specified in the JSPTL Expression Language 
  -  (and evaluated at runtime as well). 'rtexprvalues' are not allowed when using 
  -  the EL tag library. An 'elexprvalue' is a String literal in the syntax of the 
  -  EL. It is the responsibility of the EL to define the metacharacter(s) used to 
  -  discriminate expressions from String literals (e.g. use $ at the beginning of 
  -  an expression). 
  -<p>JSPTL therefore provides two URIs, one for tags that accept rtexprvalues,
  -and one for tags that accept elexprvalues. The two libraries therefore
  -support the same tags with the same syntax, except that one takes rtexprvalues,
  -the other takes elexprvalues.
  +more than one taglib in the same JAR file. JSTL therefore has two flavors of libraries: 
  +<b>RT</b> (<b>rt</b>exprvalues) and <b>EL</b> (<b>el</b>exprvalues). They only 
  +differ in the way they support expressions for attribute values. 
  +<p>In an RT tag library, attributes that support expressions support them as 'rtexprvalues'; 
  +  i.e. as expressions specified in the page's scripting language (and evaluated 
  +  at runtime). This is exactly how things currently work in tag libraries. 
  +<p>In an EL tag library, attributes that support expressions support them as 'elexprvalues'; 
  +  i.e. as expressions specified in the JSTL Expression Language (and evaluated 
  +  at runtime as well). 'rtexprvalues' are not allowed when using an EL tag library. 
  +  An 'elexprvalue' is a String literal in the syntax of the EL. It is the responsibility 
  +  of the EL to define the metacharacter(s) used to discriminate expressions from 
  +  String literals (e.g. use $ at the beginning of an expression). 
  +<p>JSTL therefore provides two sets of URIs, one for tags that accept rtexprvalues, 
  +  and one for tags that accept elexprvalues. Twin libraries therefore support 
  +  the same tags with the same syntax, except that one takes rtexprvalues, the 
  +  other takes elexprvalues. 
   <h4>
   Usage</h4>
  -<p>These two tag libraries can be accessed in the following way in a JSP page: 
  +<p>These twin tag libraries can be accessed in the following way in a JSP page 
  +  (using the &quot;core&quot; taglib as an example):<br>
     <br>
  -  <br>
  -  <tt>&nbsp;&nbsp;&nbsp; &lt;%@ taglib uri="http://java.sun.com/jsptl/ea/jr" prefix="jr" 
  -  %><br>
  -  &nbsp;&nbsp;&nbsp; </tt><tt>&lt;%@ taglib uri="http://java.sun.com/jsptl/ea/jx" 
  -  prefix="jx" %></tt> </p>
  -<p>In our examples, we use the 'jr' prefix for the 'JSPTL Rtexprvalue" library 
  -  and 'jx' for the 'JSPTL eXpression language' library. It is possible to use 
  -  the two libraries within the same page, although not recommended for clarity 
  -  and consistency. </p>
  +  <tt>&nbsp;&nbsp;&nbsp; &lt;%@ taglib uri="http://java.sun.com/jstl/ea/core" 
  +  prefix="c" %><br>
  +  &nbsp;&nbsp;&nbsp; </tt><tt>&lt;%@ taglib uri="http://java.sun.com/jstl/ea/core-rt" 
  +  prefix="c-rt" %></tt> </p>
  +<p>In our examples, we append the value '-rt' to differentiate the 'rtexprvalue" 
  +  library from its 'elexprvalue' twin. It is possible to use the two libraries 
  +  within the same page, although not recommended for clarity and consistency. 
  +</p>
   <p>Within the same tag, all attribute values specified as expressions will
   have to be specified either as 'rtexprvalue' or 'elexprvalue' (cannot mix
   within the same tag), depending on which tag library the tag belongs to.
  @@ -135,7 +132,7 @@
   <p>The above&nbsp; rules make it possible to validate the syntax of an
   <tt>elexprvalue</tt>
   at translation time.
  -<p>If JSPTL rules on a single EL, then both the context parameter and the
  +<p>If JSTL rules on a single EL, then both the context parameter and the
   tag will become illegal.
   <h3>
   6. Expression Language API</h3>
  @@ -143,7 +140,7 @@
   which is reponsible to delegate the requested operation to the currently
   <i>active
   </i><tt>ExpressionEvaluator</tt>.
  -[Even if JSPTL eventually selects a single EL, this will still be the way
  +[Even if JSTL eventually selects a single EL, this will still be the way
   to access the EL]
   <p><tt>&nbsp;&nbsp;&nbsp; public class ExpressionEvaluatorManager {</tt>
   <br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /**</tt>
  @@ -185,10 +182,10 @@
   fatal (<tt>JspException</tt>) and what isn't (<tt>ExpressionException</tt>).
   <p><tt>&nbsp;&nbsp;&nbsp; public class ExpressionException extends JspException;</tt>
   <p>The&nbsp; integration of custom Expression Languages will be possible
  -during the Early Access phase of JSPTL to help us experiment with various
  +during the Early Access phase of JSTL to help us experiment with various
   ELs. An Expression Language implementation simply needs to implement interface
   <tt>ExpressionEvaluator</tt>.
  -Check the details of the JSPTL implementation to see if there are any constraints
  +Check the details of the JSTL implementation to see if there are any constraints
   on the implementation of an ExpressionEvaluator.
   <br>[For example, one could impose that the implementation of&nbsp; <tt>ExpressionEvaluator</tt>
   be thread-safe, and&nbsp; that there is no guarantee that a single instance
  @@ -226,7 +223,7 @@
   ExpressionException, JspException;</tt>
   <br><tt>&nbsp;&nbsp;&nbsp; }</tt>
   <h3>
  -7. Custom Tags using the JSPTL Expression Language(s)</h3>
  +7. Custom Tags using the JSTL Expression Language(s)</h3>
   Custom tag developers can support expression languages in their tags using
   the same conventions established in this document.
   <p>Assuming a custom action named <tt>foo</tt>; one could have the following
  @@ -286,7 +283,7 @@
   by a TagLibraryValidator so the proper ExpressionEvaluator can be invoked for 
   the validation (a TEI would not be able to establish the execution context). One 
   such TagLibraryValidator, <tt>ExpressionEvaluatorTLV</tt>,&nbsp; is made available 
  -to support translation time validation of elexprvalues of JSPTL tags, as well 
  +to support translation time validation of elexprvalues of JSTL tags, as well 
   as for any other custom tag library. 
   <p>It supports an initialization parameter (<tt>custom-taglibs)</tt> to
   specify the list of custom tag libraries that should be validated for elexprvalues
  @@ -303,13 +300,13 @@
   <br><tt>&nbsp;&nbsp;&nbsp; &lt;/validator></tt>
   <br><tt>&nbsp;&nbsp;&nbsp; ...</tt>
   <br><tt>&nbsp; &lt;/taglib></tt>
  -<p>If the JSPTL ends up specifying a single EL, then translation-time validation
  +<p>If the JSTL ends up specifying a single EL, then translation-time validation
   could be performed within the TagExtraInfoClass by simply calling <tt>ExpressionEvaluatorManager.validate()
   </tt>on
   each elexprvalue.
   <h3>
   9. Relationship with future JSP specs</h3>
  -The expression language integration model for JSPTL will work fine with
  +The expression language integration model for JSTL will work fine with
   JSP 1.2 containers and above. Nothing in that model gets in the way of
   the JSP specification should it decide to include native support for expression
   language(s).
  @@ -319,12 +316,12 @@
   <p>The twin libraries would behave as follows in a JSP.next environment:
   <ul>
   <li>
  -<b>JSPTL-1.0-RT</b></li>
  +<b>JSTL-1.0-RT</b></li>
   
   <br>Will keep working as before, with the addition that it will also be
   possible to specify elexprvalues.
   <li>
  -<b>JSPTL-1.0-EL</b></li>
  +<b>JSTL-1.0-EL</b></li>
   
   <br>Tags will keep working exactly as before; no change. The elexprvalues
   will still be evaluated by the tag library, and not the container since
  
  
  
  1.2       +39 -39    jakarta-taglibs/jsptl/doc/web/ExpressionTags_FunctionalDescription_1_EA1.html
  
  Index: ExpressionTags_FunctionalDescription_1_EA1.html
  ===================================================================
  RCS file: /home/cvs/jakarta-taglibs/jsptl/doc/web/ExpressionTags_FunctionalDescription_1_EA1.html,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- ExpressionTags_FunctionalDescription_1_EA1.html	2001/07/08 16:27:32	1.1
  +++ ExpressionTags_FunctionalDescription_1_EA1.html	2001/11/20 12:21:46	1.2
  @@ -28,97 +28,97 @@
   of the evaluation is coerced to a String and is subsequently emitted into
   the current JspWriter object.
   <p>For example:
  -<p><tt>&nbsp; Hello &lt;jx:expr value="$request:name"/></tt>
  +<p><tt>&nbsp; Hello &lt;c:expr value="$request:name"/></tt>
   <p>is equivalent to
   <p><tt>&nbsp; Hello &lt;%=pageContext.getAttribute("name", PageContext.SCOPE_REQUEST)%></tt>
   <p>assuming the expression language interprets the elexprvalue <tt>$request:name</tt>
   as meaning the value of the name attribute in the request scope.
  -<p>As a convenience, this action also supports the notion of <i>default
  -value</i> for cases where the value of an object in the elexprvalue is
  -not accessible. The default condition is triggered when the Expression
  -Language throws an ExpressionException while evaluating the expression
  -(to report failure to complete evaluation satisfactorily) or if the evaluation
  -of the expression completes, but the result is null.. This condition usually
  -happens when one of the objects in the expression is null. For example,
  -in the example below, this exception would be thrown if the address property
  -of the customer object were null. Check the details of the expression language
  -to clearly understand under which circumstances the ExpressionException
  -is thrown.
  +<p>As a convenience, this action also supports the notion of <i>default value</i> 
  +  for cases where the value of an object in the elexprvalue is not accessible. 
  +  The default condition is triggered when the Expression Language throws an ExpressionException 
  +  while evaluating the expression (to report failure to complete evaluation satisfactorily) 
  +  or if the evaluation of the expression completes, but the result is null. This 
  +  condition usually happens when one of the objects in the expression is null. 
  +  For example, in the example below, this exception would be thrown if the address 
  +  property of the customer object were null. Check the details of the expression 
  +  language to clearly understand under which circumstances the ExpressionException 
  +  is thrown. 
   <p>The default value can be specified either via attribute <tt>default:</tt>
  -<p><tt>&nbsp;&nbsp;&nbsp; &lt;jx:expr value="$customer.address.city" default="unknown"/></tt>
  +<p><tt>&nbsp;&nbsp;&nbsp; &lt;c:expr value="$customer.address.city" default="unknown"/></tt>
   <p>or within the body of the tag:
  -<p><tt>&nbsp;&nbsp;&nbsp; &lt;jx:expr value="$customer.address.city"></tt>
  +<p><tt>&nbsp;&nbsp;&nbsp; &lt;c:expr value="$customer.address.city"></tt>
   <br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;acme:defaultCity/></tt>
  -<br><tt>&nbsp;&nbsp;&nbsp; &lt;/jx:expr></tt>
  +<br><tt>&nbsp;&nbsp;&nbsp; &lt;/c:expr></tt>
   <p>The two ways to specify a default value cannot be used simultaneously.
  -<p>The <tt>&lt;expr></tt> action&nbsp; is only available in the jx (eXpression
  -language) version of the JSPTL tag library.
  +<p>The <tt>&lt;expr></tt> action&nbsp; is only available in the EL version of 
  +  the library. 
   <h3>
   2. <tt>&lt;set></tt></h3>
   The <tt>&lt;set></tt> action sets the value of an attribute in any of the
   JSP scopes (page, request, session, application). If the attribute does
   not already exist, it is created.
   <p>The JSP scoped attribute can be set either from attribute value:
  -<p><tt>&nbsp; &lt;jx:set id="foo" scope="session" value="..."/></tt>
  +<p><tt>&nbsp; &lt;c:set var="foo" scope="session" value="..."/></tt> 
   <p>or from the body of the tag:
  -<p><tt>&nbsp; &lt;jx:set id="foo"></tt>
  -<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ...</tt>
  -<br><tt>&nbsp; &lt;/jx:set></tt>
  +<p><tt>&nbsp; &lt;c:set var="foo"></tt> <br>
  +  <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ...</tt>
  +<br><tt>&nbsp; &lt;/c:set></tt>
   <p>Setting the value of a JSP scoped attribute from the tag's body content&nbsp;
   is useful to solve the problem associated with the fact that a tag attribute's
   value cannot be set from a tag. In the past, a tag developer would have
   to offer extra "attributes as tags" so the value of these attributes could
   be set from other tags. For example:
  -<p><tt>&nbsp; &lt;x:atag></tt>
  -<br><tt>&nbsp;&nbsp;&nbsp; &lt;x:att1>&lt;x:foo>mumbojumbo&lt;/x:foo>&lt;/x:att1></tt>
  -<br><tt>&nbsp; &lt;/x:atag></tt>
  +<p><tt>&nbsp; &lt;acme:atag></tt> <br>
  +  <tt>&nbsp;&nbsp;&nbsp; &lt;x:att1>&lt;x:foo>mumbojumbo&lt;/x:foo>&lt;/x:att1></tt>
  +<br>
  +  <tt>&nbsp; &lt;/acme:atag></tt> 
   <p>With the <tt>&lt;set></tt> tag, this can be handled without requiring
   the extra <tt>&lt;att1></tt> tag.
  -<p><tt>&nbsp; &lt;jx:set id="att1">&lt;x:foo>mumbojumbo&lt;/x:foo>&lt;/jx:set></tt>
  -<br><tt><font size=+0>&nbsp; &lt;x:atag att1="$att1"/></font></tt>
  +<p><tt>&nbsp; &lt;c:set var="att1">&lt;x:foo>mumbojumbo&lt;/x:foo>&lt;/c:set></tt> 
  +  <br>
  +  <tt>&nbsp; &lt;acme:atag att1="$att1"/></tt> 
   <p><font size=+0>Attribute <tt>scope</tt> is used to specify the scope
   of the JSP attribute targetted by the &lt;set> tag. It is an optional attribute
   that defaults to "page". The accepted values are restricted to: page, request,
   session, and application.</font>
  -<p><font size=+0>The &lt;set> tag is only available in the jx </font>(eXpression
  -language) <font size=+0>library.</font>
  +<p><font size=+0>The &lt;set> tag is only available in the EL version of the library</font><font size=+0>.</font> 
   <h3> 3. <tt>&lt;declare></tt></h3>
  -Given that an Expression Language is supported in JSPTL, the need for scripting
  +Given that an Expression Language is supported in JSTL, the need for scripting
   should be reduced substantially. However, until a JSP.next comes around
   with native support for the Expression Language, page authors will still
  -have to deal with situations where some attributes of non-JSPTL tags must
  +have to deal with situations where some attributes of non-JSTL tags must
   be specified as rtexprvalues.
   <p>For example, &lt;myTag> below expects to receive an "Order" object using an 
     rtexprvalue. Because <code>var</code> is not exported as a scripting variable 
     in the &lt;forEach> tag, the code below would trigger a translation time error 
     because the scripting variable customer does not exist. 
  -<p><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;jx:forEach items="$customers" var="customer"></tt> 
  +<p><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;c:forEach items="$customers" var="customer"></tt> 
     <br>
     <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;acme:myTag order=&lt;%=customer.getOrder()%>
   /></tt>
  -<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/jx:forEach></tt>
  +<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/c:forEach></tt>
   <p>There needs to be a simple way to define a scripting variable to bridge
   the gap between the EL and scripting worlds until JSP.next comes.
   <p>The <tt>&lt;declare></tt> tag is used for that purpose. In the example below, 
     a scripting variable "customer" is created as a reference to the JSP scoped 
     attribute of the same name. 
  -<p><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;jx:forEach items="$customers" var="customer"></tt> 
  +<p><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;c:forEach items="$customers" var="customer"></tt> 
     <br>
  -  <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;jx:declare id="customer" 
  +  <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;c:declare id="customer" 
     type="acme.Customer"/></tt> <br>
     <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;acme:myTag order=&lt;%=customer.getOrder()%>
   /></tt>
  -<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/jx:forEach></tt>
  +<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/c:forEach></tt>
   <p>When jsp.next comes, the above code would simply become:
  -<p><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;jx:forEach items="$customers" var="customer"></tt> 
  +<p><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;c:forEach items="$customers" var="customer"></tt> 
     <br>
     <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;acme:myTag order="$customer.order"
   /></tt>
  -<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/jx:forEach></tt>
  +<br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/c:forEach></tt>
   <p>without requiring any modification to the <tt>&lt;acme:myTag></tt> tag.
   <p>The same requirement for a bridge between the EL and scripting worlds exists 
  -  whether a page author uses the jr or jx version of the JSPTL tag library. This 
  -  tag therefore exists in both versions of the JSPTL library. 
  +  whether a page author uses the EL or RT version of JSTL. This tag therefore 
  +  exists in both the EL and RT versions of thelibrary. 
   <ul>
     <li> <b><tt>id</tt></b> The name of the scripting variable to be exported</li>
     <li> <b><tt>type</tt></b> The type of the scripting variable. Optional. Defaults 
  
  
  
  1.2       +27 -27    jakarta-taglibs/jsptl/doc/web/IteratorTag_FunctionalDescription_2_EAI.html
  
  Index: IteratorTag_FunctionalDescription_2_EAI.html
  ===================================================================
  RCS file: /home/cvs/jakarta-taglibs/jsptl/doc/web/IteratorTag_FunctionalDescription_2_EAI.html,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- IteratorTag_FunctionalDescription_2_EAI.html	2001/07/08 16:27:32	1.1
  +++ IteratorTag_FunctionalDescription_2_EAI.html	2001/11/20 12:21:46	1.2
  @@ -25,9 +25,9 @@
   below creates an HTML table with one column that shows the default <i>display</i> 
   value of each item in the collection. 
   <pre>&nbsp; &lt;table>
  -&nbsp;&nbsp;&nbsp; &lt;jx:forEach var="customer" items="$customers">
  -&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;tr>&lt;td>&lt;jx:expr value="$customer"/>&lt;/td>&lt;/tr>
  -&nbsp;&nbsp;&nbsp; &lt;/jx:forEach>
  +&nbsp;&nbsp;&nbsp; &lt;c:forEach var="customer" items="$customers">
  +&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;tr>&lt;td>&lt;c:expr value="$customer"/>&lt;/td>&lt;/tr>
  +&nbsp;&nbsp;&nbsp; &lt;/c:forEach>
   &nbsp; &lt;/table></pre>
   The <tt>forEach</tt> tag has the following features: 
   <ul>
  @@ -118,10 +118,10 @@
   </ul>
   So, to iterate over the values of a <tt>Hashtable</tt>, the code would
   be implemented as follows:
  -<p><tt>&nbsp; &lt;jx:forEach var="entry" items="$myHashtable"/></tt> <br>
  -  <tt>&nbsp;&nbsp;&nbsp; Next element is &lt;jx:expr value="$entry.value/></tt> 
  +<p><tt>&nbsp; &lt;c:forEach var="entry" items="$myHashtable"/></tt> <br>
  +  <tt>&nbsp;&nbsp;&nbsp; Next element is &lt;c:expr value="$entry.value/></tt> 
     <br>
  -  <tt>&nbsp; &lt;/jx:forEach></tt>
  +  <tt>&nbsp; &lt;/c:forEach></tt>
   <p><a NAME="currentItemResultSet"></a>If items is of type <tt>ResultSet</tt>, 
     then the current item is the <tt>ResultSet</tt> object itself positioned at 
     the current row. Columns are accessed using the standard <tt>ResultSet</tt> 
  @@ -141,12 +141,12 @@
   column containing the position of the item in the collection, and the second
   containing the name of the employee.
   <pre>&nbsp; &lt;table>
  -&nbsp;&nbsp;&nbsp; &lt;jx:forEach var="employee" items="$employees" status="status">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
  +&nbsp;&nbsp;&nbsp; &lt;c:forEach var="employee" items="$employees" status="status">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
   &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;tr>
  -&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;td>&lt;jx:expr value="$status.count"/>&lt;/td>
  -&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;td>&lt;jx:expr value="$employee.name"/>&lt;/td>
  +&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;td>&lt;c:expr value="$status.count"/>&lt;/td>
  +&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;td>&lt;c:expr value="$employee.name"/>&lt;/td>
   &nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/tr>
  -&nbsp;&nbsp;&nbsp; &lt;/jx:forEach>
  +&nbsp;&nbsp;&nbsp; &lt;/c:forEach>
   &nbsp; &lt;/table></pre>
   
   <h3>
  @@ -157,9 +157,9 @@
   then the value of the current item is set to the integer value of the current
   index.
   <p>In this example, <tt>i</tt> would take values from 100 to 110 (included). 
  -<pre>&nbsp; &lt;jx:forEach var="i" begin="100" end="110">
  -&nbsp;&nbsp;&nbsp; &lt;jx:expr value=&quot;$i&quot;/&gt;
  -&nbsp; &lt;/jx:forEach></pre>
  +<pre>&nbsp; &lt;c:forEach var="i" begin="100" end="110">
  +&nbsp;&nbsp;&nbsp; &lt;c:expr value=&quot;$i&quot;/&gt;
  +&nbsp; &lt;/c:forEach></pre>
   
   <table BORDER CELLSPACING=2 CELLPADDING=5 WIDTH="685" >
   <tr>
  @@ -350,23 +350,23 @@
   a JSP application without having the page author to use Java code.
   <p>In this example, a page author must handle an item of the iteration
   differently depending whether it is an odd or even element.
  -<p><tt>&nbsp; &lt;jx:forEach var=&quot;product&quot; items="products" status=&quot;status&quot;><br>
  -  &nbsp;&nbsp;&nbsp;&nbsp;&lt;jx:declare id=&quot;status&quot; type=&quot;javax.servlet.jsptl.IteratorTagStatus&quot;/&gt;</tt><br>
  -  <tt>&nbsp;&nbsp;&nbsp; &lt;jr:choose></tt> <br>
  -  <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;jr:when test="&lt;%= status.getCount() 
  +<p><tt>&nbsp; &lt;c:forEach var=&quot;product&quot; items="products" status=&quot;status&quot;><br>
  +  &nbsp;&nbsp;&nbsp;&nbsp;&lt;c:declare id=&quot;status&quot; type=&quot;javax.servlet.jsptl.IteratorTagStatus&quot;/&gt;</tt><br>
  +  <tt>&nbsp;&nbsp;&nbsp; &lt;c-rt:choose></tt> <br>
  +  <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;c-rt:when test="&lt;%= status.getCount() 
     % 2 == 0 %>"></tt> <br>
     <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;!-- even item --></tt> <br>
  -  <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/jr:when></tt> <br>
  -  <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;jr:otherwise></tt> <br>
  +  <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/c-rt:when></tt> <br>
  +  <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;c-rt:otherwise></tt> <br>
     <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;!-- odd item --></tt> <br>
  -  <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/jr:otherwise></tt> <br>
  -  <tt>&nbsp;&nbsp;&nbsp; &lt;/jr:choose></tt> <br>
  -  <tt>&nbsp; &lt;/jx:forEach></tt> 
  +  <tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;/c-rt:otherwise></tt> <br>
  +  <tt>&nbsp;&nbsp;&nbsp; &lt;/c-rt:choose></tt> <br>
  +  <tt>&nbsp; &lt;/c:forEach></tt> 
   <p>If this type of processing needs to be repeated often in the web applications
   of a company, it might be worth to provide page authors with a couple extra
   tags that would remove the need for conditional tags and expressions. For
   example:
  -<p><tt>&nbsp; &lt;jx:forEach items="$products"></tt> <br>
  +<p><tt>&nbsp; &lt;c:forEach items="$products"></tt> <br>
     <tt>&nbsp;&nbsp;&nbsp; &lt;xyz:even></tt>
   <br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;!-- even item --></tt>
   <br><tt>&nbsp;&nbsp;&nbsp; &lt;/xyz:even></tt>
  @@ -374,12 +374,12 @@
   <br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;!-- odd item --></tt>
   <br><tt>&nbsp;&nbsp;&nbsp; &lt;/xyz:odd></tt>
   <br>
  -  <tt>&nbsp; &lt;/jx:forEach></tt> 
  +  <tt>&nbsp; &lt;/c:forEach></tt> 
   <p>In order to make this possible, tags like <tt>&lt;odd></tt> and <tt>&lt;even></tt>
   need to be able to get access to the information exported by the <tt>forEach</tt>
   tag. This could be done explicitely, by specifying the name of the status
   object exported by the forEach tag. For example:
  -<p><tt>&nbsp; &lt;jx:forEach items="&lt;%=products%>" <font color="#3366FF">status="status"</font>></tt> 
  +<p><tt>&nbsp; &lt;c:forEach items="&lt;%=products%>" <font color="#3366FF">status="status"</font>></tt> 
     <br>
     <tt>&nbsp;&nbsp;&nbsp; &lt;xyz:even <font color="#3366FF">iter="status"</font>></tt>
   <br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;!-- even item --></tt>
  @@ -388,7 +388,7 @@
   <br><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; &lt;!-- odd item --></tt>
   <br><tt>&nbsp;&nbsp;&nbsp; &lt;/xyz:odd></tt>
   <br>
  -  <tt>&nbsp; &lt;/jx:forEach></tt> 
  +  <tt>&nbsp; &lt;/c:forEach></tt> 
   <p>The cooperation between these tags and the forEach tag can also be done
   implicitely via the <tt>findAncestorWithClass()</tt> method of the JSP
   API. This is possible because the <tt>forEach</tt> tag implements an interface
  @@ -421,7 +421,7 @@
   <pre>&nbsp; public abstract class IteratorTagSupport {
   &nbsp;&nbsp;&nbsp;&nbsp; ... (see source code)...
   &nbsp; }</pre>
  -JSPTL itself uses this inheritance-based mechanism to support additional specialized 
  +JSTL itself uses this inheritance-based mechanism to support additional specialized 
   iterator tags. For example, the <tt>&lt;forTokens></tt> tag is specialized to 
   support string tokens. It leverages the iteration behavior implemented in <tt>IteratorTagSupport</tt>, 
   and simply exposes a set of attributes that facilitate the specification of how 
  
  
  
  1.4       +240 -80   jakarta-taglibs/jsptl/doc/web/Overview.html
  
  Index: Overview.html
  ===================================================================
  RCS file: /home/cvs/jakarta-taglibs/jsptl/doc/web/Overview.html,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- Overview.html	2001/07/19 02:09:48	1.3
  +++ Overview.html	2001/11/20 12:21:46	1.4
  @@ -6,96 +6,152 @@
   
   <body bgcolor="#FFFFFF" text="#000000">
   <h1>Overview</h1>
  -<p>This document provides a high level overview of JSPTL as it stands for EA1 
  -  (Early Access release 1). If you have a strong opinion on the topic &#151; positive 
  -  (you really like it), or constructive (we messed up some parts and you have 
  -  some constructive comments for improvements) &#151; we'll be happy to hear from 
  -  you at <a href="mailto:jsr052-comments@sun.com">jsr052-comments@sun.com</a>. 
  +<p>This document provides a high level overview of the JSP&#153; Standard Tag 
  +  Library (JSTL) as it stands for EA2 (Early Access release 2). If you have a 
  +  strong opinion on the topic &#151; positive (you really like it), or constructive 
  +  (we messed up some parts and you have some constructive comments for improvements) 
  +  &#151; we'll be happy to hear from you at <a href="mailto:jsr052-comments@sun.com">jsr052-comments@sun.com</a>. 
     All comments will be read but we cannot guaranteee personal replies to all of 
     them. </p>
  -<p>Make sure you read this document first, then check out the jsptl-examples web 
  +<p>Make sure you read this document first, then check out the jstl-examples web 
     application in the release (once you have installed it on your web container 
     following the instructions in the <a href="GettingStarted.html">Getting Started</a> 
  -  document). This will help you get a good feel for what JSPTL is all about. Then 
  -  browse the other docs to get all the details, and finally give JSPTL a ride 
  -  in your own <b>prototype</b> web application. You should use JSPTL only in prototype 
  +  document). This will help you get a good feel for what JSTL is all about. Then 
  +  browse the other docs to get all the details, and finally give JSTL a ride in 
  +  your own <b>prototype</b> web application. You should use JSTL only in prototype 
     webapps because this is Early Access and things may/will change as we gather 
  -  feedback and make adjustments. Thanks for your help making JSPTL an awesome 
  -  standard tag library...</p>
  +  feedback and make adjustments. Thanks for your help making JSTL an awesome standard 
  +  tag library...</p>
   <h3>Design Philosophy</h3>
   <p>JSP tag libraries help provide a clean separation between the business logic 
     and the presentation layer of web applications. By keeping the programming logic 
     out of JSP pages, web designers are now empowered to develop sophisticated JSP 
     pages without having to resort to the scripting language associated with their 
     JSP pages (usually the Java programming language). </p>
  -<p>The base design philosophy in JSPTL is therefore to provide page authors with 
  +<p>The base design philosophy in JSTL is therefore to provide page authors with 
     a script free environment. EA1 defines the foundation elements to make this 
     possible.</p>
  -<h3>Expression Language Support</h3>
  -<p>A key contribution of JSPTL is the integration of an Expression Language (EL). 
  +<h3>Multiple TLDs</h3>
  +<p>A Tag Library is a collection of actions that encapsulate functionality to 
  +  be used from within a JSP page. JSTL includes a wide variety of actions that 
  +  naturally fit into discrete functional areas. This is why JSTL, altough a single 
  +  standard tag library, is exposed via multiple TLDs to clearly show the functional 
  +  areas it covers, as well as to give each one of them their own namespace. The 
  +  table below lists these functional areas along with their URI. The table also 
  +  shows the prefixes used in our documentation and examples (although web applications 
  +  can use any prefix they want).</p>
  +<div align="center"> 
  +  <table border="1" cellpadding="5">
  +    <tr> 
  +      <th>Funtional Area</th>
  +      <th>URI</th>
  +      <th>Prefix</th>
  +      <th>Example</th>
  +    </tr>
  +    <tr> 
  +      <td>Core</td>
  +      <td>http://java.sun.com/jstl/ea/core</td>
  +      <td> 
  +        <div align="center"><font face="Courier New, Courier, mono">c</font></div>
  +      </td>
  +      <td><font face="Courier New, Courier, mono">&lt;c:<i>tagname</i> ...&gt;</font></td>
  +    </tr>
  +    <tr> 
  +      <td>XML processing</td>
  +      <td>http://java.sun.com/jstl/ea/xml</td>
  +      <td> 
  +        <div align="center"><font face="Courier New, Courier, mono">x</font></div>
  +      </td>
  +      <td><font face="Courier New, Courier, mono">&lt;x:<i>tagname</i> ...&gt;</font></td>
  +    </tr>
  +    <tr> 
  +      <td>I18N capable formatting</td>
  +      <td>http://java.sun.com/jstl/ea/fmt</td>
  +      <td> 
  +        <div align="center"><font face="Courier New, Courier, mono">fmt</font></div>
  +      </td>
  +      <td><font face="Courier New, Courier, mono">&lt;fmt:<i>tagname</i> ...&gt;</font></td>
  +    </tr>
  +    <tr> 
  +      <td>Database access</td>
  +      <td>http://java.sun.com/jstl/ea/db</td>
  +      <td> 
  +        <div align="center"><font face="Courier New, Courier, mono">db</font></div>
  +      </td>
  +      <td><font face="Courier New, Courier, mono">&lt;db:<i>tagname</i> ...&gt;</font></td>
  +    </tr>
  +  </table>
  +</div>
  +<h3><br>
  +  Expression Language Support</h3>
  +<p>A key contribution of JSTL is the integration of an Expression Language (EL). 
     An EL leverages the fact that JSP scoped attributes are the privileged way to 
     communicate information from the business logic to the JSP pages. It makes it 
     possible to easily access application data and manipulate it in simple ways 
     without having to use scriptlets or request-time expression values. </p>
   <p>For example, this conditional tag tests whether the country of a customer is 
     the USA.</p>
  -<p><code> &nbsp;&nbsp;&lt;jx:if test=&quot;$customer.address.country == 'USA'&quot&gt;<br>
  +<p><code> &nbsp;&nbsp;&lt;c:if test=&quot;$customer.address.country == 'USA'&quot&gt;<br>
     &nbsp;&nbsp;&nbsp;&nbsp;...</code><br>
  -  <code>&nbsp;&nbsp;&lt;/jx:if&gt;</code></p>
  +  <code>&nbsp;&nbsp;&lt;/c:if&gt;</code></p>
   <p>There were quite a few issues involved with the support of an Expression Language 
  -  within JSPTL given the constraint that it had to work without requiring any 
  -  change to the JSP spec.&nbsp;In order to be able to support both the scripting 
  -  (rtexprvalues) and the EL (elexprvalues) worlds, we had to come up with the 
  -  concept of twin tag libraries: the jr tag library (Request-time expr values) 
  -  and the jx tag library (eXpression Language). Our assumption is that people 
  -  will mostly use the jx tag library, while hard core scripting page authors can 
  -  still use JSPTL with rtexprvalues (provides benefits for type safety and performance) 
  -  via the jr tag library.</p>
  +  within JSTL given the constraint that it had to work without requiring any change 
  +  to the JSP spec.&nbsp;In order to be able to support both the scripting (rtexprvalues) 
  +  and the EL (elexprvalues) worlds, we had to come up with the concept of twin 
  +  tag libraries: one that supports the expression language, and one that supports 
  +  request time expression values. Our assumption is that people will mostly use 
  +  the EL-based tag libraries, while it is still possible for hard core scripting 
  +  page authors to use JSTL with rtexprvalues (provides benefits for type safety 
  +  and performance) via the request-time based tag libraries (their URI simply 
  +  has the &quot;-rt&quot; suffix appended).</p>
   <p>It is a hard task for the Expert Group to decide on a specific EL without first 
  -  getting the general feeling from the community. This is why JSPTL currently 
  +  getting the general feeling from the community. This is why JSTL currently 
     does not define a specific EL, but provides mechanisms for experimentation with 
     a variety of ELs. Tell us what you feel is important for that EL, and feel free 
     to implement one that others can experiment with. The goal is to select a single 
  -  EL once the JSPTL spec is ready for Community Review.</p>
  -<p>Early Access one contains several candidate Expression Languages.  For
  -  more information on the "SPEL" (Simplest Possible Expression Language)
  -  language, you can read the <a href="spel">SPEL Overview</a>.</p>
  +  EL once the JSTL spec is ready for Community Review.</p>
  +<p>Early Access contains several candidate Expression Languages. One of them is 
  +  an implementation subset of ECMAScript (JavaScript) and is the one used by default. 
  +  You can read an <a href="@@@">overview of the ECMAScript subset of interest 
  +  for JSTL</a>.</p>
   <h3>Tag Collaboration</h3>
   <p>Tags usually collaborate with their environment in implicit and/or explicit 
     ways. Implicit collaboration is done via a well defined interface that allows 
     nested tags to work seamleasly with the ancestor tag exposing that interface. 
  -  The JSPTL iterator tags support this mode of collaboration. Explicit collaboration 
  +  The JSTL iterator tags support this mode of collaboration. Explicit collaboration 
     happens when a tag explicitely exposes information to its environment. Traditionally, 
     this has been done by exposing a scripting variable (with a JSP scoped attribute 
  -  providing the actual object). Because JSPTL supports an expression language, 
  +  providing the actual object). Because JSTL supports an expression language, 
     the need for scripting variables is significantly reduced. This is why all the 
  -  JSPTL tags expose information only as JSP scoped attributes (no scripting variable 
  +  JSTL tags expose information only as JSP scoped attributes (no scripting variable 
     exposed). A bold move, we agree, but we feel this is the proper design decision 
     to support script-free JSP pages. </p>
   <p>The convention is to use the name &quot;var&quot; for any tag attribute that 
     exports information about the tag. For example, an iterator tag exposes the 
     current item of the collection it is iterating over in the following way:</p>
  -<p><code>&nbsp;&nbsp;&lt;jx:forEach var=&quot;customer&quot; items=&quot;$customers&quot;&gt;</code><code><br>
  +<p><code>&nbsp;&nbsp;&lt;c:forEach var=&quot;customer&quot; items=&quot;$customers&quot;&gt;</code><code><br>
     &nbsp;&nbsp;&nbsp;&nbsp;...</code><br>
  -  <code>&nbsp;&nbsp;&lt;/jx:forEach&gt;</code></p>
  -<p>It is importnat to note that a name different that 'id' was selected to stress 
  -  the fact that a variable is exposed (actually a JSP scoped attribute), but not 
  -  a scripting variable (which is normally the case when using an attribute named 
  -  'id').</p>
  +  <code>&nbsp;&nbsp;&lt;/c:forEach&gt;</code></p>
  +<p>It is important to note that a name different than &quot;id&quot; was selected 
  +  to stress the fact that a variable is exposed (actually a JSP scoped attribute), 
  +  but not a scripting variable (which is normally the case when using an attribute 
  +  named &quot;id&quot;).</p>
  +<p>The convention also establishes the attribute &quot;scope&quot; to set the 
  +  scope (page, request, session, application) of the JSP scoped attribute.</p>
   <p>In situations where a tag exposes more than one piece of information, the name 
  -  'var' is used for the primary piece of information being exported, and an appriate 
  -  name is selected for any other secondary piece of information exposed (e.g. 
  -  an iteration current status information is exported by the foreach tag via attribute 
  -  <code>status</code>.)</p>
  -<p>The fact that JSPTL tags do not expose scripting variables would make it hard 
  +  &quot;var&quot; is used for the primary piece of information being exported, 
  +  and an appropriate name is selected for any other secondary piece of information 
  +  exposed (e.g. an iteration current status information is exported by the foreach 
  +  tag via attribute <code>status</code>.)</p>
  +<p>The fact that JSTL tags do not expose scripting variables would make it hard 
     to collaborate with other tags whose data must be passed as rtexprvalues. To 
     that effect, tag &lt;declare&gt; allows to declare a scripting variable to be 
     associated with the JSP scoped attribute of the same name.</p>
   <h3>Tag Overloading</h3>
  -<p>In JSPTL, we try as much as possible to avoid too much &quot;overloading&quot; 
  +<p>In JSTL, we try as much as possible to avoid too much &quot;overloading&quot; 
     of a tag; i.e. tags with lots of attributes that can do just about anything. 
     Rather, we privilege a larger number of tags with well focused behavior.</p>
  -<h2>JSPTL EA1 &#151; Quick Reference</h2>
  +<h2>JSTL EA1 &#151; Quick Reference</h2>
   <table width="100%" border="1" cellpadding="5">
     <tr bgcolor="#000099"> 
       <td colspan="2"><b><font color="#FFFFFF" size="+1">Expression Language Selection</font></b></td>
  @@ -104,7 +160,7 @@
       <td colspan="2"> 
         <p>Temporary mechanisms that allow for runtime pluggability of expression-language 
           evaluators. This allows for experimentation with expression languages 
  -        and is not expected to remain in the final release of JSPTL 1.0.</p>
  +        and is not expected to remain in the final release of JSTL 1.0.</p>
       </td>
     </tr>
     <tr> 
  @@ -120,10 +176,10 @@
       <td width="76%"> 
         <p><code>&lt;context-param&gt;<br>
           &nbsp;&nbsp;&lt;param-name&gt;<br>
  -        &nbsp;&nbsp;&nbsp; </code><code>javax.servlet.jsptl.ExpressionEvaluatorClass<br>
  +        &nbsp;&nbsp;&nbsp; </code><code>javax.servlet.jstl.ExpressionEvaluatorClass<br>
           &nbsp;&nbsp;&lt;/param-name&gt;<br>
           &nbsp;&nbsp;&lt;param-value&gt;<br>
  -        &nbsp;&nbsp;&nbsp; org.apache.taglibs.jsptl.lang.spel.Evaluator<br>
  +        &nbsp;&nbsp;&nbsp; org.apache.taglibs.jstl.lang.spel.Evaluator<br>
           &nbsp;&nbsp;&lt;/param-value&gt;<br>
           &lt;/context-param&gt;</code></p>
       </td>
  @@ -134,10 +190,10 @@
         <p>Change the current Expression Language</p>
       </td>
       <td width="76%"> 
  -      <p><code>&lt;jx:expressionLanguage<br>
  -        &nbsp;&nbsp;</code><code>evaluator=&quot;org.apache.taglibs.jsptl.lang.jpath.Evaluator"&gt;<br>
  +      <p><code>&lt;c:expressionLanguage<br>
  +        &nbsp;&nbsp;</code><code>evaluator=&quot;org.apache.taglibs.jstl.lang.jpath.Evaluator"&gt;<br>
           &nbsp;&nbsp;...<br>
  -        &lt;/expressionLanguage&gt;</code></p>
  +        &lt;/c:expressionLanguage&gt;</code></p>
       </td>
     </tr>
   </table>
  @@ -145,7 +201,7 @@
   <table width="100%" border="1" cellpadding="5">
     <tr bgcolor="#000099"> 
       <td colspan="2"><b><font color="#FFFFFF" size="+1">Expression Language Support 
  -      Tags</font></b></td>
  +      Tags (Core)</font></b></td>
     </tr>
     <tr bgcolor="#FFFF66"> 
       <td width="31%"><b>Element</b></td>
  @@ -154,49 +210,49 @@
     <tr> 
       <td width="31%"> 
         <p><code><b>&lt;expr&gt;</b></code><br>
  -        <code>value <font color="#0000FF">default</font> </code><br>
  +        <code><b>value</b> <font color="#000000">default</font> </code><br>
           <br>
           Like <code>&lt;%= ... %&gt;</code> but for EL expressions.<br>
         </p>
       </td>
       <td width="48%"> 
  -      <p><code>&lt;jx:set var=&quot;city&quot; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;value=&quot;$customer.address.city&quot;&gt;<br>
  +      <p><code>&lt;c:set var=&quot;city&quot; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;value=&quot;$customer.address.city&quot;&gt;<br>
           <br>
  -        &lt;jx:set var=&quot;customerFmt&quot; scope=&quot;request&quot;&gt;<br>
  +        &lt;c:set var=&quot;customerFmt&quot; scope=&quot;request&quot;&gt;<br>
           &nbsp;&nbsp;&lt;font color=red&gt;<br>
  -        &nbsp;&nbsp;&nbsp; </code><code>&lt;jx:expr value=&quot;$customer&quot;/&gt;<br>
  +        &nbsp;&nbsp;&nbsp; </code><code>&lt;c:expr value=&quot;$customer&quot;/&gt;<br>
           &nbsp; &lt;/font&gt;<br>
  -        &lt;/jx:set&gt;</code></p>
  +        &lt;/c:set&gt;</code></p>
         </td>
     </tr>
     <tr> 
       <td width="31%"><code><b>&lt;set&gt;</b></code><br>
  -      <code>var <font color="#0000FF">value</font> <font color="#0000FF">scope</font></code> 
  +      <code><b>var</b> <font color="#000000">value</font> <font color="#000000">scope</font></code> 
         <br>
         <br>
         Sets the result of an expression evaluation in a scoped attribute.<br>
         <code><br>
         </code></td>
       <td width="48%"> 
  -      <p><code>&lt;jx:set var=&quot;city&quot; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;value=&quot;$customer.address.city&quot;&gt;<br>
  +      <p><code>&lt;c:set var=&quot;city&quot; &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;value=&quot;$customer.address.city&quot;&gt;<br>
           <br>
  -        &lt;jx:set var=&quot;customerFmt&quot; scope=&quot;request&quot;&gt;<br>
  +        &lt;c:set var=&quot;customerFmt&quot; scope=&quot;request&quot;&gt;<br>
           &nbsp;&nbsp;&lt;font color=red&gt;<br>
  -        &nbsp;&nbsp;&nbsp; &lt;jx:expr value=&quot;$customer&quot;/&gt;<br>
  +        &nbsp;&nbsp;&nbsp; &lt;c:expr value=&quot;$customer&quot;/&gt;<br>
           &nbsp; &lt;/font&gt;<br>
  -        &lt;/jx:set&gt;</code></p>
  +        &lt;/c:set&gt;</code></p>
       </td>
     </tr>
     <tr> 
       <td width="31%"> 
         <p><code><b>&lt;declare&gt;<br>
  -        </b>id <font color="#0000FF">type</font><b> </b></code></p>
  +        id</b> <font color="#000000">type</font><b> </b></code></p>
         <p>Declares a scripting variable, initially defined by an existing scoped 
           attribute of the same name. The type of the variable defaults to java.lang.Object 
           but can be modified by using the 'type' attribute.</p>
       </td>
       <td width="48%"> 
  -      <p><code>&lt;jx:declare id=&quot;customer&quot; type=&quot;acme.Customer&quot;/&gt;</code></p>
  +      <p><code>&lt;c:declare id=&quot;customer&quot; type=&quot;acme.Customer&quot;/&gt;</code></p>
       </td>
     </tr>
   </table>
  @@ -204,7 +260,7 @@
   <table width="100%" border="1" cellpadding="5">
     <tr> 
       <td colspan="2" bgcolor="#000099"><b><font color="#FFFFFF" size="+1">Iterator 
  -      Tags</font></b></td>
  +      Tags (core)</font></b></td>
     </tr>
     <tr bgcolor="#FFFF66"> 
       <td width="31%"><b>Element</b></td>
  @@ -218,18 +274,18 @@
         <p>The basic iteration tag, accepting many different collection types and 
           supporting subsetting and other functionality</p>
       </td>
  -    <td width="48%" height="123"><code>&lt;jx:forEach var=&quot;customer&quot; 
  +    <td width="48%" height="123"><code>&lt;c:forEach var=&quot;customer&quot; 
         items=&quot;$customers&quot;&gt;</code><code><br>
         &nbsp;&nbsp;...<br>
  -      &lt;/jx:forEach&gt;<br>
  +      &lt;/c:forEach&gt;<br>
         <br>
  -      &lt;jx:forEach var=&quot;customer&quot; items=&quot;$customers&quot;<br>
  +      &lt;c:forEach var=&quot;customer&quot; items=&quot;$customers&quot;<br>
         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;status=&quot;status&quot; 
         <br>
         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;begin=&quot;100&quot; 
         end=&quot;200&quot; step=&quot;2&quot;&gt;</code><code><br>
         &nbsp;&nbsp;...<br>
  -      &lt;/jx:forEach&gt; </code></td>
  +      &lt;/c:forEach&gt; </code></td>
     </tr>
     <tr> 
       <td width="38%"> 
  @@ -239,10 +295,10 @@
           delims <b> </b></code></p>
         <p>Iterates over tokens, separated by the supplied delimiters</p>
       </td>
  -    <td width="48%"><code>&lt;jx:forTokens var=&quot;token&quot; items=&quot;blue|white|red&quot;<br>
  +    <td width="48%"><code>&lt;c:forTokens var=&quot;token&quot; items=&quot;blue|white|red&quot;<br>
         &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;delims=&quot;|&quot;&gt;</code><code><br>
         &nbsp;&nbsp;... <br>
  -      &lt;/jx:forTokens&gt; </code></td>
  +      &lt;/c:forTokens&gt; </code></td>
     </tr>
     <tr> 
       <td width="38%"><code><b>interface IteratorTag</b></code></td>
  @@ -252,7 +308,7 @@
     <tr> 
       <td width="38%"><code><b>interface IteratorTagStatus</b></code></td>
       <td>Provides an interface for objects representing the current status of an 
  -      iteration. JSPTL 1.0 provides a mechanism for IteratorTags to return information 
  +      iteration. JSTL 1.0 provides a mechanism for IteratorTags to return information 
         about the current index of the iteration and convenience methods to determine 
         whether or not the current round is either the first or last in the iteration. 
         It also lets authors use the status object to obtain information about the 
  @@ -261,7 +317,7 @@
     <tr> 
       <td width="38%"><code><b>abstract class IteratorTagSupport </b></code></td>
       <td>Since most iteration tags will behave identically with respect to actual 
  -      iterative behavior, JSPTL 1.0 provides this base support class to facilitate 
  +      iterative behavior, JSTL 1.0 provides this base support class to facilitate 
         implementation. Many iteration tags will extend this and merely implement 
         the hasNext() and next() methods to provide contents for the handler to 
         iterate over.</td>
  @@ -271,7 +327,7 @@
   <table width="100%" border="1" cellpadding="5">
     <tr> 
       <td colspan="2" bgcolor="#000099"><b><font color="#FFFFFF" size="+1">Conditional 
  -      Tags</font></b></td>
  +      Tags (core)</font></b></td>
     </tr>
     <tr bgcolor="#FFFF66"> 
       <td width="31%"><b>Element</b></td>
  @@ -286,12 +342,12 @@
           evaluation of this condition.</p>
       </td>
       <td width="58%" height="123"> 
  -      <p><code>&lt;jx:if test=&quot;$customer.address.country == 'USA'&quot;&gt; 
  +      <p><code>&lt;c:if test=&quot;$customer.address.country == 'USA'&quot;&gt; 
           </code><code><br>
           &nbsp;&nbsp;...<br>
  -        &lt;/jx:if&gt;<br>
  +        &lt;/c:if&gt;<br>
           <br>
  -        &lt;jx:if var=&quot;isUsCustomer&quot;<br>
  +        &lt;c:if var=&quot;isUsCustomer&quot;<br>
           &nbsp;&nbsp;test=&quot;$customer.address.country == 'USA'&quot;/&gt;</code></p>
       </td>
     </tr>
  @@ -305,7 +361,7 @@
           conditional operations, marked by<code> &lt;when&gt;</code> and <code>&lt;otherwise&gt;.</code></p>
       </td>
       <td width="58%"> 
  -      <p><code>&lt;jx:choose&gt;</code><code><br>
  +      <p><code>&lt;c:choose&gt;</code><code><br>
           &nbsp;&nbsp;&lt;when test=&quot;...&quot;&gt;<br>
           &nbsp;&nbsp;&nbsp;&nbsp;...<br>
           &nbsp;&nbsp;&lt;/when&gt; </code><code><br>
  @@ -317,7 +373,7 @@
           &nbsp;&nbsp;&nbsp;&nbsp;...<br>
           &nbsp;&nbsp;&lt;/otherwise&gt; </code><code></code><code> </code><code> 
           <br>
  -        &lt;/jx:choose&gt; </code></p>
  +        &lt;/c:choose&gt; </code></p>
       </td>
     </tr>
     <tr> 
  @@ -343,7 +399,7 @@
       </td>
       <td width="53%"> 
         <p>(Nothing special is required to use the Core TLV. This validator simply 
  -        does its best to ensure that JSPTL's tags are used correctly, reporting 
  +        does its best to ensure that JSTL's tags are used correctly, reporting 
           useful error messages when it can.)</p>
       </td>
     </tr>
  @@ -356,5 +412,109 @@
       </td>
     </tr>
   </table>
  +<br>
  +<table width="100%" border="1" cellpadding="5">
  +  <tr> 
  +    <td colspan="2" bgcolor="#000099"><b><font color="#FFFFFF" size="+1">Import 
  +      Tags (core)</font></b></td>
  +  </tr>
  +  <tr bgcolor="#FFFF66"> 
  +    <td width="39%"><b>Element</b></td>
  +    <td width="61%"><b>Sample usage</b></td>
  +  </tr>
  +  <tr> 
  +    <td width="39%" height="123"> 
  +      <p><code><b>&lt;import&gt;<br>
  +        </b><font color="#FF0000"><b><font color="#000000">url</font></b></font><font color="#0000FF"> 
  +        <font color="#000000">var varReader charEncoding</font></font> <font color="#000000">context 
  +        </font><br>
  +        <b></b><font color="#0000FF"> </font></code></p>
  +      <p>Action for a simple, generic way to access URL based resources. Extends 
  +        &lt;jsp:include&gt; to support foreign contexts and absolute URLs, as 
  +        well as to export an object for explicit collaboration with process/transformation 
  +        tags (avoiding unnecessary buffering).</p>
  +    </td>
  +    <td width="61%" height="123"> 
  +      <p><code>&lt;c:import url=&quot;ftp://ftp.acme.com/README&quot;/&gt;<br>
  +        <br>
  +        </code><code>&lt;c:import url=&quot;/xml/doc.xml&quot; varReader=&quot;in&quot;/><br>
  +        &lt;acme:process in=&quot;$in&quot;</code><code>/></code></p>
  +    </td>
  +  </tr>
  +  <tr> 
  +    <td width="39%"> 
  +      <p><code><b>&lt;param&gt;</b><br>
  +        <font color="#000000"><b>name</b></font><font color="#CC0000"> </font><font color="#000000">value 
  +        encode</font></code></p>
  +      <p>Sub-element to specify request parameters for the enclosing &lt;import&gt;. 
  +        If importing a resource using an absolute URL, the value of the parameter 
  +        is automatically encoded.</p>
  +    </td>
  +    <td width="61%"> 
  +      <p><code>&lt;c:import url=&quot;/exec/register&quot;><br>
  +        &nbsp;&nbsp;&lt;c:param name=&quot;id&quot; value=&quot;foo&quot;/&gt;<br>
  +        &lt;/c:import&gt; </code></p>
  +    </td>
  +  </tr>
  +  <tr> 
  +    <td width="39%"> 
  +      <p><code><b>&lt;urlEncode&gt;</b><br>
  +        <font color="#FF0000">value</font><font color="#CC0000"> </font><font color="#0000FF">var</font></code></p>
  +      <p>URL encoding.</p>
  +    </td>
  +    <td width="61%"> 
  +      <pre>&lt;a href=&quot;http://acme.com/register
  +   ?name=&lt;c:urlEncode value='$name'/&gt;&quot;/></pre>
  +    </td>
  +  </tr>
  +</table>
  +<br>
  +<table border="1" cellpadding="5">
  +  <tr> 
  +    <td colspan="2" bgcolor="#000099"><b><font color="#FFFFFF" size="+1">XML Core 
  +      Tags (xml)</font></b></td>
  +  </tr>
  +  <tr bgcolor="#FFFF66"> 
  +    <td width="318"><b>Element</b></td>
  +    <td width="392"><b>Sample usage</b></td>
  +  </tr>
  +  <tr> 
  +    <td width="318"><code><b>&lt;parse&gt;</b></code><br>
  +      <code><font color="#FF0000"><b><font color="#000000">var</font></b></font> 
  +      source filter</code><br>
  +      <br>
  +      Parses an XML and saves its internal representation into the JSP scoped 
  +      attribute specified by &quot;var&quot;.</td>
  +    <td width="392"> <code>&lt;c:import url=&quot;http://acme.com/athletes?country=ethiopia&quot; 
  +      var=&quot;xml&quot;/><br>
  +      &lt;x:parse source=&quot;$xml&quot; var=&quot;athletes&quot;/&gt; </code></td>
  +  </tr>
  +  <tr> 
  +    <td width="318"> 
  +      <p><code><b>&lt;expr&gt;</b></code><br>
  +        <code><font color="#000000"><b>select</b></font></code><br>
  +        <br>
  +        Evaluates the given XPath expression and outputs its text value.<br>
  +      </p>
  +    </td>
  +    <td width="392"> 
  +      <p><code>&lt;x:expr select=&quot;$ath/name&quot;/&gt;</code></p>
  +    </td>
  +  </tr>
  +  <tr> 
  +    <td width="318"> 
  +      <p><code><b>&lt;set&gt;</b></code><br>
  +        <code><font color="#000000"><b>var</b></font> <b><font color="#000000">select</font></b></code><br>
  +        <br>
  +        Evaluates the given XPath expression and saves the result into the JSP 
  +        scoped attribute specified by &quot;var&quot;.</p>
  +    </td>
  +    <td width="392"> <code>&lt;x:set<br>
  +      &nbsp;&nbsp;select=&quot;$athletes/athlete[country=$request:country]&quot; 
  +      &nbsp;&nbsp;var=&quot;athletesOfCountry&quot;/&gt;</code></td>
  +  </tr>
  +</table>
  +<br>
  +<p>&nbsp;</p>
   </body>
   </html>
  
  
  

--
To unsubscribe, e-mail:   <mailto:taglibs-dev-unsubscribe@jakarta.apache.org>
For additional commands, e-mail: <mailto:taglibs-dev-help@jakarta.apache.org>


Mime
View raw message