    001    package 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
    024    import java.util.HashMap;
    025    import java.util.Map;
    026
    027    import org.apache.commons.lang.StringUtils;
    028    import org.apache.turbine.services.template.TemplateEngineService;
    029    import 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 1073174 2011-02-21 22:18:45Z tv $
    037     */
    038
    039    public 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 newUseCache 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    }