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

Go to the documentation of this file.

#ifndef _GEMFIRE_CACHEABLESTRING_HPP_
#define _GEMFIRE_CACHEABLESTRING_HPP_
/*=========================================================================
 * (c) Copyright 2002-2007, GemStone Systems, Inc. All Rights Reserved.  
 * 1260 NW Waterhouse Ave., Suite 200,  Beaverton, OR 97006
 *=========================================================================
 */
#include "gfcpp_globals.hpp"
#include "gf_types.hpp"
#include "CacheableKey.hpp"
#include "GemfireTypeIds.hpp"
#include "ExceptionTypes.hpp"


#ifndef CACHEABLESTRING_MAX_LENGTH
  #define CACHEABLESTRING_MAX_LENGTH 64*1024
#endif

namespace gemfire {

#define GF_STRING (int8_t)GemfireTypeIds::CacheableASCIIString
#define GF_WIDESTRING (int8_t)GemfireTypeIds::CacheableString
#define GF_NULLSTRING (int8_t)GemfireTypeIds::CacheableNullString

class CPPCACHE_EXPORT CacheableString
  : public CacheableKey
{
  protected:

    void* m_str;
    int8_t m_type;
    uint16_t m_len; // K64

  public:

  virtual void toData( DataOutput& output ) const;

  virtual Serializable* fromData( DataInput& input );
  
  static Serializable* createNullDeserializable( );

  static Serializable* createDeserializable( );

  static Serializable* createUTFDeserializable( );

  virtual int8_t classId( ) const;

  virtual int8_t typeId( ) const;

  virtual bool operator==( const CacheableKey& other ) const;

  virtual uint32_t hashcode( ) const;

  static CacheableStringPtr create( const char* value )
  {
    return new CacheableString( value );
  }

  static CacheableStringPtr create( const char* value, size_t len )
  {
    return new CacheableString( value, len );
  }

  static CacheableStringPtr createNoCopy( char* value, size_t len )
  {
    return new CacheableString( value, len, true );
  }

  static CacheableStringPtr create( const wchar_t* value )
  {
    return new CacheableString( value );
  }

  static CacheableStringPtr create( const wchar_t* value, size_t len )
  {
    return new CacheableString( value, len );
  }

  static CacheableStringPtr createNoCopy( wchar_t* value, size_t len )
  {
    return new CacheableString( value, len, true );
  }


  const char* asChar( ) const
  {
    if ( m_type == GF_WIDESTRING ) {
      throw IllegalStateException( "CacheableString::asChar: the string is a "
          "wide character string; use asWChar() to obtain it." );
    }
    return (const char*)m_str;
  }

  const wchar_t* asWChar( ) const
  {
    if ( m_type == GF_STRING ) {
      throw IllegalStateException( "CacheableString::asWChar: the string is "
          "not a wide character string; use asChar() to obtain it." );
    }
    return (const wchar_t*)m_str;
  }

  inline bool isWideString( ) const
  {
    return ( m_type == GF_WIDESTRING );
  }

  inline uint16_t length( ) const { // 64K
    return m_len;
  }

  const char* toString( )
  {
    return (const char*)m_str;
  }

  virtual CacheableStringPtr toString( ) const
  {
    return this;
  }

  virtual ~CacheableString( );

  virtual size_t logString( char* buffer, size_t maxLength ) const;
  
  virtual uint32_t objectSize() const;
  
  protected:

  void checkSize( const char* value, size_t& len );
  void checkSize( const wchar_t* value, size_t& len );
  void copyString( const char* value, size_t len );
  void copyString( const wchar_t* value, size_t len );
  CacheableString( const char* value, size_t len = 0 );
  CacheableString( char* value, size_t len, bool noCopy );
  CacheableString( const wchar_t* value, size_t len = 0 );
  CacheableString( wchar_t* value, size_t len, bool noCopy );
  inline CacheableString( int8_t type = GF_NULLSTRING )
    : m_str( NULL ), m_type( type ), m_len( 0 ) { }

  private:

  // never implemented.
  void operator=( const CacheableString& other );
  CacheableString( const CacheableString& other );

};

inline CacheableKeyPtr createKeyArr( const char* value )
{
  return CacheableKeyPtr( CacheableString::create( value ).ptr( ) );
}

inline CacheableKeyPtr createKeyArr( const wchar_t* value )
{
  return CacheableKeyPtr( CacheableString::create( value ).ptr( ) );
}

inline CacheablePtr createValueArr( const char* value )
{
  return CacheablePtr( CacheableString::create( value ).ptr( ) );
}

inline CacheablePtr createValueArr( const wchar_t* value )
{
  return CacheablePtr( CacheableString::create( value ).ptr( ) );
}

}

#endif

---