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 }