root/msg/entity.hh

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

    Copyright © 2009, 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_HH
#define GUARD_MSG_ENTITY_HH

#include "entity_header.hh"

#define DEFAULT_CT "text/plain; charset=\"US-ASCII\""

namespace tlate { class value; }

namespace msg
{
        class content_type;
        class multipart;

        class entity
        {
        public:
                typedef boost::shared_ptr<entity> ptr;
                typedef boost::shared_ptr<const entity> const_ptr;
                typedef entity_header::field_iterator field_iterator;

                static ptr mk(std::string msgstr,
                              bool validate,
                              std::string default_ct = DEFAULT_CT);

                virtual ~entity() {}

                virtual ptr clone() const = 0;

                virtual boost::shared_ptr<multipart> clone_as_multipart() const;

                virtual boost::shared_ptr<tlate::value>
                get_tlate_value(bool hide_addreses) const = 0;

                boost::posix_time::ptime parsed_date() const {
                        return hdr->parsed_date();
                }

                field_iterator fields_begin() const {
                        return hdr->fields_begin();
                }

                field_iterator fields_end() const { return hdr->fields_end(); }

                std::string get_header() const { return hdr->get_header(); } 
                virtual std::string get_body() const = 0;
                virtual std::string get_decoded_body() const {
                        return get_body();
                }
                std::string get_entity() const {
                        return get_header() + "\r\n" + get_body();
                }

                bool has_field(std::string s) const{ return hdr->has_field(s); }

                // returns the field unprocessed
                std::string get_field(std::string s, bool full) const {
                        return hdr->get_field(s, full);
                }

                size_t get_size() const;
                size_t get_body_lines() const;

                void replace_field(std::string name, std::string body) {
                        return hdr->replace_field(name, body);
                }

                content_type get_content_type() const {
                        return hdr->get_content_type();
                }

        protected:
                entity(entity_header::ptr hdr)
                        : hdr(hdr)
                        {}
                entity(const entity &ent)
                        : hdr(new entity_header(*ent.hdr))
                        {}

        private:
                entity_header::ptr hdr;

                entity &operator=(const entity &); // DISABLED
        };
}

#endif /* GUARD_MSG_ENTITY_HH */