root/tlate/thread_value.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_TLATE_THREAD_VALUE_HH
#define GUARD_TLATE_THREAD_VALUE_HH

#include "msg_value.hh"
#include "sequential_value.hh"

#include "../db/threaded.hh"

#include <vector>

namespace db { class user; }

namespace tlate
{
        class thread_value : public sequential_value
        {
                typedef std::vector<db::thread_node::const_ptr> tl;
                tl tnl;
                boost::shared_ptr<const db::user> u;
        private:
                class vit : public virtual_iterator
                {
                        tl::const_iterator it;
                        mutable value::ptr cur;
                        boost::shared_ptr<const db::user> u;

                public:
                        vit(tl::const_iterator it,
                            boost::shared_ptr<const db::user> u)
                                : it(it), u(u)
                                {}

                        virtual_iterator *clone() const {
                                return new vit(*this);
                        }
                        value::const_ptr get() const {
                                if (!cur) cur = msg_value::mk(*it, u);
                                return cur;
                        }
                        void next() {
                                cur.reset();
                                it++;
                        }
                        bool eq(const virtual_iterator &o_) const {
                                const vit *o = dynamic_cast<const vit *>(&o_);
                                return o ? it == o->it : false;
                        }
                };

        public:
                typedef boost::shared_ptr<thread_value> ptr;
                typedef boost::shared_ptr<const thread_value> const_ptr;

                const_iterator begin() const { return new vit(tnl.begin(), u); }
                const_iterator end() const   { return new vit(tnl.end(),   u); }

                thread_value(db::thread_node::const_ptr tn,
                             boost::shared_ptr<const db::user> u);
                void slice_window(size_t start, size_t length);
                size_t size() const { return tnl.size(); }
        };
}

#endif /* GUARD_TLATE_THREAD_VALUE_HH */