root/tlate/header_value.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_TLATE_HEADER_VALUE_HH
#define GUARD_TLATE_HEADER_VALUE_HH

#include "field_value.hh"
#include "sequential_value.hh"
#include "../msg/entity.hh"

namespace tlate
{
        class header_value : public sequential_value
        {
                msg::entity::const_ptr m;
                bool munge;

                class vit : public virtual_iterator
                {
                        msg::entity::field_iterator it;
                        mutable value::const_ptr cur;
                        bool munge;
 
                        vit(msg::entity::field_iterator it,
                            value::const_ptr cur,
                            bool munge)
                                : it(it)
                                , cur(cur)
                                , munge(munge)
                                {}
               public:
                        vit(msg::entity::field_iterator it, bool munge)
                                : it(it)
                                , munge(munge)
                                {}
                        virtual_iterator *clone() const {
                                return new vit(it, cur, munge);
                        }
                        value::const_ptr get() const {
                                if (!cur)
                                        cur.reset(new field_value(*it, munge));
                                return cur;
                        }
                        void next() {
                                it++;
                                cur.reset();
                        }
                        bool eq(const virtual_iterator &o_) const {
                                const vit *o = dynamic_cast<const vit *>(&o_);
                                return o ? it == o->it : false;
                        }
                };

        public:
                header_value(msg::entity::const_ptr m, bool munge)
                        : m(m)
                        , munge(munge)
                        {}
                const_iterator begin() const {
                        return const_iterator
                                (new vit(m->fields_begin(), munge));
                }
                const_iterator end() const {
                        return const_iterator
                                (new vit(m->fields_end(), munge));
                }
        };

}

#endif /* GUARD_TLATE_HEADER_VALUE_HH */