NPLDispatcher.h

#pragma once

#include <boost/bimap.hpp>
#include <boost/thread/shared_mutex.hpp>
#include <string>

#include "NPLCommon.h"
#include "NPLMessageQueue.h"
#include "NPLConnection.h"
#include "NPLRuntimeState.h"
#include "util/mutex.h"

namespace NPL
{
    class CNPLDispatcher
    {
    public:
        CNPLDispatcher(CNPLNetServer* server);
        ~CNPLDispatcher();

        CNPLNetServer* GetNetServer() { return m_pServer; }

        void Cleanup();

        NPLConnection_ptr CreateGetNPLConnectionByNID(const string& sNID);

        NPLConnection_ptr GetNPLConnectionByNID(const string& sNID);

        void AddNPLConnection(const string& sNID, NPLConnection_ptr pConnection);

        bool RemoveNPLConnection(NPLConnection_ptr pConnection);

        void NPL_accept(const char* tid, const char* nid = NULL);

        void NPL_SetProtocol(const char* nid, CNPLConnection::ProtocolType protocolType = CNPLConnection::ProtocolType::NPL);

        void RenameConnection(NPLConnection_ptr pConnection, const char* sNid);

        NPLReturnCode Activate_Async(const NPLFileName& file_name, const char * code = NULL, int nLength=0, int priority=0);

        NPLReturnCode DispatchMsg(NPLMsgIn& msg);
        

        bool AddNPLRuntimeAddress(NPLRuntimeAddress_ptr pAddress);

        NPLRuntimeAddress_ptr GetNPLRuntimeAddress(const string& sNID);


        void AddPublicFile(const string& filename, int nID);

        void ClearPublicFiles();

        bool GetPubFileNameByID(string& filename, int nID);

        bool CheckPubFile(string& filename, int& nID);

        int GetIDByPubFileName(const string& sString);

        int PostNetworkEvent(NPLReturnCode nNPLNetworkCode, const char * sNid=NULL, const char* sMsg=NULL);

        void SetUseCompressionIncomingConnection(bool bCompressIncoming);
        bool IsUseCompressionIncomingConnection();

        void SetUseCompressionOutgoingConnection(bool bCompressOutgoing);
        bool IsUseCompressionOutgoingConnection();

        void SetCompressionLevel(int nLevel);
        int GetCompressionLevel();


        void SetCompressionThreshold(int nThreshold);
        int GetCompressionThreshold();

    protected:
        NPLConnection_ptr CreateConnection(NPLRuntimeAddress_ptr pAddress);

        void RenameConnectionImp(NPLConnection_ptr pConnection, const char* sNid);

    protected:
        typedef std::map<string, NPLConnection_ptr> ActiveConnectionMap_Type;
        typedef std::map<string, NPLRuntimeAddress_ptr> ServerAddressMap_Type;
        typedef boost::bimap<int, std::string>  StringBimap_Type;
        
        ActiveConnectionMap_Type m_active_connection_map;

        ActiveConnectionMap_Type m_pending_connection_map;

        ServerAddressMap_Type m_server_address_map;

        ParaEngine::mutex m_mutex;
        
        bool m_bUseCompressionIncomingConnection;

        bool m_bUseCompressionOutgoingConnection;

        int m_nCompressionLevel;

        int m_nCompressionThreshold;

        StringBimap_Type m_public_filemap;

        CNPLNetServer* m_pServer;
    };
}