source: db/threaded.cc @ 7f6e52f

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

    Copyright © 2009 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/>.

 */

#include "threaded.hh"

#include "../msg/lexutils.hh"
#include "../msg/msg.hh"
#include "../html/util.hh"
#include "../tlate/sequential_value.hh"
#include "../tlate/lazy_structured_value.hh"
#include "../uri.hh"

#include "../assert.hh"

namespace db
{
        thread_node::ptr thread_node::previous() const
        {
                if (!parent) return ptr();
                if (sibling_iterator == parent->children.begin())
                        return parent;
                std::list<ptr>::iterator it = sibling_iterator;
                assert(msgid == (*it)->msgid);
                it--;
                return *it;
        }

        thread_node::ptr thread_node::next() const
        {
                if (!children.empty()) return *children.begin();
                const_ptr tn = shared_from_this();
                while (true)
                {
                        if (!tn->parent) return ptr();
                        std::list<ptr>::iterator it = tn->sibling_iterator;
                        assert(it != tn->parent->children.end());
                        it++;
                        if (it == tn->parent->children.end())
                        {
                                tn = tn->parent;
                                continue;
                        }
                        return *it;
                }
        }

        void thread_node::disown_children()
        {
                for (std::list<ptr>::iterator it = children.begin();
                     it != children.end(); it++)
                {
                        (*it)->parent.reset();
                }
                children.clear();
        }

        void thread_node::set_parent(ptr p)
        {
                if (parent)
                        parent->children.erase(sibling_iterator);
                parent = p;
                if (!parent) return;
                p->children.push_back(shared_from_this());
                sibling_iterator = p->children.end();
                assert(sibling_iterator != p->children.begin());
                sibling_iterator--;
        }

        thread_node::ptr
        thread_node::get_principal()
        {
                if (art) return ptr();
                if (children.empty()) return ptr();
                std::list<ptr>::iterator it = children.begin();
                it++;
                if (it != children.end()) return ptr();
                return *it;
        }

        size_t thread_node::cardinality() const
        {
                size_t rv = art ? 1 : 0;
                for (std::list<ptr>::const_iterator it = children.begin();
                     it != children.end(); it++)
                {
                        rv += (*it)->cardinality();
                }
                return rv;
        }

        bool thread_node::has_descendant(ptr tn)
        {
                for (std::list<ptr>::const_iterator it = children.begin();
                     it != children.end(); it++)
                {
                        if (*it == tn) return true;
                        if ((*it)->has_descendant(tn)) return true;
                }
                return false;
        }

        void thread_node::prune()
        {
                for (std::list<ptr>::iterator it = children.begin();
                     it != children.end(); /**/)
                {
                        (*it)->prune();
                        if ((*it)->art)
                        {
                                it++;
                        }
                        else
                        {
                                for (std::list<ptr>::iterator jt =
                                             (*it)->children.begin();
                                     jt != (*it)->children.end();
                                     jt++)
                                {
                                        (*jt)->sibling_iterator =
                                                children.insert(it, *jt);
                                        (*jt)->parent = shared_from_this();
                                }

                                std::list<ptr>::iterator next = it;
                                next++;
                                children.erase(it);
                                (*it)->parent.reset();
                                it = next;
                        }
                }
        }
        
        void thread_node::add_msg(db::group::number grinx_, 
                                  boost::shared_ptr<msg::msg> art_)
        {
                if (art) return;
                grinx = grinx_;
                art = art_;
                std::string refss = art->get_field("references", false);
                ptr prev;
                while (!refss.empty())
                {
                        std::string ref = msg::get_msgid(refss);
                        if (ref.empty()) continue;
                        ptr &tn = msgids[ref];
                        if (!tn) tn.reset(new thread_node(msgids,ref));
                        if (prev && !tn->parent && !tn->has_descendant(prev))
                                tn->set_parent(prev);
                        prev = tn;
                }
                if (prev)
                {
                        set_parent(prev);
                }
        }

        void threaded::add_msg(db::group::number grinx,
                               boost::shared_ptr<msg::msg> art)
        {
                thread_node::ptr &tn = msgids[art->msgid()];
                if (!tn) tn.reset(new thread_node(msgids, art->msgid()));
                tn->add_msg(grinx, art);
        }

        void threaded::recalc_roots()
        {
                root->disown_children();
                for (std::map<std::string, thread_node::ptr>::const_iterator it
                             = msgids.begin();
                     it != msgids.end(); it++)
                {
                        thread_node::ptr tn = it->second;
                        if (tn->parent) continue;

                        thread_node::ptr princ = tn->get_principal();
                        if (princ)
                                tn = princ;

                        if (!tn->is_empty())
                                tn->set_parent(root);
                }
                root->prune();
        }
        void threaded::sort()
        {
                root->sort_children_recursive(thread_node::cmp_grinx);
        }

        thread_node::ptr 
        thread_node::restrict_to_group(boost::shared_ptr<group> gr,
                                       ptr parent) const
        {
                ptr rv(new thread_node(msgids, msgid));
                rv->grinx = grinx;
                rv->art = art;
                rv->set_parent(parent);

                for (std::list<ptr>::const_iterator it = children.begin();
                     it != children.end(); it++)
                {
                        (*it)->restrict_to_group(gr, rv);
                }
                if (rv->children.empty() && !art) return ptr();
                if (art)
                {
                        std::map<boost::shared_ptr<db::group>,db::group::number>
                                ::const_iterator git = art->get_xref().find(gr);
                        if (git == art->get_xref().end()) 
                        {
                                rv->set_parent(ptr());
                                return ptr();
                        }
                }
                return rv;
        }

        const std::list<thread_node::ptr> threaded::empty_list;

        const std::list<thread_node::ptr> &threaded::get_threads
        (boost::shared_ptr<group> gr) const 
        {
                thread_node::ptr tn = root->restrict_to_group
                        (gr, thread_node::ptr());
                if (!tn) return empty_list;
                return tn->get_children();
        }

}