DtMessage.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2007 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile: DtMessage.h,v $ $Revision: 1.28 $ $State: Exp $
******************************************************************************/

#ifndef DtMessage_H_
#define DtMessage_H_

#include <vrvUtil/vrvUtil.h>
#include <vector>
#include <sstream>
#include <ostream>

class portable_binary_iarchive;
class portable_binary_oarchive;

namespace makVrv
{

   class DtUnicode;

class DT_DLL_VRVUTIL DtMessage
{
public:

   typedef unsigned char Byte;
   typedef std::vector<Byte> ByteBuffer;

   static const int theHeaderSize = (sizeof(unsigned short) + sizeof(char)) * 2;

   //Helper Macro to pack the size of a type into a unique id.
   #define packSizeOf(type) ((sizeof(type)-1)<<4)

   //Helper Macro to unpack the size of a datatype.
   #define unpackSizeOf(dataType) ((dataType>>4)+1)

   //Help macro to check to see if a datatype enum is a simple type.
   #define isSimpleType(dataType) (dataType<128)

   //Simple data types are encoded as 1 bit 0, 3 bit size, 4 bit id
   //Complex data types are encoded as 8bit id, w/ MSBit = 1 (ie >= 128)
   enum DataType
   {  
      Unknown          = 0,
      Char             = 1  | packSizeOf(char),
      UnsignedChar     = 2  | packSizeOf(unsigned char),
      Short            = 3  | packSizeOf(short),
      UnsignedShort    = 4  | packSizeOf(unsigned short),
      Int              = 5  | packSizeOf(int),
      UnsignedInt      = 6  | packSizeOf(unsigned int),
      Float            = 7  | packSizeOf(float),
      LongLong         = 8  | packSizeOf(long long),
      UnsignedLongLong = 9  | packSizeOf(unsigned long long),
      Double           = 10 | packSizeOf(double),
      Bool             = 11 | packSizeOf(bool),
      Long             = 12 | packSizeOf(long),
      UnsignedLong     = 13 | packSizeOf(unsigned long),
      String           = 128,
      FixedArray       = 129,
      UnicodeString    = 130,
      User_Start       = 150,
      User_Last        = 255
   };

   //Data Format:
   //
   //

   DtMessage(unsigned short classId = 0,unsigned short functionId = 0);

   DtMessage(const Byte* buffer,size_t size);

   DtMessage(const DtMessage& orig);

   ~DtMessage();

   void printDebugMessageContents(std::ostream&);

   const char* dataTypeName(unsigned char dataType);

   unsigned short classId() const;

   unsigned short functionId() const;

   const Byte* data() const;

   size_t size() const;

   void emptyMessage();

   void resetRead();

   void serializeHeader(unsigned short classId, unsigned short functionId);

   bool serializeWriteOut() const;

   void setSerializeWriteOut(bool writeOut);



   DtMessage& operator >> (bool& b);
   DtMessage& operator >> (char& c);
   DtMessage& operator >> (unsigned char& c);
   DtMessage& operator >> (short& i);
   DtMessage& operator >> (unsigned short& i);
   DtMessage& operator >> (int& i);
   DtMessage& operator >> (unsigned int& i);   
   DtMessage& operator >> (long long& i);
   DtMessage& operator >> (unsigned long long& i);   
   DtMessage& operator >> (float& f);
   DtMessage& operator >> (double& f);
   DtMessage& operator >> (long& i);  
   DtMessage& operator >> (unsigned long& i);  
   DtMessage& operator >> (std::string& s);
   DtMessage& operator >> (DtUnicode& s);
   DtMessage& operator >> (ByteBuffer& rawData);

   DtMessage& operator >> (std::pair<void*,int>& rawData);


   DtMessage& operator << (bool b);
   DtMessage& operator << (char c);
   DtMessage& operator << (unsigned char c);
   DtMessage& operator << (short i);
   DtMessage& operator << (unsigned short i);
   DtMessage& operator << (int i);
   DtMessage& operator << (unsigned int i);
   DtMessage& operator << (long long i);
   DtMessage& operator << (unsigned long long i);  
   DtMessage& operator << (float f);
   DtMessage& operator << (double f);
   DtMessage& operator << (long i);
   DtMessage& operator << (unsigned long i);
   DtMessage& operator << (const std::string& s);
   DtMessage& operator << (const DtUnicode& s);
   DtMessage& operator << (const char* str);
   DtMessage& operator << (const ByteBuffer& rawData);
   DtMessage& operator << (const std::pair<void*,int>& rawData);

