H:/gfcppsancout/product/include/gfcpp/DataInput.hpp

Go to the documentation of this file.

#ifndef __GEMFIRE_DATAINPUT_H__
#define __GEMFIRE_DATAINPUT_H__

/*=========================================================================
 * (c) Copyright 2002-2007, GemStone Systems, Inc. All Rights Reserved.
 * 1260 NW Waterhouse Ave., Suite 200,  Beaverton, OR 97006
 *=========================================================================
 */

#include "gfcpp_globals.hpp"
#include "ExceptionTypes.hpp"
#include <string.h>
#include "Serializable.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 = (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 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 void readObject( SerializablePtr& ptr )
  {
    readObjectInternal( ptr );
  }

  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)
  {
  }

  ~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;
  }

  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;
  }

private:

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

  void readObjectInternal( SerializablePtr& ptr );

  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 = ((bt & 0x0f) << 12) | (((*m_buf++) & 0x3f) << 6);
        *str |= ((*m_buf++) & 0x3f);
      } else {
        // two bytes.
        *str = ((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__

---