chat.hpp

Go to the documentation of this file.

/* libobby - Network text editing library
 * Copyright (C) 2005 0x539 dev group
 *
 * This program 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 2 of the License, or (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#ifndef _OBBY_CHAT_HPP_
#define _OBBY_CHAT_HPP_

#include <ctime>
#include <list>
#include <sigc++/signal.h>
#include <sigc++/connection.h>
#include "user.hpp"
#include "user_table.hpp"
//#include "document_info.hpp"

namespace obby
{

class chat
{
public:
        class message: private net6::non_copyable
        {
        public:
                message(const std::string& text,
                        std::time_t timestamp);
                message(const serialise::object& obj,
                        const user_table& user_table);
                virtual ~message();

                virtual void serialise(serialise::object& obj) const;

                const std::string& get_text() const;
                std::time_t get_timestamp() const;

                std::string format_timestamp(const char* format) const;

                virtual std::string repr() const = 0;
        protected:
                std::string m_text;
                std::time_t m_timestamp;
        };

        class user_message: public message
        {
        public:
                user_message(const std::string& text,
                             std::time_t timestamp,
                             const user& from);
                user_message(const serialise::object& obj,
                             const user_table& user_table);

                virtual void serialise(serialise::object& obj) const;

                const user& get_user() const;
                virtual std::string repr() const;
        protected:
                const user& m_user;
        };

        class emote_message: public user_message
        {
        public:
                emote_message(const std::string& text,
                              std::time_t timestamp,
                              const user& from);
                emote_message(const serialise::object& obj,
                              const user_table& user_table);

                virtual std::string repr() const;
        };

        class server_message: public message
        {
        public:
                server_message(const std::string& text,
                               std::time_t timestamp);
                server_message(const serialise::object& obj,
                               const user_table& user_table);

                virtual std::string repr() const;
        };

        class system_message: public message
        {
        public:
                system_message(const std::string& text,
                               std::time_t timestamp);
                system_message(const serialise::object& obj,
                               const user_table& user_table);

                virtual std::string repr() const;
        };

        typedef ptr_iterator<
                message,
                std::list<message*>,
                std::list<message*>::const_iterator
        > message_iterator;

        typedef sigc::signal<void, const message&>
                signal_message_type;

        template<typename Buffer>
        chat(const Buffer& buffer, unsigned int max_messages);

        ~chat();

        void serialise(serialise::object& obj) const;

        void deserialise(const serialise::object& obj,
                         const user_table& user_table);

        void clear();

        void add_user_message(const std::string& text,
                              const user& from);

        void add_emote_message(const std::string& text,
                               const user& from);

        void add_server_message(const std::string& text);

        message_iterator message_begin() const;

        message_iterator message_end() const;

        signal_message_type message_event() const;
protected:
        void add_message(message* msg);

        void on_sync_init(unsigned int);
        void on_sync_final();

        void on_user_join(const user& user);
        void on_user_part(const user& user);

        template<typename DocumentInfo>
        void on_document_insert(DocumentInfo& document);

        template<typename DocumentInfo>
        void on_document_remove(DocumentInfo& document);

        unsigned int m_max_messages;
        std::list<message*> m_messages;

        signal_message_type m_signal_message;

        sigc::connection m_user_join_conn;
        sigc::connection m_user_part_conn;
        sigc::connection m_document_insert_conn;
        sigc::connection m_document_remove_conn;
};

template<typename Buffer>
chat::chat(const Buffer& buffer, unsigned int max_messages):
        m_max_messages(max_messages)
{
        typedef typename Buffer::document_info_type document_info_type;

        buffer.sync_init_event().connect(
                sigc::mem_fun(*this, &chat::on_sync_init) );
        buffer.sync_final_event().connect(
                sigc::mem_fun(*this, &chat::on_sync_final) );
        m_user_join_conn = buffer.user_join_event().connect(
                sigc::mem_fun(*this, &chat::on_user_join) );
        m_user_part_conn = buffer.user_part_event().connect(
                sigc::mem_fun(*this, &chat::on_user_part) );

        m_document_insert_conn = buffer.document_insert_event().connect(
                sigc::mem_fun(
                        *this,
                        &chat::on_document_insert<document_info_type>
                )
        );

        m_document_remove_conn = buffer.document_remove_event().connect(
                sigc::mem_fun(
                        *this,
                        &chat::on_document_remove<document_info_type>
                )
        );
}

template<typename DocumentInfo>
void chat::on_document_insert(DocumentInfo& document)
{
        const user* user = document.get_owner();
        std::string localised_str;

        // The document has no owner, it was created by the server.
        if(user != NULL)
        {
                obby::format_string str(
                        _("%0% has created a new document: %1%") );
                str << (*user).get_name() << document.get_title();
                localised_str = str.str();
        }
        else
        {
                obby::format_string str(_("A new document was created: %0%") );
                str << document.get_title();
                localised_str = str.str();
        }

        add_message(new system_message(localised_str, std::time(NULL)) );
}

template<typename DocumentInfo>
void chat::on_document_remove(DocumentInfo& document)
{
        obby::format_string str(_("Document %0% has been removed"));
        str << document.get_title();
        add_message(new system_message(str.str(), std::time(NULL)));
}

} // namespace obby

#endif // _OBBY_CHAT_HPP_

---