   void addOnlyData(DtMessage& message);

   void addData(unsigned int dataType,const void* data,int dataSize);

   bool canReadData() const;

   unsigned char nextDataType() const;

   unsigned int nextDataSize() const;

   const void* nextDataPointer() const;

   void skipToNextData();

   void advanceRead(size_t bytes);

   void getData(int dataType,void* output);



   void addMultiple()
   {
   }

   template <typename T1>
   void addMultiple(T1 t1)
   {
      *this << t1;
   }

   template <typename T1,typename T2>
   void addMultiple(T1 t1,T2 t2)
   {
      *this << t1 << t2;
   }

   template <typename T1,typename T2,typename T3>
   void addMultiple(T1 t1,T2 t2,T3 t3)
   {
      *this << t1 << t2 << t3;
   }

   template <typename T1,typename T2,typename T3,typename T4>
   void addMultiple(T1 t1,T2 t2,T3 t3,T4 t4)
   {
      *this << t1 << t2 << t3 << t4;
   }

   template <typename T1,typename T2,typename T3,typename T4,typename T5>
   void addMultiple(T1 t1,T2 t2,T3 t3,T4 t4,T5 t5)
   {
      *this << t1 << t2 << t3 << t4 << t5;
   }

   template <typename T1,typename T2,typename T3,typename T4,typename T5,
      typename T6>
   void addMultiple(T1 t1,T2 t2,T3 t3,T4 t4,T5 t5,T6 t6)
   {
      *this << t1 << t2 << t3 << t4 << t5 << t6;
   }

   template <typename T1,typename T2,typename T3,typename T4,typename T5,
      typename T6,typename T7>
   void addMultiple(T1 t1,T2 t2,T3 t3,T4 t4,T5 t5,T6 t6,T7 t7)
   {
      *this << t1 << t2 << t3 << t4 << t5 << t6 << t7;
   }

   template <typename T1,typename T2,typename T3,typename T4,typename T5,
      typename T6,typename T7,typename T8>
   void addMultiple(T1 t1,T2 t2,T3 t3,T4 t4,T5 t5,T6 t6,T7 t7,T8 t8)
   {
      *this << t1 << t2 << t3 << t4 << t5 << t6 << t7 << t8;
   }

   void readMultiple()
   {
   }

   template <typename T1>
   void readMultiple(T1& t1)
   {
      *this >> t1;
   }

   template <typename T1,typename T2>
   void readMultiple(T1& t1,T2& t2)
   {
      *this >> t1 >> t2;
   }

   template <typename T1,typename T2,typename T3>
   void readMultiple(T1& t1,T2& t2,T3& t3)
   {
      *this >> t1 >> t2 >> t3;
   }

   template <typename T1,typename T2,typename T3,typename T4>
   void readMultiple(T1& t1,T2& t2,T3& t3,T4& t4)
   {
      *this >> t1 >> t2 >> t3 >> t4;
   }

   template <typename T1,typename T2,typename T3,typename T4,typename T5>
   void readMultiple(T1& t1,T2& t2,T3& t3,T4& t4,T5& t5)
   {
      *this >> t1 >> t2 >> t3 >> t4 >> t5;
   }

   template <typename T1,typename T2,typename T3,typename T4,typename T5,
      typename T6>
   void readMultiple(T1& t1,T2& t2,T3& t3,T4& t4,T5& t5,T6& t6)
   {
      *this >> t1 >> t2 >> t3 >> t4 >> t5 >> t6;
   }

   template <typename T1,typename T2,typename T3,typename T4,typename T5,
      typename T6,typename T7>
   void readMultiple(T1& t1,T2& t2,T3& t3,T4& t4,T5& t5,T6& t6,T7& t7)
   {
      *this >> t1 >> t2 >> t3 >> t4 >> t5 >> t6 >> t7;
   }

   template <typename T1,typename T2,typename T3,typename T4,typename T5,
      typename T6,typename T7,typename T8>
   void readMultiple(T1& t1,T2& t2,T3& t3,T4& t4,T5& t5,T6& t6,T7& t7,T8& t8)
   {
      *this >> t1 >> t2 >> t3 >> t4 >> t5 >> t6 >> t7 >> t8;
   }


   template <typename T1>
   void serialize(T1& t1)
   {
      if(mySerializeWriteOutFlag)
         *this >> t1;
      else
         *this << t1;
   }

