CacheableString.hpp

Go to the documentation of this file.

#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"

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;
    mutable int m_hashcode;

  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, int32_t len = 0)
    {
      CacheableStringPtr str = NULLPTR;
      if (value != NULL) {
        str = new CacheableString();
        str->initString(value, len);
      }
      return str;
    }

    static CacheableStringPtr createNoCopy(char* value, int32_t len = 0)
    {
      CacheableStringPtr str = NULLPTR;
      if (value != NULL) {
        str = new CacheableString();
        str->initStringNoCopy(value, len);
      }
      return str;
    }

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

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

    inline bool isCString() const
    {
      return (m_type == GF_STRING || m_type == GF_STRING_HUGE);
    }

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

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

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

    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 int32_t logString(char* buffer, int32_t maxLength) const;

    virtual uint32_t objectSize() const;

  protected:

    void copyString(const char* value, int32_t len);
    void copyString(const wchar_t* value, int32_t len);
    void initString(const char* value, int32_t len);
    void initStringNoCopy(char* value, int32_t len);
    void initString(const wchar_t* value, int32_t len);
    void initStringNoCopy(wchar_t* value, int32_t len);
    char* getASCIIString(const wchar_t* value, int32_t& len,
        int32_t& encodedLen);
    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);
  };

  inline CacheableKeyPtr createKeyArr(const char* value)
  {
    return (value != NULL ? CacheableKeyPtr(CacheableString::create(
        value).ptr()) : NULLPTR);
  }

  inline CacheableKeyPtr createKeyArr(const wchar_t* value)
  {
    return (value != NULL ? CacheableKeyPtr(CacheableString::create(
        value).ptr()) : NULLPTR);
  }

  inline CacheablePtr createValueArr(const char* value)
  {
    return (value != NULL ? CacheablePtr(CacheableString::create(
        value).ptr()) : NULLPTR);
  }

  inline CacheablePtr createValueArr(const wchar_t* value)
  {
    return (value != NULL ? CacheablePtr(CacheableString::create(
        value).ptr()) : NULLPTR);
  }
}


#endif