lgrVariableLengthData.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
******************************************************************************/


#ifndef lgrVariableLengthData_H_
#define lgrVariableLengthData_H_

#include <memory.h>

namespace MAKLogger
{

   class DT_DLL_LGRSIM DtLgrVariableLengthData
   {
   public:
      DtLgrVariableLengthData() :
         myData(0),
         mySize()
      {
      }

      DtLgrVariableLengthData(void const * inData, unsigned long inSize) :
         myData(0),
         mySize(0)
      {
         setData(inData,inSize);
      }

      //Dupcliate object (with new copy of the object).
      DtLgrVariableLengthData(DtLgrVariableLengthData const & rhs) :
         myData(0),
         mySize(0)
      {
         setData(rhs.data(),rhs.size());
      }

      
      ~DtLgrVariableLengthData()
      {
         delete[] (char*)myData;
         myData = 0;
         mySize = 0;
      }

      bool operator<(const DtLgrVariableLengthData& rhs) const
      {
         if(size() < rhs.size()) return true;
         if(size() > rhs.size()) return false;
         int count1 = size();
         int count2 = rhs.size();
         int count = (count1<count2)?count1:count2;
         const char* data1 = (const char*)data();
         const char* data2 = (const char*)rhs.data();
         for(int i = 0;i < count;++i,++data1,++data2)
         {
            if(*data1 > *data2) return false;
            if(*data1 < *data2) return true;
         }
         return count1 < count2;
      }

      bool operator==(const DtLgrVariableLengthData& rhs) const
      {
         if(size() != rhs.size()) return false;
         int integerCompares = size() >> 2;
         const unsigned int* intPtr1 = (const unsigned int*)data();
         const unsigned int* intPtr2 = (const unsigned int*)rhs.data();
         while(integerCompares--)
         {
            if(*intPtr1 != *intPtr2) return false;
            ++intPtr1;
            ++intPtr2;
         }
         int byteCompares = size() & 0x3;
         const unsigned char* bytePtr1 = (const unsigned char*)intPtr1;
         const unsigned char* bytePtr2 = (const unsigned char*)intPtr2;
         while(byteCompares)
         {
            if(*bytePtr1 != *bytePtr2) return false;
            ++bytePtr1;
            ++bytePtr2;
         }
         return true;        
      }

      DtLgrVariableLengthData& operator=(DtLgrVariableLengthData const & rhs)
      {         
         setData(rhs.data(),rhs.size());
         return *this;
      }

      void const * data() const {return myData;}
      void* data() {return myData;}
      unsigned int size() const {return mySize;}

      void setData(void const * inData, unsigned long inSize)
      {
         delete[] (char*)myData; 
         if(inSize != 0)
         {
            myData = (void*)new char[inSize];
         }
         else
         {
            myData = 0;
         }         
         mySize = inSize;
         memcpy(myData,inData,mySize);
      }

      void setDataPointer(void* inData, unsigned long inSize)
      {
         myData = inData;
         mySize = inSize;
      }

      void takeDataPointer(void* inData, unsigned long inSize)
      {
         delete[] (char*)myData;
         myData = inData;
         mySize = inSize;
      }

      void releaseDataPointer()
      {
         myData = 0;
         mySize = 0;
      }

   private:
      void* myData;
      unsigned long mySize;

   };
}

#endif