Message.h

Go to the documentation of this file.

//==============================================================================================
//  FILENAME    :   Message.h
//  AUTHOR      :   vovechkin
//  CREATION    :   2004-10-26
//  Copyright (C) MicroStrategy Incorporated 2004
//  All Rights Reserved
//==============================================================================================
#ifndef MBase_Message_h
#define MBase_Message_h

#include "Base.h"

#include "../Defines/BasicTypes.h"
#include "../Defines/Asserte.h"
#include "ReturnString.h"
#include "Language.h"
#include "MessageDomain.h"

namespace MBase
{
    typedef Int32 MessageID;

    class DLL_BASE_EXIM Message
    {
    public:

        typedef unsigned Int32 SizeType;

        static const SizeType MIN_SIZE;

        // 
        // Construction, assignment, destruction
        //

        Message();
        Message(const Message& irOther);
        Message(MessageDomain iDomain, MessageID iID, const char* ipTemplate = NULL);

        // (deep) assigment operator
        Message& operator=(const Message& irOther);

        bool Swap(Message& irOther) throw();

        // destructor
        ~Message() throw();

        // 
        // Chaining
        //

        Message& WrapBy(MessageDomain iDomain, MessageID iID, const char* ipTemplate = NULL);

        const Message* GetLowerLevelMessageOrNULL() const;

        Message& PrependBy(MessageDomain iDomain, MessageID iID, const char* ipTemplate = NULL);

        Message& PrependBy(const Message& irMessage);

        const Message* GetSameLevelMessageOrNULL() const;

        // 
        // Placement construction/destruction
        //

        class DLL_BASE_EXIM PlacementPtr
        {
        public:

            PlacementPtr(
                void* ipBuffer,
                SizeType iBufferSizeInBytes);

            PlacementPtr(
                void* ipBuffer,
                SizeType iBufferSizeInBytes,
                const Message& irOther);

            PlacementPtr(
                void* ipBuffer,
                SizeType iBufferSizeInBytes,
                MessageDomain iDomain,
                MessageID iID,
                const char* ipTemplate = NULL);

            ~PlacementPtr() throw();

            inline Message& operator*() const throw()
            {
                _ASSERT(mpMessage != NULL);
                return *mpMessage;
            }

            inline Message* operator->() const throw()
            {
                _ASSERT(mpMessage != NULL);
                return mpMessage;
            }

            inline Message* Get() const throw()
            {
                _ASSERT(mpMessage != NULL);
                return mpMessage;
            }

            inline bool IsNull() const
            {
                return (mpMessage == NULL);
            }

        private:

            // do not allow copying
            PlacementPtr(const PlacementPtr&);
            PlacementPtr& operator=(const PlacementPtr&);

        private:

            Message* mpMessage;
        };

        class DLL_BASE_EXIM PlacementArrayPtr
        {
        public:

            PlacementArrayPtr(
                void* ipBuffer,
                SizeType iBufferSizeInBytes,
                SizeType iMessageSizeInBytes);
            
            PlacementArrayPtr(
                void* ipBuffer,
                SizeType iBufferSizeInBytes,
                SizeType iMessageSizeInBytes, 
                const Message& irOther);

            PlacementArrayPtr(
                void* ipBuffer,
                SizeType iBufferSizeInBytes,
                SizeType iMessageSizeInBytes,
                MessageDomain iDomain,
                MessageID iID,
                const char* ipTemplate = NULL);

            ~PlacementArrayPtr() throw();

            inline MBase::Message& operator [](unsigned int iIndex)
            {
                _ASSERT(mpMessage != NULL);
                _ASSERT(iIndex < (mBufferSizeInBytes / mMessageSizeInBytes));

                return *reinterpret_cast<MBase::Message*>(mpMessage + mMessageSizeInBytes * iIndex);
            }

            inline bool IsNull() const
            {
                return (mpMessage == NULL);
            }

        private:

            // do not allow copying
            PlacementArrayPtr(const PlacementArrayPtr&);
            PlacementArrayPtr& operator=(const PlacementArrayPtr&);

        private:

            unsigned char* mpMessage;
            const SizeType mBufferSizeInBytes;
            const SizeType mMessageSizeInBytes;
        };

        // 
        // Value getters/setters
        //

        bool IsEmpty() const;

        void Clear();

        MBase::MessageDomain GetDomain() const;

        MBase::MessageID GetID() const;

        void SetDomainAndID(MBase::MessageDomain iDomain, MessageID iID);

        const char* GetTemplate() const;
        void SetTemplate(const char* ipTemplate);

        const char* GetParameter(unsigned int iIndex) const;

        Message& operator << (bool iParameter);
        Message& operator << (int iParameter);
        Message& operator << (unsigned int iParameter);
        Message& operator << (long iParameter);
        Message& operator << (unsigned long iParameter);
        Message& operator << (const char* ipParameter); // assumed to be UTF-8 (or ASCII)
#ifndef NO_WCHAR_SUPPORT
        Message& operator << (const WCHAR* ipParameter);
#endif

        typedef void (*Manipulator)(Message& irMessage);
        Message& operator << (Manipulator ipManipulator);

        static void Dec(Message& irMessage);
        static void Hex(Message& irMessage); // ex: 0x1
        static void WideHex(Message& irMessage); // ex: 0x00000001
        static void WideWideHex(Message& irMessage); // ex: 0x0000000000000001

        // 
        // Localization
        //

        const char* GetLocalizedText(MBase::LanguageID iLanguageID) const;

        void SetLocalizedText(MBase::LanguageID iLanguageID, const char* ipText);

        class Localizer
        {
        public:

            virtual MBase::ReturnString Localize(
                MBase::LanguageID iLanguageID,
                MBase::MessageDomain iMessageDomain,
                MBase::MessageID iID,
                const char* ipTemplate,
                const char* ipParameters[]/*,
                ParameterType ipParameterTypes[]*/) = 0;
        };

//      const char* GetLocalizedText(Localizer& irLocalizer, MBase::LanguageID iLanguageID);

        MBase::ReturnString Localize(Localizer& irLocalizer, MBase::LanguageID iLanguageID) const;

        // 
        // Private declarations
        //

    private:

        // placement constructors
        friend class PlacementPtr;
        friend class PlacementArrayPtr;

        Message(SizeType iBufferSizeInBytes);
        Message(SizeType iBufferSizeInBytes, const Message& irOther);
        Message(SizeType iBufferSizeInBytes, MessageDomain iDomain, MessageID iID, const char* ipTemplate);

        void SetNumberFormat(unsigned char iRadix, unsigned char iWidth);
        void GetNumberFormat(unsigned char& orRadix, unsigned char& orWidth) const;

    private:

        // the only data member, which determines the default Message size (as local/temp variable)
        unsigned char mBuffer[100];

    public:

        // 
        // Compatibility with MBase::BaseException
        //

#ifndef NO_BASE_EXCEPTION_COMPATIBILITY
        // for compatibility with MBase::Exception
        const WCHAR* GetMessage() const throw();
        void SetMessage(const WCHAR* ipMessage) throw();

        inline unsigned Int32 GetErrorCode() const throw()
        {
            return static_cast<unsigned Int32>(GetID());
        }
#endif // NO_BASE_EXCEPTION_COMPATIBILITY
    };
}

#endif // MBase_Message_h