detail_object.hpp

#pragma once
 
#include "../_decl/decl_context.hpp"
#include "../_decl/decl_object.hpp"
 
 
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace PyScript
  {
    inline ObjectPtr Object::MakeVoidTuple(size_t size)
    {
      return Internal::DoResCallShareOut<Object>([size](void *&handle) {
        return CVPYSCreateObj(Context::CreateOrGet()->Handle(), CExports::CVPYSOTY_Tuple, nullptr, size, handle);
      });
    }
 
    inline ObjectPtr Object::MakeVoidList(size_t size)
    {
      return Internal::DoResCallShareOut<Object>([size](void *&handle) {
        return CVPYSCreateObj(Context::CreateOrGet()->Handle(), CExports::CVPYSOTY_List, nullptr, size, handle);
      });
    }
 
    template <class T>
    inline ObjectPtr Object::CreateImpl(const T &value, PodTag)
    {
      return Internal::DoResCallShareOut<Object>([&value](void *&handle) {
        auto storage = static_cast<typename Private::IsPod<T>::StorageType>(value);
        return CVPYSCreateObj(Context::CreateOrGet()->Handle(), Private::IsPod<T>::TypeId, &storage, Private::IsPod<T>::Size, handle);
      });
    }
 
    template <class T>
    inline ObjectPtr Object::CreateImpl(const T &value, HandleTag)
    {
      return Internal::DoResCallShareOut<Object>([&value](void *&handle) {
        auto h = value.Handle();
        return CVPYSCreateObj(Context::CreateOrGet()->Handle(), Private::IsHandleType<T>::TypeId, &h, sizeof(void *),
                              handle);
      });
    }
 
    template <class T>
    inline ObjectPtr Object::CreateImpl(const T &value, EnumTag)
    {
      // use int64_t as some CVB enums use more than 32 bit!
      return Create(static_cast<int64_t>(value));
    }
 
    template <class T>
    inline ObjectPtr Object::CreateImpl(const T &value, CvbTag)
    {
      return Internal::DoResCallShareOut<Object>([&value](void *&handle) {
        return CVPYSCreateObj(Context::CreateOrGet()->Handle(), Private::IsCvbType<T>::TypeId, &value, sizeof(T), handle);
      });
    }
 
    template <>
    inline ObjectPtr Object::Create<std::string>(const std::string &value)
    {
      return Internal::DoResCallShareOut<Object>([&value](void *&handle) {
        return CVPYSCreateObj(Context::CreateOrGet()->Handle(), CExports::CVPYSOTY_String, value.c_str(),
                              value.size() + 1,
                              handle);
      });
    }
 
    inline ObjectPtr Object::Create(const char *value)
    {
      return Create(std::string(value));
    }
 
    template <>
    inline std::string Object::As<std::string>() const
    {
      CExports::CVPYSObjType type = CExports::CVPYSOTY_String;
      size_t size = 0;
      CVB_CALL_CAPI_CHECKED(CVPYSObjToBuffer(Handle(), type, nullptr, size));
      std::vector<char> buffer(size);
      CVB_CALL_CAPI_CHECKED(CVPYSObjToBuffer(Handle(), type, buffer.data(), size));
      return std::string(buffer.data());
    }
 
    template <>
    inline ObjectPtr Object::Create<std::wstring>(const std::wstring &value)
    {
      return Internal::DoResCallShareOut<Object>([&value](void *&handle) {
        return CVPYSCreateObj(Context::CreateOrGet()->Handle(), CExports::CVPYSOTY_WString, value.c_str(),
                              (value.size() + 1) * sizeof(wchar_t), handle);
      });
    }
 
    inline ObjectPtr Object::Create(const wchar_t *value)
    {
      return Create(std::wstring(value));
    }
 
    template <>
    inline std::wstring Object::As<std::wstring>() const
    {
      CExports::CVPYSObjType type = CExports::CVPYSOTY_WString;
      size_t size = 0;
      CVB_CALL_CAPI_CHECKED(CVPYSObjToBuffer(Handle(), type, nullptr, size));
      std::vector<wchar_t> buffer(size / sizeof(wchar_t));
      CVB_CALL_CAPI_CHECKED(CVPYSObjToBuffer(Handle(), type, buffer.data(), size));
      return std::wstring(buffer.data());
    }
  }
 
  CVB_END_INLINE_NS
}  // namespace Cvb