build-artifacts/win/product/include/gfcpp/DataInput.hpp

Go to the documentation of this file.

#ifndef __GEMFIRE_DATAINPUT_H__
#define __GEMFIRE_DATAINPUT_H__

/*=========================================================================
 * Copyright (c) 2002-2014 Pivotal Software, Inc. All Rights Reserved.
 * This product is protected by U.S. and international copyright
 * and intellectual property laws. Pivotal products are covered by
 * more patents listed at http://www.pivotal.io/patents.
 *=========================================================================
 */

#include "gfcpp_globals.hpp"
#include "ExceptionTypes.hpp"
#include <string.h>
#include "gf_types.hpp"
#include "Serializable.hpp"
#include "CacheableString.hpp"

#if GF_DEBUG_ASSERTS == 1
#define DINP_THROWONERROR_DEFAULT true
#else
#define DINP_THROWONERROR_DEFAULT false
#endif

#define checkBufferSize(x) _checkBufferSize(x,__LINE__)

namespace gemfire
{

extern int gf_sprintf(char* buffer, const char* fmt, ...);

class CPPCACHE_EXPORT DataInput
{
public:

  inline void read( uint8_t* value )
  {
    checkBufferSize(1);
    *value = *(m_buf++);
  }

  inline void read( int8_t* value )
  {
    checkBufferSize(1);
    *value = *(m_buf++);
  }

  inline void readBoolean( bool* value )
  {
    checkBufferSize(1);
    *value = (*m_buf == 1 ? true : false);
    m_buf++;
  }

  inline void readBytesOnly(uint8_t* buffer, uint32_t len)
  {
    if (len > 0) {
      checkBufferSize(len);
      memcpy( buffer, m_buf, len );
      m_buf += len;
    }
  }

  inline void readBytesOnly(int8_t* buffer, uint32_t len)
  {
    if (len > 0) {
      checkBufferSize(len);
      memcpy( buffer, m_buf, len );
      m_buf += len;
    }
  }

  inline void readBytes( uint8_t** bytes, int32_t* len )
  {
    int32_t length;
    readArrayLen( &length );
    *len = length;
    uint8_t* buffer = NULL;
    if ( length > 0 ) {
      checkBufferSize(length);
      GF_NEW( buffer, uint8_t[ length ] );
      memcpy( buffer, m_buf, length );
      m_buf += length;
    }
    *bytes = buffer;
  }

  inline void readBytes( int8_t** bytes, int32_t* len )
  {
    int32_t length;
    readArrayLen( &length );
    *len = length;
    int8_t* buffer = NULL;
    if ( length > 0 ) {
      checkBufferSize(length);
      GF_NEW( buffer, int8_t[ length ] );
      memcpy( buffer, m_buf, length );
      m_buf += length;
    }
    *bytes = buffer;
  }

  inline void readInt( uint16_t* value )
  {
    checkBufferSize(2);
    uint16_t tmp = *(m_buf++);
    tmp = (uint16_t)((tmp << 8) | *(m_buf++));
    *value = tmp;
  }

  inline void readInt( uint32_t* value )
  {
    checkBufferSize(4);
    uint32_t tmp = *(m_buf++);
    tmp = (tmp << 8) | *(m_buf++);
    tmp = (tmp << 8) | *(m_buf++);
    tmp = (tmp << 8) | *(m_buf++);
    *value = tmp;
  }

  inline void readInt( uint64_t* value )
  {
    checkBufferSize(8);
    uint64_t tmp;
    if ( sizeof( long ) == 8 ) {
      tmp = *(m_buf++);
      tmp = (tmp << 8) | *(m_buf++);
      tmp = (tmp << 8) | *(m_buf++);
      tmp = (tmp << 8) | *(m_buf++);
      tmp = (tmp << 8) | *(m_buf++);
      tmp = (tmp << 8) | *(m_buf++);
      tmp = (tmp << 8) | *(m_buf++);
      tmp = (tmp << 8) | *(m_buf++);
    } else {
      uint32_t hword = *(m_buf++);
      hword = (hword << 8) | *(m_buf++);
      hword = (hword << 8) | *(m_buf++);
      hword = (hword << 8) | *(m_buf++);

      tmp = hword;
      hword = *(m_buf++);
      hword = (hword << 8) | *(m_buf++);
      hword = (hword << 8) | *(m_buf++);
      hword = (hword << 8) | *(m_buf++);
      tmp = (tmp << 32) | hword;
    }
    *value = tmp;
  }

