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>
#include <vlutil/vlMachineTypes.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;
         //Check size and do 1 integer compare if possible.  Start with 4 for MAK RTI
         if( size() == 4 )
         {   
            const DtInt32* intPtr1 = (const DtInt32*)data();
            const DtInt32* intPtr2 = (const DtInt32*)rhs.data();
            return (*intPtr1 < *intPtr2);
         }
         else if( size() == 8 )
         {   
            const DtInt64* intPtr1 = (const DtInt64*)data();
            const DtInt64* intPtr2 = (const DtInt64*)rhs.data();
            if(*intPtr1 < *intPtr2) return true;
         }
         else if( size() == 2 )
         {
            const DtInt16* intPtr1 = (const DtInt16*)data();
            const DtInt16* intPtr2 = (const DtInt16*)rhs.data();
            return (*intPtr1 < *intPtr2);
         }
         
         //Do memcmp
         return memcmp(data(), rhs.data(), size()) < 0;
      }

      bool operator==(const DtLgrVariableLengthData& rhs) const
      {
         if(size() != rhs.size()) return false;

         if( size() == 4 )
         {   
            const DtInt32* intPtr1 = (const DtInt32*)data();
            const DtInt32* intPtr2 = (const DtInt32*)rhs.data();
            if(*intPtr1 != *intPtr2) return false;
         }
         else if( size() == 8 )
         {   
            const DtInt64* intPtr1 = (const DtInt64*)data();
            const DtInt64* intPtr2 = (const DtInt64*)rhs.data();
            if(*intPtr1 != *intPtr2) return false;
         }
         else if( size() == 2 )
         {
            const DtInt16* intPtr1 = (const DtInt16*)data();
            const DtInt16* intPtr2 = (const DtInt16*)rhs.data();
            if(*intPtr1 != *intPtr2) return false;
         }
         else
         {
            return memcmp(data(), rhs.data(), size()) == 0;
         }
         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