NPLCommon.h

#pragma once
#include "util/mutex.h"
#include "NPLMemPool.h"
#include "NPLTypes.h"

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

using namespace std;

namespace NPL
{
    typedef std::basic_string<char, std::char_traits<char>, ParaEngine::CNPLPool_Char_alloc<> > NPLString;  

    struct NPLFileName
    {
        string sRuntimeStateName;
        string sNID;
        string sRelativePath;
        string sDNSServerName;

    public:
        NPLFileName();

        NPLFileName(const char * filename);

        void SetRelativePath(const char* sPath, int nCount=-1);

    public:
        string ToString();
        void ToString(string & output);

        void FromString(const char* filename);
    };

    struct NPLRuntimeAddress: 
        public boost::enable_shared_from_this<NPLRuntimeAddress>,
        private boost::noncopyable
    {
    public:
        NPLRuntimeAddress(const string& sHost, const string& sPort, const string& sNID)
            :m_sHost(sHost), m_sPort(sPort), m_sNID(sNID){};

        inline const std::string& GetHost() const {return m_sHost;} 
        inline const std::string& GetPort() const {return m_sPort;} 
        inline const std::string& GetNID() const {return m_sNID;}
        inline void SetNID(const char* nid) {m_sNID = nid;}
        inline void SetNID(const std::string& nid) {m_sNID = nid;}

    private:
        //
        // ip address and port are const, because NPL runtime address are immutable.
        //
        const std::string m_sHost;
        const std::string m_sPort;

        // nid may be changed during the course of authentication. 
        std::string m_sNID;
    };


    struct NPLAddress
    {
        string m_sAddress;
    public:
        NPLAddress(){m_sAddress = "";};
        NPLAddress(const char* sAddress){m_sAddress = sAddress;};

    public:
        bool IsLocal(){return m_sAddress.empty();}
        string GetIP(){return "";};
        string GetPort(){return "";};
        string ToString(){return m_sAddress;}
    };

    class UIReceivers
    {
    private:
        list <NPLAddress> m_listReceivers;
    public:
        UIReceivers(){m_listReceivers.clear();}

        bool empty(){return m_listReceivers.empty();};

        void AddReceiver(const char* sAddress){
            if(sAddress!=0)
                m_listReceivers.push_back(NPLAddress(sAddress));
        };
        void Cleanup(){
            m_listReceivers.clear();
        };
        string ToString(){
            string sReceivers = "";
            list<NPLAddress>::iterator itCurCP, itEndCP = m_listReceivers.end();
            for( itCurCP = m_listReceivers.begin(); itCurCP != itEndCP; ++ itCurCP){
                sReceivers += (*itCurCP).ToString() + ";";
            }
            return sReceivers;
        }
        void FromString(const char* sReceivers){
            int nTo=0;
            int nFrom = 0;
            while( sReceivers[nTo]!='\0'){
                if(sReceivers[nTo] == ';'){
                    string sAddress;
                    sAddress.assign(sReceivers+nFrom, nTo-nFrom);
                    AddReceiver(sAddress.c_str());
                    nFrom = nTo+1;
                }
                nTo++;
            }
        }
    };

    struct NPLTimer : public boost::enable_shared_from_this<NPLTimer>,
        private boost::noncopyable
    {
        const string m_nplFile;
        const string m_sCode;

    private:
        // interval in milliseconds
        DWORD  m_nInterval;
        // value returned from last activation call of ::timeGetTime()
        DWORD  m_lastTick;
        // mutex
        ParaEngine::mutex m_mutex;

    public:
        NPLTimer(const string& nplFile, const string& sCode, float fInterval);

        NPLTimer(const string& nplFile, const string& sCode, DWORD dwInterval);

    
        void Change(int dueTime, int period);

        bool Tick(NPLRuntimeState_ptr runtime_state, DWORD nTickCount = 0);
    };

    class NPLServerInfo : public boost::enable_shared_from_this<NPLServerInfo>
    {
    public:
        NPLServerInfo(const string& sNID, const string& sIP, const string& sPort, bool bTrusted=true)
            :m_sNID(sNID), m_sIP(sIP), m_sPort(sPort), m_bTrusted(bTrusted){};
        NPLServerInfo():m_bTrusted(true){};
    public:
        string m_sNID;
        string m_sIP;
        string m_sPort;

        bool m_bTrusted;
    };
}