  inline void readInt( int16_t* value )
  {
    checkBufferSize(2);
    readInt( (uint16_t*)value );
  }

  inline void readInt( int32_t* value )
  {
    checkBufferSize(4);
    readInt( (uint32_t*)value );
  }

  inline void readInt( int64_t* value )
  {
    checkBufferSize(8);
    readInt( (uint64_t*)value );
  }

  inline void readArrayLen( int32_t* len )
  {
    uint8_t code;
    read(&code);
    if (code == 0xFF) {
      *len = -1;
    } else {
      int32_t result = code;
      if (result > 252) {  // 252 is java's ((byte)-4 && 0xFF)
        if (code == 0xFE) {
          uint16_t val;
          readInt(&val);
          result = val;
        } else if (code == 0xFD) {
          uint32_t val;
          readInt(&val);
          result = val;
        } else {
          throw IllegalStateException("unexpected array length code");
        }
      }
      *len = result;
    }
  }

  inline void readUnsignedVL(int64_t * value)
  {
    int32_t shift = 0;
    int64_t result = 0;
    while (shift < 64) {
      int8_t b;
      read(&b);
      result |= (int64_t)(b & 0x7F) << shift;
      if ((b & 0x80) == 0) {
        *value = result;
        return;
      }
      shift += 7;
    }
    throw IllegalStateException("Malformed variable length integer");
  }

  inline void readFloat( float* value )
  {
    checkBufferSize(4);
    union float_uint32_t
    {
        float f;
        uint32_t u;
    }v;
    readInt( (uint32_t*)&v.u);
    *value = v.f;
  }

  inline void readDouble( double* value )
  {
    checkBufferSize(8);
    union double_uint64_t
    {
        double d;
        uint64_t        ll;
    }v;
    readInt( (uint64_t*)&v.ll);
    *value = v.d;
  }

  static inline void freeUTFMemory( char* value )
  {
    delete [] value;
  }

  static inline void freeUTFMemory( wchar_t* value )
  {
    delete [] value;
  }

  inline void readASCII( char** value, uint16_t* len = NULL )
  {
    uint16_t length;
    readInt( &length );
    checkBufferSize(length);
    if ( len != NULL ) {
      *len = length;
    }
    char* str;
    GF_NEW( str, char[ length + 1 ] );
    *value = str;
    readBytesOnly((int8_t*)str, length);
    str[ length ] = '\0';
  }

  inline void readASCIIHuge( char** value, uint32_t* len = NULL )
  {
    uint32_t length;
    readInt( &length );
    if ( len != NULL ) {
      *len = length;
    }
    char* str;
    GF_NEW( str, char[ length + 1 ] );
    *value = str;
    readBytesOnly( (int8_t*)str, length );
    str[ length ] = '\0';
  }

  inline void readUTF( char** value, uint16_t* len = NULL )
  {
    uint16_t length;
    readInt( &length );
    checkBufferSize(length);
    uint16_t decodedLen = (uint16_t)getDecodedLength( m_buf, length );
    if ( len != NULL ) {
      *len = decodedLen;
    }
    char* str;
    GF_NEW( str, char[ decodedLen + 1 ] );
    *value = str;
    for( uint16_t i = 0; i < decodedLen; i++ ) {
      decodeChar( str++ );
    }
    *str = '\0'; // null terminate for c-string.
  }

  inline void readUTFNoLen(wchar_t** value, uint16_t decodedLen)
  {
    wchar_t* str;
    GF_NEW(str, wchar_t[decodedLen + 1]);
    *value = str;
    for (uint16_t i = 0; i < decodedLen; i++) {
      decodeChar(str++);
    }
    *str = L'\0'; // null terminate for c-string.
  }

