sdk_any_handler.h

Go to the documentation of this file.

#ifndef SDK_SDK_ANY_HANDLER_H_
#define SDK_SDK_ANY_HANDLER_H_
 
#include <cwchar>
#include <memory>
#include <string>
#include <algorithm>
#include <base/inc/platform.h>
#include <base/inc/base_types.h>
#include <base/inc/sdk_string_handler.h>
#include <base/inc/sdk_any_helpers.h>
#include <base/inc/base_library/base_types_functions.h>
#include <base/inc/sdk_component_interface.h>
 
namespace sdk {
 
inline SDKUInt64 GetSDKAnySize(const SDKAny& any);
inline SDKUInt64 GetSDKStringSize(const SDKString& str);
inline SDKUInt64 GetSDKArraySize(const SDKArray& arr);
 
class SDKAnyHandler : public SDKAny {
public:
  SDKAnyHandler() noexcept {
    ANY_TYPE(this) = kSDKAnyType_Empty;
    ANY_UI64(this) = 0;
  }
 
  explicit SDKAnyHandler(const SDKInt8/*&*/ i8) noexcept {
    ANY_TYPE(this) = kSDKAnyType_Int8;
    ANY_I8(this)   = i8;
  }
 
  explicit SDKAnyHandler(const SDKUInt8/*&*/ ui8) noexcept {
    ANY_TYPE(this) = kSDKAnyType_Uint8;
    ANY_UI8(this)  = ui8;
  }
 
  explicit SDKAnyHandler(const SDKInt16/*&*/ i16) noexcept {
    ANY_TYPE(this) = kSDKAnyType_Int16;
    ANY_I16(this)  = i16;
  }
 
  explicit SDKAnyHandler(const SDKUInt16/*&*/ ui16) noexcept {
    ANY_TYPE(this) = kSDKAnyType_Uint16;
    ANY_UI16(this) = ui16;
  }
 
  explicit SDKAnyHandler(const SDKInt32/*&*/ i32) noexcept {
    ANY_TYPE(this) = kSDKAnyType_Int32;
    ANY_I32(this) = i32;
  }
 
  explicit SDKAnyHandler(const SDKUInt32/*&*/ ui32) noexcept {
    ANY_TYPE(this) = kSDKAnyType_Uint32;
    ANY_UI32(this) = ui32;
  }
 
  explicit SDKAnyHandler(const SDKInt64/*&*/ i64) noexcept {
    ANY_TYPE(this) = kSDKAnyType_Int64;
    ANY_I64(this) = i64;
  }
 
  explicit SDKAnyHandler(const SDKInt64/*&*/ i64, 
    SDKAnyTypeEnum any_type) noexcept {
    ANY_TYPE(this) = any_type;
    ANY_I64(this) = i64;
  }
 
  explicit SDKAnyHandler(const SDKUInt64/*&*/ ui64) noexcept {
    ANY_TYPE(this) = kSDKAnyType_Uint64;
    ANY_UI64(this) = ui64;
  }
 
  explicit SDKAnyHandler(const SDKUInt64/*&*/ ui64, 
    SDKAnyTypeEnum any_type) noexcept {
    ANY_TYPE(this) = any_type;
    ANY_UI64(this) = ui64;
  }
#if defined(SDK_ARCH_32BITS)
  explicit SDKAnyHandler(const int/*&*/ ival) noexcept {
    ANY_TYPE(this) = kSDKAnyType_Int64;
    ANY_I64(this)  = ival;
  }
 
  explicit SDKAnyHandler(const unsigned int/*&*/ uival) noexcept {
    ANY_TYPE(this) = kSDKAnyType_Uint64;
    ANY_UI64(this) = uival;
  }
#endif
#if defined(SDK_ARCH_64BITS) && defined(SDK_CC_MSVC)
  explicit SDKAnyHandler(const long/*&*/ ival) noexcept {
    ANY_TYPE(this) = kSDKAnyType_Int64;
    ANY_I64(this)  = ival;
  }
 
  explicit SDKAnyHandler(const unsigned long/*&*/ uival) noexcept {
    ANY_TYPE(this) = kSDKAnyType_Uint64;
    ANY_UI64(this) = uival;
  }
#endif
  explicit SDKAnyHandler(const float/*&*/ flt) noexcept {
    ANY_TYPE(this) = kSDKAnyType_Float;
    ANY_FLOAT(this) = flt;
  }
 
