View Javadoc

1   package org.apache.turbine.services.mimetype;
2   
3   /*
4    * Copyright 2001-2005 The Apache Software Foundation.
5    *
6    * Licensed under the Apache License, Version 2.0 (the "License")
7    * you may not use this file except in compliance with the License.
8    * You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
17   */
18  
19  import java.io.File;
20  import java.io.IOException;
21  
22  import java.util.Locale;
23  
24  import org.apache.commons.configuration.Configuration;
25  
26  import org.apache.turbine.services.InitializationException;
27  import org.apache.turbine.services.TurbineBaseService;
28  import org.apache.turbine.services.mimetype.util.CharSetMap;
29  import org.apache.turbine.services.mimetype.util.MimeType;
30  import org.apache.turbine.services.mimetype.util.MimeTypeMap;
31  import org.apache.turbine.services.servlet.TurbineServlet;
32  
33  /***
34   * The MimeType Service maintains mappings between MIME types and
35   * the corresponding file name extensions, and between locales and
36   * character encodings.
37   *
38   * <p>The MIME type mappings can be defined in MIME type files
39   * located in user's home directory, Java home directory or
40   * the current class jar. The default mapping file is defined
41   * with the mime.type.file property. In addition, the service maintains
42   * a set of most common mappings.
43   *
44   * <p>The charset mappings can be defined in property files
45   * located in user's home directory, Java home directory or
46   * the current class jar. The default mapping file is defined
47   * with the charset.file property. In addition, the service maintains
48   * a set of most common mappings.
49   *
50   * @author <a href="mailto:ilkka.priha@simsoft.fi">Ilkka Priha</a>
51   * @version $Id: TurbineMimeTypeService.java 264148 2005-08-29 14:21:04Z henning $
52   */
53  public class TurbineMimeTypeService
54          extends TurbineBaseService
55          implements MimeTypeService
56  {
57      /***
58       * The MIME type file property.
59       */
60      public static final String MIME_TYPES = "mime.types";
61  
62      /***
63       * The charset file property.
64       */
65      public static final String CHARSETS = "charsets";
66  
67      /***
68       * The MIME type map used by the service.
69       */
70      private MimeTypeMap mimeTypeMap;
71  
72      /***
73       * The charset map used by the service.
74       */
75      private CharSetMap charSetMap;
76  
77      /***
78       * Constructs a new service.
79       */
80      public TurbineMimeTypeService()
81      {
82      }
83  
84      /***
85       * Initializes the service.
86       *
87       * @throws InitializationException if initialization fails.
88       */
89      public void init()
90              throws InitializationException
91      {
92          String path = null;
93          Configuration conf = getConfiguration();
94          if (conf != null)
95          {
96              path = conf.getString(MIME_TYPES);
97              if (path != null)
98              {
99                  path = TurbineServlet.getRealPath(path);
100             }
101         }
102         if (path != null)
103         {
104             try
105             {
106                 mimeTypeMap = new MimeTypeMap(path);
107             }
108             catch (IOException x)
109             {
110                 throw new InitializationException(path, x);
111             }
112         }
113         else
114         {
115             mimeTypeMap = new MimeTypeMap();
116         }
117 
118         if (conf != null)
119         {
120             path = conf.getString(CHARSETS);
121             if (path != null)
122             {
123                 path = TurbineServlet.getRealPath(path);
124             }
125         }
126         if (path != null)
127         {
128             try
129             {
130                 charSetMap = new CharSetMap(path);
131             }
132             catch (IOException x)
133             {
134                 throw new InitializationException(path, x);
135             }
136         }
137         else
138         {
139             charSetMap = new CharSetMap();
140         }
141         setInit(true);
142     }
143 
144     /***
145      * Sets a MIME content type mapping to extensions to the map.
146      * The extension is specified by a MIME type name followed
147      * by a list of file name extensions separated by a whitespace.
148      *
149      * @param spec a MIME type extension specification to add.
150      */
151     public void setContentType(String spec)
152     {
153         mimeTypeMap.setContentType(spec);
154     }
155 
156     /***
157      * Gets the MIME content type for a file as a string.
158      *
159      * @param file the file.
160      * @return the MIME type string.
161      */
162     public String getContentType(File file)
163     {
164         return mimeTypeMap.getContentType(file);
165     }
166 
167     /***
168      * Gets the MIME content type for a named file as a string.
169      *
170      * @param name the name of the file.
171      * @return the MIME type string.
172      */
173     public String getContentType(String name)
174     {
175         return mimeTypeMap.getContentType(name);
176     }
177 
178     /***
179      * Gets the MIME content type for a file name extension as a string.
180      *
181      * @param ext the file name extension.
182      * @param def the default type if none is found.
183      * @return the MIME type string.
184      */
185     public String getContentType(String ext,
186                                  String def)
187     {
188         return mimeTypeMap.getContentType(ext, def);
189     }
190 
191     /***
192      * Gets the MIME content type for a file.
193      *
194      * @param file the file.
195      * @return the MIME type.
196      */
197     public MimeType getMimeContentType(File file)
198     {
199         return mimeTypeMap.getMimeContentType(file);
200     }
201 
202     /***
203      * Gets the MIME content type for a named file.
204      *
205      * @param name the name of the file.
206      * @return the MIME type.
207      */
208     public MimeType getMimeContentType(String name)
209     {
210         return mimeTypeMap.getMimeContentType(name);
211     }
212 
213     /***
214      * Gets the MIME content type for a file name extension.
215      *
216      * @param ext the file name extension.
217      * @param def the default type if none is found.
218      * @return the MIME type.
219      */
220     public MimeType getMimeContentType(String ext,
221                                        String def)
222     {
223         return mimeTypeMap.getMimeContentType(ext, def);
224     }
225 
226     /***
227      * Gets the default file name extension for a MIME type.
228      * Note that the mappers are called in the reverse order.
229      *
230      * @param type the MIME type as a string.
231      * @return the file name extension or null.
232      */
233     public String getDefaultExtension(String type)
234     {
235         return mimeTypeMap.getDefaultExtension(type);
236     }
237 
238     /***
239      * Gets the default file name extension for a MIME type.
240      * Note that the mappers are called in the reverse order.
241      *
242      * @param mime the MIME type.
243      * @return the file name extension or null.
244      */
245     public String getDefaultExtension(MimeType mime)
246     {
247         return mimeTypeMap.getDefaultExtension(mime);
248     }
249 
250     /***
251      * Sets a locale-charset mapping.
252      *
253      * @param key the key for the charset.
254      * @param charset the corresponding charset.
255      */
256     public void setCharSet(String key,
257                            String charset)
258     {
259         charSetMap.setCharSet(key, charset);
260     }
261 
262     /***
263      * Gets the charset for a locale. First a locale specific charset
264      * is searched for, then a country specific one and lastly a language
265      * specific one. If none is found, the default charset is returned.
266      *
267      * @param locale the locale.
268      * @return the charset.
269      */
270     public String getCharSet(Locale locale)
271     {
272         return charSetMap.getCharSet(locale);
273     }
274 
275     /***
276      * Gets the charset for a locale with a variant. The search
277      * is performed in the following order:
278      * "lang"_"country"_"variant"="charset",
279      * _"counry"_"variant"="charset",
280      * "lang"__"variant"="charset",
281      * __"variant"="charset",
282      * "lang"_"country"="charset",
283      * _"country"="charset",
284      * "lang"="charset".
285      * If nothing of the above is found, the default charset is returned.
286      *
287      * @param locale the locale.
288      * @param variant a variant field.
289      * @return the charset.
290      */
291     public String getCharSet(Locale locale,
292                              String variant)
293     {
294         return charSetMap.getCharSet(locale, variant);
295     }
296 
297     /***
298      * Gets the charset for a specified key.
299      *
300      * @param key the key for the charset.
301      * @return the found charset or the default one.
302      */
303     public String getCharSet(String key)
304     {
305         return charSetMap.getCharSet(key);
306     }
307 
308     /***
309      * Gets the charset for a specified key.
310      *
311      * @param key the key for the charset.
312      * @param def the default charset if none is found.
313      * @return the found charset or the given default.
314      */
315     public String getCharSet(String key,
316                              String def)
317     {
318         return charSetMap.getCharSet(key, def);
319     }
320 }