vmessagehandler.h

Go to the documentation of this file.

/*
Copyright c1997-2014 Trygve Isaacson. All rights reserved.
This file is part of the Code Vault version 4.1
http://www.bombaydigital.com/
License: MIT. See LICENSE.md in the Vault top level directory.
*/

#ifndef vmessagehandler_h
#define vmessagehandler_h

#include "vtypes.h"
#include "vstring.h"
#include "vmutex.h"
#include "vmutexlocker.h"
#include "vmessage.h"
#include "vclientsession.h"

class VServer;
class VSocketThread;

class VMessageHandlerFactory;
typedef std::map<VMessageID, VMessageHandlerFactory*> VMessageHandlerFactoryMap;

class VMessageHandler {
    public:

        static VMessageHandler* get(VMessagePtr m, VServer* server, VClientSessionPtr session, VSocketThread* thread);
        static void registerHandlerFactory(VMessageID messageID, VMessageHandlerFactory* factory);

        VMessageHandler(const VString& name, VMessagePtr m, VServer* server, VClientSessionPtr session, VSocketThread* thread, const VMessageFactory* messageFactory, VMutex* mutex);
        virtual ~VMessageHandler();

        virtual void processMessage() = 0;
        VMessagePtr getMessage(VMessageID messageID);
        void logMessageContentRecord(const VString& details, VNamedLoggerPtr logger = VNamedLoggerPtr()) const;
        void logMessageContentFields(const VString& details, VNamedLoggerPtr logger = VNamedLoggerPtr()) const;
        void logMessageDetailsFields(const VString& details, VNamedLoggerPtr logger = VNamedLoggerPtr()) const;
        virtual void logProcessMessageStart() const;
        virtual void logProcessMessageEnd() const;

    protected:

        void _logDetailedDispatch(const VString& dispatchInfo) const;
        void _logMessageContentRecord(const VString& contentInfo) const;
        VNamedLoggerPtr _getMessageContentRecordLogger() const; 

        void _logMessageContentFields(const VString& contentInfo) const;
        VNamedLoggerPtr _getMessageContentFieldsLogger() const; 

        void _logMessageContentHexDump(const VString& info, const Vu8* buffer, Vs64 length) const;

        VString                 mName;          
        VString                 mLoggerName;    
        VMessagePtr             mMessage;       
        VServer*                mServer;        
        VClientSessionPtr       mSession;       
        VSocketThread*          mThread;        
        const VMessageFactory*  mMessageFactory;
        VInstant                mStartTime;     
        VMutexLocker            mLocker;        
        VInstant                mUnblockTime;   
        VString                 mSessionName;   

    private:

        VMessageHandler(const VMessageHandler&); // not copyable
        VMessageHandler& operator=(const VMessageHandler&); // not assignable

        static VMessageHandlerFactoryMap* mapInstance();

        static VMessageHandlerFactoryMap* gFactoryMap;    
};

class VMessageHandlerFactory {
    public:

        VMessageHandlerFactory() {}
        virtual ~VMessageHandlerFactory() {}

        virtual VMessageHandler* createHandler(VMessagePtr m, VServer* server, VClientSessionPtr session, VSocketThread* thread) = 0;
};

// This macro goes in the handler's .h file to define the handler's factory.
#define DEFINE_MESSAGE_HANDLER_FACTORY(messageid, factoryclassname, handlerclassname, descriptivename) \
class factoryclassname : public VMessageHandlerFactory { \
    public: \
    \
        factoryclassname() : VMessageHandlerFactory(), mName(VSTRING_ARGS("%s (%s)",#handlerclassname,descriptivename)) { VMessageHandler::registerHandlerFactory(messageid, this); } \
        virtual ~factoryclassname() {} \
        \
        virtual VMessageHandler* createHandler(VMessagePtr m, VServer* server, VClientSessionPtr session, VSocketThread* thread) \
            { return new handlerclassname(mName, m, server, session, thread); } \
    \
    private: \
    \
        static factoryclassname gFactory; \
        VString mName; \
    \
}

// This macro goes in the handler's .cpp file to declare the handler's factory.
#define DECLARE_MESSAGE_HANDLER_FACTORY(factoryclassname) \
factoryclassname factoryclassname::gFactory

// This macro goes in a global init function to prevent linker dead-stripping
// of the static initialization in the previous macro.
#define FORCE_LINK_MESSAGE_HANDLER_FACTORY(factoryclassname) \
if (false) { factoryclassname dummy; }

class VMessageHandlerTask {
    public:

        VMessageHandlerTask(VClientSessionPtr session) : mSession(session) {}
        virtual ~VMessageHandlerTask() {}

    protected:

        VClientSessionPtr mSession;  

};

#endif /* vmessagehandler_h */