root/msg/entity_header.hh

/*  This file is part of Alue, the multiprotocol Internet discussion daemon

    Copyright © 2010 Antti-Juhani Kaijanaho

    Alue is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Alue is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Alue.  If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef GUARD_MSG_ENTITY_HEADER_HH
#define GUARD_MSG_ENTITY_HEADER_HH

#include "content_type.hh"

#include <boost/algorithm/string/case_conv.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/shared_ptr.hpp>
#include <list>
#include <map>
#include <string>

namespace msg
{
        class entity_header
        {
        public:
                typedef boost::shared_ptr<entity_header> ptr;
                typedef boost::shared_ptr<const entity_header> const_ptr;
                typedef std::list<std::string>::const_iterator field_iterator;

                // convenience wrapper
                static ptr mk(std::string &str, bool validate,
                              std::string default_ct) {
                        ptr rv(new entity_header(str, validate, default_ct));
                        return rv;
                }

                explicit entity_header(std::string default_ct)
                        : the_date(boost::posix_time::not_a_date_time)
                        , default_ct(default_ct)
                        {}

                // NOTE! Overwrites msg, leaving the body in it
                explicit entity_header(std::string &msg, bool validate,
                                       std::string default_ct);

                entity_header(const entity_header &o)
                        : field_content(o.field_content)
                        , the_date(o.the_date)
                        , default_ct(o.default_ct)
                        { reindex(); }

                entity_header &operator=(const entity_header &o) {
                        if (this != &o)
                        {
                                field_content = o.field_content;
                                the_date = o.the_date;
                                default_ct = o.default_ct;
                                reindex();
                        }
                        return *this;
                }

                boost::posix_time::ptime parsed_date() const;

                field_iterator fields_begin() const {
                        return field_content.begin();
                }

                field_iterator fields_end() const {
                        return field_content.end();
                }

                std::string get_header() const;

                bool has_field(std::string s) const{
                        boost::to_lower(s);
                        return fields.find(s) != fields.end();
                }

                // returns the field unprocessed
                std::string get_field(std::string s, bool full) const;

                void add_field(std::string name, std::string body) {
                        field_content.push_front(name + ": " + body + "\r\n");
                        boost::to_lower(name);
                        fields[name] = field_content.begin();
                        if (name == "date")
                                the_date = boost::posix_time::not_a_date_time;
                }
                void replace_field(std::string name, std::string body);
                void delete_field(std::string name);

                content_type get_content_type() const;

        private:
                // this split is to both provide a fast name lookup
                // and to preserve the field ordering
                std::list<std::string> field_content; // includes the names
                std::map<std::string, std::list<std::string>::iterator> fields;
                mutable boost::posix_time::ptime the_date;
                std::string default_ct;

                void reindex();
        };
}

#endif /* GUARD_MSG_ENTITY_HEADER_HH */