sdk_string_handler.h

Go to the documentation of this file.

#ifndef SDK_SDK_STRING_HANDLER_H_
#define SDK_SDK_STRING_HANDLER_H_
 
#include <cassert>
#include <string>
#include <iterator>
#include <base/inc/platform.h>
#include <base/inc/memory_portable.h>
#include <base/inc/base_types.h>
#include <base/inc/base_library/base_types_functions.h>
 
namespace sdk {
 
static std::string SDKMakeString(const SDKString& sdk_string) {
  if (0 == sdk_string.length || NULL == sdk_string.data)
    return std::string();
 
  std::string str;
  try
  {
    // TODO: Refactoring
    for (unsigned int counter = 0; counter < sdk_string.length; ++counter) {
      char symb = static_cast<char>(sdk_string.data[counter]);
      str.push_back(symb);
    }
  } catch(...) {
  }
  //TODO: handle errors
  return str;
}
 
static std::wstring SDKMakeWString(const SDKString& sdk_string) {
  if (0 == sdk_string.length || NULL == sdk_string.data)
    return std::wstring();
 
  std::wstring wstr;
  try
  {
    std::copy(sdk_string.data, sdk_string.data + sdk_string.length, 
      std::back_inserter(wstr));
  } catch(...) {
  }
  //TODO: handle errors
  return wstr;
}
 
#if !defined(WideFromSDKString)
#define WideFromSDKString(arg) SDKMakeWString(arg)
#endif
 
#if !defined(ASCIIFromSDKString)
#define ASCIIFromSDKString(arg) SDKMakeString(arg)
#endif
 
static inline SDKResult SDKStringFromWide(const std::wstring& wide, 
  SDKString* sdk_string) {
  return SDKStringCreateW(sdk_string, wide.c_str(), 
    static_cast<SDKUInt32>(wide.size()));
}
 
static inline SDKResult SDKStringFromASCII(const std::string& ascii, 
  SDKString* sdk_string) {
  return SDKStringCreateA(sdk_string, ascii.c_str(), 
    static_cast<SDKUInt32>(ascii.size()));
}
 
class SDKAnyHandler;
 
class SDKStringHandler : public SDKString {
public:
  SDKStringHandler() {
    //SDKStringInit(&(*this));
    (*this).length = 0;
    (*this).data = NULL;
  }
 
  explicit SDKStringHandler(const char* ascii, SDKUInt32 size = 0) {
    SDKStringCreateA(&(*this), ascii, size);
    //TODO: handle errors
  }
 
  explicit SDKStringHandler(const wchar_t* wide, SDKUInt32 size = 0) {
    SDKStringCreateW(&(*this), wide, size);
    //TODO: handle errors
  }
 
  explicit SDKStringHandler(SDKUInt32 size, const SDKUInt16* wide) {
    SDKStringCreateI(&(*this), wide, size);
  }
 
  explicit SDKStringHandler(const std::wstring& wide) {
    SDKStringInit(&(*this));
    if (!wide.empty()) {
      SDKStringCreateW(&(*this), wide.c_str(), 
        static_cast<SDKUInt32>(wide.size()));
      //TODO: handle errors
    }
  }
 
  explicit SDKStringHandler(const std::string& ascii) {
    SDKStringInit(&(*this));
    if (!ascii.empty()) {
      SDKStringCreateA(&(*this), ascii.c_str(), 
        static_cast<SDKUInt32>(ascii.size()));
      //TODO: handle errors
    }
  }
 
  explicit SDKStringHandler(const SDKString& instance) {
    SDKStringInit(&(*this));
    SDKStringDuplicate(&instance, &(*this));
  }
 
  explicit SDKStringHandler(SDKString& instance, bool duplicate) {
    SDKStringInit(&(*this));
    if (duplicate) {
      SDKStringDuplicate(&instance, &(*this));
    } else {
      Attach(instance);
    }
  }
 
  /*explicit */SDKStringHandler(const SDKStringHandler& from) {
    SDKStringInit(&(*this));
    SDKStringDuplicate(&from.GetReference(), &(*this)); 
  }
 
  ~SDKStringHandler() {
    Clear();
  }
 
  SDKStringHandler& operator=(const SDKStringHandler& from) {
    if (&from != this) {
      Clear();
      SDKStringDuplicate(&from, &(*this));
    }
    return *this;
  }
 
  SDKStringHandler& operator=(const SDKString& from) {
    if (&from != this) {
      Clear();
      SDKStringDuplicate(&from, &(*this));
    }
    return *this;
  }
 
  #if defined(SDK_HAS_CXX0X_RVALUE_REFS)
  // C++0x is supported
  SDKStringHandler(SDKStringHandler&& from) : SDKString(from) {
    from.length = 0;
    from.data = NULL;
  }
 
  SDKStringHandler(SDKString&& from) : SDKString(from) {
    from.length = 0;
    from.data = NULL;
  }
 
  SDKStringHandler& operator=(SDKStringHandler&& from)
  {
    assert(&from != this);
    static_cast<SDKString&>(*this) = from;
    from.length = 0;
    from.data = NULL;
    return *this;
  }
 
