root/db/threaded.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_DB_THREADED_HH
#define GUARD_DB_THREADED_HH

#include "group.hh"
#include "msg.hh"

#include "../tlate/tlate.hh"

#include <boost/enable_shared_from_this.hpp>
#include <boost/noncopyable.hpp>
#include <list>
#include <map>

namespace db
{
        class thread_node  : public boost::enable_shared_from_this<thread_node>
        {
        public:
                typedef boost::shared_ptr<thread_node> ptr;
                typedef boost::shared_ptr<const thread_node> const_ptr;
        private:
                std::map<std::string, thread_node::ptr> &msgids;
                std::string msgid;
                group::number grinx;
                boost::shared_ptr<msg> art;
                boost::posix_time::ptime my_date, latest_date;
                std::list<ptr> children;
                ptr parent;

                // valid only if parent is valid
                std::list<ptr>::iterator sibling_iterator;

                void set_parent(ptr);
                void disown_children();
                void recalc_latest_date();

                ptr restrict_to_group(boost::shared_ptr<group> gr,
                                      ptr parent) const;
                friend class threaded;
        public:
                thread_node(std::map<std::string, thread_node::ptr> &msgids,
                            std::string msgid)
                        : msgids(msgids)
                        , msgid(msgid)
                        , grinx(-1)
                        , my_date(boost::posix_time::neg_infin)
                        , latest_date(boost::posix_time::neg_infin)
                        {}

                ptr previous() const;
                ptr next() const;

                boost::posix_time::ptime get_latest_date() const {
                        return latest_date;
                }

                std::string get_msgid() const { return msgid; }

                void add_msg(group::number grinx,
                             boost::shared_ptr<msg> art);
                void prune();
                bool has_descendant(ptr);
                bool is_empty() { return !art && children.empty(); }
                ptr get_principal();
               
                size_t cardinality() const;
 
                ptr get_parent() const {
                        if (parent && parent->msgid.empty()) return ptr();
                        return parent;
                }
                const std::list<ptr> &get_children() const { return children; }
                boost::shared_ptr<msg> get_article() const { return art; }
                template <typename Cmp>
                void sort_children(Cmp cmp) {
                        children.sort(cmp);
                }
                
                template <typename Cmp>
                void sort_children_recursive(Cmp cmp) {
                        sort_children(cmp);
                        for (std::list<ptr>::iterator it 
                                     = children.begin();
                             it != children.end(); it++)
                        {
                                (*it)->sibling_iterator = it;
                                (*it)->sort_children_recursive(cmp);
                        }
                }
                
                static bool cmp_date_rev(thread_node::const_ptr a,
                                         thread_node::const_ptr b) {
                        return a != b && !cmp_date(a,b);
                }
                static bool cmp_latest_date_rev(thread_node::const_ptr a,
                                                thread_node::const_ptr b) {
                        return a != b && !cmp_latest_date(a,b);
                }
                static bool cmp_date(thread_node::const_ptr a,
                                     thread_node::const_ptr b) {
                        if (!a->my_date.is_not_a_date_time() &&
                            !b->my_date.is_not_a_date_time() )
                        {
                                return a->my_date < b->my_date;
                        }
                        return a->grinx < b->grinx;
                }
                static bool cmp_latest_date(thread_node::const_ptr a,
                                            thread_node::const_ptr b) {
                        boost::posix_time::ptime ad = a->latest_date;
                        boost::posix_time::ptime bd = b->latest_date;
                        if (!ad.is_neg_infinity() &&
                            !bd.is_neg_infinity())
                        {
                                return ad < bd;
                        }
                        return a->grinx < b->grinx;                        
                }
        };

        class threaded : public boost::noncopyable
        {
        public:
                threaded() 
                        : root(new thread_node(msgids, "")) 
                        { msgids[""] = root; }

                void add_msg(group::number grinx, 
                             boost::shared_ptr<msg> art);
                const std::list<thread_node::ptr> &get_threads() const
                        { return root->get_children(); }
                const std::list<thread_node::ptr> &get_threads
                (boost::shared_ptr<group> gr) const;

                thread_node::ptr lookup_msgid(std::string s) const {
                        // let's not export an implementation detail
                        if (s.empty()) return thread_node::ptr();

                        std::map<std::string, thread_node::ptr>::const_iterator
                                it = msgids.find(s);
                        if (it == msgids.end()) return thread_node::ptr();
                        return it->second;
                }
                void recalc_roots();
                void sort();

        private:
                std::map<std::string, thread_node::ptr> msgids;
                thread_node::ptr root;

                static const std::list<thread_node::ptr> empty_list;
        };
}

#endif /* GUARD_DB_THREADED_HH */