  inline void readUTFHuge( char** value, uint32_t* len = NULL )
  {
    uint32_t length;
    readInt( &length );
    if ( len != NULL ) {
      *len = length;
    }
    char* str;
    GF_NEW( str, char[ length + 1 ] );
    *value = str;
    for( uint32_t i = 0; i < length; i++ ) {
      int8_t item;
      read(&item); // ignore this - should be higher order zero byte
      read(&item);
      *str = item;
      str++;
    }
    *str = '\0'; // null terminate for c-string.
  }

  inline void readUTF( wchar_t** value, uint16_t* len = NULL )
  {
    uint16_t length;
    readInt( &length );
    checkBufferSize(length);
    uint16_t decodedLen = (uint16_t)getDecodedLength( m_buf, length );
    if ( len != NULL ) {
      *len = decodedLen;
    }
    wchar_t* str;
    GF_NEW( str, wchar_t[ decodedLen + 1 ] );
    *value = str;
    for( uint16_t i = 0; i < decodedLen; i++ ) {
      decodeChar( str++ );
    }
    *str = L'\0'; // null terminate for c-string.
  }

  inline void readUTFHuge( wchar_t** value, uint32_t* len = NULL )
  {
    uint32_t length;
    readInt( &length );
    if ( len != NULL ) {
      *len = length;
    }
    wchar_t* str;
    GF_NEW( str, wchar_t[ length + 1 ] );
    *value = str;
    for( uint32_t i = 0; i < length; i++ ) {
      uint8_t hibyte;
      read(&hibyte);
      uint8_t lobyte;
      read(&lobyte);
      *str = (((uint16_t)hibyte) << 8) | (uint16_t)lobyte;
      str++;
    }
    *str = L'\0'; // null terminate for c-string.
  }

  template< class PTR >
  inline void readObject( SharedPtr<PTR>& ptr,
      bool throwOnError = DINP_THROWONERROR_DEFAULT )
  {
    SerializablePtr sPtr;
    readObjectInternal( sPtr );
    if ( throwOnError ) {
      ptr = dynCast< SharedPtr<PTR> >( sPtr );
    } else {
      ptr = staticCast< SharedPtr<PTR> >( sPtr );
    }
  }

  inline bool readNativeBool( )
  {
    int8_t typeId = 0;
    read( &typeId );
    
    bool val;
    readBoolean(&val);
    return val;
  }

  inline int32_t readNativeInt32( )
  {
    int8_t typeId = 0;
    read( &typeId );
    
    int32_t val;
    readInt(&val);
    return val;
  }

  inline bool readNativeString(CacheableStringPtr& csPtr)
  {
    int8_t typeId = 0;
    read( &typeId );
    int64_t compId = typeId;
    if (compId == GemfireTypeIds::NullObj) {
     csPtr = NULLPTR;
    }
    else if (compId == GemfireTypeIds::CacheableNullString) {
      csPtr = CacheableStringPtr(dynamic_cast<CacheableString *>(CacheableString::createDeserializable()));
    }
    else if ( compId == gemfire::GemfireTypeIds::CacheableASCIIString) {
      csPtr = CacheableStringPtr(dynamic_cast<CacheableString *>(CacheableString::createDeserializable()));
      csPtr.ptr()->fromData(*this);
    }
    else if ( compId == gemfire::GemfireTypeIds::CacheableASCIIStringHuge) {
      csPtr = CacheableStringPtr(dynamic_cast<CacheableString *>(CacheableString::createDeserializableHuge()));
      csPtr.ptr()->fromData(*this);
    }
    else if ( compId == gemfire::GemfireTypeIds::CacheableString) {
      csPtr = CacheableStringPtr(dynamic_cast<CacheableString *>(CacheableString::createUTFDeserializable()));
      csPtr.ptr()->fromData(*this);
    }
    else if ( compId == gemfire::GemfireTypeIds::CacheableStringHuge) {
      csPtr = CacheableStringPtr(dynamic_cast<CacheableString *>(CacheableString::createUTFDeserializableHuge()));
      csPtr.ptr()->fromData(*this);
    }
    else {
      LOGDEBUG("In readNativeString something is wrong while expecting string");
      rewindCursor(1);
      csPtr = NULLPTR;
      return false;
    }
    return true;
  }

