sdk_array_handler.h

Go to the documentation of this file.

#ifndef SDK_SDK_ARRAY_HANDLER_H_
#define SDK_SDK_ARRAY_HANDLER_H_
 
#include <algorithm>
#include <vector>
#include <set>
#include <stdexcept>
#if defined(SDK_OS_MAC) || defined(SDK_OS_ANDROID)
# include <string>
#endif
#include <base/inc/platform.h>
#include <base/inc/memory_portable.h>
#include <base/inc/base_types.h>
#include <base/inc/sdk_results_enum.h>
#include <base/inc/base_library/base_types_functions.h>
 
namespace sdk {
 
class SDKAnyHandler;
class SDKArrayHandler;
 
class SDKArrayHandler {
public:
  SDKArrayHandler() noexcept {
    m_instance.num_of_elements = 0;
    m_instance.element_type    = kSDKAnyType_Empty;
    m_instance.element_size    = 0;
    m_instance.data            = NULL;
  }
 
#if 0
  SDKArrayHandler(const SDKArrayHandler& rhs) noexcept {
    try
    {
      m_instance.num_of_elements = 0;
      m_instance.element_type    = kSDKAnyType_Empty;
      m_instance.element_size    = 0;
      m_instance.data            = nullptr;
 
      SDKResult res = SDKArrayCreate(&m_instance, rhs.m_instance.element_type,
          rhs.m_instance.element_size, rhs.m_instance.num_of_elements);
      if (kSDKResult_Succeeded == res &&
        (rhs.m_instance.num_of_elements * rhs.m_instance.element_size) > 0) {
        SDKMemCopy(m_instance.data, static_cast<size_t>(
            m_instance.num_of_elements * m_instance.element_size),
          rhs.m_instance.data, static_cast<size_t>(
            rhs.m_instance.num_of_elements * rhs.m_instance.element_size));
      }
    } catch (...) {}
    //TODO: handle errors
  }
 
  SDKArrayHandler& operator=(const SDKArrayHandler& rhs) noexcept {
    if (this != &rhs) {
      this->~SDKArrayHandler();
      new (this) SDKArrayHandler(rhs);
    }
    return *this;
  }
#endif
 
  SDKArrayHandler(SDKAnyType element_type, SDKUInt32 element_size,
    SDKUInt64 num_of_elements) noexcept {
    try
    {
      m_instance.num_of_elements = 0;
      m_instance.element_type    = kSDKAnyType_Empty;
      m_instance.element_size    = 0;
      m_instance.data            = nullptr;
 
      SDKArray instance = {0, kSDKAnyType_Empty, 0, nullptr};
      SDKResult res = SDKArrayCreate(&instance, element_type, element_size,
        num_of_elements);
      if (kSDKResult_Succeeded == res)
        Attach(instance);
    }
    catch (...) {}
    //TODO: handle errors
  }
 
  SDKArrayHandler(SDKAnyType element_type, SDKUInt32 element_size,
    SDKUInt64 num_of_elements, const void* init_data, SDKUInt64 data_size) noexcept {
    try
    {
      m_instance.num_of_elements = 0;
      m_instance.element_type    = kSDKAnyType_Empty;
      m_instance.element_size    = 0;
      m_instance.data            = nullptr;
 
      SDKArray instance = {0, kSDKAnyType_Empty, 0, nullptr};
      SDKResult res = SDKArrayCreate(&instance, element_type, element_size,
        num_of_elements);
      if (kSDKResult_Succeeded == res) {
        Attach(instance);
 
        SDKUInt64 size = m_instance.element_size * m_instance.num_of_elements;
        if (init_data != NULL && size == data_size) {
          SDKMemCopy(m_instance.data, static_cast<size_t>(size), init_data,
            static_cast<size_t>(data_size));
        }
      }
    }
    catch (...) {}
    //TODO: handle errors
  }
 
