NPLRuntime.h

#pragma once
#include <set>
struct lua_State;

// include NPLScriptingState
#include "ParaScripting.h"
#include "NPLRuntimeState.h"
#include "INPLRuntime.h"
/* internal data structure used by NPL runtime */
#include "NPLCommon.h"
#include "IAttributeFields.h"

#include <boost/scoped_ptr.hpp>
#include <boost/thread/shared_mutex.hpp>

namespace ParaEngine
{
    class INPLWebServiceClient;
    class INPLJabberClient;
    class CNPLNetClient;
    class CURLRequestTask;
}

namespace NPL
{
    class CNPLNetServer;
    using namespace ParaScripting;
    class INPLStimulationPipe;
    class CNPLNameSpaceBinding;
    struct NPLPacket;


    struct ChannelProperty
    {
    public:
        int m_nPriority;
        int m_nReliability;
        ChannelProperty():m_nPriority(2),m_nReliability(3){};
        ChannelProperty(int nPriority, int nReliability):m_nPriority(nPriority),m_nReliability(nReliability){};

    public:
        void Set(int nPriority, int nReliability)
        {
            m_nPriority = nPriority;
            m_nReliability = nReliability;
        };
    };

    class CNPLRuntime : public ParaEngine::IAttributeFields, public INPLRuntime
    {
    public:
        CNPLRuntime();
        virtual ~CNPLRuntime(void);

        static CNPLRuntime* GetInstance();
        static void SetDefaultNPLStateType(NPL::NPLRuntimeStateType val);

        virtual void Init();

        virtual void Run(bool bToEnd = true);

        virtual void Cleanup();

        // implementation of IAttributeFields

        virtual int GetAttributeClassID(){return ParaEngine::ATTRIBUTE_CLASSID_CNPLRuntime;}
        virtual const char* GetAttributeClassName(){static const char name[] = "CNPLRuntime"; return name;}
        virtual const char* GetAttributeClassDescription(){static const char desc[] = ""; return desc;}
        virtual int InstallFields(ParaEngine::CAttributeClass* pClass, bool bOverride);
        virtual int GetChildAttributeObjectCount(int nColumnIndex = 0);
        virtual ParaEngine::IAttributeFields* GetChildAttributeObject(int nRowIndex, int nColumnIndex = 0);

        ATTRIBUTE_METHOD1(CNPLRuntime, IsServerStarted_s, bool*) { *p1 = cls->IsServerStarted(); return S_OK; }
        ATTRIBUTE_METHOD1(CNPLRuntime, GetHostIP_s, const char**) { *p1 = cls->GetHostIP().c_str(); return S_OK; }
        ATTRIBUTE_METHOD1(CNPLRuntime, GetHostPort_s, const char**) { *p1 = cls->GetHostPort().c_str(); return S_OK; }

