1 /*

     2  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 /*

    27  * @(#)ContentType.java       1.7 02/03/27

    28  */

    29 

    30 

    31 

    32 package com.sun.xml.internal.messaging.saaj.packaging.mime.internet;

    33 

    34 

    35 /**

    36  * This class represents a MIME ContentType value. It provides

    37  * methods to parse a ContentType string into individual components

    38  * and to generate a MIME style ContentType string.

    39  *

    40  * @version 1.7, 02/03/27

    41  * @author  John Mani

    42  */

    43 public final class ContentType {

    44 

    45     private String primaryType; // primary type

    46     private String subType;     // subtype

    47     private ParameterList list; // parameter list

    48 

    49     /**

    50      * No-arg Constructor.

    51      */

    52     public ContentType() { }

    53 

    54     /**

    55      * Constructor.

    56      *

    57      * @param   primaryType     primary type

    58      * @param   subType subType

    59      * @param   list    ParameterList

    60      */

    61     public ContentType(String primaryType, String subType,

    62                        ParameterList list) {

    63         this.primaryType = primaryType;

    64         this.subType = subType;

    65         if (list == null)

    66             list = new ParameterList();

    67         this.list = list;

    68     }

    69 

    70     /**

    71      * Constructor that takes a Content-Type string. The String

    72      * is parsed into its constituents: primaryType, subType

    73      * and parameters. A ParseException is thrown if the parse fails.

    74      *

    75      * @param   s       the Content-Type string.

    76      * @exception       ParseException if the parse fails.

    77      */

    78     public ContentType(String s) throws ParseException {

    79         HeaderTokenizer h = new HeaderTokenizer(s, HeaderTokenizer.MIME);

    80         HeaderTokenizer.Token tk;

    81 

    82         // First "type" ..

    83         tk = h.next();

    84         if (tk.getType() != HeaderTokenizer.Token.ATOM)

    85             throw new ParseException();

    86         primaryType = tk.getValue();

    87 

    88         // The '/' separator ..

    89         tk = h.next();

    90         if ((char)tk.getType() != '/')

    91             throw new ParseException();

    92 

    93         // Then "subType" ..

    94         tk = h.next();

    95         if (tk.getType() != HeaderTokenizer.Token.ATOM)

    96             throw new ParseException();

    97         subType = tk.getValue();

    98 

    99         // Finally parameters ..

   100         String rem = h.getRemainder();

   101         if (rem != null)

   102             list = new ParameterList(rem);

   103     }

   104 

   105     public ContentType copy() {

   106         return new ContentType(primaryType,subType,list.copy());

   107     }

   108 

   109     /**

   110      * Return the primary type.

   111      * @return the primary type

   112      */

   113     public String getPrimaryType() {

   114         return primaryType;

   115     }

   116 

   117     /**

   118      * Return the subType.

   119      * @return the subType

   120      */

   121     public String getSubType() {

   122         return subType;

   123     }

   124 

   125     /**

   126      * Return the MIME type string, without the parameters.

   127      * The returned value is basically the concatenation of

   128      * the primaryType, the '/' character and the secondaryType.

   129      *

   130      * @return the type

   131      */

   132     public String getBaseType() {

   133         return primaryType + '/' + subType;

   134     }

   135 

   136     /**

   137      * Return the specified parameter value. Returns <code>null</code>

   138      * if this parameter is absent.

   139      * @return  parameter value

   140      */

   141     public String getParameter(String name) {

   142         if (list == null)

   143             return null;

   144 

   145         return list.get(name);

   146     }

   147 

   148     /**

   149      * Return a ParameterList object that holds all the available

   150      * parameters. Returns null if no parameters are available.

   151      *

   152      * @return  ParameterList

   153      */

   154     public ParameterList getParameterList() {

   155         return list;

   156     }

   157 

   158     /**

   159      * Set the primary type. Overrides existing primary type.

   160      * @param   primaryType     primary type

   161      */

   162     public void setPrimaryType(String primaryType) {

   163         this.primaryType = primaryType;

   164     }

   165 

   166     /**

   167      * Set the subType. Overrides existing subType

   168      * @param   subType subType

   169      */

   170     public void setSubType(String subType) {

   171         this.subType = subType;

   172     }

   173 

   174     /**

   175      * Set the specified parameter. If this parameter already exists,

   176      * it is replaced by this new value.

   177      *

   178      * @param   name    parameter name

   179      * @param   value   parameter value

   180      */

   181     public void setParameter(String name, String value) {

   182         if (list == null)

   183             list = new ParameterList();

   184 

   185         list.set(name, value);

   186     }

   187 

   188     /**

   189      * Set a new ParameterList.

   190      * @param   list    ParameterList

   191      */

   192     public void setParameterList(ParameterList list) {

   193         this.list = list;

   194     }

   195 

   196     /**

   197      * Retrieve a RFC2045 style string representation of

   198      * this Content-Type. Returns <code>null</code> if

   199      * the conversion failed.

   200      *

   201      * @return  RFC2045 style string

   202      */

   203     public String toString() {

   204         if (primaryType == null || subType == null) // need both

   205             return null;

   206 

   207         StringBuffer sb = new StringBuffer();

   208         sb.append(primaryType).append('/').append(subType);

   209         if (list != null)

   210         // Http Binding section of the "SOAP with attachments" specification says,

   211         // "SOAP message senders should send Content-Type headers on a single long line."

   212         // (http://www.w3.org/TR/SOAP-attachments#HTTPBinding)

   213             sb.append(list.toString());

   214 

   215         return sb.toString();

   216     }

   217 

   218     /**

   219      * Match with the specified ContentType object. This method

   220      * compares <strong>only the <code>primaryType</code> and

   221      * <code>subType</code> </strong>. The parameters of both operands

   222      * are ignored. <p>

   223      *

   224      * For example, this method will return <code>true</code> when

   225      * comparing the ContentTypes for <strong>"text/plain"</strong>

   226      * and <strong>"text/plain; charset=foobar"</strong>.

   227      *

   228      * If the <code>subType</code> of either operand is the special

   229      * character '*', then the subtype is ignored during the match.

   230      * For example, this method will return <code>true</code> when

   231      * comparing the ContentTypes for <strong>"text/plain"</strong>

   232      * and <strong>"text/*" </strong>

   233      *

   234      * @param   cType to compare this against

   235      */

   236     public boolean match(ContentType cType) {

   237         // Match primaryType

   238         if (!primaryType.equalsIgnoreCase(cType.getPrimaryType()))

   239             return false;

   240 

   241         String sType = cType.getSubType();

   242 

   243         // If either one of the subTypes is wildcarded, return true

   244         if ((subType.charAt(0) == '*') || (sType.charAt(0) == '*'))

   245             return true;

   246 

   247         // Match subType

   248         if (!subType.equalsIgnoreCase(sType))

   249             return false;

   250 

   251         return true;

   252     }

   253 

   254     /**

   255      * Match with the specified content-type string. This method

   256      * compares <strong>only the <code>primaryType</code> and

   257      * <code>subType</code> </strong>.

   258      * The parameters of both operands are ignored. <p>

   259      *

   260      * For example, this method will return <code>true</code> when

   261      * comparing the ContentType for <strong>"text/plain"</strong>

   262      * with <strong>"text/plain; charset=foobar"</strong>.

   263      *

   264      * If the <code>subType</code> of either operand is the special

   265      * character '*', then the subtype is ignored during the match.

   266      * For example, this method will return <code>true</code> when

   267      * comparing the ContentType for <strong>"text/plain"</strong>

   268      * with <strong>"text/*" </strong>

   269      */

   270     public boolean match(String s) {

   271         try {

   272             return match(new ContentType(s));

   273         } catch (ParseException pex) {

   274             return false;

   275         }

   276     }

   277 }