protocol_manager.hpp

Go to the documentation of this file.

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2013-2015 SuperTuxKart-Team
//
//  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 3
//  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
#ifndef PROTOCOL_MANAGER_HPP
#define PROTOCOL_MANAGER_HPP
 
#include "network/network_string.hpp"
#include "network/protocol.hpp"
#include "utils/no_copy.hpp"
#include "utils/singleton.hpp"
#include "utils/stk_process.hpp"
#include "utils/synchronised.hpp"
#include "utils/types.hpp"
 
#include <array>
#include <atomic>
#include <condition_variable>
#include <list>
#include <memory>
#include <mutex>
#include <vector>
#include <thread>
 
class Event;
class STKPeer;
 
// ============================================================================
class ProtocolManager : public NoCopy
{
private:
 
    class OneProtocolType
    {
    private:
        std::vector<std::shared_ptr<Protocol> > m_protocols;
    public:
        void removeProtocol(std::shared_ptr<Protocol> p);
        bool notifyEvent(Event *event);
        void update(int ticks, bool async);
        void abort();
        // --------------------------------------------------------------------
        std::shared_ptr<Protocol> getFirstProtocol() { return m_protocols[0]; }
        // --------------------------------------------------------------------
        bool handleConnects() const
        {
            return !m_protocols.empty() &&
                    m_protocols[0]->handleConnects();
        }   // handleConnects
        // --------------------------------------------------------------------
        bool handleDisconnects() const
        {
            return !m_protocols.empty() &&
                m_protocols[0]->handleDisconnects();
        }   // handleDisconnects
        // --------------------------------------------------------------------
        void addProtocol(std::shared_ptr<Protocol> p);
        // --------------------------------------------------------------------
        bool isEmpty() const { return m_protocols.empty(); }
        // --------------------------------------------------------------------
 
    };   // class OneProtocolType
 
    // ------------------------------------------------------------------------
    
    std::array<OneProtocolType, PROTOCOL_MAX> m_all_protocols;
 
    typedef std::list<Event*> EventList;
 
    Synchronised<EventList> m_sync_events_to_process;
 
    Synchronised<EventList> m_async_events_to_process;
 
    std::atomic_bool m_exit;
 
    std::thread m_asynchronous_update_thread;
 
    std::thread m_game_protocol_thread;
 
    std::condition_variable m_game_protocol_cv;
 
    std::mutex m_game_protocol_mutex, m_protocols_mutex;
 
    EventList m_controller_events_list;
 
    static std::weak_ptr<ProtocolManager> m_protocol_manager[PT_COUNT];
 
    bool sendEvent(Event* event,
                   std::array<OneProtocolType, PROTOCOL_MAX>& protocols);
 
    void asynchronousUpdate();
 
public:
    // ===========================================
    // Public constructor is required for shared_ptr
              ProtocolManager();
             ~ProtocolManager();
    void      abort();
    void      propagateEvent(Event* event);
    std::shared_ptr<Protocol> getProtocol(ProtocolType type);
    void      requestStart(std::shared_ptr<Protocol> protocol);
    void      requestTerminate(std::shared_ptr<Protocol> protocol);
    void      findAndTerminate(ProtocolType type);
    void      update(int ticks);
    // ------------------------------------------------------------------------
    bool isExiting() const                            { return m_exit.load(); }
    // ------------------------------------------------------------------------
    const std::thread& getThread() const
    {
        return m_asynchronous_update_thread; 
    }   // getThreadID
    // ------------------------------------------------------------------------
    static std::shared_ptr<ProtocolManager> createInstance();
    // ------------------------------------------------------------------------
    static bool emptyInstance()
    {
        return m_protocol_manager[STKProcess::getType()].expired();
    }   // emptyInstance
    // ------------------------------------------------------------------------
    static std::shared_ptr<ProtocolManager> lock()
    {
        return m_protocol_manager[STKProcess::getType()].lock();
    }   // lock
 
};   // class ProtocolManager
 
#endif // PROTOCOL_MANAGER_HPP