  SDKArrayHandler(const SDKArray& instance) noexcept {
    try
    {
      m_instance.num_of_elements = 0;
      m_instance.element_type    = kSDKAnyType_Empty;
      m_instance.element_size    = 0;
      m_instance.data            = NULL;
 
      SDKResult res = SDKArrayCreate(&m_instance, instance.element_type,
        instance.element_size, instance.num_of_elements);
      if (kSDKResult_Succeeded == res &&
        (instance.num_of_elements * instance.element_size) > 0ULL)
      {
        SDKMemCopy(m_instance.data, static_cast<unsigned int>(
          m_instance.num_of_elements * m_instance.element_size),
          instance.data, static_cast<unsigned int>(
          instance.num_of_elements * instance.element_size));
      }
    }
    catch(...) {}
    //TODO: handle errors
  }
 
  virtual ~SDKArrayHandler() noexcept
  {
    try
    {
      SDKArrayDelete(&m_instance);
    }
    catch(...) {}
    //TODO: handle errors
  }
 
  operator SDKArray&() noexcept {
    return m_instance;
  }
 
  operator const SDKArray&() const noexcept {
    return m_instance;
  }
 
  SDKAnyType GetType() const noexcept {
    return m_instance.element_type;
  }
 
  SDKUInt32 GetElementSize() const noexcept {
    return m_instance.element_size;
  }
 
  SDKUInt64 GetElementsCount() const noexcept {
    return m_instance.num_of_elements;
  }
 
  SDKUInt8* GetBuffer() noexcept {
    return m_instance.data;
  }
 
  const SDKUInt8* GetBuffer() const noexcept {
    return m_instance.data;
  }
 
  SDKUInt64 GetBufferSize() const noexcept {
    return GetElementSize() * GetElementsCount();
  }
 
  SDKArray& GetReference() noexcept {
    return m_instance;
  }
 
  const SDKArray& GetReference() const noexcept {
    return m_instance;
  }
 
  SDKArray& Get() noexcept {
    return m_instance;
  }
  const SDKArray& Get() const noexcept {
    return m_instance;
  }
 
  void Attach(SDKArray& instance) noexcept
  {
    SDKArrayDelete(&m_instance);
 
    m_instance.num_of_elements = instance.num_of_elements;
    m_instance.element_type    = instance.element_type;
    m_instance.element_size    = instance.element_size;
    m_instance.data            = instance.data;
 
    instance.num_of_elements = 0;
    instance.element_type    = kSDKAnyType_Empty;
    instance.element_size    = 0;
    instance.data            = NULL;
  }
 
  SDKArray Detach() noexcept
  {
    SDKArray instance;
    instance.num_of_elements = m_instance.num_of_elements;
    instance.element_type    = m_instance.element_type;
    instance.element_size    = m_instance.element_size;
    instance.data            = m_instance.data;
 
    m_instance.num_of_elements = 0;
    m_instance.element_type    = kSDKAnyType_Empty;
    m_instance.element_size    = 0;
    m_instance.data            = NULL;
 
    return instance;
  }
 
  SDKAny DetachAsAny() noexcept
  {
    SDKAny any;
    SDKAnyInitArray(&any, kSDKAnyType_Empty, 0);
    any.any_type = kSDKAnyType_SDKArrayPtr;
    any.arr->num_of_elements = m_instance.num_of_elements;
    any.arr->element_type    = m_instance.element_type;
    any.arr->element_size    = m_instance.element_size;
    any.arr->data            = m_instance.data;
 
    m_instance.num_of_elements = 0;
    m_instance.element_type    = kSDKAnyType_Empty;
    m_instance.element_size    = 0;
    m_instance.data            = NULL;
 
    return any;
  }
 
  void DetachAsAny(SDKAny& dest) noexcept
  {
    SDKAnyClear(&dest);
    SDKAny any = DetachAsAny();
    dest = any;
  }
 