  inline void readDirectObject( SerializablePtr& ptr, int8_t typeId = -1 )
  {
    readObjectInternal( ptr, typeId );
  }

  inline void readObject( SerializablePtr& ptr )
  {
    readObjectInternal( ptr );
  }

  inline void readObject(wchar_t* value){
    uint16_t temp = 0;
    readInt(&temp);
    *value = (wchar_t)temp;
  }

  inline void readObject(bool* value){
    readBoolean(value);
  }

  inline void readObject(int8_t* value){
    read(value);
  }

  inline void readObject(int16_t* value){
    readInt(value);
  }

  inline void readObject(int32_t* value){
    readInt(value);
  }

  inline void readObject(int64_t* value){
    readInt(value);
  }

  inline void readObject(float* value){
      readFloat(value);
  }

  inline void readObject(double* value){
    readDouble(value);
  }

  inline void readCharArray(char** value, int32_t& length){
    int arrayLen = 0;
    readArrayLen(&arrayLen);
    length = arrayLen;
    char* objArray = NULL;
    if(arrayLen > 0) {
    objArray = new char[arrayLen];
      int i = 0;
      for( i = 0; i < arrayLen; i++ ){
        char tmp = 0;
        readPdxChar(&tmp);
        objArray[i] =  tmp;
      }
      *value = objArray;
    }
  }

  inline void readWideCharArray(wchar_t** value, int32_t& length){
    readObject(value, length);
  }

  inline void readBooleanArray(bool** value, int32_t& length){
    readObject(value, length);
  }

  inline void readByteArray(int8_t** value, int32_t& length){
    readObject(value, length);
  }

  inline void readShortArray(int16_t** value, int32_t& length){
    readObject(value, length);
  }

  inline void readIntArray(int32_t** value, int32_t& length){
    readObject(value, length);
  }

  inline void readLongArray(int64_t** value, int32_t& length){
    readObject(value, length);
  }

  inline void readFloatArray(float** value, int32_t& length){
    readObject(value, length);
  }

  inline void readDoubleArray(double** value, int32_t& length){
    readObject(value, length);
  }

  inline void readString(char** value) {
    int8_t typeId;
    read(&typeId);

    //Check for NULL String
    if (typeId == GemfireTypeIds::CacheableNullString){
        *value = NULL;
        return;
    }
    /*
    if (typeId == GemfireTypeIds::CacheableString) {
      readUTF(value);
    } else {
      readUTFHuge(value);
    }
    */
    if (typeId == (int8_t)GemfireTypeIds::CacheableASCIIString || typeId == (int8_t)GemfireTypeIds::CacheableString) {
      //readUTF( value);
      readASCII(value);
        //m_len = shortLen;
    }else if (typeId == (int8_t)GemfireTypeIds::CacheableASCIIStringHuge || typeId == (int8_t)GemfireTypeIds::CacheableStringHuge) {
      //readUTFHuge( value);
      readASCIIHuge(value);
    }
    else {
        throw IllegalArgumentException("DI readString error:: String type not supported ");
    }

  }

  inline void readWideString(wchar_t** value) {
    int8_t typeId;
    read(&typeId);

    //Check for NULL String
    if (typeId == GemfireTypeIds::CacheableNullString){
      *value = NULL;
      return;
    }

    if (typeId == (int8_t)GemfireTypeIds::CacheableASCIIString || typeId == (int8_t)GemfireTypeIds::CacheableString) {
      readUTF( value);
    }else if (typeId == (int8_t)GemfireTypeIds::CacheableASCIIStringHuge || typeId == (int8_t)GemfireTypeIds::CacheableStringHuge) {
      readUTFHuge( value);
    }
    else {
      throw IllegalArgumentException("DI readWideString error:: WideString type provided is not supported ");
    }
  }