  explicit SDKAnyHandler(const double/*&*/ dbl) noexcept {
    ANY_TYPE(this) = kSDKAnyType_Double;
    ANY_DOUBLE(this) = dbl;
  }
 
  explicit SDKAnyHandler(const bool/*&*/ bl) noexcept {
    ANY_TYPE(this) = kSDKAnyType_Bool;
    ANY_BOOL(this) = bl;
  }
 
  explicit SDKAnyHandler(const SDKTime/*&*/ time, bool /*is_time*/) noexcept {
    ANY_TYPE(this) = kSDKAnyType_SDKTime;
    ANY_DATE(this) = time;
  }
 
  explicit SDKAnyHandler(const SDKAny& any) {
    ANY_TYPE(this) = kSDKAnyType_Empty;
    SDKAnyDuplicate(&any, this);
  }
 
  explicit SDKAnyHandler(const SDKString& str) {
    SDKAnyInitString(this);
    SDKStringDuplicate(&str, ANY_STR(this));
  }
 
  explicit SDKAnyHandler(const std::wstring& str) {
    SDKAnyInitString(this);
    SDKStringCreateW(ANY_STR(this), str.c_str(),
      static_cast<SDKUInt32>(str.size()));
  }
 
  explicit SDKAnyHandler(const std::string& str) {
    SDKAnyInitString(this);
    SDKStringCreateA(ANY_STR(this), str.c_str(),
      static_cast<SDKUInt32>(str.size()));
  }
 
  explicit SDKAnyHandler(const wchar_t* str) noexcept {
    SDKAnyInitString(this);
    if (str) {
      SDKStringCreateW(ANY_STR(this), str, static_cast<SDKUInt32>(wcslen(str)));
    }
  }
 
  explicit SDKAnyHandler(const char* str) noexcept {
    SDKAnyInitString(this);
    if (str) {
      SDKStringCreateA(ANY_STR(this), str, static_cast<SDKUInt32>(strlen(str)));
    }
  }
 
  SDKAnyHandler(SDKAny& any, bool duplicate) {
    ANY_TYPE(this) = kSDKAnyType_Empty;
    if (duplicate)
      SDKAnyDuplicate(&any, this);
    else
      Attach(any);
  }
 
  SDKAnyHandler(SDKString& str, bool duplicate) {
    if (duplicate) {
      SDKAnyInitString(this);
      SDKStringDuplicate(&str, ANY_STR(this));
    } else {
      ANY_TYPE(this) = kSDKAnyType_Empty;
      Attach(str);
    }
  }
 
  SDKAnyHandler(const SDKAnyHandler& any) {
    ANY_TYPE(this) = kSDKAnyType_Empty;
    SDKAnyDuplicate(&any, this);
  }
 
  explicit SDKAnyHandler(const SDKStringHandler& str) {
    SDKAnyInitString(this);
    SDKStringDuplicate(&str.GetReference(), ANY_STR(this));
  }
 
  explicit SDKAnyHandler(const SDKArrayHandler& arr) {
    SDKAnyInitArray(this, arr.GetType(), arr.GetElementSize());
    SDKArrayDuplicate(&arr.GetReference(), ANY_ARRAY(this));
  }
 
  explicit SDKAnyHandler(const SDKComponentSP& obj) noexcept {
    #if 1
    ANY_TYPE(this) = kSDKAnyType_SDKComponentPtr;
    ANY_COMPONENT(this) = obj;
    if (ANY_COMPONENT(this)) {
      ANY_COMPONENT(this)->AddRef();
  }
    #else
    ANY_TYPE(this) = kSDKAnyType_Null;
    ANY_COMPONENT(this) = obj;
    if (ANY_COMPONENT(this)) {
      ANY_TYPE(this) = kSDKAnyType_SDKComponentPtr;
      ANY_COMPONENT(this)->AddRef();
  }
    #endif
  }
 
  explicit SDKAnyHandler(sdk::ISDKComponent* obj) noexcept {
    #if 1    
    ANY_TYPE(this) = kSDKAnyType_SDKComponentPtr;
    ANY_COMPONENT(this) = obj;
    if (ANY_COMPONENT(this)) {
      ANY_COMPONENT(this)->AddRef();
  }
    #else
    ANY_TYPE(this) = kSDKAnyType_Null;
    ANY_COMPONENT(this) = obj;
    if (ANY_COMPONENT(this)) {
      ANY_TYPE(this) = kSDKAnyType_SDKComponentPtr;
      ANY_COMPONENT(this)->AddRef();
    }
    #endif
  }
 
