001package org.apache.turbine.services.template.mapper;
002
003
004/*
005 * Licensed to the Apache Software Foundation (ASF) under one
006 * or more contributor license agreements.  See the NOTICE file
007 * distributed with this work for additional information
008 * regarding copyright ownership.  The ASF licenses this file
009 * to you under the Apache License, Version 2.0 (the
010 * "License"); you may not use this file except in compliance
011 * with the License.  You may obtain a copy of the License at
012 *
013 *   http://www.apache.org/licenses/LICENSE-2.0
014 *
015 * Unless required by applicable law or agreed to in writing,
016 * software distributed under the License is distributed on an
017 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
018 * KIND, either express or implied.  See the License for the
019 * specific language governing permissions and limitations
020 * under the License.
021 */
022
023
024import java.util.HashMap;
025import java.util.Map;
026
027import org.apache.commons.lang.StringUtils;
028import org.apache.turbine.services.template.TemplateEngineService;
029import org.apache.turbine.services.template.TurbineTemplate;
030
031/**
032 * A base class for the various mappers which contains common
033 * code.
034 *
035 * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
036 * @version $Id: BaseMapper.java 1706239 2015-10-01 13:18:35Z tv $
037 */
038
039public abstract class BaseMapper
040{
041    /** True if this mapper should cache template -> name mappings */
042    private boolean useCache = false;
043
044    /** Default cache size. Just a number out of thin air. Will be set at init time */
045    private int cacheSize = 5;
046
047    /** The internal template -> name mapping cache */
048    private Map<String, String> templateCache = null;
049
050    /** The name of the default property to pull from the Template Engine Service if the default is requested */
051    protected String defaultProperty;
052
053    /** The separator used to concatenate the result parts for this mapper. */
054    protected char separator;
055
056    // Note: You might _not_ use TurbineTemplate.<xxx> in the C'tor and the init method.
057    // The service isn't configured yet and if you do, the Broker will try to reinit the
058    // Service which leads to an endless loop and a deadlock.
059
060    /**
061     * Default C'tor. If you use this C'tor, you must use
062     * the bean setter to set the various properties needed for
063     * this mapper before first usage.
064     */
065    public BaseMapper()
066    {
067        // empty
068    }
069
070    /**
071     * Get the CacheSize value.
072     * @return the CacheSize value.
073     */
074    public int getCacheSize()
075    {
076        return cacheSize;
077    }
078
079    /**
080     * Set the CacheSize value.
081     * @param cacheSize The new CacheSize value.
082     */
083    public void setCacheSize(int cacheSize)
084    {
085        this.cacheSize = cacheSize;
086    }
087
088    /**
089     * Get the UseCache value.
090     * @return the UseCache value.
091     */
092    public boolean isUseCache()
093    {
094        return useCache;
095    }
096
097    /**
098     * Set the UseCache value.
099     * @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}