  inline void readStringArray(char*** strArray, int32_t& length) {
    int32_t arrLen;
    readArrayLen(&arrLen);
    length = arrLen;
    if (arrLen == -1) {
      *strArray = NULL;
      return;
    } else {
      char** tmpArray;
      GF_NEW( tmpArray, char*[arrLen]);
      for (int i = 0; i < arrLen; i++) {
        readString(&tmpArray[i]);
      }
      *strArray = tmpArray;
    }
  }

  inline void readWideStringArray(wchar_t*** strArray, int32_t& length) {
    int32_t arrLen;
    readArrayLen(&arrLen);
    length = arrLen;
    if (arrLen == -1) {
      *strArray = NULL;
      return;
    } else {
      wchar_t** tmpArray;
      GF_NEW( tmpArray, wchar_t*[arrLen]);
      for (int i = 0; i < arrLen; i++) {
        readWideString(&tmpArray[i]);
      }
      *strArray = tmpArray;
    }
  }

  inline void readArrayOfByteArrays(int8_t*** arrayofBytearr,
    int32_t& arrayLength, int32_t** elementLength) {
    int32_t arrLen;
    readArrayLen(&arrLen);
    arrayLength = arrLen;

    if (arrLen == -1) {
      *arrayofBytearr = NULL;
      return;
    } else {
      int8_t** tmpArray;
      int32_t* tmpLengtharr;
      GF_NEW( tmpArray, int8_t*[arrLen]);
      GF_NEW( tmpLengtharr, int32_t[arrLen]);
      for (int i = 0; i < arrLen; i++) {
        readBytes(&tmpArray[i], &tmpLengtharr[i]);
      }
      *arrayofBytearr = tmpArray;
      *elementLength = tmpLengtharr;
    }
  }

  static int32_t getDecodedLength( const uint8_t* value, int32_t length )
  {
    const uint8_t* end = value + length;
    int32_t decodedLen = 0;
    while ( value < end ) {
       // get next byte unsigned
    int32_t b = *value++ & 0xff;
    int32_t k = b >> 5;
    // classify based on the high order 3 bits
      switch (  k )
        {       
        case 6:
          {
            value++;
            break;
          }
        case 7:
          {
            value += 2;
            break;
          }
        default:
          break;
        }
      decodedLen += 1;
    }
    if ( value > end ) decodedLen--;
    return decodedLen;
  }

  DataInput(const uint8_t* m_buffer, int32_t len)
    : m_buf(m_buffer), m_bufHead(m_buffer), m_bufLength(len), m_poolName(NULL)
  {
  }

  ~DataInput( ) { }

  inline const uint8_t* currentBufferPosition() const
  {
    return m_buf;
  }

  inline int32_t getBytesRead() const
  {
    return static_cast<int32_t>(m_buf - m_bufHead);
  }

  inline int32_t getBytesRemaining() const
  {
    return (m_bufLength - getBytesRead());
  }

  inline void advanceCursor(int32_t offset)
  {
    m_buf += offset;
  }

  inline void rewindCursor(int32_t offset)
  {
    m_buf -= offset;
  }

  inline void reset()
  {
    m_buf = m_bufHead;
  }

  inline void setBuffer()
  {
    m_buf = currentBufferPosition();    
    m_bufLength = getBytesRemaining();   
  }

  inline void resetPdx(int32_t offset )
  {
    m_buf = m_bufHead + offset;
    //setBuffer();
  }

  inline int32_t getPdxBytes() const
  {
    return m_bufLength;
  }

  static uint8_t * getBufferCopy(const uint8_t *from, uint32_t length)
  {
    uint8_t * result;
    GF_NEW( result, uint8_t[ length ] );
    memcpy( result, from, length);
    
    return result;
  }

  inline void reset(int32_t offset )
  {
    m_buf = m_bufHead + offset;
  }