  SDKAnyHandler(SDKAnyType element_type, SDKUInt32 element_size,
    SDKUInt64 num_of_elements) noexcept {
    SDKAnyInit(this);
    SDKArrayHandler arr(element_type, element_size, num_of_elements);
    *static_cast<SDKAny*>(this) = arr.DetachAsAny();
  }
 
  SDKAnyHandler(SDKAnyType element_type, SDKUInt32 element_size,
    SDKUInt64 num_of_elements, const void* init_data, 
    SDKUInt64 data_size) noexcept {
    SDKAnyInit(this);
    SDKArrayHandler arr(element_type, element_size, num_of_elements, init_data, 
      data_size);
    *static_cast<SDKAny*>(this) = arr.DetachAsAny();
  }
 
  ~SDKAnyHandler() {
    Clear();
  }
 
  SDKAnyHandler& operator=(const SDKAny& any) noexcept {
    if (this != &any) {
      Clear();
      SDKAnyDuplicate(&any, this);
    }
    return *this;
  }
 
  SDKAnyHandler& operator=(const SDKAnyHandler& any) noexcept {
    if (this != &any) {
      Clear();
      SDKAnyDuplicate(&any, this);
    }
    return *this;
  }
 
#if defined(SDK_HAS_CXX0X_RVALUE_REFS)
  // C++0x is supported
  //SDKAnyHandler(SDKAny&& any) throw ()
  //{
  //  *static_cast<SDKAny*>(this) = any;
  //  ANY_TYPE(&any) = kSDKAnyType_Empty;
  //}
  //explicit SDKAnyHandler(SDKString&& str) throw ()
  //{
  //  ANY_TYPE(this) = kSDKAnyType_Empty;
  //  Attach(str);
  //}
 
  SDKAnyHandler(SDKAnyHandler&& any) noexcept {
    *static_cast<SDKAny*>(this) = any;
    ANY_TYPE(&any) = kSDKAnyType_Empty;
  }
 
  explicit SDKAnyHandler(SDKStringHandler&& str) noexcept {
    ANY_TYPE(this) = kSDKAnyType_Empty;
    Attach(str);
  }
 
  explicit SDKAnyHandler(SDKArrayHandler&& arr) {
    SDKAnyInitArray(this, arr.GetType(), arr.GetElementSize());
    SDKArrayDuplicate(&arr.GetReference(), ANY_ARRAY(this));
  }
 
  //SDKAnyHandler& operator=(SDKAny&& any) {
  //  if (this != &any)
  //  {
  //    Clear();
  //    *static_cast<SDKAny*>(this) = any;
  //    ANY_TYPE(&any) = kSDKAnyType_Empty;
  //  }
  //  return *this;
  //}
 
  SDKAnyHandler& operator=(SDKAnyHandler&& any) {
    if (this != &any) {
      Clear();
      *static_cast<SDKAny*>(this) = any;
      ANY_TYPE(&any) = kSDKAnyType_Empty;
    }
    return *this;
  }
#endif
  //bool operator==(const SDKAny& any_src) const noexcept {
  //  return (kSDKResult_True == SDKAnyCompare(this, &any_src));
  //}
 
  //bool operator!=(const SDKAny& any_src) const noexcept {
  //  return !operator==(any_src);
  //}
 
  friend bool operator==(const SDKAny& any_lhs, const SDKAny& any_rhs) noexcept {
    return (kSDKResult_True == SDKAnyCompare(&any_lhs, &any_rhs));
  }
 
  friend bool operator!=(const SDKAny& any_lhs, const SDKAny& any_rhs) noexcept {
    return (kSDKResult_True != SDKAnyCompare(&any_lhs, &any_rhs));
  }
 
#if defined(__GNUC__)
  const SDKAny* operator&() const noexcept {
    return (this);
  }
 
  SDKAny* operator&() noexcept {
    return (this);
  }
#endif
 
  //operator SDKAny&() noexcept {
  //  return (*this);
  //}
 
  //operator const SDKAny&() const noexcept {
  //  return (*this);
  //}
 
