001    /*
002    * Licensed to the Apache Software Foundation (ASF) under one or more
003    * contributor license agreements.  See the NOTICE file distributed with
004    * this work for additional information regarding copyright ownership.
005    * The ASF licenses this file to You under the Apache License, Version 2.0
006    * (the "License"); you may not use this file except in compliance with
007    * the License.  You may obtain a copy of the License at
008    *
009    *     http://www.apache.org/licenses/LICENSE-2.0
010    *
011    * Unless required by applicable law or agreed to in writing, software
012    * distributed under the License is distributed on an "AS IS" BASIS,
013    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014    * See the License for the specific language governing permissions and
015    * limitations under the License.
016    */
017    
018     
019    package javax.servlet.jsp.tagext;
020    
021    /**
022     * Tag information for a tag in a Tag Library;
023     * This class is instantiated from the Tag Library Descriptor file (TLD)
024     * and is available only at translation time.
025     *
026     * 
027    */
028    
029    public class TagInfo {
030    
031        /**
032         * Static constant for getBodyContent() when it is JSP.
033         */
034    
035        public static final String BODY_CONTENT_JSP = "JSP";
036    
037        /**
038         * Static constant for getBodyContent() when it is Tag dependent.
039         */
040    
041        public static final String BODY_CONTENT_TAG_DEPENDENT = "tagdependent";
042    
043    
044        /**
045         * Static constant for getBodyContent() when it is empty.
046         */
047    
048        public static final String BODY_CONTENT_EMPTY = "empty";
049        
050        /**
051         * Static constant for getBodyContent() when it is scriptless.
052         * 
053         * @since 2.0
054         */ 
055        public static final String BODY_CONTENT_SCRIPTLESS = "scriptless";                      
056    
057        /**
058         * Constructor for TagInfo from data in the JSP 1.1 format for TLD.
059         * This class is to be instantiated only from the TagLibrary code
060         * under request from some JSP code that is parsing a
061         * TLD (Tag Library Descriptor).
062         *
063         * Note that, since TagLibibraryInfo reflects both TLD information
064         * and taglib directive information, a TagInfo instance is
065         * dependent on a taglib directive.  This is probably a
066         * design error, which may be fixed in the future.
067         *
068         * @param tagName The name of this tag
069         * @param tagClassName The name of the tag handler class
070         * @param bodycontent Information on the body content of these tags
071         * @param infoString The (optional) string information for this tag
072         * @param taglib The instance of the tag library that contains us.
073         * @param tagExtraInfo The instance providing extra Tag info.  May be null
074         * @param attributeInfo An array of AttributeInfo data from descriptor.
075         * May be null;
076         *
077         */
078        public TagInfo(String tagName,
079                String tagClassName,
080                String bodycontent,
081                String infoString,
082                TagLibraryInfo taglib,
083                TagExtraInfo tagExtraInfo,
084                TagAttributeInfo[] attributeInfo) {
085            this.tagName       = tagName;
086            this.tagClassName  = tagClassName;
087            this.bodyContent   = bodycontent;
088            this.infoString    = infoString;
089            this.tagLibrary    = taglib;
090            this.tagExtraInfo  = tagExtraInfo;
091            this.attributeInfo = attributeInfo;
092    
093            if (tagExtraInfo != null)
094                tagExtraInfo.setTagInfo(this);
095        }
096                             
097        /**
098         * Constructor for TagInfo from data in the JSP 1.2 format for TLD.
099         * This class is to be instantiated only from the TagLibrary code
100         * under request from some JSP code that is parsing a
101         * TLD (Tag Library Descriptor).
102         *
103         * Note that, since TagLibibraryInfo reflects both TLD information
104         * and taglib directive information, a TagInfo instance is
105         * dependent on a taglib directive.  This is probably a
106         * design error, which may be fixed in the future.
107         *
108         * @param tagName The name of this tag
109         * @param tagClassName The name of the tag handler class
110         * @param bodycontent Information on the body content of these tags
111         * @param infoString The (optional) string information for this tag
112         * @param taglib The instance of the tag library that contains us.
113         * @param tagExtraInfo The instance providing extra Tag info.  May be null
114         * @param attributeInfo An array of AttributeInfo data from descriptor.
115         * May be null;
116         * @param displayName A short name to be displayed by tools
117         * @param smallIcon Path to a small icon to be displayed by tools
118         * @param largeIcon Path to a large icon to be displayed by tools
119         * @param tvi An array of a TagVariableInfo (or null)
120         */
121        public TagInfo(String tagName,
122                String tagClassName,
123                String bodycontent,
124                String infoString,
125                TagLibraryInfo taglib,
126                TagExtraInfo tagExtraInfo,
127                TagAttributeInfo[] attributeInfo,
128                String displayName,
129                String smallIcon,
130                String largeIcon,
131                TagVariableInfo[] tvi) {
132            this.tagName       = tagName;
133            this.tagClassName  = tagClassName;
134            this.bodyContent   = bodycontent;
135            this.infoString    = infoString;
136            this.tagLibrary    = taglib;
137            this.tagExtraInfo  = tagExtraInfo;
138            this.attributeInfo = attributeInfo;
139            this.displayName = displayName;
140            this.smallIcon = smallIcon;
141            this.largeIcon = largeIcon;
142            this.tagVariableInfo = tvi;
143    
144            if (tagExtraInfo != null)
145                tagExtraInfo.setTagInfo(this);
146        }
147                             
148        /**
149         * Constructor for TagInfo from data in the JSP 2.0 format for TLD.
150         * This class is to be instantiated only from the TagLibrary code
151         * under request from some JSP code that is parsing a
152         * TLD (Tag Library Descriptor).
153         *
154         * Note that, since TagLibibraryInfo reflects both TLD information
155         * and taglib directive information, a TagInfo instance is
156         * dependent on a taglib directive.  This is probably a
157         * design error, which may be fixed in the future.
158         *
159         * @param tagName The name of this tag
160         * @param tagClassName The name of the tag handler class
161         * @param bodycontent Information on the body content of these tags
162         * @param infoString The (optional) string information for this tag
163         * @param taglib The instance of the tag library that contains us.
164         * @param tagExtraInfo The instance providing extra Tag info.  May be null
165         * @param attributeInfo An array of AttributeInfo data from descriptor.
166         * May be null;
167         * @param displayName A short name to be displayed by tools
168         * @param smallIcon Path to a small icon to be displayed by tools
169         * @param largeIcon Path to a large icon to be displayed by tools
170         * @param tvi An array of a TagVariableInfo (or null)
171         * @param dynamicAttributes True if supports dynamic attributes
172         *
173         * @since 2.0
174         */
175        public TagInfo(String tagName,
176                String tagClassName,
177                String bodycontent,
178                String infoString,
179                TagLibraryInfo taglib,
180                TagExtraInfo tagExtraInfo,
181                TagAttributeInfo[] attributeInfo,
182                String displayName,
183                String smallIcon,
184                String largeIcon,
185                TagVariableInfo[] tvi,
186                boolean dynamicAttributes) {
187            this.tagName       = tagName;
188            this.tagClassName  = tagClassName;
189            this.bodyContent   = bodycontent;
190            this.infoString    = infoString;
191            this.tagLibrary    = taglib;
192            this.tagExtraInfo  = tagExtraInfo;
193            this.attributeInfo = attributeInfo;
194            this.displayName = displayName;
195            this.smallIcon = smallIcon;
196            this.largeIcon = largeIcon;
197            this.tagVariableInfo = tvi;
198            this.dynamicAttributes = dynamicAttributes;
199    
200            if (tagExtraInfo != null)
201                tagExtraInfo.setTagInfo(this);
202        }
203    
204        /**
205         * The name of the Tag.
206         *
207         * @return The (short) name of the tag.
208         */
209    
210        public String getTagName() {
211            return tagName;
212        }
213    
214        /**
215         * Attribute information (in the TLD) on this tag.
216         * The return is an array describing the attributes of this tag, as
217         * indicated in the TLD.
218         *
219         * @return The array of TagAttributeInfo for this tag, or a
220         *         zero-length array if the tag has no attributes.
221         */
222    
223       public TagAttributeInfo[] getAttributes() {
224           return attributeInfo;
225       }
226    
227        /**
228         * Information on the scripting objects created by this tag at runtime.
229         * This is a convenience method on the associated TagExtraInfo class.
230         *
231         * @param data TagData describing this action.
232         * @return if a TagExtraInfo object is associated with this TagInfo, the
233         *     result of getTagExtraInfo().getVariableInfo( data ), otherwise
234         *     null.
235         */
236       public VariableInfo[] getVariableInfo(TagData data) {
237           VariableInfo[] result = null;
238           TagExtraInfo tei = getTagExtraInfo();
239           if (tei != null) {
240               result = tei.getVariableInfo( data );
241           }
242           return result;
243       }
244    
245        /**
246         * Translation-time validation of the attributes. 
247         * This is a convenience method on the associated TagExtraInfo class.
248         *
249         * @param data The translation-time TagData instance.
250         * @return Whether the data is valid.
251         */
252        public boolean isValid(TagData data) {
253            TagExtraInfo tei = getTagExtraInfo();
254            if (tei == null) {
255                return true;
256            }
257            return tei.isValid(data);
258        }
259    
260        /**
261         * Translation-time validation of the attributes.
262         * This is a convenience method on the associated TagExtraInfo class.
263         *
264         * @param data The translation-time TagData instance.
265         * @return A null object, or zero length array if no errors, an
266         *     array of ValidationMessages otherwise.
267         * @since 2.0
268         */
269        public ValidationMessage[] validate( TagData data ) {
270            TagExtraInfo tei = getTagExtraInfo();
271            if( tei == null ) {
272                return null;
273            }
274            return tei.validate( data );
275        }
276    
277        /**
278         * Set the instance for extra tag information.
279         * 
280         * @param tei the TagExtraInfo instance
281         */
282        public void setTagExtraInfo(TagExtraInfo tei) {
283            tagExtraInfo = tei;
284        }
285    
286    
287        /**
288         * The instance (if any) for extra tag information.
289         * 
290         * @return The TagExtraInfo instance, if any.
291         */
292        public TagExtraInfo getTagExtraInfo() {
293            return tagExtraInfo;
294        }
295    
296    
297        /**
298         * Name of the class that provides the handler for this tag.
299         *
300         * @return The name of the tag handler class.
301         */
302        
303        public String getTagClassName() {
304            return tagClassName;
305        }
306    
307    
308        /**
309         * The bodycontent information for this tag.
310         * If the bodycontent is not defined for this
311         * tag, the default of JSP will be returned.
312         *
313         * @return the body content string.
314         */
315    
316        public String getBodyContent() {
317            return bodyContent;
318        }
319    
320    
321        /**
322         * The information string for the tag.
323         *
324         * @return the info string, or null if 
325         *         not defined
326         */
327    
328        public String getInfoString() {
329            return infoString;
330        }
331    
332    
333        /**
334         * Set the TagLibraryInfo property.
335         *
336         * Note that a TagLibraryInfo element is dependent
337         * not just on the TLD information but also on the
338         * specific taglib instance used.  This means that
339         * a fair amount of work needs to be done to construct
340         * and initialize TagLib objects.
341         *
342         * If used carefully, this setter can be used to avoid having to
343         * create new TagInfo elements for each taglib directive.
344         *
345         * @param tl the TagLibraryInfo to assign
346         */
347    
348        public void setTagLibrary(TagLibraryInfo tl) {
349            tagLibrary = tl;
350        }
351    
352        /**
353         * The instance of TabLibraryInfo we belong to.
354         *
355         * @return the tag library instance we belong to
356         */
357    
358        public TagLibraryInfo getTagLibrary() {
359            return tagLibrary;
360        }
361    
362    
363        // ============== JSP 2.0 TLD Information ========
364    
365    
366        /**
367         * Get the displayName.
368         *
369         * @return A short name to be displayed by tools,
370         *         or null if not defined
371         */
372    
373        public String getDisplayName() {
374            return displayName;
375        }
376    
377        /**
378         * Get the path to the small icon.
379         *
380         * @return Path to a small icon to be displayed by tools,
381         *         or null if not defined
382         */
383    
384        public String getSmallIcon() {
385            return smallIcon;
386        }
387    
388        /**
389         * Get the path to the large icon.
390         *
391         * @return Path to a large icon to be displayed by tools,
392         *         or null if not defined
393         */
394    
395        public String getLargeIcon() {
396            return largeIcon;
397        }
398    
399        /**
400         * Get TagVariableInfo objects associated with this TagInfo.
401         *
402         * @return Array of TagVariableInfo objects corresponding to
403         *         variables declared by this tag, or a zero length
404         *         array if no variables have been declared
405         */
406    
407        public TagVariableInfo[] getTagVariableInfos() {
408            return tagVariableInfo;
409        }
410    
411    
412        // ============== JSP 2.0 TLD Information ========
413    
414        /**
415         * Get dynamicAttributes associated with this TagInfo.
416         *
417         * @return True if tag handler supports dynamic attributes
418         * @since 2.0
419         */
420        public boolean hasDynamicAttributes() {
421            return dynamicAttributes;
422        }
423    
424        /*
425         * private fields for 1.1 info
426         */
427        private String             tagName; // the name of the tag
428        private String             tagClassName;
429        private String             bodyContent;
430        private String             infoString;
431        private TagLibraryInfo     tagLibrary;
432        private TagExtraInfo       tagExtraInfo; // instance of TagExtraInfo
433        private TagAttributeInfo[] attributeInfo;
434    
435        /*
436         * private fields for 1.2 info
437         */
438        private String             displayName;
439        private String             smallIcon;
440        private String             largeIcon;
441        private TagVariableInfo[]  tagVariableInfo;
442    
443        /*
444         * Additional private fields for 2.0 info
445         */
446        private boolean dynamicAttributes;
447    }