root/db/db.hh

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

    Copyright © 2009, 2010, 2011 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_DB_HH
#define GUARD_DB_DB_HH

#include "filing_exception.hh"
#include "group.hh"
#include "no_such_article.hh"
#include "no_such_group.hh"
#include "threaded.hh"

#include  "../server.hh"

#include <boost/asio.hpp>
#include <boost/nondet_random.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread/recursive_mutex.hpp>
#include <fstream>

namespace msg { class entity; }

namespace db
{
        class msg;
        class user;
        class password_handler;
        class db_reader;

        class db : private boost::noncopyable
                 , public boost::enable_shared_from_this<db>
        {
                db();
                void init();

        public:
                typedef std::map<std::string,boost::shared_ptr<group> >
                ::const_iterator  group_iterator;
                typedef std::map<std::string,boost::shared_ptr<msg> >
                ::const_iterator  msgid_iterator;

                static boost::shared_ptr<db> create() {
                        boost::shared_ptr<db> rv(new db());
                        rv->init();
                        return rv;
                }

                group_iterator groups_begin() const { return groups.begin(); }
                group_iterator groups_end() const { return groups.end(); }

                msgid_iterator msgids_begin() const { return msgid.begin(); }
                msgid_iterator msgids_end() const { return msgid.end(); }

                boost::shared_ptr<msg> lookup_msgid(std::string s)  {
                        boost::lock_guard<boost::recursive_mutex> lg(mt);
                        msgid_iterator it = msgid.find(s);
                        if (it == msgid.end()) throw no_such_article();
                        return it->second;
                }

                boost::shared_ptr<group> lookup_group(std::string s) {
                        boost::lock_guard<boost::recursive_mutex> lg(mt);
                        group_iterator it = groups.find(s);
                        if (it == groups.end()) throw no_such_group();
                        return it->second;
                }

                boost::shared_ptr<msg> file(boost::shared_ptr< ::msg::entity >,
                                            boost::asio::ip::address source,
                                            boost::shared_ptr<user> poster,
                                            server::conn_cb);

                const threaded &get_threaded() {
                        boost::lock_guard<boost::recursive_mutex> lg(mt);
                        return thr;
                }

                boost::shared_ptr<user> create_user(std::string userid,
                                                    std::string passwd);

                boost::shared_ptr<user> lookup_user(std::string userid) {
                        boost::lock_guard<boost::recursive_mutex> lg(mt);
                        return users[userid];
                }

                boost::shared_ptr<user> lookup_user_by_email(std::string s) {
                        boost::lock_guard<boost::recursive_mutex> lg(mt);
                        return users_email[s];
                }

                boost::shared_ptr<role> create_role(std::string name,
                                                    std::string description);

                boost::shared_ptr<role> lookup_role(std::string name) {
                        boost::lock_guard<boost::recursive_mutex> lg(mt);
                        return roles[name];
                }

                void add_record(std::string record);
        private:
                mutable boost::recursive_mutex mt;

                std::map<std::string, boost::shared_ptr<user> > users;
                std::map<std::string, boost::shared_ptr<user> > users_email;
                std::map<std::string, boost::shared_ptr<role> > roles;
                std::map<std::string, boost::shared_ptr<group> > groups;
                std::map<std::string, boost::shared_ptr<msg> > msgid;

                std::string dbname;

                boost::shared_ptr<password_handler> pwh;

                threaded thr;
                group::number global_next;

                boost::random_device rand;

                void do_newgroup(db_reader &, std::string,
                                 boost::posix_time::ptime);
                void do_user(db_reader &, std::string);
                void do_article(db_reader &, std::string);
                void do_role(db_reader &, std::string);
                void do_moderation(db_reader &, std::string);
                void read_record(db_reader &dr, boost::posix_time::ptime);
                void register_role(boost::shared_ptr<role>);
        };
};

#endif /* GUARD_DB_DB_HH */