MimeTypeMapping


1   /*
2    * The contents of this file are subject to the 
3    * Mozilla Public License Version 1.1 (the "License"); 
4    * you may not use this file except in compliance with the License. 
5    * You may obtain a copy of the License at http://www.mozilla.org/MPL/
6    *
7    * Software distributed under the License is distributed on an "AS IS"
8    * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. 
9    * See the License for the specific language governing rights and 
10   * limitations under the License.
11   *
12   * The Initial Developer of the Original Code is Simulacra Media Ltd.
13   * Portions created by Simulacra Media Ltd are Copyright (C) Simulacra Media Ltd, 2004.
14   *
15   * All Rights Reserved.
16   *
17   * Contributor(s):
18   */
19  package org.openharmonise.commons.net;
20  import java.util.ArrayList  ;
21  import java.util.HashMap  ;
22  import java.util.Iterator  ;
23  import java.util.List  ;
24  
25  /**
26   * Contains mappings between mimetype and file extension. Each core type,
27   * i.e. JPEG Image which also maps to 'image/jpeg' and 'image/jpg'
28   * and extensions 'JPG' and 'JPEG', also contains a description e.g.
29   * 'Image(JPEG)'.
30   * 
31   * @author Matthew Large
32   * @version $Revision: 1.2 $
33   *
34   */
35  public class MimeTypeMapping {
36  
37      /**
38       * <code>Map</code> of extensions to <code>Mapping</code>s.
39       */
40      private static HashMap   m_aExtensionMap = new HashMap  ();
41      
42      /**
43       * <code>Map</code> of mime types to <code>Mapping</code>s.
44       */
45      private static HashMap   m_aMimeTypeMap = new HashMap  ();
46      
47      /**
48       * GIF mapping.
49       */
50      public static Mapping GIF = new Mapping("Image(GIF)");
51      
52      /**
53       * JPEG mapping.
54       */
55      public static Mapping JPEG = new Mapping("Image(JPEG)");
56      
57      /**
58       * TIFF mapping.
59       */
60      public static Mapping TIFF = new Mapping("Image(TIFF)");
61      
62      /**
63       * PNG mapping
64       */
65      public static Mapping PNG = new Mapping("Image(PNG)");
66      
67      /**
68       * SVG mapping
69       */
70      public static Mapping SVG = new Mapping("Scalable Vector Graphics (SVG)");
71      
72      /**
73       * PDF mapping
74       */
75      public static Mapping PDF = new Mapping("PDF");
76      
77      /**
78       * Plain text mapping
79       */
80      public static Mapping TEXT = new Mapping("Plain Text");
81      
82      /**
83       * XML mapping
84       */
85      public static Mapping XML = new Mapping("XML");
86      
87      /**
88       * XSLT mapping
89       */
90      public static Mapping XSLT = new Mapping("XSLT");
91      
92      /**
93       * HTML mapping
94       */
95      public static Mapping HTML = new Mapping("HTML");
96      
97      /**
98       * Flash mapping
99       */
100     public static Mapping FLASH = new Mapping("Flash Movie");
101     
102     /**
103      * WAV mapping
104      */
105     public static Mapping WAV = new Mapping("Audio(WAV)");
106     
107     /**
108      * Ogg Vorbis mapping
109      */
110     public static Mapping OGG = new Mapping("Audio(Ogg Vorbis)");
111     
112     /**
113      * MP3 mapping
114      */
115     public static Mapping MP3 = new Mapping("Audio(MP3)");
116     
117     /**
118      * AU mapping
119      */
120     public static Mapping AU = new Mapping("Audio(AU)");
121     
122     /**
123      * Real media mapping
124      */
125     public static Mapping REAL_MEDIA = new Mapping("Real Media");
126     
127     /**
128      * Active Streaming Format mapping
129      */
130     public static Mapping ASF = new Mapping("Active Streaming Format");
131     
132     /**
133      * MS Word mapping
134      */
135     public static Mapping WORD = new Mapping("Word Document");
136     
137     /**
138      * Word perfect mapping
139      */
140     public static Mapping WORD_PERFECT = new Mapping("Word Perfect Document");
141     
142     /**
143      * RTF mapping
144      */
145     public static Mapping RTF = new Mapping("RTF Document");
146     
147     /**
148      * MS Powerpoint mapping
149      */
150     public static Mapping PPT = new Mapping("PowerPoint Presentation");
151     
152     /**
153      * MS Excel mapping
154      */
155     public static Mapping XLS = new Mapping("Excel Spreadsheet");
156     
157     /**
158      * Harmonise email mapping
159      */
160     public static Mapping EMAIL = new Mapping("Email address");
161     
162     /**
163      * Harmonise URL mapping
164      */
165     public static Mapping URL = new Mapping("URL");
166     
167     /**
168      * MPEG mapping
169      */
170     public static Mapping MOVIE_MPEG = new Mapping("Movie(MPEG)");
171     
172     /**
173      * AVI mapping
174      */
175     public static Mapping MOVIE_AVI = new Mapping("Movie(AVI)");
176     
177     /**
178      * MOV mapping
179      */
180     public static Mapping MOVIE_MOV = new Mapping("Movie(MOV)");
181     
182     /**
183      * CSV mapping
184      */
185     public static Mapping CSV = new Mapping("Comma Separated Values (CSV)");
186         
187     //initialise all mappings
188     static {
189         Mapping mapping = null;
190         
191         GIF.addExtension("gif");
192         GIF.addMimeType("image/gif");
193         GIF.addMimeType("image/x-xbitmap");
194         GIF.addMimeType("image/gi_");
195         MimeTypeMapping.addMapping(GIF);
196         
197 
198         JPEG.addExtension("jpg");
199         JPEG.addExtension("jpeg");
200         JPEG.addMimeType("image/jpeg");
201         JPEG.addMimeType("image/jpg");
202         JPEG.addMimeType("image/jp_");
203         JPEG.addMimeType("application/jpg");
204         JPEG.addMimeType("application/x-jpg");
205         JPEG.addMimeType("image/pjpeg");
206         JPEG.addMimeType("image/pipeg");
207         JPEG.addMimeType("image/vnd.swiftview-jpeg");
208         JPEG.addMimeType("image/x-xbitmap");
209         MimeTypeMapping.addMapping(JPEG);
210         
211         TIFF.addExtension("tif");
212         TIFF.addExtension("tiff");
213         TIFF.addMimeType("image/tif");
214         TIFF.addMimeType("image/x-tif");
215         TIFF.addMimeType("image/tiff");
216         TIFF.addMimeType("image/x-tiff");
217         TIFF.addMimeType("application/tif");
218         TIFF.addMimeType("application/x-tif");
219         TIFF.addMimeType("application/tiff");
220         TIFF.addMimeType("application/x-tiff");
221         MimeTypeMapping.addMapping(TIFF);
222         
223         PNG.addExtension("png");
224         PNG.addMimeType("image/png");
225         PNG.addMimeType("application/png");
226         PNG.addMimeType("application/x-png");
227         MimeTypeMapping.addMapping(PNG);
228         
229         SVG.addExtension("svg");
230         SVG.addMimeType("image/svg+xml");
231         SVG.addMimeType("image/svg");
232         SVG.addMimeType("image/svg-xml");
233         SVG.addMimeType("text/xml-svg");
234         SVG.addMimeType("image/vnd.adobe.svg+xml");
235         SVG.addMimeType("image/svg-xml");
236         MimeTypeMapping.addMapping(SVG);
237         
238         PDF.addExtension("pdf");
239         PDF.addMimeType("application/pdf");
240         PDF.addMimeType("application/x-pdf");
241         PDF.addMimeType("application/acrobat");
242         PDF.addMimeType("applications/vnd.pdf");
243         PDF.addMimeType("text/pdf");
244         PDF.addMimeType("text/x-pdf");
245         MimeTypeMapping.addMapping(PDF);
246         
247         TEXT.addExtension("txt");
248         TEXT.addMimeType("text/plain");
249         MimeTypeMapping.addMapping(TEXT);
250         
251         XML.addExtension("xml");
252         XML.addMimeType("text/xml");
253         XML.addMimeType("application/xml");
254         XML.addMimeType("application/x-xml");
255         MimeTypeMapping.addMapping(XML);
256         
257         XSLT.addExtension("xsl");
258         XSLT.addExtension("xslt");
259         XSLT.addMimeType("text/xsl");
260         MimeTypeMapping.addMapping(XSLT);
261         
262         HTML.addExtension("html");
263         HTML.addExtension("htm");
264         HTML.addMimeType("text/html");
265         MimeTypeMapping.addMapping(HTML);
266         
267         FLASH.addExtension("swf");
268         FLASH.addMimeType("application/x-shockwave-flash");
269         FLASH.addMimeType("application/x-shockwave-flash2-preview");
270         FLASH.addMimeType("application/futuresplash");
271         FLASH.addMimeType("image/vnd.rn-realflash");
272         MimeTypeMapping.addMapping(FLASH);
273         
274         WAV.addExtension("wav");
275         WAV.addMimeType("audio/wav");
276         WAV.addMimeType("audio/x-wav");
277         WAV.addMimeType("audio/wave");
278         WAV.addMimeType("audio/x-pn-wav");
279         MimeTypeMapping.addMapping(WAV);
280         
281         AU.addExtension("au");
282         AU.addMimeType("audio/basic");
283         AU.addMimeType("audio/x-basic");
284         AU.addMimeType("audio/au");
285         AU.addMimeType("audio/x-au");
286         AU.addMimeType("audio/x-pn-au");
287         AU.addMimeType("audio/rmf");
288         AU.addMimeType("audio/x-rmf");
289         AU.addMimeType("audio/x-ulaw");
290         AU.addMimeType("audio/vnd.qcelp");
291         AU.addMimeType("audio/x-gsm");
292         AU.addMimeType("audio/snd");
293         MimeTypeMapping.addMapping(AU);
294         
295         REAL_MEDIA.addExtension("rm");
296         REAL_MEDIA.addMimeType("application/vnd.rn-realmedia");
297         REAL_MEDIA.addMimeType("audio/vnd.rn-realaudio");
298         REAL_MEDIA.addMimeType("audio/x-pn-realaudio");
299         REAL_MEDIA.addMimeType("audio/x-realaudio");
300         REAL_MEDIA.addMimeType("audio/x-pm-realaudio-plugin");
301         MimeTypeMapping.addMapping(REAL_MEDIA);
302         
303         ASF.addExtension("asf");
304         ASF.addMimeType("audio/asf");
305         ASF.addMimeType("application/asx");
306         ASF.addMimeType("video/x-ms-asf-plugin");
307         ASF.addMimeType("application/x-mplayer2");
308         ASF.addMimeType("video/x-ms-asf");
309         ASF.addMimeType("application/vnd.ms-asf");
310         ASF.addMimeType("video/x-ms-asf-plugin");
311         ASF.addMimeType("video/x-ms-wm");
312         ASF.addMimeType("video/x-ms-wmx");
313         MimeTypeMapping.addMapping(ASF);
314         
315         OGG.addExtension("ogg");
316         OGG.addMimeType("audio/x-ogg");
317         OGG.addMimeType("application/x-ogg");
318         MimeTypeMapping.addMapping(OGG);
319         
320         MP3.addExtension("mp3");
321         MP3.addMimeType("audio/mpeg");
322         MP3.addMimeType("audio/x-mpeg");
323         MP3.addMimeType("audio/mp3");
324         MP3.addMimeType("audio/x-mp3");
325         MP3.addMimeType("audio/mpeg3");
326         MP3.addMimeType("audio/x-mpeg3");
327         MP3.addMimeType("audio/mpg");
328         MP3.addMimeType("audio/x-mpg");
329         MP3.addMimeType("audio/x-mpegaudio");
330         MimeTypeMapping.addMapping(MP3);
331         
332         WORD.addExtension("doc");
333         WORD.addMimeType("application/msword");
334         WORD.addMimeType("application/doc");
335         WORD.addMimeType("appl/text");
336         WORD.addMimeType("application/vnd.msword");
337         WORD.addMimeType("application/vnd.ms-word");
338         WORD.addMimeType("application/winword");
339         WORD.addMimeType("application/word");
340         WORD.addMimeType("application/x-msw6");
341         WORD.addMimeType("application/x-msword");
342         WORD.addMimeType("zz-application/zz-winassoc-doc");
343         MimeTypeMapping.addMapping(WORD);
344         
345         WORD_PERFECT.addExtension("wp");
346         WORD_PERFECT.addMimeType("application/wordperfect5.1");
347         MimeTypeMapping.addMapping(WORD_PERFECT);
348         
349         RTF.addExtension("rtf");
350         RTF.addMimeType("application/rtf");
351         RTF.addMimeType("application/x-rtf");
352         RTF.addMimeType("text/rtf");
353         RTF.addMimeType("text/richtext");
354         RTF.addMimeType("application/x-soffice");
355         MimeTypeMapping.addMapping(RTF);
356         
357         PPT.addExtension("ppt");
358         PPT.addMimeType("application/mspowerpoint");
359         PPT.addMimeType("application/ms-powerpoint");
360         PPT.addMimeType("application/mspowerpnt");
361         PPT.addMimeType("application/vnd-mspowerpoint");
362         PPT.addMimeType("application/vnd.ms-powerpoint");
363         PPT.addMimeType("application/powerpoint");
364         PPT.addMimeType("application/x-powerpoint");
365         PPT.addMimeType("application/x-mspowerpoint");
366         MimeTypeMapping.addMapping(PPT);
367         
368         XLS.addExtension("xls");
369         XLS.addMimeType("application/msexcel");
370         XLS.addMimeType("application/x-msexcel");
371         XLS.addMimeType("application/x-ms-excel");
372         XLS.addMimeType("application/vnd.ms-excel");
373         XLS.addMimeType("application/x-excel");
374         XLS.addMimeType("application/x-dos_ms_excel");
375         XLS.addMimeType("application/xls");
376         XLS.addMimeType("application/x-xls");
377         XLS.addMimeType("zz-application/zz-winassoc-xls");
378         MimeTypeMapping.addMapping(XLS);
379         
380         MOVIE_MPEG.addExtension("mpg");
381         MOVIE_MPEG.addExtension("mpeg");
382         MOVIE_MPEG.addMimeType("video/mpeg");
383         MOVIE_MPEG.addMimeType("video/mpg");
384         MOVIE_MPEG.addMimeType("video/x-mpg");
385         MOVIE_MPEG.addMimeType("video/mpeg2");
386         MOVIE_MPEG.addMimeType("video/x-mpeg");
387         MOVIE_MPEG.addMimeType("video/x-mpeg2a");
388         MimeTypeMapping.addMapping(MOVIE_MPEG);
389         
390         MOVIE_AVI.addExtension("avi");
391         MOVIE_AVI.addMimeType("video/avi"); 
392         MOVIE_AVI.addMimeType("video/msvideo");
393         MOVIE_AVI.addMimeType("video/x-msvideo");
394         MOVIE_AVI.addMimeType("video/xmpg2");
395         MimeTypeMapping.addMapping(MOVIE_AVI);
396         
397         MOVIE_MOV.addExtension("mov");
398         MOVIE_MOV.addMimeType("video/quicktime");
399         MOVIE_MOV.addMimeType("video/x-quicktime");
400         MimeTypeMapping.addMapping(MOVIE_MOV);
401         
402         EMAIL.addExtension("adr");
403         EMAIL.addMimeType("link/mailto");
404         
405         MimeTypeMapping.addMapping(EMAIL);
406         
407         URL.addExtension("url");
408         URL.addMimeType("link/http");
409 
410         MimeTypeMapping.addMapping(URL);
411         
412         CSV.addExtension("csv");
413         CSV.addMimeType("text/csv");
414         MimeTypeMapping.addMapping(CSV);
415     }
416 
417     /**
418      * Inaccessible constructor.
419      */
420     private MimeTypeMapping() {
421         super();
422     }
423     
424     /**
425      * Adds a Mapping object to the relevant <code>HashMap<code>s.
426      * 
427      * @param mapping Mapping object to be added to all the relevant HashMaps.
428      */
429     private static void addMapping(Mapping mapping) {
430         List   aExtensions = mapping.getExtensions();
431         Iterator   itor = aExtensions.iterator();
432         while(itor.hasNext()) {
433             m_aExtensionMap.put((String  )itor.next(), mapping);
434         }
435         List   aMimeTypes = mapping.getMimeTypes();
436         itor = aMimeTypes.iterator();
437         while(itor.hasNext()) {
438             m_aMimeTypeMap.put((String  )itor.next(), mapping);
439         }
440     }
441     
442     /**
443      * Gets a list of Mime-Types that match the given file extension.
444      * 
445      * @param sExtension File extension to be matched.
446      * @return a list of <code>String</code>s 
447      */
448     public static List   getMimeTypes(String   sExtension) {
449         List   result = null;
450         
451         Mapping mapping = (Mapping)MimeTypeMapping.m_aExtensionMap.get(sExtension.toLowerCase());
452         
453         if(mapping != null) {
454             result = mapping.getMimeTypes();
455         }
456         
457         return result;
458     }
459     
460     /**
461      * Gets a list of file extensions that match the given Mime-Type.
462      * 
463      * @param sMimeType Mime-Type to be matched.
464      * @return a list of <code>String</code>s 
465      */
466     public static List   getExtensions(String   sMimeType) {
467         if(sMimeType!=null && m_aMimeTypeMap!=null && MimeTypeMapping.m_aMimeTypeMap.get(sMimeType)!=null) {
468             return ((Mapping)MimeTypeMapping.m_aMimeTypeMap.get(sMimeType)).getExtensions();    
469         } else {
470             return null;
471         }
472     }
473     
474     /**
475      * Returns an extension which is appropriate for the specified mime-type.
476      * 
477      * @param mime the mime-type
478      * @return the extension which is appropriate for the mime type given
479      */
480     public static String   getExtensionFromMimeType(String   mime) {
481         String   ext = null;
482 
483         List   extList = MimeTypeMapping.getExtensions(mime);
484     
485 
486         if (extList != null && extList.size() > 0) {
487             ext = (String  ) extList.get(0);
488         }
489 
490         return ext;
491     }
492     
493     /**
494      * Returns a mime type which matches the specified extension.
495      * 
496      * @param ext the extension
497      * @return a mime type which matches the specified extension
498      */
499     public static String   getMimeTypeFromExtension(String   ext) {
500         String   type = ext;
501 
502         List   mimeList = MimeTypeMapping.getMimeTypes(ext);
503 
504         if (mimeList != null && mimeList.size() > 0) {
505             type = (String  ) mimeList.get(0);
506         }
507 
508         return type;
509     }
510     
511     /**
512      * Gets a description that matches the given file extension.
513      * 
514      * @param sExtension File extension to be matched.
515      * @return a description of the mapping
516      */
517     public static String   getDescriptionForExtension(String   sExtension) {
518         return ((Mapping)MimeTypeMapping.m_aExtensionMap.get(sExtension)).getDescription();
519     }
520     
521     /**
522      * Gets a description that matches the given Mime-Type.
523      * 
524      * @param sMimeType Mime-Type to be matched.
525      * @return a description of the mapping
526      */
527     public static String   getDescriptionForMimeType(String   sMimeType) {
528         return ((Mapping)MimeTypeMapping.m_aMimeTypeMap.get(sMimeType)).getDescription();
529     }
530     
531     /**
532      * Class to contain all the information about a single mapping. Each instance
533      * holds a description of the mapping, to be used as the human readable version
534      * of the mapping e.g. 'Image(JPEG)'. Each instance also holds lists of the
535      * Mime-Types and file extensions which are relevant to this mapping.
536      * 
537      * @author Matthew Large
538      * @version $Revision: 1.2 $
539      *
540      */
541     public static class Mapping {
542         /**
543          * Description of mapping
544          */
545         private String   m_sDescription = "";
546         /**
547          * List of <code>String</code> mime types for mapping
548          */
549         private ArrayList   m_aMimeTypes = new ArrayList  ();
550         /**
551          * List of <code>String</code> extensions for mapping
552          */
553         private ArrayList   m_aFileExtensions = new ArrayList  ();
554         
555         /**
556          * Constructs mapping with the given description
557          * 
558          * @param sDescription the description for this mapping
559          */
560         private Mapping(String   sDescription) {
561             this.m_sDescription = sDescription;
562         }
563         
564         /**
565          * Returns the descirption for this mapping
566          * 
567          * @return the description for this mapping
568          */
569         public String   getDescription() {
570             return this.m_sDescription;
571         }
572         
573         /**
574          * Adds the given mime type to the the list of mime types
575          * applicable for this mapping
576          * 
577          * @param sMimeType the mime type to add to this mapping
578          */
579         public void addMimeType(String   sMimeType) {
580             this.m_aMimeTypes.add(sMimeType);
581         }
582         
583         /**
584          * Returns the list of mime types for this mapping
585          * 
586          * @return the list of mime types for this mapping
587          */
588         public List   getMimeTypes() {
589             return this.m_aMimeTypes;
590         }
591         
592         /**
593          * Returns the default mime type for this mapping
594          * 
595          * @return the default mime type for this mapping
596          */
597         public String   getMimeType() {
598             return (String  ) m_aMimeTypes.get(0);
599         }
600         
601         /**
602          * Adds the given extension to the the list of extensions
603          * applicable for this mapping
604          * 
605          * @param sExtension
606          */
607         public void addExtension(String   sExtension) {
608             this.m_aFileExtensions.add(sExtension);
609         }
610         
611         /**
612          * Returns the list of extensions applicable for this mapping
613          * 
614          * @return a list of extensions
615          */
616         public List   getExtensions() {
617             return this.m_aFileExtensions;
618         }
619         
620         /**
621          * Returns the default extension for this mapping
622          * 
623          * @return the default extension for this mapping
624          */
625         public String   getExtension() {
626             return (String  ) m_aFileExtensions.get(0);
627         }
628     }
629     
630     /**
631      * Runs a test of this class printing contents to the standard output
632      * 
633      * @param args
634      */
635     public static void main(String  [] args) {
636         System.out.println(MimeTypeMapping.getMimeTypes("GIF"));
637         System.out.println(MimeTypeMapping.getExtensions("image/gif"));
638         System.out.println(MimeTypeMapping.getDescriptionForExtension("gif"));
639         System.out.println(MimeTypeMapping.getDescriptionForMimeType("image/gif"));
640         System.out.println("----------------------------------------------------");
641         Iterator   itor = MimeTypeMapping.m_aExtensionMap.values().iterator();
642         while(itor.hasNext()) {
643             Mapping map = (Mapping)itor.next();
644             System.out.println(map.getDescription() + " exts=" + map.getExtensions() + " mimetypes=" + map.getMimeTypes());
645             System.out.println("----------------------------------------------------");
646         }
647         System.exit(0);
648     }
649 
650 }
651
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags