/home/tommi/tntnet/framework/common/tnt/contenttype.h

00001 /*
00002  * Copyright (C) 2003-2005 Tommi Maekitalo
00003  * 
00004  * This library is free software; you can redistribute it and/or
00005  * modify it under the terms of the GNU Lesser General Public
00006  * License as published by the Free Software Foundation; either
00007  * version 2.1 of the License, or (at your option) any later version.
00008  * 
00009  * As a special exception, you may use this file as part of a free
00010  * software library without restriction. Specifically, if other files
00011  * instantiate templates or use macros or inline functions from this
00012  * file, or you compile this file and link it with other files to
00013  * produce an executable, this file does not by itself cause the
00014  * resulting executable to be covered by the GNU General Public
00015  * License. This exception does not however invalidate any other
00016  * reasons why the executable file might be covered by the GNU Library
00017  * General Public License.
00018  * 
00019  * This library is distributed in the hope that it will be useful,
00020  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00021  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00022  * Lesser General Public License for more details.
00023  * 
00024  * You should have received a copy of the GNU Lesser General Public
00025  * License along with this library; if not, write to the Free Software
00026  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
00027  */
00028 
00029 
00030 #ifndef TNT_CONTENTTYPE_H
00031 #define TNT_CONTENTTYPE_H
00032 
00033 #include <tnt/messageattribute.h>
00034 #include <map>
00035 
00036 namespace tnt
00037 {
00039   class Contenttype : public MessageattributeParser
00040   {
00041     public:
00042       typedef std::multimap<std::string, std::string> parameter_type;
00043       typedef parameter_type::const_iterator parameter_iterator;
00044 
00045     private:
00046       virtual return_type onType(const std::string& type, const std::string& subtype);
00047       virtual return_type onParameter(const std::string& attribute, const std::string& value);
00048 
00049       std::string type;
00050       std::string subtype;
00051       parameter_type parameter;
00052       std::string boundary;
00053 
00054     public:
00055       Contenttype()
00056       { }
00057 
00058       explicit Contenttype(const std::string& ct);
00059       Contenttype(const std::string& type_, const std::string& subtype_)
00060         : type(type_),
00061           subtype(subtype_)
00062           { }
00063 
00064       const std::string& getType() const     { return type; }
00065       const std::string& getSubtype() const  { return subtype; }
00066       const std::string& getBoundary() const { return boundary; }
00067       bool isMultipart() const
00068         { return type == "multipart" && !boundary.empty(); }
00069 
00070       parameter_iterator parameter_begin() const
00071         { return parameter.begin(); }
00072       parameter_iterator parameter_end() const
00073         { return parameter.end(); }
00074       parameter_iterator parameter_find(parameter_type::key_type key) const
00075         { return parameter.find(key); }
00076       parameter_iterator parameter_upper_bound(parameter_type::key_type key) const
00077         { return parameter.upper_bound(key); }
00078 
00079       bool operator== (const Contenttype& ct) const
00080         { return type == ct.type
00081               && subtype == ct.subtype
00082               && parameter == ct.parameter
00083               && boundary == ct.boundary; }
00084   };
00085 
00086   inline std::istream& operator>> (std::istream& in, Contenttype& ct)
00087   {
00088     ct.parse(in);
00089     return in;
00090   }
00091 }
00092 
00093 #endif // TNT_CONTENTTYPE_H
00094