Clover coverage report - Code Coverage for tapestry release 4.0-beta-10
Coverage timestamp: Sat Oct 8 2005 19:08:05 EDT
file stats: LOC: 188   Methods: 14
NCLOC: 93   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
ContentType.java 64.3% 97.3% 100% 90.8%
coverage coverage
 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;
 18    import java.util.Map;
 19    import java.util.Set;
 20    import java.util.StringTokenizer;
 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 _baseType;
 34    private String _subType;
 35    private Map _parameters;
 36   
 37    /**
 38    * Creates a new empty content type
 39    */
 40  283 public ContentType()
 41    {
 42  283 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  281 public ContentType(String contentType)
 52    {
 53  281 this();
 54  281 parse(contentType);
 55    }
 56   
 57  564 private void initialize()
 58    {
 59  564 _baseType = "";
 60  564 _subType = "";
 61  564 _parameters = new HashMap();
 62    }
 63   
 64    /**
 65    * @return the base type of the content type
 66    */
 67  2 public String getBaseType()
 68    {
 69  2 return _baseType;
 70    }
 71   
 72    /**
 73    * @param baseType
 74    */
 75  283 public void setBaseType(String baseType)
 76    {
 77  283 _baseType = baseType;
 78    }
 79   
 80    /**
 81    * @return the sub-type of the content type
 82    */
 83  2 public String getSubType()
 84    {
 85  2 return _subType;
 86    }
 87   
 88    /**
 89    * @param subType
 90    */
 91  283 public void setSubType(String subType)
 92    {
 93  283 _subType = subType;
 94    }
 95   
 96    /**
 97    * @return the MIME type of the content type
 98    */
 99  444 public String getMimeType()
 100    {
 101  444 return _baseType + "/" + _subType;
 102    }
 103   
 104    /**
 105    * @return the list of names of parameters in this content type
 106    */
 107  418 public String[] getParameterNames()
 108    {
 109  418 Set parameterNames = _parameters.keySet();
 110  418 return (String[]) parameterNames.toArray(new String[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  684 public String getParameter(String key)
 118    {
 119  684 return (String) _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  274 public void setParameter(String key, String value)
 127    {
 128  274 _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  281 public void parse(String contentType)
 138    {
 139  281 initialize();
 140   
 141  281 StringTokenizer tokens = new StringTokenizer(contentType, ";");
 142  281 if (!tokens.hasMoreTokens())
 143  0 return;
 144   
 145  281 String mimeType = tokens.nextToken();
 146  281 StringTokenizer mimeTokens = new StringTokenizer(mimeType, "/");
 147  281 setBaseType(mimeTokens.hasMoreTokens() ? mimeTokens.nextToken() : "");
 148  281 setSubType(mimeTokens.hasMoreTokens() ? mimeTokens.nextToken() : "");
 149   
 150  281 while (tokens.hasMoreTokens()) {
 151  137 String parameter = tokens.nextToken();
 152   
 153  137 StringTokenizer parameterTokens = new StringTokenizer(parameter, "=");
 154  137 String key = parameterTokens.hasMoreTokens() ? parameterTokens.nextToken() : "";
 155  137 String value = parameterTokens.hasMoreTokens() ? parameterTokens.nextToken() : "";
 156  137 setParameter(key, value);
 157    }
 158    }
 159   
 160   
 161   
 162    /**
 163    * @return the string representation of this content type
 164    */
 165  416 public String unparse()
 166    {
 167  416 StringBuffer buf = new StringBuffer(getMimeType());
 168   
 169  416 String[] parameterNames = getParameterNames();
 170  416 for (int i = 0; i < parameterNames.length; i++)
 171    {
 172  409 String key = parameterNames[i];
 173  409 String value = getParameter(key);
 174  409 buf.append(";" + key + "=" + value);
 175    }
 176   
 177  416 return buf.toString();
 178    }
 179   
 180    /**
 181    * @return the string representation of this content type. Same as unparse().
 182    */
 183  414 public String toString()
 184    {
 185  414 return unparse();
 186    }
 187   
 188    }