ParaScriptingNPL.h

//-----------------------------------------------------------------------------
// Copyright (C) 2004 - 2006 ParaEngine Dev Studio, All Rights Reserved.
// Date:    2004.5
// Description: API for NPL. 
//-----------------------------------------------------------------------------
#pragma once
#include <boost/shared_ptr.hpp>
#include "ParaScriptingGlobal.h"


namespace luabind
{
    namespace adl {
        class object;
    }
    using adl::object;
}

struct lua_State;

namespace ParaScripting
{
    using namespace luabind;
    using namespace std;

    class ParaNPLRuntimeState
    {
    public:
        ParaNPLRuntimeState();
        ParaNPLRuntimeState(NPL::CNPLRuntimeState* rts_);
        ParaNPLRuntimeState(NPL::NPLRuntimeState_ptr rts_);
        ~ParaNPLRuntimeState();

        NPL::CNPLRuntimeState* m_rts;

        bool IsValid();

        const char* GetName() const;

        object GetField(const char*  sFieldname, const object& output);
        void SetField(const char*  sFieldname, const object& input);

        int Start();

        bool Stop();

        void Reset();
        void Reset1(const char* onResetScode);

        object GetStats(const object& input);

        int GetCurrentQueueSize();

        int GetProcessedMsgCount();

        int GetMsgQueueSize();

        void SetMsgQueueSize(int nSize = 500);

        void WaitForMessage();

        void WaitForMessage2(int nMessageCount);

        object PeekMessage(int nIndex, const object& inout);

        object PopMessageAt(int nIndex, const object& inout);
    };

    class PE_CORE_DECL CNPL
    {
    public:
        static int activate(const object& sNPLFilename, const object& sCode);
        static int activate1(const object& sNPLFilename);
        static int activate3(const object& sNPLFilename, const object& sCode, int channel);
        static int activate5(const object& sNPLFilename, const object& sCode, int channel, int priority, int reliability);
        static int activate2_(const char * sNPLFilename, const char* sCode);
        static int activate_(const char * sNPLFilename, const char* sCode, int channel, int priority, int reliability);

        static void call(const object& sNPLFilename, const object& sCode);
        static void call_(const char * sNPLFilename, const char* sCode);

        static void this_(const object& funcActivate);
        static void this2_(const object& funcActivate, const object& params);

        static ParaAttributeObject GetAttributeObject();

        
        static void load(const object& filePath, bool bReload);
        static void load_(const char* filePath, bool bReload);
        static void load1(const object& filePath);

        static int export_(lua_State* L);
        static const char* GetFileName(lua_State* L = 0);
        
        static void DoString(const object& sCode);

        static void DoString2(const object& sCode, const char* sFilename);

        static void DoString_(const char* sCode);

        static void test(const object& input);

        static bool SetTimer(const object& nIDEvent, float fElapse, const object& sNeuronFile);

        static bool KillTimer(const object& nIDEvent);

        static bool ChangeTimer(const object& nIDEvent, int dueTime, int period);

        static const string& SerializeToSCode(const char* sStorageVar, const object& input);
        static const string& SerializeToSCode2(const char* sStorageVar, const object& input, bool sort);

        static bool IsSCodePureData(const char* sCode);

        static bool IsPureData(const char* sCode);

        static bool IsPureTable(const char* sCode);

        static luabind::object LoadTableFromString(const object& input);
        static luabind::object LoadObjectFromString(const object& input);


        static void StartNetServer(const object& server, const object& port);

        static void StopNetServer();

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

        static void RegisterEvent(int nType, const char* sID, const char* sScript);

        static void UnregisterEvent(int nType, const char* sID);

        static object GetStats(const object& inout);

        static void ClearPublicFiles();

        static bool AddNPLRuntimeAddress(const object& npl_address);

        static string GetIP(const char* nid);

        static void accept(const object& tid, const object& nid);

        static void accept_(const char* tid, const char* nid);

        static void SetProtocol(const char* nid, int protocolType);
        

        static void reject(const object& nid);

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

        static void SetUseCompression(bool bCompressIncoming, bool bCompressOutgoing);
    
        static void SetCompressionKey(const object& input);

        //
        // old network implementations. functions in this categories are obsoleted at the moment. 
        //

        static const char* GetSourceName();
        static void SetSourceName(const char* sName);

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

        static void AddDNSRecord(const char * sDNSName, const char* sAddress);

        static void SetDefaultChannel(int channel_ID);

        static int GetDefaultChannel();

        static void SetChannelProperty(int channel_ID, int priority, int reliability);

        static void ResetChannelProperties();

        static void GetChannelProperty(int channel_ID, int* priority, int* reliability);

        static void RegisterWSCallBack(const char * sWebServiceFile, const char * sCode);
        static void UnregisterWSCallBack(const char * sWebServiceFile);

        //
        // downloader functions
        //

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

        static void CancelDownload(const char* DownloaderName);

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

        //
        // neuron file function
        //




        static ParaNPLRuntimeState CreateRuntimeState(const string& name, int type_);

        static ParaNPLRuntimeState GetRuntimeState(const string& name);

        static ParaNPLRuntimeState CreateGetRuntimeState(const string& name, int type_);

        static bool DeleteRuntimeState(ParaNPLRuntimeState runtime_state);

        static void Compile(const char* arguments);

        //
        // new libcUrl interface. 
        //

        //static bool AppendURLRequest(CURLRequestTask* pUrlTask, const char* sPoolName);

        static bool AppendURLRequest1(const object& url, const char* sCallback, const object& sForm, const char* sPoolName);

        static string EncodeURLQuery(const char * baseUrl, const object& sParams);

        static std::string GetExternalIP();

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

        static bool FromJson(const char* sJson, const object& output);

        static const string& ToJson(const object& output);
        static const string& ToJson2(const object& output, bool bUseEmptyArray);

        static bool Compress(const object& output);

        static bool Decompress(const object& output);
    };
}