  bool IsEmpty()
  {
    return (m_instance.num_of_elements == 0) ||
           (m_instance.element_type    == kSDKAnyType_Empty) ||
           (m_instance.element_size    == 0) ||
           (m_instance.data            == NULL);
  }
 
  template< typename T >
  static bool FromStdVector(const std::vector< T >& v, SDKAnyType element_type,
    SDKArray& arr) noexcept {
    if (v.empty())
      return false;
    SDKArrayDelete(&arr);
    arr.num_of_elements = v.size();
    arr.element_type = static_cast<SDKArrayElementType>(element_type);
    arr.element_size = sizeof(T);
    arr.data = NULL;
    if (SDK_FAILED(SDKArrayCreate(&arr, arr.element_type, arr.element_size, 
      arr.num_of_elements))) {
      return false;
    }
    SDKMemCopy(arr.data, size_t(arr.num_of_elements * arr.element_size),
      &v.front(), size_t(arr.num_of_elements * arr.element_size));
    return true;
  }
 
  template< typename T >
  static bool FromStdSet(const std::set< T >& s, SDKAnyType element_type,
    SDKArray& arr) noexcept {
    if (s.empty())
      return false;
    SDKArrayDelete(&arr);
    arr.num_of_elements = s.size();
    arr.element_type = static_cast<SDKArrayElementType>(element_type);
    arr.element_size = sizeof(T);
    arr.data = NULL;
    if (SDK_FAILED(SDKArrayCreate(&arr, arr.element_type, arr.element_size,
      arr.num_of_elements))) {
      return false;
    }
    T* ptr = reinterpret_cast<T*>(arr.data);
    for (typename std::set< T >::const_iterator it = s.cbegin(); it != s.cend(); ++it) {
      *ptr = *it;
      ptr++;
    }
    return true;
  }
 
  template< typename T >
  static bool ToStdVector(const SDKArray* arr, SDKAnyType element_type,
    std::vector< T >& v) noexcept {
    v.clear();
    if (!arr || !arr->data || !arr->num_of_elements || 
      (sizeof(T) != arr->element_size) ||
      (static_cast<SDKArrayElementType>(element_type) != arr->element_type)) {
      return false;
    }
    v.resize(static_cast<size_t>(arr->num_of_elements));
    SDKMemCopy(&v.front(), size_t(arr->num_of_elements * arr->element_size),
      arr->data, size_t(arr->num_of_elements * arr->element_size));
    return true;
  }
 
  template< typename T >
  bool ToStdVector(SDKAnyType element_type, std::vector< T >& v) const noexcept {
    return ToStdVector(this, element_type, v);
  }
 
  template< typename T >
  static bool ToStdSet(const SDKArray* arr, SDKAnyType element_type,
    std::set< T >& out) noexcept {
    out.clear();
    if (!arr || !arr->data || !arr->num_of_elements ||
      (sizeof(T) != arr->element_size) ||
      (static_cast<SDKArrayElementType>(element_type) != arr->element_type)) {
      return false;
    }
    const T* ptr = reinterpret_cast<const T*>(arr->data);
    SDKUInt64 count = arr->num_of_elements;
    for (SDKUInt64 i = 0; i < count; ++i) {
      out.insert(ptr[i]);
    }
    return true;
  }
 
  static inline bool FromStdString(const std::string& str,
    SDKArray& arr) noexcept {
    try
    {
      if (str.empty())
        return false;
      SDKArrayDelete(&arr);
      arr.num_of_elements = str.size();
      arr.element_type = kSDKAnyType_Uint8;
      arr.element_size = 1;
      arr.data = NULL;
      if (SDK_FAILED(SDKArrayCreate(&arr, arr.element_type, arr.element_size,
        arr.num_of_elements))) {
        return false;
      }
      SDKMemCopy(arr.data, size_t(arr.num_of_elements * arr.element_size),
        str.c_str(), size_t(arr.num_of_elements * arr.element_size));
      return true;
    } catch(...) {}
    return false;
  }
 
