View Javadoc

    1   /**
    2    *
    3    * Copyright 2003-2004 The Apache Software Foundation
    4    *
    5    *  Licensed under the Apache License, Version 2.0 (the "License");
    6    *  you may not use this file except in compliance with the License.
    7    *  You may obtain a copy of the License at
    8    *
    9    *     http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   *  Unless required by applicable law or agreed to in writing, software
    12   *  distributed under the License is distributed on an "AS IS" BASIS,
    13   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   *  See the License for the specific language governing permissions and
    15   *  limitations under the License.
    16   */
    17
    18  //
    19  // This source code implements specifications defined by the Java
    20  // Community Process. In order to remain compliant with the specification
    21  // DO NOT add / change / or delete method signatures!
    22  //
    23
    24  package javax.servlet.jsp.tagext;
    25
    26  /**
    27   * Tag information for a tag in a Tag Library;
    28   * This class is instantiated from the Tag Library Descriptor file (TLD)
    29   * and is available only at translation time.
    30   *
    31   *
    32  */
    33
    34  public class TagInfo {
    35
    36      /**
    37       * Static constant for getBodyContent() when it is JSP.
    38       */
    39
    40      public static final String BODY_CONTENT_JSP = "JSP";
    41
    42      /**
    43       * Static constant for getBodyContent() when it is Tag dependent.
    44       */
    45
    46      public static final String BODY_CONTENT_TAG_DEPENDENT = "TAGDEPENDENT";
    47
    48
    49      /**
    50       * Static constant for getBodyContent() when it is empty.
    51       */
    52
    53      public static final String BODY_CONTENT_EMPTY = "EMPTY";
    54
    55      /**
    56       * Static constant for getBodyContent() when it is scriptless.
    57       *
    58       * @since 2.0
    59       */
    60      public static final String BODY_CONTENT_SCRIPTLESS = "SCRIPTLESS";
    61
    62      /**
    63       * Constructor for TagInfo from data in the JSP 1.1 format for TLD.
    64       * This class is to be instantiated only from the TagLibrary code
    65       * under request from some JSP code that is parsing a
    66       * TLD (Tag Library Descriptor).
    67       *
    68       * Note that, since TagLibibraryInfo reflects both TLD information
    69       * and taglib directive information, a TagInfo instance is
    70       * dependent on a taglib directive.  This is probably a
    71       * design error, which may be fixed in the future.
    72       *
    73       * @param tagName The name of this tag
    74       * @param tagClassName The name of the tag handler class
    75       * @param bodycontent Information on the body _content of these tags
    76       * @param infoString The (optional) string information for this tag
    77       * @param taglib The instance of the tag library that contains us.
    78       * @param tagExtraInfo The instance providing extra Tag info.  May be null
    79       * @param attributeInfo An array of AttributeInfo data from descriptor.
    80       * May be null;
    81       *
    82       */
    83      public TagInfo(String tagName,
    84  	    String tagClassName,
    85  	    String bodycontent,
    86  	    String infoString,
    87  	    TagLibraryInfo taglib,
    88  	    TagExtraInfo tagExtraInfo,
    89  	    TagAttributeInfo[] attributeInfo) {
    90  	this.tagName       = tagName;
    91  	this.tagClassName  = tagClassName;
    92  	this.bodyContent   = bodycontent;
    93  	this.infoString    = infoString;
    94  	this.tagLibrary    = taglib;
    95  	this.tagExtraInfo  = tagExtraInfo;
    96  	this.attributeInfo = attributeInfo;
    97
    98  	if (tagExtraInfo != null)
    99              tagExtraInfo.setTagInfo(this);
    100     }
    101
    102     /**
    103      * Constructor for TagInfo from data in the JSP 1.2 format for TLD.
    104      * This class is to be instantiated only from the TagLibrary code
    105      * under request from some JSP code that is parsing a
    106      * TLD (Tag Library Descriptor).
    107      *
    108      * Note that, since TagLibibraryInfo reflects both TLD information
    109      * and taglib directive information, a TagInfo instance is
    110      * dependent on a taglib directive.  This is probably a
    111      * design error, which may be fixed in the future.
    112      *
    113      * @param tagName The name of this tag
    114      * @param tagClassName The name of the tag handler class
    115      * @param bodycontent Information on the body _content of these tags
    116      * @param infoString The (optional) string information for this tag
    117      * @param taglib The instance of the tag library that contains us.
    118      * @param tagExtraInfo The instance providing extra Tag info.  May be null
    119      * @param attributeInfo An array of AttributeInfo data from descriptor.
    120      * May be null;
    121      * @param displayName A short name to be displayed by tools
    122      * @param smallIcon Path to a small icon to be displayed by tools
    123      * @param largeIcon Path to a large icon to be displayed by tools
    124      * @param tvi An array of a TagVariableInfo (or null)
    125      */
    126     public TagInfo(String tagName,
    127 	    String tagClassName,
    128 	    String bodycontent,
    129 	    String infoString,
    130 	    TagLibraryInfo taglib,
    131 	    TagExtraInfo tagExtraInfo,
    132 	    TagAttributeInfo[] attributeInfo,
    133 	    String displayName,
    134 	    String smallIcon,
    135 	    String largeIcon,
    136 	    TagVariableInfo[] tvi) {
    137 	this.tagName       = tagName;
    138 	this.tagClassName  = tagClassName;
    139 	this.bodyContent   = bodycontent;
    140 	this.infoString    = infoString;
    141 	this.tagLibrary    = taglib;
    142 	this.tagExtraInfo  = tagExtraInfo;
    143 	this.attributeInfo = attributeInfo;
    144 	this.displayName = displayName;
    145 	this.smallIcon = smallIcon;
    146 	this.largeIcon = largeIcon;
    147 	this.tagVariableInfo = tvi;
    148
    149 	if (tagExtraInfo != null)
    150             tagExtraInfo.setTagInfo(this);
    151     }
    152
    153     /**
    154      * Constructor for TagInfo from data in the JSP 2.0 format for TLD.
    155      * This class is to be instantiated only from the TagLibrary code
    156      * under request from some JSP code that is parsing a
    157      * TLD (Tag Library Descriptor).
    158      *
    159      * Note that, since TagLibibraryInfo reflects both TLD information
    160      * and taglib directive information, a TagInfo instance is
    161      * dependent on a taglib directive.  This is probably a
    162      * design error, which may be fixed in the future.
    163      *
    164      * @param tagName The name of this tag
    165      * @param tagClassName The name of the tag handler class
    166      * @param bodycontent Information on the body _content of these tags
    167      * @param infoString The (optional) string information for this tag
    168      * @param taglib The instance of the tag library that contains us.
    169      * @param tagExtraInfo The instance providing extra Tag info.  May be null
    170      * @param attributeInfo An array of AttributeInfo data from descriptor.
    171      * May be null;
    172      * @param displayName A short name to be displayed by tools
    173      * @param smallIcon Path to a small icon to be displayed by tools
    174      * @param largeIcon Path to a large icon to be displayed by tools
    175      * @param tvi An array of a TagVariableInfo (or null)
    176      * @param dynamicAttributes True if supports dynamic attributes
    177      *
    178      * @since 2.0
    179      */
    180     public TagInfo(String tagName,
    181             String tagClassName,
    182             String bodycontent,
    183             String infoString,
    184             TagLibraryInfo taglib,
    185             TagExtraInfo tagExtraInfo,
    186             TagAttributeInfo[] attributeInfo,
    187             String displayName,
    188             String smallIcon,
    189             String largeIcon,
    190             TagVariableInfo[] tvi,
    191             boolean dynamicAttributes) {
    192         this.tagName       = tagName;
    193         this.tagClassName  = tagClassName;
    194         this.bodyContent   = bodycontent;
    195         this.infoString    = infoString;
    196         this.tagLibrary    = taglib;
    197         this.tagExtraInfo  = tagExtraInfo;
    198         this.attributeInfo = attributeInfo;
    199         this.displayName = displayName;
    200         this.smallIcon = smallIcon;
    201         this.largeIcon = largeIcon;
    202         this.tagVariableInfo = tvi;
    203         this.dynamicAttributes = dynamicAttributes;
    204
    205         if (tagExtraInfo != null)
    206             tagExtraInfo.setTagInfo(this);
    207     }
    208
    209     /**
    210      * The name of the Tag.
    211      *
    212      * @return The (short) name of the tag.
    213      */
    214
    215     public String getTagName() {
    216 	return tagName;
    217     }
    218
    219     /**
    220      * Attribute information (in the TLD) on this tag.
    221      * The return is an array describing the attributes of this tag, as
    222      * indicated in the TLD.
    223      *
    224      * @return The array of TagAttributeInfo for this tag, or a
    225      *         zero-length array if the tag has no attributes.
    226      */
    227
    228    public TagAttributeInfo[] getAttributes() {
    229        return attributeInfo;
    230    }
    231
    232     /**
    233      * Information on the scripting objects created by this tag at runtime.
    234      * This is a convenience method on the associated TagExtraInfo class.
    235      *
    236      * @param data TagData describing this action.
    237      * @return if a TagExtraInfo object is associated with this TagInfo, the
    238      *     result of getTagExtraInfo().getVariableInfo( data ), otherwise
    239      *     null.
    240      */
    241    public VariableInfo[] getVariableInfo(TagData data) {
    242        VariableInfo[] result = null;
    243        TagExtraInfo tei = getTagExtraInfo();
    244        if (tei != null) {
    245 	   result = tei.getVariableInfo( data );
    246        }
    247        return result;
    248    }
    249
    250     /**
    251      * Translation-time validation of the attributes.
    252      * This is a convenience method on the associated TagExtraInfo class.
    253      *
    254      * @param data The translation-time TagData instance.
    255      * @return Whether the data is valid.
    256      */
    257     public boolean isValid(TagData data) {
    258         TagExtraInfo tei = getTagExtraInfo();
    259         if (tei == null) {
    260 	    return true;
    261         }
    262         return tei.isValid(data);
    263     }
    264
    265     /**
    266      * Translation-time validation of the attributes.
    267      * This is a convenience method on the associated TagExtraInfo class.
    268      *
    269      * @param data The translation-time TagData instance.
    270      * @return A null object, or zero length array if no errors, an
    271      *     array of ValidationMessages otherwise.
    272      * @since 2.0
    273      */
    274     public ValidationMessage[] validate( TagData data ) {
    275 	TagExtraInfo tei = getTagExtraInfo();
    276 	if( tei == null ) {
    277 	    return null;
    278 	}
    279 	return tei.validate( data );
    280     }
    281
    282     /**
    283      * Set the instance for extra tag information.
    284      *
    285      * @param tei the TagExtraInfo instance
    286      */
    287     public void setTagExtraInfo(TagExtraInfo tei) {
    288 	tagExtraInfo = tei;
    289     }
    290
    291
    292     /**
    293      * The instance (if any) for extra tag information.
    294      *
    295      * @return The TagExtraInfo instance, if any.
    296      */
    297     public TagExtraInfo getTagExtraInfo() {
    298 	return tagExtraInfo;
    299     }
    300
    301
    302     /**
    303      * Name of the class that provides the handler for this tag.
    304      *
    305      * @return The name of the tag handler class.
    306      */
    307
    308     public String getTagClassName() {
    309 	return tagClassName;
    310     }
    311
    312
    313     /**
    314      * The bodycontent information for this tag.
    315      * If the bodycontent is not defined for this
    316      * tag, the default of JSP will be returned.
    317      *
    318      * @return the body _content string.
    319      */
    320
    321     public String getBodyContent() {
    322 	return bodyContent;
    323     }
    324
    325
    326     /**
    327      * The information string for the tag.
    328      *
    329      * @return the info string, or null if
    330      *         not defined
    331      */
    332
    333     public String getInfoString() {
    334 	return infoString;
    335     }
    336
    337
    338     /**
    339      * Set the TagLibraryInfo property.
    340      *
    341      * Note that a TagLibraryInfo element is dependent
    342      * not just on the TLD information but also on the
    343      * specific taglib instance used.  This means that
    344      * a fair amount of work needs to be done to construct
    345      * and initialize TagLib objects.
    346      *
    347      * If used carefully, this setter can be used to avoid having to
    348      * create new TagInfo elements for each taglib directive.
    349      *
    350      * @param tl the TagLibraryInfo to assign
    351      */
    352
    353     public void setTagLibrary(TagLibraryInfo tl) {
    354 	tagLibrary = tl;
    355     }
    356
    357     /**
    358      * The instance of TabLibraryInfo we belong to.
    359      *
    360      * @return the tag library instance we belong to
    361      */
    362
    363     public TagLibraryInfo getTagLibrary() {
    364 	return tagLibrary;
    365     }
    366
    367
    368     // ============== JSP 2.0 TLD Information ========
    369
    370
    371     /**
    372      * Get the displayName.
    373      *
    374      * @return A short name to be displayed by tools,
    375      *         or null if not defined
    376      */
    377
    378     public String getDisplayName() {
    379 	return displayName;
    380     }
    381
    382     /**
    383      * Get the path to the small icon.
    384      *
    385      * @return Path to a small icon to be displayed by tools,
    386      *         or null if not defined
    387      */
    388
    389     public String getSmallIcon() {
    390 	return smallIcon;
    391     }
    392
    393     /**
    394      * Get the path to the large icon.
    395      *
    396      * @return Path to a large icon to be displayed by tools,
    397      *         or null if not defined
    398      */
    399
    400     public String getLargeIcon() {
    401 	return largeIcon;
    402     }
    403
    404     /**
    405      * Get TagVariableInfo objects associated with this TagInfo.
    406      *
    407      * @return Array of TagVariableInfo objects corresponding to
    408      *         variables declared by this tag, or a zero length
    409      *         array if no variables have been declared
    410      */
    411
    412     public TagVariableInfo[] getTagVariableInfos() {
    413 	return tagVariableInfo;
    414     }
    415
    416
    417     // ============== JSP 2.0 TLD Information ========
    418
    419     /**
    420      * Get dynamicAttributes associated with this TagInfo.
    421      *
    422      * @return True if tag handler supports dynamic attributes
    423      * @since 2.0
    424      */
    425     public boolean hasDynamicAttributes() {
    426         return dynamicAttributes;
    427     }
    428
    429     /*
    430      * private fields for 1.1 info
    431      */
    432     private String             tagName; // the name of the tag
    433     private String             tagClassName;
    434     private String             bodyContent;
    435     private String             infoString;
    436     private TagLibraryInfo     tagLibrary;
    437     private TagExtraInfo       tagExtraInfo; // instance of TagExtraInfo
    438     private TagAttributeInfo[] attributeInfo;
    439
    440     /*
    441      * private fields for 1.2 info
    442      */
    443     private String             displayName;
    444     private String             smallIcon;
    445     private String             largeIcon;
    446     private TagVariableInfo[]  tagVariableInfo;
    447
    448     /*
    449      * Additional private fields for 2.0 info
    450      */
    451     private boolean dynamicAttributes;
    452 }