   template <typename T1,typename T2>
   void serialize(T1& t1,T2& t2)
   {
      if(mySerializeWriteOutFlag)
         *this >> t1 >> t2;
      else
         *this << t1 << t2;
   }

   template <typename T1,typename T2,typename T3>
   void serialize(T1& t1,T2& t2,T3& t3)
   {
      if(mySerializeWriteOutFlag)
         *this >> t1 >> t2 >> t3;
      else
         *this << t1 << t2 << t3;
   }

   template <typename T1,typename T2,typename T3,typename T4>
   void serialize(T1& t1,T2& t2,T3& t3,T4& t4)
   {
      if(mySerializeWriteOutFlag)
         *this >> t1 >> t2 >> t3 >> t4;
      else
         *this << t1 << t2 << t3 << t4;
   }

   template <typename T1,typename T2,typename T3,typename T4,typename T5>
   void serialize(T1& t1,T2& t2,T3& t3,T4& t4,T5& t5)
   {
      if(mySerializeWriteOutFlag)
         *this >> t1 >> t2 >> t3 >> t4 >> t5;
      else
         *this << t1 << t2 << t3 << t4 << t5;
   }

   template <typename T1,typename T2,typename T3,typename T4,typename T5,
      typename T6>
   void serialize(T1& t1,T2& t2,T3& t3,T4& t4,T5& t5,T6& t6)
   {
      if(mySerializeWriteOutFlag)
         *this >> t1 >> t2 >> t3 >> t4 >> t5 >> t6;
      else
         *this << t1 << t2 << t3 << t4 << t5 << t6;
   }

   template <typename T1,typename T2,typename T3,typename T4,typename T5,
      typename T6,typename T7>
   void serialize(T1& t1,T2& t2,T3& t3,T4& t4,T5& t5,T6& t6,T7& t7)
   {
      if(mySerializeWriteOutFlag)
         *this >> t1 >> t2 >> t3 >> t4 >> t5 >> t6 >> t7;
      else
         *this << t1 << t2 << t3 << t4 << t5 << t6 << t7;
   }

   template <typename T1,typename T2,typename T3,typename T4,typename T5,
      typename T6,typename T7,typename T8>
   void serialize(T1& t1,T2& t2,T3& t3,T4& t4,T5& t5,T6& t6,T7& t7,T8& t8)
   {
      if(mySerializeWriteOutFlag)
         *this >> t1 >> t2 >> t3 >> t4 >> t5 >> t6 >> t7 >> t8;
      else
         *this << t1 << t2 << t3 << t4 << t5 << t6 << t7 << t8;
   }

   //Allows serialize any serialize via archive classes.
   template <typename T>
   void serializeViaArchive(T& t)
   {
      class FastStringBuf : public std::stringbuf
      {
      public:
         const char* c_str() const { return pbase();}
         size_t outputSize() const 
         { 
            return pptr() - pbase();
         }
      };

      std::pair<void*,int> configMemory;
      //Are we writing to the configuration.
      if(serializeWriteOut())
      {         
         //Yank out a binary chunk from the message.
         serialize(configMemory);
         //Create an input string stream.
         std::istringstream memoryStream;
         //Set the stream to the message data.
         memoryStream.str(std::string((char*)configMemory.first,configMemory.second));
         //Create an archive to read the stream.
         portable_binary_iarchive ia(memoryStream);
         //Serialize out from the stream.
         //t.serialize(ia,0);
         ia & t;
         //Clean up the message memory.
         delete[] (char*)configMemory.first;
      }
      else
      {

         //Create a fast buffer.
         FastStringBuf fastBuffer;
         //Create a output stream for it.
         std::ostream memoryStream(&fastBuffer);
         //Create an archive to write to it.
         portable_binary_oarchive oa(memoryStream);
         //Write the object to the archive.
         oa & t;
         //t.serialize(oa,boost::serialization::version<T>::value);
         //Grab the written data.
         configMemory.first = (void*) fastBuffer.c_str();
         configMemory.second = fastBuffer.outputSize();
         //Put that data into this message.
         serialize(configMemory);
      }
   }

protected:

   void setClassId(unsigned short classId);

   void setFunctionId(unsigned short functionId);   
   
   ByteBuffer myBuffer;
   ByteBuffer::const_iterator myReadIter;
   bool mySerializeWriteOutFlag;

};

}

#endif