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"

namespace gemfire {

#define GF_STRING (int8_t)GemfireTypeIds::CacheableASCIIString
#define GF_STRING_HUGE (int8_t)GemfireTypeIds::CacheableASCIIStringHuge
#define GF_WIDESTRING (int8_t)GemfireTypeIds::CacheableString
#define GF_WIDESTRING_HUGE (int8_t)GemfireTypeIds::CacheableStringHuge

class CPPCACHE_EXPORT CacheableString
  : public CacheableKey
{
protected:

    void* m_str;
    int8_t m_type;
    uint32_t m_len;

public:

  virtual void toData( DataOutput& output ) const;

  virtual Serializable* fromData( DataInput& input );

  static Serializable* createDeserializable( );

  static Serializable* createDeserializableHuge( );

  static Serializable* createUTFDeserializable( );

  static Serializable* createUTFDeserializableHuge( );

  virtual int32_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 CacheableStringPtr(new CacheableString(value));
  }

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

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

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

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

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


  const char* asChar( ) const
  {
    if ( m_type == GF_WIDESTRING || m_type == GF_WIDESTRING_HUGE ) {
      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 || m_type == GF_STRING_HUGE ) {
      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 || m_type == GF_WIDESTRING_HUGE );
  }

  inline uint32_t length( ) const {
    return m_len;
  }

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

  virtual CacheableStringPtr toString() const
  {
    return CacheableStringPtr(this);
  }

  virtual const char* className() const
  {
    return "CacheableString";
  }

  virtual ~CacheableString( );

  virtual size_t logString( char* buffer, size_t maxLength ) const;

  virtual uint32_t objectSize() const;

  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_STRING )
    : 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

---