    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}