  SDKAnyHandler& Attach(const SDKAny& any) noexcept {
    Clear();
    *static_cast<SDKAny*>(this) = any;
    SDKAnyInit(&(const_cast<SDKAny&>(any))); // clear input variable
    return *this;
  }
 
  SDKAnyHandler& Attach(const SDKString& str) noexcept {
    Clear();
    if (kSDKResult_Succeeded == SDKAnyInitString(this)) {
      *ANY_STR(this) = str;
      SDKStringInit(&(const_cast<SDKString&>(str))); // clear input variable
    }
    return *this;
  }
 
  SDKAnyHandler& Attach(const SDKArray& arr) noexcept {
    Clear();
    SDKArrayHandler handler;
    handler.Attach(const_cast<SDKArray&>(arr));
    *static_cast<SDKAny*>(this) = handler.DetachAsAny();
    return *this;
  }
 
  SDKAny Detach() noexcept {
    SDKAny any = (*this);
    ANY_TYPE(this) = kSDKAnyType_Empty;
    return any;
  }
 
  SDKString DetachAsString() noexcept {
    if (IsString()) {
      SDKString& int_ref = *ANY_STR(this);
      SDKString str_copy = int_ref;
      SDKStringInit(&int_ref);
      SDKAnyClear(this);
      return str_copy;
    }
    SDKString empty_str;
    SDKStringInit(&empty_str);
    return empty_str;
  }
 
  SDKArray DetachAsArray() noexcept {
    if (IsArray()) {
      SDKArray& int_ref = *ANY_ARRAY(this);
      SDKArray arr_copy = int_ref;
      SDKArrayInit(&int_ref);
      SDKAnyClear(this);
      return arr_copy;
    }
    SDKArray empty_arr;
    SDKArrayInit(&empty_arr);
    return empty_arr;
  }
 
  void Clear() noexcept {
    SDKAnyClear(this);
  }
 
  SDKAnyType GetType() const noexcept {
    return ANY_TYPE(this);
  }
 
  bool IsEmpty() const noexcept {
    return IsSDKAnyEmpty(*this);
  }
 
  bool IsNULL() const noexcept {
    return IsSDKAnyNull(*this);
  }
 
  bool IsEmptyOrNULL() const noexcept {
    return IsSDKAnyEmpty(*this) || IsSDKAnyNull(*this);
  }
 
  bool IsInteger() const noexcept {
    return IsSDKAnyInteger(*this);
  }
 
  bool IsNumeric() const noexcept {
    return IsSDKAnyNumeric(*this);
  }
 
  bool IsString() const noexcept {
    return IsSDKAnyString(*this);
  }
 
  bool IsArray() const noexcept {
    return IsSDKAnyArray(*this);
  }
 
  bool IsComponent() const noexcept {
    return IsSDKAnyComponent(*this);
  }
 
  SDKResult ChangeType(SDKAnyType new_type) noexcept {
    return SDKAnyChangeType(this, new_type);
  }
 
  SDKResult Compare(const SDKAny& any_src) const noexcept {
    return SDKAnyCompare(this, &any_src);
  }
 
  template< typename T >
  bool GetAs(T& value) const {
    try
    {
      if (ANY_IS_EMPTY(this))
        return false;
      value = GetAnyValue< T >(*this);
    } catch (...) {
      return false;
    }
    return true;
  }
 
  inline std::wstring WString() const noexcept {
    std::wstring out_value;
    if (GetAs< std::wstring >(out_value))
      return out_value;
    return std::wstring();
  }
 
  inline std::wstring GetAsWString() const noexcept {
    return WString();
  }
 
  inline std::string ASCIIString() const noexcept {
    std::string out_value;
    if (GetAs< std::string >(out_value))
      return out_value;
    return std::string();
  }
 
  inline std::string GetAsString() const noexcept {
    return ASCIIString();
  }
 
  template <typename T>
  inline SDKResult GetInterface(T **obj_ptr) const noexcept {
    if (kSDKAnyType_Empty == ANY_TYPE(this))
      return kSDKResult_NULLPointer;
    if (kSDKAnyType_Null == ANY_TYPE(this))
      return kSDKResult_NULLPointer;
    if (kSDKAnyType_SDKComponentPtr != ANY_TYPE(this))
      return kSDKResult_InvalidArgument;
    if (NULL == (*this).obj)
      return kSDKResult_NULLPointer;
    return (*this).obj->GetInterface(T::IID(), (void**)obj_ptr);
  }
 
