jupiter_server.hpp

Go to the documentation of this file.

/* libobby - Network text editing library
 * Copyright (C) 2005, 2006 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_JUPITER_SERVER_HPP_
#define _OBBY_JUPITER_SERVER_HPP_

#include <map>
#include <net6/non_copyable.hpp>
#include "operation.hpp"
#include "record.hpp"
#include "jupiter_algorithm.hpp"
#include "jupiter_undo.hpp"

namespace obby
{

template<typename Document>
class jupiter_server: private net6::non_copyable
{
public:
        typedef Document document_type;
        typedef jupiter_algorithm<document_type> algorithm_type;
        typedef jupiter_undo<document_type> undo_type;
        typedef operation<document_type> operation_type;
        typedef record<document_type> record_type;

        typedef sigc::signal<void, const record_type&, const user&, const user*>
                signal_record_type;

        jupiter_server(document_type& doc);
        ~jupiter_server();

        void client_add(const user& client);

        void client_remove(const user& client);

        void local_op(const operation_type& op, const user* from);

        void remote_op(const record_type& rec, const user* from);

        void undo_op(const user* from);

        signal_record_type record_event() const;
protected:
        typedef std::map<const user*, algorithm_type*> client_map;

        client_map m_clients;
        document_type& m_document;
        undo_type m_undo;

        signal_record_type m_signal_record;
};

template<typename Document>
jupiter_server<Document>::jupiter_server(document_type& doc):
        m_document(doc), m_undo(doc)
{
}

template<typename Document>
jupiter_server<Document>::~jupiter_server()
{
        for(typename client_map::iterator iter = m_clients.begin();
            iter != m_clients.end();
            ++ iter)
        {
                delete iter->second;
        }
}

template<typename Document>
void jupiter_server<Document>::client_add(const user& client)
{
        if(m_clients.find(&client) != m_clients.end() )
        {
                throw std::logic_error(
                        "obby::jupiter_server::client_add:\n"
                        "Client has already been added"
                );
        }

        m_clients[&client] = new algorithm_type;
}

template<typename Document>
void jupiter_server<Document>::client_remove(const user& client)
{
        typename client_map::iterator iter = m_clients.find(&client);
        if(iter == m_clients.end() )
        {
                throw std::logic_error(
                        "obby::jupiter_server::client_remove:\n"
                        "Client has not been added"
                );
        }

        delete iter->second;
        m_clients.erase(iter);
}

template<typename Document>
void jupiter_server<Document>::local_op(const operation_type& op,
                                        const user* from)
{
        op.apply(m_document, from);
        m_undo.local_op(op, from);

        for(typename client_map::iterator iter = m_clients.begin();
            iter != m_clients.end();
            ++ iter)
        {
                std::auto_ptr<record_type> rec = iter->second->local_op(op);
                m_signal_record.emit(*rec, *iter->first, from);
        }
}

template<typename Document>
void jupiter_server<Document>::remote_op(const record_type& rec,
                                         const user* from)
{
        typename client_map::iterator iter = m_clients.find(from);
        if(iter == m_clients.end() )
        {
                throw std::logic_error(
                        "obby::jupiter_server::remote_op:\n"
                        "Client has not been added"
                );
        }

        std::auto_ptr<operation_type> op = iter->second->remote_op(rec);
        op->apply(m_document, from);
        m_undo.remote_op(*op, from);

        for(iter = m_clients.begin(); iter != m_clients.end(); ++ iter)
        {
                if(iter->first != from)
                {
                        std::auto_ptr<record_type> rec =
                                iter->second->local_op(*op);

                        m_signal_record.emit(*rec, *iter->first, from);
                }
        }
}

template<typename Document>
void jupiter_server<Document>::undo_op(const user* from)
{
        std::auto_ptr<operation_type> op = m_undo.undo();
        op->apply(m_document, from);

        for(typename client_map::iterator iter = m_clients.begin();
            iter != m_clients.end();
            ++ iter)
        {
                std::auto_ptr<record_type> rec = iter->second->local_op(*op);
                m_signal_record.emit(*rec, *iter->first, from);
        }
}

template<typename Document>
typename jupiter_server<Document>::signal_record_type
jupiter_server<Document>::record_event() const
{
        return m_signal_record;
}

} // namespace obby

#endif // _OBBY_JUPITER_SERVER_HPP_

---