KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > tapestry > util > ContentType


1 // Copyright 2004, 2005 The Apache Software Foundation
2 //
3 // Licensed under the Apache License, Version 2.0 (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
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 package org.apache.tapestry.util;
16
17 import java.util.HashMap JavaDoc;
18 import java.util.Map JavaDoc;
19 import java.util.Set JavaDoc;
20 import java.util.StringTokenizer JavaDoc;
21
22 /**
23  * Represents an HTTP content type. Allows to set various elements like
24  * the mime type, the character set, and other parameters.
25  * This is similar to a number of other implementations of the same concept in JAF, etc.
26  * We have created this simple implementation to avoid including the whole libraries.
27  *
28  * @author mindbridge
29  * @since 3.0
30  **/
31 public class ContentType
32 {
33     private String JavaDoc _baseType;
34     private String JavaDoc _subType;
35     private Map JavaDoc _parameters;
36
37     /**
38      * Creates a new empty content type
39      */
40     public ContentType()
41     {
42         initialize();
43     }
44     
45     /**
46      * Creates a new content type from the argument.
47      * The format of the argument has to be basetype/subtype(;key=value)*
48      *
49      * @param contentType the content type that needs to be represented
50      */
51     public ContentType(String JavaDoc contentType)
52     {
53         this();
54         parse(contentType);
55     }
56     
57     private void initialize()
58     {
59         _baseType = "";
60         _subType = "";
61         _parameters = new HashMap JavaDoc();
62     }
63     
64     /**
65      * @return the base type of the content type
66      */
67     public String JavaDoc getBaseType()
68     {
69         return _baseType;
70     }
71
72     /**
73      * @param baseType
74      */
75     public void setBaseType(String JavaDoc baseType)
76     {
77         _baseType = baseType;
78     }
79
80     /**
81      * @return the sub-type of the content type
82      */
83     public String JavaDoc getSubType()
84     {
85         return _subType;
86     }
87
88     /**
89      * @param subType
90      */
91     public void setSubType(String JavaDoc subType)
92     {
93         _subType = subType;
94     }
95
96     /**
97      * @return the MIME type of the content type
98      */
99     public String JavaDoc getMimeType()
100     {
101         return _baseType + "/" + _subType;
102     }
103
104     /**
105      * @return the list of names of parameters in this content type
106      */
107     public String JavaDoc[] getParameterNames()
108     {
109         Set JavaDoc parameterNames = _parameters.keySet();
110         return (String JavaDoc[]) parameterNames.toArray(new String JavaDoc[parameterNames.size()]);
111     }
112
113     /**
114      * @param key the name of the content type parameter
115      * @return the value of the content type parameter
116      */
117     public String JavaDoc getParameter(String JavaDoc key)
118     {
119         return (String JavaDoc) _parameters.get(key);
120     }
121
122     /**
123      * @param key the name of the content type parameter
124      * @param value the value of the content type parameter
125      */
126     public void setParameter(String JavaDoc key, String JavaDoc value)
127     {
128         _parameters.put(key.toLowerCase(), value);
129     }
130
131     /**
132      * Parses the argument and configures the content type accordingly.
133      * The format of the argument has to be type/subtype(;key=value)*
134      *
135      * @param contentType the content type that needs to be represented
136      */
137     public void parse(String JavaDoc contentType)
138     {
139         initialize();
140
141         StringTokenizer JavaDoc tokens = new StringTokenizer JavaDoc(contentType, ";");
142         if (!tokens.hasMoreTokens())
143             return;
144         
145         String JavaDoc mimeType = tokens.nextToken();
146         StringTokenizer JavaDoc mimeTokens = new StringTokenizer JavaDoc(mimeType, "/");
147         setBaseType(mimeTokens.hasMoreTokens() ? mimeTokens.nextToken() : "");
148         setSubType(mimeTokens.hasMoreTokens() ? mimeTokens.nextToken() : "");
149         
150         while (tokens.hasMoreTokens()) {
151             String JavaDoc parameter = tokens.nextToken();
152
153             StringTokenizer JavaDoc parameterTokens = new StringTokenizer JavaDoc(parameter, "=");
154             String JavaDoc key = parameterTokens.hasMoreTokens() ? parameterTokens.nextToken() : "";
155             String JavaDoc value = parameterTokens.hasMoreTokens() ? parameterTokens.nextToken() : "";
156             setParameter(key, value);
157         }
158     }
159
160     
161
162     /**
163      * @return the string representation of this content type
164      */
165     public String JavaDoc unparse()
166     {
167         StringBuffer JavaDoc buf = new StringBuffer JavaDoc(getMimeType());
168
169         String JavaDoc[] parameterNames = getParameterNames();
170         for (int i = 0; i < parameterNames.length; i++)
171         {
172             String JavaDoc key = parameterNames[i];
173             String JavaDoc value = getParameter(key);
174             buf.append(";" + key + "=" + value);
175         }
176         
177         return buf.toString();
178     }
179     
180     /**
181      * @return the string representation of this content type. Same as unparse().
182      */
183     public String JavaDoc toString()
184     {
185         return unparse();
186     }
187
188 }
189
Popular Tags