  uint8_t * getBufferCopyFrom(const uint8_t *from, uint32_t length)
  {
    uint8_t * result;
    GF_NEW( result, uint8_t[ length ] );
    memcpy( result, from, length);
    
    return result;
  }

  /*
   * This is for internal use
   */
  const char* getPoolName()
  {
    return m_poolName;
  }

  /*
   * This is for internal use
   */
  void setPoolName(const char* poolName)
  {
    m_poolName = poolName;
  }

private:

  const uint8_t* m_buf;
  const uint8_t* m_bufHead;
  int32_t m_bufLength;
  const char* m_poolName;

  void readObjectInternal( SerializablePtr& ptr, int8_t typeId = -1 );

  template <typename mType>
  void readObject(mType** value, int32_t& length)
  {
    int arrayLen;
    readArrayLen(&arrayLen);
    length = arrayLen;
    mType* objArray;
    if(arrayLen > 0) {
      objArray = new mType[arrayLen];
      int i = 0;
      for( i = 0; i < arrayLen; i++ ){
        mType tmp = 0;
        readObject(&tmp);
        objArray[i] =  tmp; //*value[i] = tmp;
      }
      *value = objArray;
    }
  }

  inline void readPdxChar(char* value){
    int16_t val = 0;
    readInt(&val);
    *value = (char)val;
  }

  inline void _checkBufferSize(int32_t size, int32_t line)
  {
    if ((m_bufLength - (m_buf - m_bufHead)) < size) {
      char exMsg[128];
      gf_sprintf(exMsg, "DataInput: attempt to read beyond buffer at line %d: "
          "available buffer size %d, attempted read of size %d ", line,
          m_bufLength - (m_buf - m_bufHead), size);
      throw OutOfRangeException(exMsg);
    }
  }

  inline void decodeChar( char* str )
  {
    uint8_t bt = *(m_buf++);
    if ( bt & 0x80 ) {
      if ( bt & 0x20 ) {
        // three bytes.
        *str = (char)(((bt & 0x0f) << 12) | (((*m_buf++) & 0x3f) << 6));
        *str |= (char)((*m_buf++) & 0x3f);
      } else {
        // two bytes.
        *str = (char)(((bt & 0x1f) << 6) | ((*m_buf++) & 0x3f));
      }
    } else {
      // single byte...
      *str = bt;
    }
  }

  inline void decodeChar( wchar_t* str )
  {
    // get next byte unsigned
    int32_t b = *m_buf++ & 0xff;
    int32_t k = b >> 5;
    // classify based on the high order 3 bits
    switch (  k )
      {     
      case 6:
        {
          // two byte encoding
          // 110yyyyy 10xxxxxx
          // use low order 6 bits
          int32_t y = b & 0x1f;
          // use low order 6 bits of the next byte
          // It should have high order bits 10, which we don't check.
          int32_t x = *m_buf++ & 0x3f;
          // 00000yyy yyxxxxxx
          *str = ( y << 6 | x );
          break;
        }
    case 7:
      {
        // three byte encoding
        // 1110zzzz 10yyyyyy 10xxxxxx
        //assert ( b & 0x10 )
          //     == 0 : "UTF8Decoder does not handle 32-bit characters";
        // use low order 4 bits
        int32_t z = b & 0x0f;
        // use low order 6 bits of the next byte
        // It should have high order bits 10, which we don't check.
        int32_t y = *m_buf++ & 0x3f;
        // use low order 6 bits of the next byte
        // It should have high order bits 10, which we don't check.
        int32_t x = *m_buf++ & 0x3f;
        // zzzzyyyy yyxxxxxx
        int32_t asint = ( z << 12 | y << 6 | x );
        *str =  asint;
        break;
      }
       default:
        // one byte encoding
        // 0xxxxxxx
        // use just low order 7 bits
        // 00000000 0xxxxxxx
        *str = ( b & 0x7f );
        break;
    }    
  }

  // disable other constructors and assignment
  DataInput();
  DataInput(const DataInput&);
  DataInput& operator =(const DataInput&);
};

}

#endif // __GEMFIRE_DATAINPUT_H__

---