  SDKStringHandler& operator=(SDKString&& from) {
    assert(&from != this); // Paranoid
    static_cast<SDKString&>(*this) = from;
    from.length = 0;
    from.data = NULL;
    return *this;
  }
  #endif
 
  void operator=(const char* ascii) {
    Clear();
    SDKStringCreateA(&(*this), ascii, 0);
  }
 
  void operator=(const wchar_t* wide) {
    Clear();
    SDKStringCreateW(&(*this), wide, 0);
  }
 
  void operator=(const std::string& ascii) {
    Clear();
    SDKStringCreateA(&(*this), ascii.c_str(), 
      static_cast<SDKUInt32>(ascii.size()));
  }
 
  void operator=(const std::wstring& wide) {
    Clear();
    SDKStringCreateW(&(*this), wide.c_str(), 
      static_cast<SDKUInt32>(wide.size()));
  }
 
  bool operator==(const char* ascii) const {
    SDKStringHandler scoped_ascii(ascii);
    return (kSDKResult_True == SDKStringCompare(&(*this), &scoped_ascii));
  }
 
  bool operator==(const wchar_t* wide) const {
    SDKStringHandler scoped_wide(wide);
    return (kSDKResult_True == SDKStringCompare(&(*this), &scoped_wide));
  }
 
  SDKString* operator&() {
    return static_cast<SDKString*>(this);
  }
 
  //operator SDKString&() {
  //  return GetReference();
  //}
 
  //operator const SDKString&() const {
  //  return GetReference();
  //}
 
  SDKStringHandler& Attach(SDKString& instance) {
    Clear();
    static_cast<SDKString&>(*this) = instance;
    SDKStringInit(&instance); // clear input variable
    return *this;
  }
 
  SDKString Detach() {
    SDKString instance;
    instance = static_cast<SDKString&>(*this);
    SDKStringInit(&(*this));
    return instance;
  }
 
  SDKString Copy() {
    SDKString res;
    SDKStringInit(&res);
    SDKStringDuplicate(&(*this), &res);
    return res;
  }
 
  SDKAny DetachAsAny() {
    SDKAny any;
    SDKAnyInitString(&any);
    *any.str = static_cast<SDKString&>(*this);
    SDKStringInit(&(*this));
    return any;
  }
 
  void Clear() {
    SDKStringDelete(&(*this));
  }
 
  std::wstring WString() const {
    return WideFromSDKString((*this));
  }
  std::string ASCIIString() const {
    return ASCIIFromSDKString((*this));
  }
 
  SDKUInt64 GetLength() const { 
    return (*this).length; 
  }
 
  SDKUInt16* GetData() { 
    return (*this).data; 
  }
 
  const SDKUInt16* GetData() const { 
    return (*this).data; 
  }
 
  SDKString& GetReference() { 
    return *(static_cast<SDKString*>(this)); 
  }
 
  const SDKString& GetReference() const { 
    return *(static_cast<const SDKString*>(this)); 
  }
 
private:
//  SDKString m_instance;
  friend class SDKAnyHandler;
};
typedef sdk::SDKStringHandler ScopedString;
 
class SDKStringWrapper {
public:
  SDKStringWrapper(SDKString& instance) : m_instance(instance) {
  }
 
  SDKUInt64        GetLength() const { 
    return m_instance.length; 
  }
 
  SDKUInt16* GetData() { 
    return m_instance.data; 
  }
 
  const SDKUInt16* GetData() const { 
    return m_instance.data; 
  }
 
private:
  SDKStringWrapper(const SDKStringWrapper&);
  void operator=(const SDKStringWrapper&);
 
  SDKString& m_instance;
};
 
class SDKStringReturnHelper {
public:
  SDKStringReturnHelper(std::wstring& wstr) : m_wstr(wstr) {
    SDKStringInit(&m_sdk_string);
  }
 
  ~SDKStringReturnHelper() {
    m_wstr = SDKMakeWString(m_sdk_string);
    SDKStringDelete(&m_sdk_string);
  }
 
  operator SDKString&() { 
    return m_sdk_string; 
  }
 
  operator const SDKString&() const { 
    return m_sdk_string; 
  }
 
  SDKString& GetReference() { 
    return m_sdk_string; 
  }
 
private:
  SDKStringReturnHelper(const SDKStringReturnHelper&);
  void operator=(const SDKStringReturnHelper&);
 
private:
  SDKString     m_sdk_string;
  std::wstring& m_wstr;
};
 
inline bool IsSDKStringEqual(const SDKString* str1, const SDKString* str2) {
  if (!str1 && !str2)
    return true;
  if (!str1 || !str2)
    return false;
  
  if (str1->length != str2->length)
    return false;
 
  if (0 == str1->length)
    return true;
 
  if (NULL == str1->data || NULL == str2->data)
    return false; // wrong strings actually
 
#ifndef SDK_CC_BCC
  int cmp = memcmp(str1->data, str2->data, 
    str1->length * sizeof(str1->data[0]));
#else
  int cmp = std::memcmp(str1->data, str2->data, 
    str1->length * sizeof(str1->data[0]));
#endif
 
  return (0 == cmp);
}
 
} // namespace sdk 
 
#endif // SDK_SDK_STRING_HANDLER_H_