View Javadoc

    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 }