  template <typename _Elem, typename _Alloc, typename _SDKAnyHandler=SDKAnyHandler>
  static bool FromStdString(const std::basic_string<_Elem, _Alloc>& str,
    SDKArray& arr) noexcept {
    try
    {
      SDKArrayDelete(&arr);
      if (str.empty())
        return false;
      arr.num_of_elements = str.size();
      arr.element_type = static_cast<SDKArrayElementType>(
        _SDKAnyHandler::template TypeToSDKAnyType<_Elem>::value);
      arr.element_size = sizeof(_Elem);
      arr.data = NULL;
      if (SDK_FAILED(SDKArrayCreate(&arr, arr.element_type, arr.element_size,
        arr.num_of_elements))) {
        return false;
      }
 
      using std::copy_n;
      copy_n(str.c_str(), size_t(arr.num_of_elements), reinterpret_cast<_Elem *>(arr.data));
      return true;
    } catch (...) {}
    return false;
  }
 
  static inline bool ToStdString(const SDKArray* arr,
    std::string& str) noexcept {
    try
    {
      str.clear();
      if ((NULL != arr) && (NULL != arr->data) && (arr->num_of_elements > 0) &&
        (arr->element_type == kSDKAnyType_Uint8 ||
          arr->element_type == kSDKAnyType_Int8)) {
        str.assign(arr->data,
          arr->data + size_t(arr->num_of_elements * arr->element_size));
        return true;
      }
    } catch(...) {}
    return false;
  }
 
private:
#if 1
  SDKArrayHandler(const SDKArrayHandler&);
  void operator=(const SDKArrayHandler&);
#endif
 
  SDKArray m_instance;
};
 
typedef sdk::SDKArrayHandler ScopedArray;
 
class SDKArrayWrapper
{
public:
  SDKArrayWrapper(SDKArray& instance) noexcept
    : m_instance(instance)
  {
  }
 
  SDKAnyType GetType() const noexcept {
    return m_instance.element_type;
  }
 
  SDKUInt32 GetElementSize() const noexcept {
    return m_instance.element_size;
  }
 
  SDKUInt64 GetElementsCount() const noexcept {
    return m_instance.num_of_elements;
  }
 
  SDKUInt8* GetBuffer() noexcept {
    return m_instance.data;
  }
 
  const SDKUInt8* GetBuffer() const noexcept {
    return m_instance.data;
  }
 
  SDKUInt64 GetBufferSize() const noexcept {
    return GetElementSize() * GetElementsCount();
  }
 
  SDKArray& GetReference() noexcept {
    return m_instance;
  }
 
  const SDKArray& GetReference() const noexcept {
    return m_instance;
  }
 
  SDKArray& Get() noexcept {
    return m_instance;
  }
 
  const SDKArray& Get() const noexcept {
    return m_instance;
  }
 
private:
  SDKArrayWrapper(const SDKArrayWrapper&);
  void operator=(const SDKArrayWrapper&);
 
