C:/Active/libraries/cxutils/2.0/include/cxutils/ipc/messageclient.h

Go to the documentation of this file.

#ifndef _CXUTILS_MAPPED_MESSAGE_CLIENT__H
#define _CXUTILS_MAPPED_MESSAGE_CLIENT__H

#include "cxutils/ipc/mappedmessagebox.h"
#include "cxutils/ipc/messageserver.h"
#include <set>
#include <vector>

namespace CxUtils
{
    class CX_UTILS_DLL MessageClient
    {
    public:
        typedef MappedMemory::ID ID;                 
        static const ID AnyID = 0;                   

        class CX_UTILS_DLL Callback
        {
        public:
            class CX_UTILS_DLL Function
            {
            public:
                Function();
                Function(void (*callback)(Packet& packet, 
                                      void* args), 
                         void* cbArgs = NULL);
                Function(const Function& data);
                ~Function();
                void Run(Packet& packet);
                Function& operator=(const Function& data);
                void (*mpCallback)(Packet& packet, void* args);
                void *mpCallbackArgs;
            };
            virtual void ProcessMessage(const Packet& packet) = 0;
        };

        MessageClient();
        ~MessageClient();
        int Initialize(const std::string& serverID,
                       const ID clientID = AnyID,
                       const unsigned int messageBoxSize = MappedMessageBox::DefaultSize,
                       const bool mustConnect = true);
        int Initialize(const ID serverID,
                       const ID clientID,
                       const unsigned int messageBoxSize = MappedMessageBox::DefaultSize,
                       const bool mustConnect = true);
        int Initialize(const ID clientID,
                       const unsigned int messageBoxSize = MappedMessageBox::DefaultSize);
        void Shutdown();
        bool IsInitialized() const;
        bool ReadMessage(Packet& message) const;
        bool ReadMessage(std::string& message) const;
        bool RegisterCallback(Callback* callback);
        bool RegisterCallback(const Callback::Function& callback);
        void RemoveCallback(Callback* callback);
        void RemoveCallback(const Callback::Function& callback);
        bool IsConnected(const unsigned int thresholdMs = 500) const { return mRegistry.IsActive(thresholdMs); } 
        void SetUpdateDelayMs(const unsigned int delayTimeMs = 0); 
        ID GetID() const { return mID; }
    private:
        static void ReceiveThread(void* messageClient);
        ID mID;                              
        volatile bool mConnectToServerFlag;  
        unsigned int mDesiredBoxSize;        
        volatile unsigned int mUpdateDelayMs;
        MappedMessageBox mMessageBox;        
        MessageServer::Registry mRegistry;   
        Thread mReceiveThread;               
        Mutex  mReceivedDataMutex;           
        Mutex mDelayMutex;                   
        Mutex  mCallbacksMutex;              
        Packet::Queue mReceivedMessages;     
        std::string mServerID;               
        std::set<Callback*> mCallbacks;      
        std::vector<Callback::Function> mFunctionCallbacks; 
        Packet mTempPacket;                  
    };
}

#endif
/* End of File */