MessageHelper.h

/* START_LICENSE_HEADER

Copyright (C) 2000 Martin Piper, original design and program code
Copyright (C) 2001 Replica Software

This program file is copyright (C) Replica Software and can only be used under license.
For more information visit: http://www.replicanet.com/
Or email: info@replicanet.com

END_LICENSE_HEADER */
#include "RNPlatform/Inc/MemoryTracking.h"
#ifndef __MESSAGEHELPER_H__
#define __MESSAGEHELPER_H__
#include <string>

namespace RNReplicaNet
{

#define MESSAGEHELPER_ADDVARIABLE(x)    \
AddVariable(&(x),sizeof(x));

#define MESSAGEHELPER_GETVARIABLE(x)    \
GetVariable(&(x),sizeof(x));

#define MESSAGEHELPER_ADDVARIABLEp(y,x) \
y.AddVariable(&(x),sizeof(x));

#define MESSAGEHELPER_GETVARIABLEp(y,x) \
y.GetVariable(&(x),sizeof(x));

class MessageHelper
{
public:
    class Exception
    {
    public:
        Exception() {}
        virtual ~Exception() {}
    };
    MessageHelper();

    virtual ~MessageHelper();

    void SetBuffer(void *const buffer);

    void *GetBuffer(void) const;

    void *GetCurrentPosition(void) const;

    virtual void AddVariable(const void *variable,const int size);
    static void AddVariable(void *buffer, const void *variable, const int size);

    virtual void AddData(const void *data,const int size);

    void GetVariable(void *const variable,const int size);
    static void GetVariable(const void *buffer, void *const variable, const int size);

    void GetData(void *const data,const int size);

    void SkipData(const int size);

    int GetSize(void) const;

    void SetSize(const int size);

    void AddInteger(const int value);

    void AddFloat(const float value);

    int GetInteger(void);

    float GetFloat(void);

    // Direct buffer modification functions with endian checking
    // The offset is in chars into the buffer.
    static int GetInt(const void *buffer, const int offset);
    static short GetShort(const void *buffer, const int offset);
    static void SetInt(void *buffer, const int offset, const int value);
    static void SetShort(void *buffer, const int offset, const short value);

    static std::string DumpAsHex(const void *data,const int size,const bool csv = true);

    std::string DumpAsHex(const bool csv = true) const
    {
        return DumpAsHex(GetBuffer(),GetSize(),csv);
    }

    void SetGuardSize(const int size = -1);
    void SanityCheckGuardSize(const int newSize = 0);

    int GetLastSizeAdded(void) const;

    // Define operator<< and operator>> to make using this class a little easier.
    // For all operator>> the rhs is replaced with the data in lhs.
    // Generic cases
    template <typename T>
    void operator<<(const T& rhs)
    {
        MESSAGEHELPER_ADDVARIABLE(rhs);
    }
    template <typename T>
    void operator>>(T& rhs)
    {
        MESSAGEHELPER_GETVARIABLE(rhs);
    }
    
    // Special cases
    void operator<<(const char *rhs);
    void operator<<(const std::string &rhs);
    void operator>>(std::string &rhs);

    // For platforms where sizeof(bool) is different
    void operator<<(const bool &rhs);
    void operator>>(bool &rhs);

private:
    unsigned char *mFirstPtr;           
    unsigned char *mBufferPtr;          
    int mGuardSize;

protected:
    int mLastSizeAdded;
};

class DynamicMessageHelper : public MessageHelper
{
public:
    DynamicMessageHelper();

    DynamicMessageHelper( const int size );

    DynamicMessageHelper( const void * message , const int size );

    virtual ~DynamicMessageHelper();

private:
    void SetBuffer(void *const) {}
public:

    void SetBufferSize(const int size = 1024);

    int GetBufferSize(void);

    void SetSize(const int size);


    void AddVariable(const void *variable,const int size);

    void AddData(const void *data,const int size);

    void FreeBuffer(void);

    void EnsureBufferAllocated(void);

    bool Write(const char *filename,const bool rawData = false);

    bool Read(const char *filename,const bool rawData = false);

    // Define operator<< and operator>> to make using this class a little easier.
    // For all operator>> the rhs is replaced with the data in lhs.
    // Generic cases
    template <typename T>
    void operator<<(const T& rhs)
    {
        MESSAGEHELPER_ADDVARIABLE(rhs);
    }
    template <typename T>
    void operator>>(T& rhs)
    {
        MESSAGEHELPER_GETVARIABLE(rhs);
    }

    // Special cases
    void operator<<(const char *rhs);
    void operator<<(const std::string &rhs);
    void operator>>(std::string &rhs);

    void operator<<(const DynamicMessageHelper &rhs);
    void operator>>(DynamicMessageHelper &rhs);

    // Tests using GetSize() for the length of the data to test.
    bool operator==(const DynamicMessageHelper &rhs) const;
    bool operator!=(const DynamicMessageHelper &rhs) const;

    // For platforms where sizeof(bool) is different
    void operator<<(const bool &rhs);
    void operator>>(bool &rhs);

    bool ReadAsHex(const std::string &data);

private:
    void CheckBufferSize(const int newSize);
    void *mBuffer;
    int mSize;
};

} // namespace RNReplicaNet

#endif