1 package org.apache.turbine.services.template.mapper;
2
3
4 /*
5 * Licensed to the Apache Software Foundation (ASF) under one
6 * or more contributor license agreements. See the NOTICE file
7 * distributed with this work for additional information
8 * regarding copyright ownership. The ASF licenses this file
9 * to you under the Apache License, Version 2.0 (the
10 * "License"); you may not use this file except in compliance
11 * with the License. You may obtain a copy of the License at
12 *
13 * http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing,
16 * software distributed under the License is distributed on an
17 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
18 * KIND, either express or implied. See the License for the
19 * specific language governing permissions and limitations
20 * under the License.
21 */
22
23
24 import java.util.HashMap;
25 import java.util.Map;
26
27 import org.apache.commons.lang.StringUtils;
28 import org.apache.turbine.services.template.TemplateEngineService;
29 import org.apache.turbine.services.template.TurbineTemplate;
30
31 /**
32 * A base class for the various mappers which contains common
33 * code.
34 *
35 * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
36 * @version $Id: BaseMapper.java 1706239 2015-10-01 13:18:35Z tv $
37 */
38
39 public abstract class BaseMapper
40 {
41 /** True if this mapper should cache template -> name mappings */
42 private boolean useCache = false;
43
44 /** Default cache size. Just a number out of thin air. Will be set at init time */
45 private int cacheSize = 5;
46
47 /** The internal template -> name mapping cache */
48 private Map<String, String> templateCache = null;
49
50 /** The name of the default property to pull from the Template Engine Service if the default is requested */
51 protected String defaultProperty;
52
53 /** The separator used to concatenate the result parts for this mapper. */
54 protected char separator;
55
56 // Note: You might _not_ use TurbineTemplate.<xxx> in the C'tor and the init method.
57 // The service isn't configured yet and if you do, the Broker will try to reinit the
58 // Service which leads to an endless loop and a deadlock.
59
60 /**
61 * Default C'tor. If you use this C'tor, you must use
62 * the bean setter to set the various properties needed for
63 * this mapper before first usage.
64 */
65 public BaseMapper()
66 {
67 // empty
68 }
69
70 /**
71 * Get the CacheSize value.
72 * @return the CacheSize value.
73 */
74 public int getCacheSize()
75 {
76 return cacheSize;
77 }
78
79 /**
80 * Set the CacheSize value.
81 * @param cacheSize The new CacheSize value.
82 */
83 public void setCacheSize(int cacheSize)
84 {
85 this.cacheSize = cacheSize;
86 }
87
88 /**
89 * Get the UseCache value.
90 * @return the UseCache value.
91 */
92 public boolean isUseCache()
93 {
94 return useCache;
95 }
96
97 /**
98 * Set the UseCache value.
99 * @param useCache The new UseCache value.
100 */
101 public void setUseCache(boolean useCache)
102 {
103 this.useCache = useCache;
104 }
105
106 /**
107 * Get the DefaultProperty value.
108 * @return the DefaultProperty value.
109 */
110 public String getDefaultProperty()
111 {
112 return defaultProperty;
113 }
114
115 /**
116 * Set the DefaultProperty value.
117 * @param defaultProperty The new DefaultProperty value.
118 */
119 public void setDefaultProperty(String defaultProperty)
120 {
121 this.defaultProperty = defaultProperty;
122 }
123
124 /**
125 * Get the Separator value.
126 * @return the Separator value.
127 */
128 public char getSeparator()
129 {
130 return separator;
131 }
132
133 /**
134 * Set the Separator value.
135 * @param separator The new Separator value.
136 */
137 public void setSeparator(char separator)
138 {
139 this.separator = separator;
140 }
141
142 /**
143 * Initializes the Mapper. Must be called before the mapper might be used.
144 */
145 public void init()
146 {
147 if (useCache)
148 {
149 templateCache = new HashMap<String, String>(cacheSize);
150 }
151 }
152
153 /**
154 * Returns the default name for the passed Template.
155 * If the passed template has no extension,
156 * the default extension is assumed.
157 * If the template is empty, the default template is
158 * returned.
159 *
160 * @param template The template name.
161 *
162 * @return the mapped default name for the template.
163 */
164
165 public String getDefaultName(String template)
166 {
167 // We might get a Name without an extension passed. If yes, then we use
168 // the Default extension
169
170 TemplateEngineService tes
171 = TurbineTemplate.getTemplateEngineService(template);
172
173 if (StringUtils.isEmpty(template) || (tes == null))
174 {
175 return TurbineTemplate.getDefaultTemplate();
176 }
177
178 String defaultName = (String) tes.getTemplateEngineServiceConfiguration()
179 .get(defaultProperty);
180
181 return StringUtils.isEmpty(defaultName)
182 ? TurbineTemplate.getDefaultTemplate()
183 : defaultName;
184 }
185
186 /**
187 * Return the first match name for the given template name.
188 *
189 * @param template The template name.
190 *
191 * @return The first matching class or template name.
192 */
193 public String getMappedName(String template)
194 {
195 if (StringUtils.isEmpty(template))
196 {
197 return null;
198 }
199
200 if (useCache && templateCache.containsKey(template))
201 {
202 return templateCache.get(template);
203 }
204
205 String res = doMapping(template);
206
207 // Never cache "null" return values and empty Strings.
208 if (useCache && StringUtils.isNotEmpty(res))
209 {
210 templateCache.put(template, res);
211 }
212
213 return res;
214 }
215
216 /**
217 * The actual mapping implementation class. It
218 * is guaranteed that never an empty or null
219 * template name is passed to it. This might
220 * return null.
221 *
222 * @param template The template name.
223 * @return The mapped class or template name.
224 */
225 public abstract String doMapping(String template);
226 }