  template <typename T>
  inline SDKRefPtr<T> GetInterface() const noexcept {
    SDKRefPtr<T> obj_ptr = NULL;
    SDKResult res =  GetInterface<T>(&obj_ptr);
    if (SDK_OK(res))
      return obj_ptr;
    return NULL;
  }
 
  SDKUInt64 GetSize() const {
    return GetSDKAnySize(*this);
  }
 
  SDKAny& GetReference() {
    return (*this);
  }
 
  const SDKAny& GetReference() const {
    return (*this);
  }
 
  SDKAny& Get() {
    return (*this);
  }
 
  const SDKAny& Get() const {
    return (*this);
  }
};
 
typedef sdk::SDKAnyHandler ScopedAny;
 
template<typename T>
class SDKAnyReturnHelper {
  typedef SDKAnyReturnHelper<T> MyType;
public:
  SDKAnyReturnHelper(T& value, const T* default_value = nullptr)
    : m_value(value), m_default_value(default_value) {
    ANY_TYPE(&m_any) = kSDKAnyType_Empty;
  }
 
  ~SDKAnyReturnHelper() {
    bool is_value_set = false;
    try
    {
      if (!ANY_IS_EMPTY(&m_any)) {
        m_value = GetAnyValue<T>(m_any);
        is_value_set = true;
      }
 
      if (!is_value_set && m_default_value)
        m_value = *m_default_value;
    } catch (...) {
    }
    SDKAnyClear(&m_any);
  }
 
  operator SDKAny&() noexcept {
    return m_any;
  }
 
  operator const SDKAny&() const noexcept {
    return m_any;
  }
 
  SDKAny& GetReference() noexcept {
    return m_any;
  }
 
  SDKAnyReturnHelper(const MyType& rhs)
    : m_any(), m_value(rhs.m_value), m_default_value(rhs.m_default_value) {
    SDKAnyDuplicate(&rhs.m_any, &m_any);
  }
 
  MyType& operator=(const MyType& rhs) {
    if (&rhs != this) {
      SDKAnyClear(&m_any);
      SDKAnyDuplicate(&rhs.m_any, &m_any);
    }
    return *this;
  }
 
  #ifdef SDK_HAS_CXX0X_RVALUE_REFS
  SDKAnyReturnHelper(MyType&& rhs)
    : m_any(rhs.m_any), m_value(rhs.m_value),
    m_default_value(rhs.m_default_value) {
    ANY_TYPE(&rhs.m_any) = kSDKAnyType_Empty;
    m_value = nullptr;
    m_default_value = nullptr;
  }
 
  MyType& operator=(MyType&& rhs) {
    if (&rhs != this) {
      SDKAnyClear(&m_any);
      m_any = rhs.m_any;
      m_value = rhs.m_value;
      m_default_value = rhs.m_default_value;
      ANY_TYPE(&rhs.m_any) = kSDKAnyType_Empty;
      m_value = NULL;
      m_default_value = nullptr;
    }
    return *this;
  }
  #endif
 
private:
  SDKAny m_any;
  T &m_value;
  const T *m_default_value;
};
 
template <>
class SDKAnyReturnHelper<SDKAny> {
  typedef SDKAnyReturnHelper<SDKAny> MyType;
public:
  SDKAnyReturnHelper(SDKAny& value, const SDKAny *default_value = nullptr)
    : m_value(&value), m_default_value(default_value) {
  }
 
  ~SDKAnyReturnHelper() {
    if (m_value && ANY_IS_EMPTY(m_value) && m_default_value)
      SDKAnyDuplicate(m_default_value, m_value);
  }
 
  SDKAnyReturnHelper(MyType& rhs)
    : m_value(rhs.m_value), m_default_value(rhs.m_default_value) {
    rhs.m_value = NULL;
  }
 
  MyType& operator=(MyType& rhs) {
    if (this != &rhs) {
      m_value = rhs.m_value;
      rhs.m_value = NULL;
      m_default_value = rhs.m_default_value;
    }
    return *this;
  }
 
  operator SDKAny&() noexcept {
    return *m_value;
  }
 
  operator const SDKAny&() const noexcept {
    return *m_value;
  }
 
  SDKAny& GetReference() noexcept {
    return *m_value;
  }
 
