igtlMessageBase.h

Go to the documentation of this file.

/*=========================================================================
 
 Program:   The OpenIGTLink Library
 Language:  C++
 Web page:  http://openigtlink.org/
 
 Copyright (c) Insight Software Consortium. All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
#ifndef __igtlMessageBase_h
#define __igtlMessageBase_h
 
#include "igtlMacro.h"
#include "igtlMath.h"
#include "igtlMessageHeader.h"
#include "igtlObject.h"
#include "igtlObjectFactory.h"
#include "igtlTimeStamp.h"
#include "igtl_header.h"
#include "igtl_types.h"
 
#include <string>
#include <map>
#include <vector>
 
namespace igtl
{
 
 
  class IGTLCommon_EXPORT MessageBase: public Object
  {
  public:
    typedef MessageBase               Self;
    typedef Object                    Superclass;
    typedef SmartPointer<Self>        Pointer;
    typedef SmartPointer<const Self>  ConstPointer;
 
#if OpenIGTLink_HEADER_VERSION >= 2
    // Types for managing meta data
    typedef std::map<std::string, std::pair<IANA_ENCODING_TYPE, std::string> > MetaDataMap;
#endif
 
    igtlTypeMacro(igtl::MessageBase, igtl::Object)
    igtlNewMacro(igtl::MessageBase);
 
    enum
    {
      UNPACK_UNDEF   = 0x0000,
      UNPACK_HEADER  = 0x0001,
      UNPACK_BODY    = 0x0002
    };
 
  public:
    virtual igtl::MessageBase::Pointer Clone();
 
    void SetHeaderVersion(unsigned short headerVersion);
 
    unsigned short GetHeaderVersion() const;
 
    void SetDeviceName(const char* name);
 
    void SetDeviceName(const std::string& name);
 
    void SetDeviceType(const std::string& type);
 
    const char* GetDeviceName();
 
    std::string GetDeviceName() const;
 
    const char* GetDeviceType();
 
#if OpenIGTLink_HEADER_VERSION >= 2
    igtlUint32 GetMetaDataSize();
 
    igtlUint16 GetMetaDataHeaderSize();
 
    igtlUint32 GetMessageID();
 
    void SetMessageID(igtlUint32 idValue);
 
    bool SetMetaDataElement(const std::string& key, IANA_ENCODING_TYPE encodingScheme, std::string value);
    bool SetMetaDataElement(const std::string& key, igtl_uint8);
    bool SetMetaDataElement(const std::string& key, igtl_int8);
    bool SetMetaDataElement(const std::string& key, igtl_uint16);
    bool SetMetaDataElement(const std::string& key, igtl_int16);
    bool SetMetaDataElement(const std::string& key, igtl_uint32);
    bool SetMetaDataElement(const std::string& key, igtl_int32);
    bool SetMetaDataElement(const std::string& key, igtl_uint64);
    bool SetMetaDataElement(const std::string& key, igtl_int64);
    bool SetMetaDataElement(const std::string& key, float);
    bool SetMetaDataElement(const std::string& key, double);
 
    bool GetMetaDataElement(const std::string& key, std::string& value) const;
    bool GetMetaDataElement(const std::string& key, IANA_ENCODING_TYPE& encoding, std::string& value) const;
 
    const MetaDataMap& GetMetaData() const;
 
    bool PackExtendedHeader();
 
    bool PackMetaData();
 
    bool UnpackExtendedHeader();
 
    bool UnpackMetaData();
#endif
 
    int SetTimeStamp(unsigned int sec, unsigned int frac);
 
    int GetTimeStamp(unsigned int* sec, unsigned int* frac);
 
    void SetTimeStamp(igtl::TimeStamp::Pointer& ts);
 
    void GetTimeStamp(igtl::TimeStamp::Pointer& ts);
 
    virtual int Pack();
 
    int Unpack(int crccheck = 0);
 
    void* GetBufferPointer();
    void* GetPackPointer() { return GetBufferPointer(); }
 
    void* GetBufferBodyPointer();
    void* GetPackBodyPointer() { return GetBufferBodyPointer(); }
 
    int GetBufferSize();
    int GetPackSize() { return GetBufferSize(); }
 
    int GetBufferBodySize();
    int GetPackBodySize() { return GetBufferBodySize(); }
 
    int CalculateReceiveContentSize();
 
    const char* GetBodyType();
 
    std::string GetMessageType() const;
 
    void AllocateBuffer();
    void AllocatePack() { AllocateBuffer(); }
 
    void InitBuffer();
    void InitPack() { InitBuffer(); }
 
    int Copy(const MessageBase* mb);
 
    virtual int SetMessageHeader(const MessageHeader* mb);
 
    int GetBodySizeToRead();
 
  protected:
    MessageBase();
    ~MessageBase();
 
  protected:
    virtual int CalculateContentBufferSize();
 
    virtual int PackContent();
    virtual int UnpackContent();
 
    virtual void AllocateBuffer(int contentSize);
 
    virtual void AllocateUnpack(int bodySizeToRead);
 
    int CopyBody(const MessageBase* mb);
 
    int CopyHeader(const MessageBase* mb);
 
    void UnpackHeader(int& r);
 
    void UnpackBody(int crccheck, int& r);
 
  protected:
    int            m_MessageSize;
 
    unsigned char* m_Header;
 
    unsigned char* m_Body;
 
    unsigned char* m_Content;
 
    int            m_BodySizeToRead;
 
    std::string    m_SendMessageType;
 
    std::string    m_ReceiveMessageType;
 
    unsigned short m_HeaderVersion;
 
    std::string    m_DeviceName;
 
    unsigned int   m_TimeStampSec;
 
    unsigned int   m_TimeStampSecFraction;
 
    bool           m_IsHeaderUnpacked;
 
    bool           m_IsBodyUnpacked;
 
    bool           m_IsBodyPacked;
 
#if OpenIGTLink_HEADER_VERSION >= 2
  protected:
    unsigned char*                                                            m_ExtendedHeader;
 
    bool                                                                      m_IsExtendedHeaderUnpacked;
 
    unsigned char*                                                            m_MetaData;
 
    unsigned char*                                                            m_MetaDataHeader;
 
    igtlUint32                                                                m_MessageId;
 
    MetaDataMap                                                               m_MetaDataMap;
 
#endif // if OpenIGTLink_HEADER_VERSION >= 2
 
  };
 
  class IGTLCommon_EXPORT HeaderOnlyMessageBase: public MessageBase
  {
  public:
    typedef HeaderOnlyMessageBase        Self;
    typedef MessageBase                  Superclass;
    typedef SmartPointer<Self>           Pointer;
    typedef SmartPointer<const Self>     ConstPointer;
 
    igtlTypeMacro(igtl::HeaderOnlyMessageBase, igtl::MessageBase);
    igtlNewMacro(igtl::HeaderOnlyMessageBase);
 
  protected:
    HeaderOnlyMessageBase()
    {
      this->m_SendMessageType  = "";
    };
    ~HeaderOnlyMessageBase() {};
 
  protected:
    virtual int  CalculateContentBufferSize()
    {
      return 0;
    };
    virtual int  PackContent()
    {
      AllocateBuffer();
      return 1;
    };
    virtual int  UnpackContent()
    {
      return 1;
    };
  };
 
  //  TODO: Need test.
#define igtlCreateDefaultQueryMessageClass(name, msgtype) \
class IGTLCommon_EXPORT name : public  HeaderOnlyMessageBase\
{ \
public: \
typedef name                           Self; \
typedef HeaderOnlyMessageBase          Superclass; \
typedef SmartPointer<Self>             Pointer; \
typedef SmartPointer<const Self>       ConstPointer; \
\
igtlTypeMacro(igtl::name, igtl::HeaderOnlyMessageBase); \
igtlNewMacro(igtl::name); \
\
protected: \
name() : HeaderOnlyMessageBase() { this->m_SendMessageType  = msgtype; }; \
~name() {}; \
};
 
} // namespace igtl
 
#endif // _igtlMessageBase_h