NPLRuntimeState.h

#pragma once
#include "NPLMessageQueue.h"
#include "NPLScriptingState.h"
#include "NPLCommon.h"
#include "NeuronFileState.h"
#include "INPLRuntimeState.h"
#include "INPLScriptingState.h"
#include "IAttributeFields.h"
#include "util/mutex.h"
#include "util/unordered_array.hpp"
#include <set>

#include <boost/thread.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>


namespace ParaEngine
{
    struct DLLPlugInEntity;
}
namespace NPL
{
    using namespace std;
    class INPLActivationFile;
    class CNeuronFileState;


    class CNPLRuntimeState : 
        public ParaEngine::IAttributeFields,
        public INPLRuntimeState,
        public ParaScripting::CNPLScriptingState,
        public boost::enable_shared_from_this<CNPLRuntimeState>,
        private boost::noncopyable
    {
    public:
        typedef std::map<int,NPLTimer_ptr> NPLTimer_Pool_Type;
        typedef boost::signals2::signal<void(CNPLRuntimeState* pRuntimeState)>  Signal_StateLoaded_t;

        CNPLRuntimeState(const string & name, NPLRuntimeStateType type_ = NPLRuntimeStateType_NPL);
        virtual ~CNPLRuntimeState();

        ATTRIBUTE_DEFINE_CLASS(CNPLRuntimeState);

        virtual int InstallFields(ParaEngine::CAttributeClass* pClass, bool bOverride);

        ATTRIBUTE_METHOD1(CNPLRuntimeState, GetProcessedMsgCount_s, int*)       { *p1 = cls->GetProcessedMsgCount(); return S_OK; }
        ATTRIBUTE_METHOD1(CNPLRuntimeState, GetCurrentQueueSize_s, int*)        { *p1 = cls->GetCurrentQueueSize(); return S_OK; }
        ATTRIBUTE_METHOD1(CNPLRuntimeState, GetTimerCount_s, int*)      { *p1 = cls->GetTimerCount(); return S_OK; }
        ATTRIBUTE_METHOD1(CNPLRuntimeState, SetMsgQueueSize_s, int)     { cls->SetMsgQueueSize(p1); return S_OK; }
        ATTRIBUTE_METHOD1(CNPLRuntimeState, GetMsgQueueSize_s, int*)        { *p1 = cls->GetMsgQueueSize(); return S_OK; }
        ATTRIBUTE_METHOD1(CNPLRuntimeState, HasDebugHook_s, bool*) { *p1 = cls->HasDebugHook(); return S_OK; }
        ATTRIBUTE_METHOD1(CNPLRuntimeState, IsPreemptive_s, bool*) { *p1 = cls->IsPreemptive(); return S_OK; }
        ATTRIBUTE_METHOD1(CNPLRuntimeState, PauseAllPreemptiveFunction_s, bool) { cls->PauseAllPreemptiveFunction(p1); return S_OK; }
        ATTRIBUTE_METHOD1(CNPLRuntimeState, IsAllPreemptiveFunctionPaused_s, bool*) { *p1 = cls->IsAllPreemptiveFunctionPaused(); return S_OK; }
        ATTRIBUTE_METHOD1(CNPLRuntimeState, GetFileName_s, const char**) { *p1 = cls->GetCurrentFileName(); return S_OK; }

        void Init();

        void Reset_Imp();

        void Reset(const char* onResetScode = NULL);

        
        int Run_Async();

        int Run();

        int Process();

        virtual const string& GetName() const {return m_name;}

        int Stop();

        int Stop_Async();

        int GetCurrentQueueSize();

        int GetProcessedMsgCount();

        int GetMsgQueueSize();

        void SetMsgQueueSize(int nSize = 500);


        void WaitForMessage(int nMessageCount = -1);

        NPLMessage_ptr PeekMessage(int nIndex);
        
        NPLMessage_ptr PopMessageAt(int nIndex);
                
    public:
        virtual const std::string& GetIdentifier();

        virtual int activate(const char * sNPLFilename, const char* sCode, int nCodeLength=0, int priority=2, int reliability=4);

        template <typename StringType>
        bool LoadFile_any(const StringType & filepath, bool bReload = false, lua_State* L = 0, bool bNoReturn = false);
        template <typename StringType>
        NPLReturnCode ActivateFile_any(const StringType& filepath, const char * code = NULL, int nLength=0);

        virtual NPLReturnCode Activate_async(const string & filepath, const char * code = NULL,int nLength=0, int priority=0);
        virtual NPLReturnCode Loadfile_async(const string & filepath, int priority = 0);

        virtual NPLReturnCode Activate_async(NPLMessage_ptr& msg, int priority=0);
        
        virtual NPLReturnCode ActivateLocal(const char* filepath, const char * code = NULL,int nLength=0, int priority=0);

        virtual NPLReturnCode SendMessage(NPLMessage_ptr& msg, int priority=0);


        virtual const char* GetCurrentMsg();

        virtual int GetCurrentMsgLength();
        
        virtual INPLRuntime* GetNPLRuntime();

        virtual void WriteLog(const char* text, int nTextLen=0, int nLogType = 0);

        //
        // Timer functions
        //

        int GetTimerCount();

        virtual bool SetTimer(int nIDEvent, float fElapse, const char* sNeuronFile);

        virtual bool KillTimer(int nIDEvent);

        virtual bool ChangeTimer(int nIDEvent, int dueTime, int period);

        virtual INPLRuntimeState* GetNPLStateInterface() {return this;}

        virtual void RegisterFile(const char* sFilename, INPLActivationFile* pFileHandler = NULL);

        virtual void call(const char * sNPLFilename, const char* sCode, int nCodeLength = 0);;

        std::string& GetStringBuffer(int nIndex = 0);


        Signal_StateLoaded_t StateLoaded;

        int ProcessMsg(NPLMessage_ptr msg);

        int SendTick();

        CNeuronFileState* GetNeuronFileState(const std::string& filename, bool bCreateIfNotExist = true);

        bool HasDebugHook();

        bool IsPreemptive();
    
        bool IsAllPreemptiveFunctionPaused() const;
        void PauseAllPreemptiveFunction(bool val);

    protected:

        void LoadNPLState();

        int TickTimers(DWORD nTickCount);

        int FrameMoveTick();

        class CCurrentMessage
        {
        public:
            CCurrentMessage(CNPLRuntimeState* pState, const char* msg, int nLength):m_pState(pState){
                if(m_pState)
                    m_pState->SetCurrentMessage(msg,nLength);
            }
            ~CCurrentMessage(){
                if(m_pState)
                    m_pState->SetCurrentMessage(NULL, 0);
            }
            CNPLRuntimeState* m_pState;
        };
        void SetCurrentMessage(const char* msg=NULL, int nLength = 0);

        IMonoScriptingState* GetMonoState();
        
        void SetPreemptive(bool val);
    private:
        typedef map<std::string, ParaEngine::DLLPlugInEntity*>  DLL_Plugin_Map_Type;
        typedef std::vector<NPLTimer_ptr> NPLTimer_TempPool_Type;
        DLL_Plugin_Map_Type m_dll_plugins_map;

        const string m_name;
        
        NPLTimer_Pool_Type m_activeTimers;

        NPLTimer_TempPool_Type m_temp_timer_pool;

        const NPLRuntimeStateType m_type;

        CNPLMessageQueue m_input_queue;

        boost::shared_ptr<boost::thread> m_thread;

        ParaEngine::mutex m_mutex;

        boost::condition_variable m_semaphore;

        bool m_bUseMessageEvent;

        bool m_bIsProcessing;

        bool m_bIsPreemptive;

        bool m_bPauseAllPreemptiveFunction;

        const char* m_current_msg;

        int m_current_msg_length;

        int m_processed_msg_count;

        int m_nFrameMoveCount;
        IMonoScriptingState* m_pMonoScriptingState;

        std::vector <std::string> m_string_buffers;

        std::map<std::string, INPLActivationFile*> m_act_files_cpp;

        std::map<std::string, CNeuronFileState*> m_neuron_files;
        ParaEngine::unordered_array<CNeuronFileState*> m_active_neuron_files;

        friend class CNPLRuntime;
    };

    struct NPLRuntimeState_PtrOps
    {
        bool operator()( const NPLRuntimeState_ptr & a, const NPLRuntimeState_ptr & b ) const
        { return a.get() < b.get(); }
    };
}