View Javadoc

1   /*
2    * Copyright 2002,2004 The Apache Software Foundation.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  
17  package org.apache.commons.jelly;
18  
19  import java.io.File;
20  import java.util.HashMap;
21  import java.util.Map;
22  
23  import org.apache.commons.beanutils.ConvertUtils;
24  import org.apache.commons.beanutils.Converter;
25  
26  import org.apache.commons.jelly.expression.CompositeExpression;
27  import org.apache.commons.jelly.expression.ConstantExpression;
28  import org.apache.commons.jelly.expression.Expression;
29  import org.apache.commons.jelly.expression.ExpressionFactory;
30  import org.apache.commons.jelly.impl.TagFactory;
31  import org.apache.commons.jelly.impl.TagScript;
32  
33  import org.xml.sax.Attributes;
34  
35  /*** <p><code>Taglib</code> represents the metadata for a Jelly custom tag library.</p>
36    *
37    * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
38    * @version $Revision: 155420 $
39    */
40  
41  public abstract class TagLibrary {
42  
43      private Map tags = new HashMap();
44  
45      static {
46  
47          // register standard converters
48  
49          ConvertUtils.register(
50              new Converter() {
51                  public Object convert(Class type, Object value) {
52                      if ( value instanceof File ) {
53                          return (File) value;
54                      }
55                      else if ( value != null ) {
56                          String text = value.toString();
57                          return new File( text );
58                      }
59                      return null;
60                  }
61              },
62              File.class
63          );
64      }
65  
66      public TagLibrary() {
67      }
68  
69      /*** Creates a new script to execute the given tag name and attributes */
70      public TagScript createTagScript(String name, Attributes attributes)
71          throws JellyException {
72  
73          Object value = tags.get(name);
74          if (value instanceof Class) {
75              Class type = (Class) value;
76              return TagScript.newInstance(type);
77          }
78          else if (value instanceof TagFactory) {
79              return new TagScript( (TagFactory) value );
80          }
81          return null;
82  
83      }
84  
85      /*** Creates a new Tag for the given tag name and attributes */
86      public Tag createTag(String name, Attributes attributes)
87          throws JellyException {
88  
89          Object value = tags.get(name);
90          if (value instanceof Class) {
91              Class type = (Class) value;
92              try {
93                  return (Tag) type.newInstance();
94              } catch (InstantiationException e) {
95                  throw new JellyException(e.toString());
96              } catch (IllegalAccessException e) {
97                  throw new JellyException(e.toString());
98              }
99          }
100         else if (value instanceof TagFactory) {
101             TagFactory factory = (TagFactory) value;
102             return factory.createTag(name, attributes);
103         }
104         return null;
105     }
106 
107     /*** Allows taglibs to use their own expression evaluation mechanism */
108     public Expression createExpression(
109         ExpressionFactory factory,
110         TagScript tagScript,
111         String attributeName,
112         String attributeValue)
113         throws JellyException {
114 
115         ExpressionFactory myFactory = getExpressionFactory();
116         if (myFactory == null) {
117             myFactory = factory;
118         }
119         if (myFactory != null) {
120             return CompositeExpression.parse(attributeValue, myFactory);
121         }
122 
123         // will use a constant expression instead
124         return new ConstantExpression(attributeValue);
125     }
126 
127 
128     // Implementation methods
129     //-------------------------------------------------------------------------
130 
131     /***
132      * Registers a tag implementation Class for a given tag name
133      */
134     protected void registerTag(String name, Class type) {
135         tags.put(name, type);
136     }
137 
138     /***
139      * Registers a tag factory for a given tag name
140      */
141     protected void registerTagFactory(String name, TagFactory tagFactory) {
142         tags.put(name, tagFactory);
143     }
144 
145     /*** Allows derived tag libraries to use their own factory */
146     protected ExpressionFactory getExpressionFactory() {
147         return null;
148     }
149 
150     protected Map getTagClasses() {
151         return tags;
152     }
153 
154 }