geode-client-native/src/cppcache/CacheableString.hpp - geode - Git at Google

 #ifndef _GEMFIRE_CACHEABLESTRING_HPP_
 #define _GEMFIRE_CACHEABLESTRING_HPP_

 /*=========================================================================
  * 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 "gf_types.hpp"
 #include "CacheableKey.hpp"
 #include "GemfireTypeIds.hpp"
 #include "ExceptionTypes.hpp"

 /** @file
  */

 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

   /**
    * Implement a immutable C string wrapper that can serve as a distributable
    * key object for caching as well as being a string value.
    */
   class CPPCACHE_EXPORT CacheableString: public CacheableKey
   {
   protected:
     void* m_str;
     int8_t m_type;
     uint32_t m_len;
     mutable int m_hashcode;

   public:
     /**
      *@brief serialize this object
      **/
     virtual void toData(DataOutput& output) const;

     /**
      *@brief deserialize this object
      * Throw IllegalArgumentException if the packed CacheableString is not less
      * than 64K bytes.
      **/
     virtual Serializable* fromData(DataInput& input);

     /** creation function for strings */
     static Serializable* createDeserializable();

     /** creation function for strings > 64K length */
     static Serializable* createDeserializableHuge();

     /** creation function for wide strings */
     static Serializable* createUTFDeserializable();

     /** creation function for wide strings > 64K length in UTF8 encoding */
     static Serializable* createUTFDeserializableHuge();

     /**
      *@brief Return the classId of the instance being serialized.
      * This is used by deserialization to determine what instance
      * type to create and deserialize into.
      */
     virtual int32_t classId() const;

     /**
      * Return the typeId byte of the instance being serialized.
      * This is used by deserialization to determine what instance
      * type to create and deserialize into.
      *
      * For a <code>CacheableString</code> this shall return
      * <code>GemfireTypeIds::CacheableNullString</code> if the underlying
      * string is null, <code>GemfireTypeIds::CacheableASCIIString</code>
      * if the underlying string is a char*, and
      * <code>GemfireTypeIds::CacheableString</code> if it is a wchar_t*.
      * For strings larger than 64K it will return
      * <code>GemfireTypeIds::CacheableASCIIStringHuge</code> and
      * <code>GemfireTypeIds::CacheableStringHuge</code> for char* and wchar_t*
      * respectively.
      */
     virtual int8_t typeId() const;

     /** return true if this key matches other. */
     virtual bool operator==(const CacheableKey& other) const;

     /** return the hashcode for this key. */
     virtual uint32_t hashcode() const;

     /**
      * Factory method for creating an instance of CacheableString from
      * a null terminated C string optionally giving the length.
      *
      * This should be used only for ASCII strings.
      */
     static CacheableStringPtr create(const char* value, int32_t len = 0)
     {
       CacheableStringPtr str = NULLPTR;
       if (value != NULL) {
         str = new CacheableString();
         str->initString(value, len);
       }
       return str;
     }

     /**
      * Factory method for creating an instance of CacheableString from
      * a C string of given length by taking ownership of the string without
      * making a copy. The string should have been allocated using
      * the standard C++ new operator.
      *
      * This should be used only for ASCII strings.
      *
      * CAUTION: use this only when you really know what you are doing.
      */
     static CacheableStringPtr createNoCopy(char* value, int32_t len = 0)
     {
       CacheableStringPtr str = NULLPTR;
       if (value != NULL) {
         str = new CacheableString();
         str->initStringNoCopy(value, len);
       }
       return str;
     }

     /**
      * Factory method for creating an instance of CacheableString from a
      * wide-character null terminated C string optionally giving the length.
      *
      * This should be used for non-ASCII strings.
      */
     static CacheableStringPtr create(const wchar_t* value, int32_t len = 0)
     {
       CacheableStringPtr str = NULLPTR;
       if (value != NULL) {
         str = new CacheableString();
         str->initString(value, len);
       }
       return str;
     }

     /**
      * Factory method for creating an instance of CacheableString from a
      * wide-character C string of given length by taking ownership of the
      * string without making a copy. The string should have been allocated
      * using the standard C++ new operator.
      *
      * This should be used for non-ASCII strings.
      *
      * CAUTION: use this only when you really know what you are doing.
      */
     static CacheableStringPtr createNoCopy(wchar_t* value, int32_t len = 0)
     {
       CacheableStringPtr str = NULLPTR;
       if (value != NULL) {
         str = new CacheableString();
         str->initStringNoCopy(value, len);
       }
       return str;
     }

     /** Returns true if the underlying string is a normal C string. */
     inline bool isCString() const
     {
       return (m_type == GF_STRING || m_type == GF_STRING_HUGE);
     }

     /** Returns true if the underlying string is a wide-character string. */
     inline bool isWideString() const
     {
       return (m_type == GF_WIDESTRING || m_type == GF_WIDESTRING_HUGE);
     }

     /**
      * Return the string that backs this CacheableString as a char *. This
      * shall throw an exception if the underlying string is a wchar_t* --
      * the caller should use <code>typeId</code> to determine the actual type,
      * or <code>isWideString</code> to find whether this is a wide-character
      * string.
      *
      * @throws IllegalStateException if the underlying string is a wchar_t *
      */
     const char* asChar() const
     {
       if (isWideString()) {
         throw IllegalStateException("CacheableString::asChar: the string is a "
           "wide character string; use asWChar() to obtain it.");
       }
       return (const char*) m_str;
     }

     /**
      * Return the string that backs this CacheableString as a wchar_t *. This
      * shall throw an exception if the underlying string is a char* --
      * the caller should use <code>typeId</code> to determine the actual type,
      * or <code>isWideString</code> to find whether this is indeed a
      * wide-character string.
      *
      * @throws IllegalStateException if the underlying string is a char *
      */
     const wchar_t* asWChar() const
     {
       if (isCString()) {
         throw IllegalStateException("CacheableString::asWChar: the string is "
           "not a wide character string; use asChar() to obtain it.");
       }
       return (const wchar_t*) m_str;
     }

     /** Return the length of the contained string. */
     inline uint32_t length() const
     {
       return m_len;
     }

     /**
      * Display this object as c string. In this case, it returns the same
      * value as asChar() when underlying type is a char* and returns the same
      * value as asWChar() cast to char* when the underlying type is a wchar_t*.
      * To handle this correctly the user should find the actual type by calling
      * typeId() or isWideString() and cast to the correct type accordingly.
      * Note: this is a debugging API, not intended for getting the exact value
      * of the CacheableString. In a future release this may return a more
      * summary representation. This is historical. It is preferred that the
      * user call logString or asChar/asWChar, depending on the need.
      */
     const char* toString()
     {
       return (const char*) m_str;
     }

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

     /** get the name of the class of this object for logging purpose */
     virtual const char* className() const
     {
       return "CacheableString";
     }

     /** Destructor */
     virtual ~CacheableString();

     /** used to render as a string for logging. */
     virtual int32_t logString(char* buffer, int32_t maxLength) const;

     virtual uint32_t objectSize() const;

   protected:

     /** Private method to populate the <code>CacheableString</code>. */
     void copyString(const char* value, int32_t len);
     /** Private method to populate the <code>CacheableString</code>. */
     void copyString(const wchar_t* value, int32_t len);
     /** initialize the string, given a value and length. */
     void initString(const char* value, int32_t len);
     /**
      * Initialize the string without making a copy, given a C string
      * and length.
      */
     void initStringNoCopy(char* value, int32_t len);
     /** initialize the string, given a wide-char string and length. */
     void initString(const wchar_t* value, int32_t len);
     /**
      * Initialize the string without making a copy, given a wide-char string
      * and length.
      */
     void initStringNoCopy(wchar_t* value, int32_t len);
     /** Private method to get ASCII string for wide-string if possible. */
     char* getASCIIString(const wchar_t* value, int32_t& len,
         int32_t& encodedLen);
     /** Default constructor. */
     inline CacheableString(int8_t type = GF_STRING) :
       m_str(NULL), m_type(type), m_len(0), m_hashcode(0)
     {
     }

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

   /** overload of gemfire::createKeyArr to pass char* */
   inline CacheableKeyPtr createKeyArr(const char* value)
   {
     return (value != NULL ? CacheableKeyPtr(CacheableString::create(
         value).ptr()) : NULLPTR);
   }

   /** overload of gemfire::createKeyArr to pass wchar_t* */
   inline CacheableKeyPtr createKeyArr(const wchar_t* value)
   {
     return (value != NULL ? CacheableKeyPtr(CacheableString::create(
         value).ptr()) : NULLPTR);
   }

   /** overload of gemfire::createValueArr to pass char* */
   inline CacheablePtr createValueArr(const char* value)
   {
     return (value != NULL ? CacheablePtr(CacheableString::create(
         value).ptr()) : NULLPTR);
   }

   /** overload of gemfire::createValueArr to pass wchar_t* */
   inline CacheablePtr createValueArr(const wchar_t* value)
   {
     return (value != NULL ? CacheablePtr(CacheableString::create(
         value).ptr()) : NULLPTR);
   }
 }


 #endif
	#ifndef _GEMFIRE_CACHEABLESTRING_HPP_
	#define _GEMFIRE_CACHEABLESTRING_HPP_

	/*=========================================================================
	* 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 "gf_types.hpp"
	#include "CacheableKey.hpp"
	#include "GemfireTypeIds.hpp"
	#include "ExceptionTypes.hpp"

	/** @file
	*/

	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

	/**
	* Implement a immutable C string wrapper that can serve as a distributable
	* key object for caching as well as being a string value.
	*/
	class CPPCACHE_EXPORT CacheableString: public CacheableKey
	{
	protected:
	void* m_str;
	int8_t m_type;
	uint32_t m_len;
	mutable int m_hashcode;

	public:
	/**
	*@brief serialize this object
	**/
	virtual void toData(DataOutput& output) const;

	/**
	*@brief deserialize this object
	* Throw IllegalArgumentException if the packed CacheableString is not less
	* than 64K bytes.
	**/
	virtual Serializable* fromData(DataInput& input);

	/** creation function for strings */
	static Serializable* createDeserializable();

	/** creation function for strings > 64K length */
	static Serializable* createDeserializableHuge();

	/** creation function for wide strings */
	static Serializable* createUTFDeserializable();

	/** creation function for wide strings > 64K length in UTF8 encoding */
	static Serializable* createUTFDeserializableHuge();

	/**
	*@brief Return the classId of the instance being serialized.
	* This is used by deserialization to determine what instance
	* type to create and deserialize into.
	*/
	virtual int32_t classId() const;

	/**
	* Return the typeId byte of the instance being serialized.
	* This is used by deserialization to determine what instance
	* type to create and deserialize into.
	*
	* For a <code>CacheableString</code> this shall return
	* <code>GemfireTypeIds::CacheableNullString</code> if the underlying
	* string is null, <code>GemfireTypeIds::CacheableASCIIString</code>
	* if the underlying string is a char*, and
	* <code>GemfireTypeIds::CacheableString</code> if it is a wchar_t*.
	* For strings larger than 64K it will return
	* <code>GemfireTypeIds::CacheableASCIIStringHuge</code> and
	* <code>GemfireTypeIds::CacheableStringHuge</code> for char* and wchar_t*
	* respectively.
	*/
	virtual int8_t typeId() const;

	/** return true if this key matches other. */
	virtual bool operator==(const CacheableKey& other) const;

	/** return the hashcode for this key. */
	virtual uint32_t hashcode() const;

	/**
	* Factory method for creating an instance of CacheableString from
	* a null terminated C string optionally giving the length.
	*
	* This should be used only for ASCII strings.
	*/
	static CacheableStringPtr create(const char* value, int32_t len = 0)
	{
	CacheableStringPtr str = NULLPTR;
	if (value != NULL) {
	str = new CacheableString();
	str->initString(value, len);
	}
	return str;
	}

	/**
	* Factory method for creating an instance of CacheableString from
	* a C string of given length by taking ownership of the string without
	* making a copy. The string should have been allocated using
	* the standard C++ new operator.
	*
	* This should be used only for ASCII strings.
	*
	* CAUTION: use this only when you really know what you are doing.
	*/
	static CacheableStringPtr createNoCopy(char* value, int32_t len = 0)
	{
	CacheableStringPtr str = NULLPTR;
	if (value != NULL) {
	str = new CacheableString();
	str->initStringNoCopy(value, len);
	}
	return str;
	}

	/**
	* Factory method for creating an instance of CacheableString from a
	* wide-character null terminated C string optionally giving the length.
	*
	* This should be used for non-ASCII strings.
	*/
	static CacheableStringPtr create(const wchar_t* value, int32_t len = 0)
	{
	CacheableStringPtr str = NULLPTR;
	if (value != NULL) {
	str = new CacheableString();
	str->initString(value, len);
	}
	return str;
	}

	/**
	* Factory method for creating an instance of CacheableString from a
	* wide-character C string of given length by taking ownership of the
	* string without making a copy. The string should have been allocated
	* using the standard C++ new operator.
	*
	* This should be used for non-ASCII strings.
	*
	* CAUTION: use this only when you really know what you are doing.
	*/
	static CacheableStringPtr createNoCopy(wchar_t* value, int32_t len = 0)
	{
	CacheableStringPtr str = NULLPTR;
	if (value != NULL) {
	str = new CacheableString();
	str->initStringNoCopy(value, len);
	}
	return str;
	}

	/** Returns true if the underlying string is a normal C string. */
	inline bool isCString() const
	{
	return (m_type == GF_STRING \|\| m_type == GF_STRING_HUGE);
	}

	/** Returns true if the underlying string is a wide-character string. */
	inline bool isWideString() const
	{
	return (m_type == GF_WIDESTRING \|\| m_type == GF_WIDESTRING_HUGE);
	}

	/**
	* Return the string that backs this CacheableString as a char *. This
	* shall throw an exception if the underlying string is a wchar_t* --
	* the caller should use <code>typeId</code> to determine the actual type,
	* or <code>isWideString</code> to find whether this is a wide-character
	* string.
	*
	* @throws IllegalStateException if the underlying string is a wchar_t *
	*/
	const char* asChar() const
	{
	if (isWideString()) {
	throw IllegalStateException("CacheableString::asChar: the string is a "
	"wide character string; use asWChar() to obtain it.");
	}
	return (const char*) m_str;
	}

	/**
	* Return the string that backs this CacheableString as a wchar_t *. This
	* shall throw an exception if the underlying string is a char* --
	* the caller should use <code>typeId</code> to determine the actual type,
	* or <code>isWideString</code> to find whether this is indeed a
	* wide-character string.
	*
	* @throws IllegalStateException if the underlying string is a char *
	*/
	const wchar_t* asWChar() const
	{
	if (isCString()) {
	throw IllegalStateException("CacheableString::asWChar: the string is "
	"not a wide character string; use asChar() to obtain it.");
	}
	return (const wchar_t*) m_str;
	}

	/** Return the length of the contained string. */
	inline uint32_t length() const
	{
	return m_len;
	}

	/**
	* Display this object as c string. In this case, it returns the same
	* value as asChar() when underlying type is a char* and returns the same
	* value as asWChar() cast to char* when the underlying type is a wchar_t*.
	* To handle this correctly the user should find the actual type by calling
	* typeId() or isWideString() and cast to the correct type accordingly.
	* Note: this is a debugging API, not intended for getting the exact value
	* of the CacheableString. In a future release this may return a more
	* summary representation. This is historical. It is preferred that the
	* user call logString or asChar/asWChar, depending on the need.
	*/
	const char* toString()
	{
	return (const char*) m_str;
	}

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

	/** get the name of the class of this object for logging purpose */
	virtual const char* className() const
	{
	return "CacheableString";
	}

	/** Destructor */
	virtual ~CacheableString();

	/** used to render as a string for logging. */
	virtual int32_t logString(char* buffer, int32_t maxLength) const;

	virtual uint32_t objectSize() const;

	protected:

	/** Private method to populate the <code>CacheableString</code>. */
	void copyString(const char* value, int32_t len);
	/** Private method to populate the <code>CacheableString</code>. */
	void copyString(const wchar_t* value, int32_t len);
	/** initialize the string, given a value and length. */
	void initString(const char* value, int32_t len);
	/**
	* Initialize the string without making a copy, given a C string
	* and length.
	*/
	void initStringNoCopy(char* value, int32_t len);
	/** initialize the string, given a wide-char string and length. */
	void initString(const wchar_t* value, int32_t len);
	/**
	* Initialize the string without making a copy, given a wide-char string
	* and length.
	*/
	void initStringNoCopy(wchar_t* value, int32_t len);
	/** Private method to get ASCII string for wide-string if possible. */
	char* getASCIIString(const wchar_t* value, int32_t& len,
	int32_t& encodedLen);
	/** Default constructor. */
	inline CacheableString(int8_t type = GF_STRING) :
	m_str(NULL), m_type(type), m_len(0), m_hashcode(0)
	{
	}

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

	/** overload of gemfire::createKeyArr to pass char* */
	inline CacheableKeyPtr createKeyArr(const char* value)
	{
	return (value != NULL ? CacheableKeyPtr(CacheableString::create(
	value).ptr()) : NULLPTR);
	}

	/** overload of gemfire::createKeyArr to pass wchar_t* */
	inline CacheableKeyPtr createKeyArr(const wchar_t* value)
	{
	return (value != NULL ? CacheableKeyPtr(CacheableString::create(
	value).ptr()) : NULLPTR);
	}

	/** overload of gemfire::createValueArr to pass char* */
	inline CacheablePtr createValueArr(const char* value)
	{
	return (value != NULL ? CacheablePtr(CacheableString::create(
	value).ptr()) : NULLPTR);
	}

	/** overload of gemfire::createValueArr to pass wchar_t* */
	inline CacheablePtr createValueArr(const wchar_t* value)
	{
	return (value != NULL ? CacheablePtr(CacheableString::create(
	value).ptr()) : NULLPTR);
	}
	}


	#endif