  const SDKAny& GetReference() const noexcept {
    return *m_value;
  }
 
private:
  mutable SDKAny* m_value;
  mutable const SDKAny* m_default_value;
};
 
template <typename T>
SDKAnyReturnHelper<T> MakeSDKAnyReturnHelper(T& value, 
  const T* default_value = nullptr) {
  return SDKAnyReturnHelper<T>(value, default_value);
}
 
inline SDKUInt64 GetSDKStringSize(const SDKString& str) {
  return
    sizeof(str.length) +
    sizeof(str.data) +
    str.length * sizeof(SDKUInt16);
}
 
inline SDKUInt64 GetSDKArraySize(const SDKArray& arr) {
  return
    sizeof(arr.num_of_elements) +
    sizeof(arr.element_type) +
    sizeof(arr.element_size) +
    sizeof(arr.data) +
    arr.num_of_elements * arr.element_size;
}
 
inline SDKUInt64 GetSDKAnySize(const SDKAny& any) {
  SDKUInt64 size = sizeof(any.any_type);
  switch (any.any_type) {
  case kSDKAnyType_Empty:   // = 0,   ///< variable is empty
  case kSDKAnyType_Null:    // = 1,   ///< null value or no value
  case kSDKAnyType_Uint8:   // = 2,   ///< unsigned integer 8 bit value
  case kSDKAnyType_Uint16:  // = 3,   ///< unsigned integer 16 bit value
  case kSDKAnyType_Uint32:  // = 4,   ///< unsigned integer 32 bit value
  case kSDKAnyType_Uint64:  // = 5,   ///< unsigned integer 64 bit value
  case kSDKAnyType_Int8:    // = 6,   ///< signed integer 8 bit value
  case kSDKAnyType_Int16:   // = 7,   ///< signed integer 16 bit value
  case kSDKAnyType_Int32:   // = 8,   ///< signed integer 32 bit value
  case kSDKAnyType_Int64:   // = 9,   ///< signed integer 64 bit value
  case kSDKAnyType_Float:   // = 10,  ///< single precision real value
  case kSDKAnyType_Double:  // = 11,  ///< double precision real value
  case kSDKAnyType_Bool:    // = 12,  ///< boolean value
  case kSDKAnyType_SDKTime: // = 13,  ///< SDKTime
    return size + sizeof(SDKUInt64);
  case kSDKAnyType_SDKStringPtr:    // = 14,  ///< pointer to SDKString
    return size + sizeof(SDKUInt64) + (any.str ? GetSDKStringSize(*any.str) : 0);
  case kSDKAnyType_SDKAnyPtr:       // = 15,  ///< pointer to SDKAny
    return size + sizeof(SDKUInt64) + (any.any ? GetSDKAnySize(*any.any) : 0);
  case kSDKAnyType_SDKArrayPtr:     // = 16,  ///< pointer to SDKArray
    return size + sizeof(SDKUInt64) + (any.arr ? GetSDKArraySize(*any.arr) : 0);
  case kSDKAnyType_SDKComponentPtr: // = 17,  ///< pointer to ISDKComponent
    return size + sizeof(SDKUInt64); // TODO: get IOccupiedSize?
  case kSDKAnyType_SDKTimePacked:   // = 18,  ///< SDKTime packed structure
  case kSDKAnyType_SDKTimeDelta:    // = 19,  ///< Time delta
    return size + sizeof(SDKUInt64);
  case kSDKAnyType_UserPtr:         // = 255  ///< user defined type of any size
    return size + sizeof(SDKUInt64);
  }
  return size + sizeof(SDKUInt64);
}
 
 
typedef SDKAnyReturnHelper<std::wstring> SDKAnyReturnStringHelper;
 
namespace sdk_any_handler_detail {
 
// Calculates a pair of the UTF-8 string
// and UTF-32 string lengths corresponded
// to the UTF-16 string respectively.
inline std::pair<SDKUInt32, SDKUInt32> lengths_of_utf16_string(
    const SDKUInt16 *src, size_t size) {
    std::pair<SDKUInt32, SDKUInt32> lengths(0, SDKUInt32(size));
    for (size_t i = 0; i < size; ++i) {
      if (src[i] < 0x80) {
        lengths.first += 1;
      } else if (src[i] < 0x800) {
        lengths.first += 2;
      } else {
        if ((src[i] & 0xFFFFFC00) == 0xD800) { // Probably a surrogate pair
          if ((src[i] & 0x400) != 0
            || ++i >= size
            || (src[i] & 0xFFFFFC00) != 0xDC00) { // Bad Unicode character
            lengths.first = static_cast<SDKUInt32>(i);
            lengths.second = static_cast<SDKUInt32>(-1);
            break;
          }
          lengths.first += 4;
          lengths.second -= 1;
        } else {
          lengths.first += 3;
        }
      }
    }
    return lengths;
}
 
template <typename _Elem, typename _Traits, typename _Ax>
bool sdk_string_to_std_string(const SDKString& sdk_string,
    std::basic_string<_Elem, _Traits, _Ax>& str, std::true_type) noexcept {
    str.clear();
    if (0 != sdk_string.length && NULL != sdk_string.data) {
      try
      {
      #if 0 && defined(SDK_OS_WIN)
        const wchar_t *src = reinterpret_cast<const wchar_t*>(sdk_string.data);
        enum {
          _CP_UTF8 = 65001,
          _WC_ERR_INVALID_CHARS = 0x80,
        };
        int dst_len = WideCharToMultiByte(_CP_UTF8, _WC_ERR_INVALID_CHARS, src,
          int(sdk_string.length), NULL, 0, NULL, NULL);
        if (dst_len != 0) {
          char *dst = (char*)std::alloca(dst_len + 1);
          WideCharToMultiByte(_CP_UTF8, _WC_ERR_INVALID_CHARS, src,
            int(sdk_string.length), dst, dst_len, NULL, NULL);
          dst[dst_len] = 0;
          str.assign(dst, dst + dst_len);
        }
      #else
        const SDKUInt16 *src = sdk_string.data;
        std::pair<SDKUInt32, SDKUInt32> lengths = lengths_of_utf16_string(
          src, sdk_string.length);
        if (lengths.second == SDKUInt32(-1)) { // Bad Unicode character
          return false;
        }
        str.reserve(lengths.first);
        for (SDKUInt32 i = 0; i < sdk_string.length; ++i) {
          SDKUInt32 utf32_symb = SDKUInt32(src[i]);
          if (utf32_symb < 0x80) {
            str.push_back(_Elem(utf32_symb));
          } else { // if (utf32_symb < 0x80000000)
            if ((utf32_symb & 0xFFFFFC00) == 0xD800) { // Sure the surrogate pair
              utf32_symb = (utf32_symb << 10) + src[i + 1] - ((0xD800 << 10) +
                0xDC00 - 0x10000);
              ++i;
            }
            int range = 1;
            if (utf32_symb < 0x800)
              ; // range = 1;
            else if (utf32_symb < 0x10000)
              range = 2;
            else if (utf32_symb < 0x200000)
              range = 3;
            else if (utf32_symb < 0x4000000)
              range = 4;
            else if (utf32_symb < 0x80000000)
              range = 5;
 
            _Elem utf8_symb[6];
            utf8_symb[0] = _Elem((0xFC << (5 - range)) +
              ((utf32_symb >> (6 * range)) & (0x3F >> range)));
            switch (range - 1) {
              case 4:
                utf8_symb[range - 4] = char(0x80 + ((utf32_symb >> 24) & 0x3F)); break;
              case 3:
                utf8_symb[range - 3] = char(0x80 + ((utf32_symb >> 18) & 0x3F)); break;
              case 2:
                utf8_symb[range - 2] = char(0x80 + ((utf32_symb >> 12) & 0x3F)); break;
              case 1:
                utf8_symb[range - 1] = char(0x80 + ((utf32_symb >> 06) & 0x3F)); break;
              case 0:
                utf8_symb[range - 0] = char(0x80 + ((utf32_symb >> 00) & 0x3F)); break;
              default:
                break;
            }
            str.append(utf8_symb, range + 1);
          }
        }
      #endif
    } catch (...) {
        str.clear();
        return false;
      }
    }
    //TODO: handle errors
    return true;
}
 
template <typename _Elem, typename _Traits, typename _Ax>
bool sdk_string_to_std_string(const SDKString& sdk_string,
    std::basic_string<_Elem, _Traits, _Ax>& str, std::false_type) noexcept {
    str.clear();
    if (0 != sdk_string.length && NULL != sdk_string.data) {
      try
      {
      if (sizeof(_Elem) == sizeof(sdk_string.data[0])) { // UTF16 wstring encoding case
          str.assign((_Elem*)sdk_string.data, sdk_string.length);
      } else { // UTF32 wstring encoding case -- convert UTF16 SDKString to UTF32
          const SDKUInt16 *src = sdk_string.data;
          std::pair<SDKUInt32, SDKUInt32> lengths = lengths_of_utf16_string(
            src, sdk_string.length);
          if (lengths.second == SDKUInt32(-1)) { // Bad Unicode character
            return false;
          }
          str.reserve(lengths.second);
          for (SDKUInt32 i = 0; i < sdk_string.length; ++i) {
            SDKUInt32 utf32_symb = SDKUInt32(src[i]);
            if (((utf32_symb & 0xFFFFFC00) == 0xD800)) { // Surrogate pair
            utf32_symb = (utf32_symb << 10) + src[i + 1] - ((0xD800 << 10) +
                0xDC00 - 0x10000);
              ++i;
            }
            str.push_back(_Elem(utf32_symb));
          }
        }
    } catch (...) {
        str.clear();
        return false;
      }
    }
    //TODO: handle errors
    return true;
}
 
} // namespace sdk_any_handler_detail
 
template <typename _Elem, typename _Traits, typename _Ax>
class SDKAnyReturnHelper< std::basic_string<_Elem, _Traits, _Ax> > {
  typedef std::basic_string<_Elem, _Traits, _Ax> string;
  typedef typename string::value_type value_type;
  typedef SDKAnyReturnHelper<string> MyType;
public:
  explicit SDKAnyReturnHelper(string& wstr)
    : m_value(&wstr), m_default_value(nullptr) {
    ANY_TYPE(&m_any) = kSDKAnyType_Empty;
  }
 