  SDKArray& m_instance;
};
 
typedef sdk::SDKArrayWrapper ScopedArrayWrapper;
 
template<typename T>
T GetArrayElement(const SDKArray& arr, SDKUInt64 idx)
{
  if (idx >= arr.num_of_elements)
    throw std::runtime_error("Index out of range in GetArrayElement()");
  if (NULL == arr.data)
    throw std::runtime_error("Empty array passed in GetArrayElement()");
 
  switch(arr.element_type) {
  case kSDKAnyType_Empty:
    break;
  case kSDKAnyType_Null:
    break;
  case kSDKAnyType_Uint8:
    return static_cast<T>(reinterpret_cast<SDKUInt8* >(arr.data)[idx]);
  case kSDKAnyType_Uint16:
    return static_cast<T>(reinterpret_cast<SDKUInt16*>(arr.data)[idx]);
  case kSDKAnyType_Uint32:
    return static_cast<T>(reinterpret_cast<SDKUInt32*>(arr.data)[idx]);
  case kSDKAnyType_Uint64:
    return static_cast<T>(reinterpret_cast<SDKUInt64*>(arr.data)[idx]);
  case kSDKAnyType_Int8:
    return static_cast<T>(reinterpret_cast<SDKInt8*  >(arr.data)[idx]);
  case kSDKAnyType_Int16:
    return static_cast<T>(reinterpret_cast<SDKInt16* >(arr.data)[idx]);
  case kSDKAnyType_Int32:
    return static_cast<T>(reinterpret_cast<SDKInt32* >(arr.data)[idx]);
  case kSDKAnyType_Int64:
    return static_cast<T>(reinterpret_cast<SDKInt64* >(arr.data)[idx]);
  case kSDKAnyType_Float:
    return static_cast<T>(reinterpret_cast<float*    >(arr.data)[idx]);
  case kSDKAnyType_Double:
    return static_cast<T>(reinterpret_cast<double*   >(arr.data)[idx]);
  case kSDKAnyType_Bool:
    return static_cast<T>(reinterpret_cast<bool*     >(arr.data)[idx]);
  case kSDKAnyType_SDKTime:
    return static_cast<T>(reinterpret_cast<SDKTime*  >(arr.data)[idx]);
  case kSDKAnyType_SDKStringPtr:
    break;
  case kSDKAnyType_SDKAnyPtr:
    break;
  case kSDKAnyType_SDKArrayPtr:
    break;
  case kSDKAnyType_SDKComponentPtr:
    break;
  case kSDKAnyType_UserPtr:
    break;
  }
  throw std::runtime_error("Unsupported type met in GetArrayElement()");
}
 
template<typename T>
bool GetArrayElement(const SDKArray& arr, SDKUInt64 index, T& val) noexcept
{
  if (NULL == arr.data)
    return false;
  if (index >= arr.num_of_elements)
    return false;
  val = 0;
  const SDKUInt8* ptr = arr.data + (index * arr.element_size);
  SDKMemCopy(&val, sizeof(val), ptr, arr.element_size);
  return true;
}
 
template<typename T>
bool SetArrayElement(const SDKArray& arr, SDKUInt64 index, const T& val) noexcept
{
  if (NULL == arr.data)
    return false;
  if (index >= arr.num_of_elements)
    return false;
  SDKUInt8* ptr = arr.data + (index * arr.element_size);
  SDKMemCopy(ptr, arr.element_size, &val, sizeof(val));
  return true;
}
 
template<typename T>
bool GetAllArrayElements(const SDKArray& arr, T* buffer) {
  try
  {
    if (NULL == arr.data)
      return false;
    for (size_t idx = 0; idx < arr.num_of_elements; ++idx)
      buffer[idx] = GetArrayElement<T>(arr, idx);
    return true;
  }
  catch(...) {}
  return false;
}
 
inline bool IsSDKArrayEqual(const SDKArray* arr1, const SDKArray* arr2) {
  if (!arr1 && !arr2)
    return true;
  if (!arr1 || !arr2)
    return false;
 
  if (arr1->num_of_elements != arr2->num_of_elements)
    return false;
  if (arr1->element_type != arr2->element_type)
    return false;
  if (arr1->element_size != arr2->element_size)
    return false;
 
  if (0 == arr1->num_of_elements)
    return true;
 
  if (NULL == arr1->data || NULL == arr2->data)
    return false; // wrong arrays actually
 
  size_t size = static_cast<size_t>(arr1->num_of_elements * arr1->element_size);
  #ifndef SDK_CC_BCC
  int cmp = memcmp(arr1->data, arr2->data, size);
  #else
  int cmp = std::memcmp(arr1->data, arr2->data, size);
  #endif
 
  return (0 == cmp);
}
 
} // namespace sdk
 
#endif // SDK_SDK_ARRAY_HANDLER_H_