root/db/group.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_GROUP_HH
#define GUARD_DB_GROUP_HH

#include "article_number_type.hh"
#include "no_such_article.hh"

#include "../server.hh"

#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <set>
#include <string>
#include <vector>

namespace db
{
        class db;
        class msg;
        class role;
        class threaded_group;
        class thread_node;
        class user;
        class group : private boost::noncopyable
                    , public boost::enable_shared_from_this<group>
        {
        public:
                typedef boost::shared_ptr<group> ptr;
                typedef boost::shared_ptr<const group> const_ptr;

                typedef article_number_type number;
                enum { number_max = 2147483647UL }; // RFC3977

                group(std::string name,
                      boost::shared_ptr<db> dbase,
                      boost::posix_time::ptime stamp,
                      bool reading_restricted, std::string descr);
                
                boost::posix_time::ptime get_creation_time() const {
                        return stamp;
                }

                number low_mark() const { return displacement; }
                number high_mark() const {
                        return displacement + msgs.size() - 1; 
                }

                std::string name() const { return the_name; }
                std::string one_line_description() const { return descr; }

                bool is_article(number n) const { return retrieve(n); }

                boost::shared_ptr<msg> get_article(number n) const {
                        boost::shared_ptr<msg> rv = retrieve(n);
                        if (!rv) throw no_such_article();
                        return rv;
                }

                number file(boost::shared_ptr<msg> m, server::conn_cb);

                void file(boost::shared_ptr<msg> m, number n);

                number get_count() const { return count; }

                const std::set<boost::shared_ptr<role> > &get_readers() const {
                        return readers;
                }

                void add_reader(boost::shared_ptr<role> r) {
                        readers.insert(r);
                }

                bool reading_authz(boost::shared_ptr<const user> u) const {
                        return authz(u, readers);
                }
                bool posting_authz(boost::shared_ptr<const user> u) const {
                        return authz(u, posters);
                }

                void add_subscriber(boost::shared_ptr<user> u,
                                    server::conn_cb cb,
                                   boost::asio::ip::address peer);
                void delete_subscriber(boost::shared_ptr<user> u,
                                       server::conn_cb cb);
                bool is_subscriber(boost::shared_ptr<const user> u);
        private:
                std::string the_name;
                boost::posix_time::ptime stamp;
                std::string descr;
                boost::shared_ptr<db> dbase;
                boost::shared_ptr<role> subscriber_role;

                void ensure_subscriber_role();

                number count;
                
                size_t displacement;
                std::vector<boost::shared_ptr<msg> > msgs;

                std::set<boost::shared_ptr<role> > readers;
                std::set<boost::shared_ptr<role> > posters;

                static bool authz(boost::shared_ptr<const user> u,
                                  const std::set<boost::shared_ptr<role> > &);

                void send_submail(boost::shared_ptr<const user> u,
                                  const char *tln,
                                  server::conn_cb cb);

                boost::shared_ptr<msg> retrieve(number n) const {
                        static boost::shared_ptr<msg> null;
                        if (n < displacement) return null;
                        if (n - displacement >= msgs.size()) return null;
                        return msgs[n - displacement];
                }
        };

}

#endif /* GUARD_DB_GROUP_HH */