        ATTRIBUTE_METHOD1(CNPLRuntime, IsTCPKeepAliveEnabled_s, bool*)  {*p1 = cls->IsTCPKeepAliveEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(CNPLRuntime, SetTCPKeepAlive_s, bool) {cls->SetTCPKeepAlive(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CNPLRuntime, IsKeepAliveEnabled_s, bool*) {*p1 = cls->IsKeepAliveEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(CNPLRuntime, SetKeepAlive_s, bool)    {cls->SetKeepAlive(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CNPLRuntime, IsIdleTimeoutEnabled_s, bool*)   {*p1 = cls->IsIdleTimeoutEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(CNPLRuntime, EnableIdleTimeout_s, bool)   {cls->EnableIdleTimeout(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CNPLRuntime, GetIdleTimeoutPeriod_s, int*)    {*p1 = cls->GetIdleTimeoutPeriod(); return S_OK;}
        ATTRIBUTE_METHOD1(CNPLRuntime, SetIdleTimeoutPeriod_s, int) {cls->SetIdleTimeoutPeriod(p1); return S_OK;}
        
        ATTRIBUTE_METHOD1(CNPLRuntime, GetCompressionLevel_s, int*) {*p1 = cls->GetCompressionLevel(); return S_OK;}
        ATTRIBUTE_METHOD1(CNPLRuntime, SetCompressionLevel_s, int)  {cls->SetCompressionLevel(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CNPLRuntime, GetCompressionThreshold_s, int*) {*p1 = cls->GetCompressionThreshold(); return S_OK;}
        ATTRIBUTE_METHOD1(CNPLRuntime, SetCompressionThreshold_s, int)  {cls->SetCompressionThreshold(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CNPLRuntime, IsAnsiMode_s, bool*) {*p1 = cls->IsAnsiMode(); return S_OK;}
        ATTRIBUTE_METHOD1(CNPLRuntime, EnableAnsiMode_s, bool)  {cls->EnableAnsiMode(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CNPLRuntime, GetMaxPendingConnections_s, int*)    { *p1 = cls->GetMaxPendingConnections(); return S_OK; }
        ATTRIBUTE_METHOD1(CNPLRuntime, SetMaxPendingConnections_s, int) { cls->SetMaxPendingConnections(p1); return S_OK; }
            
        ATTRIBUTE_METHOD1(CNPLRuntime, GetLogLevel_s, int*) { *p1 = cls->GetLogLevel(); return S_OK; }
        ATTRIBUTE_METHOD1(CNPLRuntime, SetLogLevel_s, int) { cls->SetLogLevel(p1); return S_OK; }
        
    public:
        virtual void SetUseCompression(bool bCompressIncoming, bool bCompressOutgoing);

        virtual void SetCompressionKey(const byte* sKey=0, int nSize=0, int nUsePlainTextEncoding = 0);

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

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

        virtual void SetTCPKeepAlive(bool bEnable);

        virtual bool IsTCPKeepAliveEnabled();

        virtual void SetKeepAlive(bool bEnable);
        virtual bool IsKeepAliveEnabled();

        virtual void EnableIdleTimeout(bool bEnable);
        virtual bool IsIdleTimeoutEnabled();

        virtual void SetIdleTimeoutPeriod(int nMilliseconds);
        virtual int GetIdleTimeoutPeriod();

        virtual void EnableAnsiMode(bool bEnable);
        virtual bool IsAnsiMode();

        virtual int GetMaxPendingConnections();
        virtual void SetMaxPendingConnections(int val);


        virtual const std::string& GetHostPort();
        virtual const std::string& GetHostIP();
        virtual bool IsServerStarted();
        

        //
        // NPL core functions
        //
        
        void NPL_LoadFile(NPLRuntimeState_ptr runtime_state, const char* filePath, bool bReload);

        int NPL_Activate(NPLRuntimeState_ptr runtime_state, const char * sNeuronFile, const char * code = NULL,int nLength=0,  int channel=0, int priority=2, int reliability=3);

        virtual int Activate(INPLRuntimeState* pRuntimeState, const char * sNeuronFile, const char * code = NULL,int nLength=0,  int channel=0, int priority=2, int reliability=3);
        
        virtual int ActivateLocalNow(const char * sNeuronFile, const char * code = NULL, int nLength = 0);

        //
        // NPL Net Server functions
        //

        void NPL_StartNetServer(const char* server=NULL, const char* port=NULL);

        void NPL_StopNetServer();

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

        void NPL_ClearPublicFiles();

        string NPL_GetIP(const char* nid);


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

        void NPL_SetProtocol(const char* nid, int protocolType = 0);

        void NPL_reject(const char* nid, int nReason = 0);

        virtual void StartNetServer(const char* server=NULL, const char* port=NULL);
        virtual void StopNetServer();
        virtual void AddPublicFile(const string& filename, int nID);
        virtual void ClearPublicFiles();
        virtual void GetIP(const char* nid, char* pOutput);
        virtual void accept(const char* tid, const char* nid = NULL);
        virtual void reject(const char* nid, int nReason = 0);

        //
        // jabber client functions
        //

        virtual ParaEngine::INPLJabberClient* GetJabberClient(const char* sJID);
        virtual ParaEngine::INPLJabberClient* CreateJabberClient(const char* sJID);

        virtual bool CloseJabberClient(const char* sJID);

        //
        // new libcUrl interface. 
        //

        virtual bool AppendURLRequest(ParaEngine::CURLRequestTask* pUrlTask, const char* sPoolName = NULL);

        virtual bool ChangeRequestPoolSize(const char* sPoolName, int nCount);


        //
        // Downloader functions
        //

        virtual void AsyncDownload(const char* url, const char* destFolder, const char* callbackScript, const char* DownloaderName);


        virtual void CancelDownload(const char* DownloaderName);

        virtual int Download(const char* url, const char* destFolder, const char* callbackScript, const char* DownloaderName);


        //
        // Web Service functions
        //

        void NPL_RegisterWSCallBack(const char * sWebServiceFile, const char * sCode);
        void NPL_UnregisterWSCallBack(const char * sWebServiceFile);

        //
        // Timer functions
        //

        bool NPL_SetTimer(NPLRuntimeState_ptr runtime_state, int nIDEvent, float fElapse, const char* sNeuronFile);

        bool NPL_KillTimer(NPLRuntimeState_ptr runtime_state,int nIDEvent);

        bool NPL_ChangeTimer(NPLRuntimeState_ptr runtime_state,int nIDEvent, int dueTime, int period);

        //
        // UDP networking functions (RakNet in NPL network layer, currently obsoleted)
        //

        static INPLStimulationPipe* GetNetworkLayerPipe();

        virtual void NPL_AddDNSRecord(const char * sDNSName, const char* sAddress);
        
        virtual void NPL_SetDefaultChannel(int channel_ID);
        virtual int NPL_GetDefaultChannel();

        virtual void NPL_SetChannelProperty(int channel_ID, int priority, int reliability);
        virtual void NPL_ResetChannelProperties();

        virtual void NPL_GetChannelProperty(int channel_ID, int* priority, int* reliability);

        void NPL_EnableNetwork(bool bEnable, const char* CenterName, const char* password);

        const string& NPL_GetSourceName();
        void NPL_SetSourceName(const char* sName);

        /* default to 1, set to 0 to silence some connection verbose log. */
        int GetLogLevel() const;

        /* default to 1, set to 0 to silence some connection verbose log. */
        void SetLogLevel(int val);

    private: // methods
        bool LoadWebServicePlugin();

        void STI_DoWebServiceFile(const char* sWebserviceFile, const char * code);

        int TranslatePriorityValue(int priority);
    public:
        virtual INPLRuntimeState* CreateState(const char* name, NPLRuntimeStateType type_=NPLRuntimeStateType_NPL);
        virtual INPLRuntimeState* GetState(const char* name);
        virtual INPLRuntimeState* CreateGetState(const char* name, NPLRuntimeStateType type_=NPLRuntimeStateType_NPL);
        virtual bool DeleteState(INPLRuntimeState* pRuntime_state);
        virtual INPLRuntimeState* GetMainState();
        virtual bool AddToMainThread(INPLRuntimeState* runtime_state);

        NPLRuntimeState_ptr CreateRuntimeState(const string& name, NPLRuntimeStateType type_=NPLRuntimeStateType_NPL);

        NPLRuntimeState_ptr GetRuntimeState(const string& name);

        NPLRuntimeState_ptr CreateGetRuntimeState(const string& name, NPLRuntimeStateType type_=NPLRuntimeStateType_NPL);

        bool DeleteRuntimeState(NPLRuntimeState_ptr runtime_state);

        NPLRuntimeState_ptr GetMainRuntimeState();

        bool AddStateToMainThread(NPLRuntimeState_ptr runtime_state);

        bool RemoveStateFromMainThread(NPLRuntimeState_ptr runtime_state);

        CNPLNetServer* GetNetServer() {return m_net_server.get();};

        ParaEngine::CNPLNetClient* GetNetClient();

        void SetHostMainStatesInFrameMove(bool bHostMainStatesInFrameMove);
        
    private: 
        stack <string> m_stackDNS;

        INPLStimulationPipe* m_pNetPipe;
        CNPLNameSpaceBinding* m_pNPLNamespaceBinding;

        int m_nDefaultChannel;
        std::vector<ChannelProperty> m_channelProperties;

        std::map <string, string> m_mapWebServiceCallBacks;

        ParaEngine::INPLWebServiceClient* m_pWebServiceClient;

        bool m_bHostMainStatesInFrameMove;

        /* default to 1, set to 0 to silence some connection verbose log. */
        int m_nLogLevel;
    private:
        typedef std::set<NPLRuntimeState_ptr, NPLRuntimeState_PtrOps>   NPLRuntime_Pool_Type;
        typedef std::vector<NPLRuntimeState_ptr>    NPLRuntime_Temp_Pool_Type;
        typedef std::map<std::string, NPLRuntimeState_ptr> ActiveStateMap_Type;

        boost::scoped_ptr<CNPLNetServer> m_net_server;
        
        NPLRuntime_Pool_Type m_runtime_states;

        NPLRuntime_Pool_Type m_runtime_states_with_timers;

        ActiveStateMap_Type m_active_state_map;

        NPLRuntime_Pool_Type m_runtime_states_main_threaded;
        NPLRuntime_Temp_Pool_Type m_temp_rts_pool;
        
        NPLRuntimeState_ptr m_runtime_state_main;

        ParaEngine::mutex m_mutex;

        static NPLRuntimeStateType m_defaultNPLStateType;
    };

}