Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* ************************************************************************
  #
  #  DivConq
  #
  #  http://divconq.com/
  #
  #  Copyright:
  #    Copyright 2014 eTimeline, LLC. All rights reserved.
  #
 #  License:
 #    See the license.txt file in the project's top-level directory for details.
 #
 #  Authors:
 #    * Andy White
 #
 ************************************************************************ */
 
 /*
  * ContentTypeParser.java February 2001
  *
  * Copyright (C) 2001, Niall Gallagher <niallg@users.sf.net>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 
  * implied. See the License for the specific language governing 
  * permissions and limitations under the License.
  */
  
 package divconq.www.http.parse;
 
This provides access to the MIME type parts, that is the primary type, the secondary type and an optional character set parameter. The charset parameter is one of many parameters that can be associated with a MIME type. This however this exposes this parameter with a typed method.

The getCharset will return the character encoding the content type is encoded within. This allows the user of the content to decode it correctly. Other parameters can be acquired from this by simply providing the name of the parameter.

Author(s):
Niall Gallagher
 
 public class ContentTypeParser extends Parser implements ContentType {

   
Used to store the characters consumed for the secondary type.
 
    private ParseBuffer secondary;   

   
Used to store the characters consumed for the primary type.
 
    private ParseBuffer primary;

   
Used to store the characters for the charset parameter.
 
    private ParseBuffer charset;
   
   
Used to store the characters consumed for the type.
 
    private ParseBuffer type;
   
   
Used to collect the name of a content type parameter.
 
    private ParseBuffer name;
   
   
Used to collect the value of the content type parameter.
 
    private ParseBuffer value;
   
   
Used to store the name value pairs of the parameters.
 
    private KeyMap<Stringmap;
   
   
The default constructor will create a ContentParser that contains no charset, primary or secondary. This can be used to extract the primary, secondary and the optional charset parameter by using the parser's parse(String) method.
   
   public ContentTypeParser(){
      this. = new ParseBuffer();
      this. = new ParseBuffer();  
      this. = new ParseBuffer();
      this. = new ParseBuffer();
      this. = new ParseBuffer(); 
      this. = new ParseBuffer(); 
      this. = new KeyMap<String>();
   }

   
This is primarily a convenience constructor. This will parse the String given to extract the MIME type. This could be achieved by calling the default no-arg constructor and then using the instance to invoke the parse method on that String.

Parameters:
header String containing a MIME type value
   public ContentTypeParser(String header){
      this();
      parse(header);
   }     
   
   
This method is used to get the primary and secondary parts joined together with a "/". This is typically how a content type is examined. Here convenience is most important, we can easily compare content types without any parameters.

Returns:
this returns the primary and secondary types
   public String getType() {
      return .toString();
   }

   
This sets the primary type to whatever value is in the string provided is. If the string is null then this will contain a null string for the primary type of the parameter, which is likely invalid in most cases.

Parameters:
value the type to set for the primary type of this
 
   public void setPrimary(String value) {
      .reset(value);
      .append('/');
      .append();
      .reset(value);
   }
   
   
This is used to retrieve the primary type of this MIME type. The primary type part within the MIME type defines the generic type. For example text/plain; charset=UTF-8. This will return the text value. If there is no primary type then this will return null otherwise the string value.

Returns:
the primary type part of this MIME type
  
   public String getPrimary() {
      return .toString();
   }   
   
   
This sets the secondary type to whatever value is in the string provided is. If the string is null then this will contain a null string for the secondary type of the parameter, which is likely invalid in most cases.

Parameters:
value the type to set for the primary type of this
 
   public void setSecondary(String value) {
      .reset();
      .append('/');
      .append(value);
      .reset(value);
   }   

   
This is used to retrieve the secondary type of this MIME type. The secondary type part within the MIME type defines the generic type. For example text/html; charset=UTF-8. This will return the HTML value. If there is no secondary type then this will return null otherwise the string value.

Returns:
the primary type part of this MIME type
 
   public String getSecondary(){
      return .toString();
   }   

   
This will set the charset to whatever value the string contains. If the string is null then this will not set the parameter to any value and the toString method will not contain any details of the parameter.

Parameters:
enc parameter value to add to the MIME type
 
   public void setCharset(String enc) {
      .reset(enc);  
   }   

   
This is used to retrieve the charset of this MIME type. This is a special parameter associated with the type, if the parameter is not contained within the type then this will return null, which typically means the default of ISO-8859-1.

Returns:
the value that this parameter contains
  
   public String getCharset() {
      return .toString();   
   }  
   
   
This is used to retrieve an arbitrary parameter from the MIME type header. This ensures that values for boundary or other such parameters are not lost when the header is parsed. This will return the value, unquoted if required, as a string.

Parameters:
name this is the name of the parameter to be retrieved
Returns:
this is the value for the parameter, or null if empty
   public String getParameter(String name) {
      return .get(name);
   }
   
   
This will add a named parameter to the content type header. If a parameter of the specified name has already been added to the header then that value will be replaced by the new value given. Parameters such as the boundary as well as other common parameters can be set with this method.

Parameters:
name this is the name of the parameter to be added
value this is the value to associate with the name
   public void setParameter(String nameString value) {
      .put(namevalue);
   }

   
This will initialize the parser when it is ready to parse a new String. This will reset the parser to a ready state. The init method is invoked by the parser when the Parser.parse method is invoked.
   protected void init(){
      if( > 0) { 
         pack();
      }
      clear();
   }
   
   
This is used to clear all previously collected tokens. This allows the parser to be reused when there are multiple source strings to be parsed. Clearing of the tokens is performed when the parser is initialized.
   private void clear() {
      .clear();
      .clear();
      .clear();
      .clear();
      .clear();
      .clear();
      .clear();
       = 0;
   }
   
   
Reads and parses the MIME type from the given String object. This uses the syntax defined by RFC 2616 for the media-type syntax. This parser is only concerned with one parameter, the charset parameter. The syntax for the media type is
 media-type = token "/" token *( ";" parameter )
 parameter = token | literal 
 
   protected void parse(){
      primary();
      ++;
      secondary();
      parameters();
   }
   
   
This is used to remove all whitespace characters from the String excluding the whitespace within literals. The definition of a literal can be found in RFC 2616.

The definition of a literal for RFC 2616 is anything between 2 quotes but excluding quotes that are prefixed with the backward slash character.

   private void pack() {
      char old = [0];
      int len = ;
      int seek = 0;
      int pos = 0;
      while(seek < len){
         char ch = [seek++];
         
         if(ch == '"' && old != '\\'){  /* qd-text*/
            [pos++] = ch;
            
            while(seek < len){
               old = [seek-1];
               ch = [seek++];  
               [pos++] = ch;  
               
               if(ch =='"'&& old!='\\'){  /*qd-text*/
                  break;
               }
            }
         }else if(!space(ch)){            
            old = [seek - 1];  
            [pos++] = old;                   
         }         
      }
       = pos;
   }
   
   
This reads the type from the MIME type. This will fill the type ParseBuffer. This will read all chars upto but not including the first instance of a '/'. The type of a media-type as defined by RFC 2616 is type/subtype;param=val;param2=val.
  
   private void primary(){
      while( < ){
         if([] =='/'){
            .append('/');
            break;
         }
         .append([]);
         .append([]);
         ++;
      }
   }
  
   
This reads the subtype from the MIME type. This will fill the subtype ParseBuffer. This will read all chars upto but not including the first instance of a ';'. The subtype of a media-type as defined by RFC 2616 is type/subtype;param=val;param2=val.
   private void secondary(){
      while( < ){
         if([] ==';'){
            break;
         }
         .append([]);
         .append([]);
         ++;
      }      
   }
   
   
This will read the parameters from the MIME type. This will search for the charset parameter within the set of parameters which are given to the type. The charset param is the only parameter that this parser will tokenize.

This will remove any parameters that preceed the charset parameter. Once the charset is retrived the MIME type is considered to be parsed.

   private void parameters(){   
      while(skip(";")){
         if(skip("charset=")){
            charset();
            break;
         }else{
            parameter();
            insert();
         }
      }
   }   
   
   
This will add the name and value tokens to the parameters map. If any previous value of the given name has been inserted into the map then this will overwrite that value. This is used to ensure that the string value is inserted to the map.
   private void insert() {
      insert();
      .clear();
      .clear();
   }
   
   
This will add the given name and value to the parameters map. If any previous value of the given name has been inserted into the map then this will overwrite that value. This is used to ensure that the string value is inserted to the map.

Parameters:
name this is the name of the value to be inserted
value this is the value of a that is to be inserted
   private void insert(ParseBuffer nameParseBuffer value) {
	   .put(name.toString(), value.toString());
   }
   
   
This is a parameter as defined by RFC 2616. The parameter is added to a MIME type e.g. type/subtype;param=val etc. The parameter name and value are not stored. This is used to simply update the read offset past the parameter. The reason for reading the parameters is to search for the charset parameter which will indicate the encoding.
   private void parameter(){
      name();
      ++; /* = */
      value();
   }
   
   
This will simply read all characters from the buffer before the first '=' character. This represents a parameter name (see RFC 2616 for token). The parameter name is not buffered it is simply read from the buffer. This will not cause an IndexOutOfBoundsException as each offset is checked before it is acccessed.
   private void name(){
      while( < ){
         if([] =='='){
            break;
         }
         .append([]);
         ++;
      }   
   }
   
   
This is used to read a parameters value from the buf. This will read all char's upto but excluding the first terminal char encountered from the off within the buf, or if the value is a literal it will read a literal from the buffer (literal is any data between quotes except if the quote is prefixed with a backward slash character).
   private void value(){
      if(quote([])){         
         for(++;  < ;){
            if(quote([])){
               if([++-2]!='\\'){
                  break;
               }
            }
            .append([++]);
         }
      }else{   
         while( < ){
            if([] ==';') {
               break;           
            }
            .append([]);
            ++;
         }
      }
   }
   
   
This method is used to determine if the specified character is a quote character. The quote character is typically used as a boundary for the values within the header. This accepts a single or double quote.

Parameters:
ch the character to determine if it is a quotation
Returns:
true if the character provided is a quotation character
   private boolean quote(char ch) {
      return ch == '\'' || ch == '"';
   }
   
   
This is used to read the value from the charset param. This will fill the charset ParseBuffer and with the charset value. This will read a literal or a token as the charset value. If the charset is a literal then the quotes will be read as part of the charset.
 
   private void charset(){
      if([] == '"'){         
         .append('"');
         for(++;  < ;){
            .append([]);
            if([++]=='"')
               if([-2]!='\\'){
                  break;
               }            
         }
      }else{   
         while( < ){
            if([]==';') {
               break;          
            }
            .append([]);
            ++;
         }
      }   
   }
   
   
This will return the value of the MIME type as a string. This will concatenate the primary and secondary type values and add the charset parameter to the type which will recreate the content type.

Returns:
this returns the string representation of the type
   private String encode() {
      StringBuilder text = new StringBuilder();
      
      if( != null) {
         text.append();
         text.append("/");
         text.append();
      }
      if(.length() > 0) {
         text.append("; charset=");
         text.append();
      }
      return encode(text);
   }
   
   
This will return the value of the MIME type as a string. This will concatenate the primary and secondary type values and add the charset parameter to the type which will recreate the content type.

Parameters:
text this is the buffer to encode the parameters to
Returns:
this returns the string representation of the type
   private String encode(StringBuilder text) {
      for(String name : ) {
         String value = .get(name);
         
         text.append("; ");
         text.append(name);
         
         if(value != null) {
            text.append("=");
            text.append(value);;
         }
      }
      return text.toString();
   }

   
This will return the value of the MIME type as a string. This will concatenate the primary and secondary type values and add the charset parameter to the type which will recreate the content type.

Returns:
this returns the string representation of the type
   public String toString() {
      return encode();
   }
New to GrepCode? Check out our FAQ X