    001// Licensed under the Apache License, Version 2.0 (the "License");
    002// you may not use this file except in compliance with the License.
    003// You may obtain a copy of the License at
    004//
    005//     http://www.apache.org/licenses/LICENSE-2.0
    006//
    007// Unless required by applicable law or agreed to in writing, software
    008// distributed under the License is distributed on an "AS IS" BASIS,
    009// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    010// See the License for the specific language governing permissions and
    011// limitations under the License.
    012
    013package org.apache.tapestry5;
    014
    015import org.apache.tapestry5.internal.InternalConstants;
    016import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
    017import org.apache.tapestry5.ioc.internal.util.InternalUtils;
    018
    019import java.util.Collections;
    020import java.util.List;
    021import java.util.Map;
    022import java.util.StringTokenizer;
    023import java.util.regex.Matcher;
    024import java.util.regex.Pattern;
    025
    026/**
    027 * Represents an HTTP content type. Allows to set various elements like the MIME type, the character set, and other
    028 * parameters. This is similar to a number of other implementations of the same concept in JAF, etc. We have created
    029 * this simple implementation to avoid including the whole libraries.
    030 *
    031 * As of Tapestry 5.4, this is now an immutable data type.
    032 */
    033public final class ContentType
    034{
    035    private final String baseType;
    036
    037    private final String subType;
    038
    039    private final Map<String, String> parameters;
    040
    041    private static final Pattern PATTERN = Pattern.compile("^(.+)/([^;]+)(;(.+=[^;]+))*$");
    042
    043    /**
    044     * Creates a new content type from the argument. The format of the argument has to be basetype/subtype(;key=value)*
    045     *
    046     * @param contentType
    047     *         the content type that needs to be represented
    048     */
    049    public ContentType(String contentType)
    050    {
    051        Matcher matcher = PATTERN.matcher(contentType);
    052
    053        if (!matcher.matches())
    054        {
    055            throw new IllegalArgumentException(String.format("Not a parseable content type '%s'.", contentType));
    056        }
    057
    058        this.baseType = matcher.group(1);
    059        this.subType = matcher.group(2);
    060        this.parameters = parseKeyValues(matcher.group(4));
    061    }
    062
    063    private ContentType(String baseType, String subType, Map<String, String> parameters)
    064    {
    065        this.baseType = baseType;
    066        this.subType = subType;
    067        this.parameters = parameters;
    068    }
    069
    070
    071    private static Map<String, String> parseKeyValues(String keyValues)
    072    {
    073        if (keyValues == null)
    074        {
    075            return Collections.emptyMap();
    076        }
    077
    078        Map<String, String> parameters = CollectionFactory.newCaseInsensitiveMap();
    079
    080        StringTokenizer tk = new StringTokenizer(keyValues, ";");
    081
    082        while (tk.hasMoreTokens())
    083        {
    084            String token = tk.nextToken();
    085            int sep = token.indexOf('=');
    086
    087            parameters.put(token.substring(0, sep), token.substring(sep + 1));
    088        }
    089
    090        return parameters;
    091    }
    092
    093    /**
    094     * Returns true only if the other object is another instance of ContentType, and has the same baseType, subType and
    095     * set of parameters.
    096     */
    097    @Override
    098    public boolean equals(Object o)
    099    {
    100        if (o == null) return false;
    101
    102        if (o.getClass() != this.getClass()) return false;
    103
    104        ContentType ct = (ContentType) o;
    105
    106        return baseType.equals(ct.baseType) && subType.equals(ct.subType) && parameters.equals(ct.parameters);
    107    }
    108
    109    /**
    110     * @return the base type of the content type
    111     */
    112    public String getBaseType()
    113    {
    114        return baseType;
    115    }
    116
    117    /**
    118     * @return the sub-type of the content type
    119     */
    120    public String getSubType()
    121    {
    122        return subType;
    123    }
    124
    125    /**
    126     * @return the MIME type of the content type (the base type and the subtype, seperated with a '/').
    127     */
    128    public String getMimeType()
    129    {
    130        return baseType + "/" + subType;
    131    }
    132
    133    /**
    134     * @return the list of names of parameters in this content type, in alphabetical order.
    135     */
    136    public List<String> getParameterNames()
    137    {
    138        return InternalUtils.sortedKeys(parameters);
    139    }
    140
    141    /**
    142     * @return the character set (the "charset" parameter) or null.
    143     */
    144    public String getCharset()
    145    {
    146        return getParameter(InternalConstants.CHARSET_CONTENT_TYPE_PARAMETER);
    147    }
    148
    149    /**
    150     * @param key
    151     *         the name of the content type parameter
    152     * @return the value of the content type parameter
    153     */
    154    public String getParameter(String key)
    155    {
    156        assert key != null;
    157        return parameters.get(key);
    158    }
    159
    160    private String unparse()
    161    {
    162        StringBuilder buffer = new StringBuilder(getMimeType());
    163
    164        for (String parameterName : getParameterNames())
    165        {
    166            buffer.append(';');
    167            buffer.append(parameterName);
    168            buffer.append('=');
    169            buffer.append(parameters.get(parameterName));
    170        }
    171
    172        return buffer.toString();
    173    }
    174
    175    /**
    176     * Returns a new content type with the indicated parameter.
    177     *
    178     * @since 5.4
    179     */
    180    public ContentType withParameter(String key, String value)
    181    {
    182        assert InternalUtils.isNonBlank(key);
    183        assert InternalUtils.isNonBlank(value);
    184
    185        Map<String, String> newParameters = CollectionFactory.newCaseInsensitiveMap();
    186
    187        newParameters.putAll(parameters);
    188        newParameters.put(key, value);
    189
    190        return new ContentType(baseType, subType, newParameters);
    191    }
    192
    193    public ContentType withCharset(String charset)
    194    {
    195        return withParameter(InternalConstants.CHARSET_CONTENT_TYPE_PARAMETER, charset);
    196    }
    197
    198    /**
    199     * @return the string representation of this content type.
    200     */
    201    @Override
    202    public String toString()
    203    {
    204        return unparse();
    205    }
    206
    207    /**
    208     * @return true if the content type includes parameters (such as 'charset').
    209     * @since 5.4
    210     */
    211    public boolean hasParameters()
    212    {
    213        return !parameters.isEmpty();
    214    }
    215}