  SDKAnyReturnHelper(string& wstr, const string* default_value)
    : m_value(&wstr), m_default_value(default_value) {
    ANY_TYPE(&m_any) = kSDKAnyType_Empty;
  }
 
  ~SDKAnyReturnHelper() {
    if (m_value) {
      if (IsSDKAnyString(m_any)) {
        sdk_any_handler_detail::sdk_string_to_std_string(*m_any.str, *m_value,
          std::integral_constant<bool, sizeof(_Elem) == sizeof(char)>());
      } else if (m_default_value) {
        *m_value = *m_default_value;
      }
    }
    SDKAnyClear(&m_any);
  }
 
  operator SDKAny&() noexcept {
    return m_any;
  }
 
  operator const SDKAny&() const noexcept {
    return m_any;
  }
 
  SDKAny& GetReference() {
    return m_any;
  }
 
  //private:
  SDKAnyReturnHelper(const MyType& rhs)
    : m_any(), m_value(rhs.m_value), m_default_value(rhs.m_default_value) {
    ANY_TYPE(&m_any) = kSDKAnyType_Empty;
    SDKAnyDuplicate(&rhs.m_any, &m_any);
  }
 
  MyType& operator=(const MyType& rhs) {
    if (&rhs != this) {
      SDKAnyClear(&m_any);
      SDKAnyDuplicate(&rhs.m_any, &m_any);
      m_value = rhs.m_value;
      m_default_value = rhs.m_default_value;
    }
    return *this;
  }
 
#ifdef SDK_HAS_CXX0X_RVALUE_REFS
  SDKAnyReturnHelper(MyType&& rhs)
    : m_any(rhs.m_any), m_value(rhs.m_value),
    m_default_value(rhs.m_default_value) {
    ANY_TYPE(&rhs.m_any) = kSDKAnyType_Empty;
    rhs.m_value = NULL;
    rhs.m_default_value = NULL;
  }
 
  MyType& operator=(MyType&& rhs) {
    if (&rhs != this) {
      SDKAnyClear(&m_any);
      m_any = rhs.m_any;
      m_value = rhs.m_value;
      m_default_value = rhs.m_default_value;
      ANY_TYPE(&rhs.m_any) = kSDKAnyType_Empty;
      rhs.m_value = NULL;
      rhs.m_default_value = NULL;
    }
    return *this;
  }
#endif
 
private:
  SDKAny  m_any;
  string* m_value;
  const string* m_default_value;
};
 
} // namespace sdk
 
#endif // SDK_SDK_ANY_HANDLER_H_