decl_object.hpp

#pragma once
 
#include "../../affine_matrix_2d.hpp"
#include "../../affine_matrix_3d.hpp"
#include "../../angle.hpp"
#include "../../circle.hpp"
#include "../../composite.hpp"
#include "../../cuboid.hpp"
#include "../../data_type.hpp"
#include "../../dense_point_cloud.hpp"
#include "../../driver/buffer_image.hpp"
#include "../../driver/composite_stream.hpp"
#include "../../driver/emu_image.hpp"
#include "../../driver/genicam_device.hpp"
#include "../../driver/image_stream.hpp"
#include "../../driver/multi_part_image.hpp"
#include "../../driver/point_cloud_stream.hpp"
#include "../../driver/video_image.hpp"
#include "../../genapi/boolean_node.hpp"
#include "../../genapi/category_node.hpp"
#include "../../genapi/command_node.hpp"
#include "../../genapi/enum_entry_node.hpp"
#include "../../genapi/enumeration_node.hpp"
#include "../../genapi/float_node.hpp"
#include "../../genapi/float_reg_node.hpp"
#include "../../genapi/int_reg_node.hpp"
#include "../../genapi/integer_node.hpp"
#include "../../genapi/node_map.hpp"
#include "../../genapi/node_map_enumerator.hpp"
#include "../../genapi/string_node.hpp"
#include "../../genapi/string_reg_node.hpp"
#include "../../image.hpp"
#include "../../line_2d.hpp"
#include "../../matrix_2d.hpp"
#include "../../matrix_3d.hpp"
#include "../../matrix_3d_h.hpp"
#include "../../pfnc_buffer.hpp"
#include "../../plane.hpp"
#include "../../plane_3d.hpp"
#include "../../point_2d.hpp"
#include "../../point_3d.hpp"
#include "../../point_3d_h.hpp"
#include "../../rect.hpp"
#include "../../rect_lt.hpp"
#include "../../sparse_point_cloud.hpp"
#include "../py_script.hpp"
 
#include <memory>
#include <type_traits>
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<PyScript::Object>::HandleGuard(void *handle) noexcept
      : HandleGuard<PyScript::Object>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
  namespace PyScript
  {
    namespace Private
    {
      template <typename T>
      struct IsPod : std::false_type
      {
      };
 
      template <>
      struct IsPod<bool> : std::true_type
      {
        using StorageType            = bool;
        static constexpr auto TypeId = CExports::CVPYSOTY_Bool;
        static constexpr size_t Size = sizeof(bool);
      };
 
      template <>
      struct IsPod<int8_t> : std::true_type
      {
        using StorageType            = int64_t;
        static constexpr auto TypeId = CExports::CVPYSOTY_Int64;
        static constexpr size_t Size = sizeof(int64_t);
      };
 
      template <>
      struct IsPod<uint8_t> : std::true_type
      {
        using StorageType            = uint64_t;
        static constexpr auto TypeId = CExports::CVPYSOTY_UInt64;
        static constexpr size_t Size = sizeof(uint64_t);
      };
 
      template <>
      struct IsPod<int16_t> : std::true_type
      {
        using StorageType            = int64_t;
        static constexpr auto TypeId = CExports::CVPYSOTY_Int64;
        static constexpr size_t Size = sizeof(int64_t);
      };
 
      template <>
      struct IsPod<uint16_t> : std::true_type
      {
        using StorageType            = uint64_t;
        static constexpr auto TypeId = CExports::CVPYSOTY_UInt64;
        static constexpr size_t Size = sizeof(uint64_t);
      };
 
      template <>
      struct IsPod<int32_t> : std::true_type
      {
        using StorageType            = int64_t;
        static constexpr auto TypeId = CExports::CVPYSOTY_Int64;
        static constexpr size_t Size = sizeof(int64_t);
      };
 
      template <>
      struct IsPod<uint32_t> : std::true_type
      {
        using StorageType            = uint64_t;
        static constexpr auto TypeId = CExports::CVPYSOTY_UInt64;
        static constexpr size_t Size = sizeof(uint64_t);
      };
 
      template <>
      struct IsPod<int64_t> : std::true_type
      {
        using StorageType            = int64_t;
        static constexpr auto TypeId = CExports::CVPYSOTY_Int64;
        static constexpr size_t Size = sizeof(int64_t);
      };
 
      template <>
      struct IsPod<uint64_t> : std::true_type
      {
        using StorageType            = uint64_t;
        static constexpr auto TypeId = CExports::CVPYSOTY_UInt64;
        static constexpr size_t Size = sizeof(uint64_t);
      };
 
      template <>
      struct IsPod<float> : std::true_type
      {
        using StorageType            = double;
        static constexpr auto TypeId = CExports::CVPYSOTY_Float64;
        static constexpr size_t Size = sizeof(double);
      };
 
      template <>
      struct IsPod<double> : std::true_type
      {
        using StorageType            = double;
        static constexpr auto TypeId = CExports::CVPYSOTY_Float64;
        static constexpr size_t Size = sizeof(double);
      };
 
      template <typename T>
      struct IsHandleType : std::false_type
      {
      };
 
      template <>
      struct IsHandleType<Composite> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_Composite;
      };
 
      template <>
      struct IsHandleType<DensePointCloud> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_DensePointCloud;
      };
 
      template <>
      struct IsHandleType<Image> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_Image;
      };
 
      template <>
      struct IsHandleType<MultiPartImage> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_MultiPartImage;
      };
 
      template <>
      struct IsHandleType<PFNCBuffer> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_PfncBuffer;
      };
 
      template <>
      struct IsHandleType<Plane> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_Plane;
      };
 
      template <>
      struct IsHandleType<SparsePointCloud> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_SparsePointCloud;
      };
 
      template <>
      struct IsHandleType<GenICamDevice> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_GenICamDevice;
      };
 
      template <>
      struct IsHandleType<CompositeStream> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_CompositeStream;
      };
 
      template <>
      struct IsHandleType<ImageStream> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_ImageStream;
      };
 
      template <>
      struct IsHandleType<PointCloudStream> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_PointCloudStream;
      };
 
      template <>
      struct IsHandleType<BooleanNode> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_BooleanNode;
      };
 
      template <>
      struct IsHandleType<CategoryNode> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_CategoryNode;
      };
 
      template <>
      struct IsHandleType<CommandNode> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_CommandNode;
      };
 
      template <>
      struct IsHandleType<EnumEntryNode> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_EnumEntryNode;
      };
 
      template <>
      struct IsHandleType<EnumerationNode> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_EnumerationNode;
      };
 
      template <>
      struct IsHandleType<FloatNode> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_FloatNode;
      };
 
      template <>
      struct IsHandleType<FloatRegNode> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_FloatRegNode;
      };
 
      template <>
      struct IsHandleType<IntRegNode> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_IntRegNode;
      };
 
      template <>
      struct IsHandleType<IntegerNode> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_IntegerNode;
      };
 
      template <>
      struct IsHandleType<NodeMap> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_NodeMap;
      };
 
      template <>
      struct IsHandleType<NodeMapEnumerator> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_NodeMapEnumerator;
      };
 
      template <>
      struct IsHandleType<StringNode> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_StringNode;
      };
 
      template <>
      struct IsHandleType<StringRegNode> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_StringRegNode;
      };
 
      template <typename T>
      struct IsCvbType : std::false_type
      {
      };
 
      template <>
      struct IsCvbType<DataType> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_DataType;
      };
 
      template <>
      struct IsCvbType<Circle> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_Circle;
      };
 
      template <>
      struct IsCvbType<AffineMatrix2D> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_AffineMatrix2D;
      };
 
      template <>
      struct IsCvbType<AffineMatrix3D> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_AffineMatrix3D;
      };
 
      template <>
      struct IsCvbType<Angle> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_Angle;
      };
 
      template <>
      struct IsCvbType<Cuboid> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_Cuboid;
      };
 
      template <>
      struct IsCvbType<Line2D> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_Line2D;
      };
 
      template <>
      struct IsCvbType<Matrix2D> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_Matrix2D;
      };
 
      template <>
      struct IsCvbType<Matrix3DH> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_Matrix3DH;
      };
 
      template <>
      struct IsCvbType<Matrix3D> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_Matrix3D;
      };
 
      template <>
      struct IsCvbType<Plane3D> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_Plane3D;
      };
 
      template <>
      struct IsCvbType<Point2D<double>> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_Point2D;
      };
 
      template <>
      struct IsCvbType<Point3D<double>> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_Point3D;
      };
 
      template <>
      struct IsCvbType<Point3DH<double>> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_Point3DH;
      };
 
      template <>
      struct IsCvbType<Rect<double>> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_Rect;
      };
 
      template <>
      struct IsCvbType<RectLT<double>> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_RectLT;
      };
 
      template <>
      struct IsCvbType<Size2D<double>> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_Size2D;
      };
 
      template <>
      struct IsCvbType<ValueRange<double>> : std::true_type
      {
        static constexpr auto TypeId = CExports::CVPYSOTY_ValueRange;
      };
 
      template <typename T>
      struct CanCastCvbType : std::false_type
      {
      };
 
      template <>
      struct CanCastCvbType<Point2D<int>> : std::true_type
      {
        using StorageType = Point2D<double>;
      };
 
      template <>
      struct CanCastCvbType<Point3D<int>> : std::true_type
      {
        using StorageType = Point3D<double>;
      };
 
      template <>
      struct CanCastCvbType<Rect<int>> : std::true_type
      {
        using StorageType = Rect<double>;
      };
 
      template <>
      struct CanCastCvbType<RectLT<int>> : std::true_type
      {
        using StorageType = RectLT<double>;
      };
 
      template <>
      struct CanCastCvbType<Size2D<int>> : std::true_type
      {
        using StorageType = Size2D<double>;
      };
 
      template <typename T>
      struct CanHandleUpCastType : std::false_type
      {
      };
 
      template <>
      struct CanHandleUpCastType<Image> : std::true_type
      {
        using StorageType = Image;
      };
 
      template <>
      struct CanHandleUpCastType<RingBufferImage> : std::true_type
      {
        using StorageType = Image;
      };
 
      template <>
      struct CanHandleUpCastType<BufferImage> : std::true_type
      {
        using StorageType = Image;
      };
 
      template <>
      struct CanHandleUpCastType<StreamImage> : std::true_type
      {
        using StorageType = Image;
      };
 
      template <>
      struct CanHandleUpCastType<WrappedImage> : std::true_type
      {
        using StorageType = Image;
      };
 
      template <>
      struct CanHandleUpCastType<VinImage> : std::true_type
      {
        using StorageType = Image;
      };
 
      template <>
      struct CanHandleUpCastType<VideoImage> : std::true_type
      {
        using StorageType = Image;
      };
 
      template <>
      struct CanHandleUpCastType<EmuImage> : std::true_type
      {
        using StorageType = Image;
      };
 
      template <>
      struct CanHandleUpCastType<DeviceImage> : std::true_type
      {
        using StorageType = Image;
      };
 
      template <>
      struct CanHandleUpCastType<IntegerNode> : std::true_type
      {
        using StorageType = IntegerNode;
      };
 
      template <>
      struct CanHandleUpCastType<FloatNode> : std::true_type
      {
        using StorageType = FloatNode;
      };
 
      template <>
      struct CanHandleUpCastType<StringNode> : std::true_type
      {
        using StorageType = StringNode;
      };
 
      template <class... T>
      struct DownCastList
      {
      };
 
      template <typename T>
      struct CanHandleDownCastType : std::false_type
      {
      };
 
      template <>
      struct CanHandleDownCastType<Image> : std::true_type
      {
        using List = DownCastList<MultiPartImage>;
      };
 
      template <>
      struct CanHandleDownCastType<StreamImage> : std::true_type
      {
        using List = DownCastList<MultiPartImage>;
      };
 
      template <>
      struct CanHandleDownCastType<Node> : std::true_type
      {
        using List = DownCastList<BooleanNode, CategoryNode, CommandNode, EnumerationNode, EnumEntryNode, FloatRegNode,
                                  FloatNode, IntRegNode, IntegerNode, StringRegNode, StringNode>;
      };
 
      template <>
      struct CanHandleDownCastType<ValueNode> : std::true_type
      {
        using List = DownCastList<BooleanNode, CategoryNode, CommandNode, EnumerationNode, EnumEntryNode, FloatRegNode,
                                  FloatNode, IntRegNode, IntegerNode, StringRegNode, StringNode>;
      };
 
      template <>
      struct CanHandleDownCastType<SelectorNode> : std::true_type
      {
        using List = DownCastList<EnumerationNode, IntRegNode, IntegerNode>;
      };
 
      template <>
      struct CanHandleDownCastType<FloatNode> : std::true_type
      {
        using List = DownCastList<FloatRegNode>;
      };
 
      template <>
      struct CanHandleDownCastType<IntegerNode> : std::true_type
      {
        using List = DownCastList<IntRegNode>;
      };
 
      template <>
      struct CanHandleDownCastType<StringNode> : std::true_type
      {
        using List = DownCastList<StringRegNode>;
      };
 
      template <>
      struct CanHandleDownCastType<PointCloud> : std::true_type
      {
        using List = DownCastList<SparsePointCloud, DensePointCloud>;
      };
 
    }  // namespace Private


    class Object final
    {
      struct PrivateTag
      {
      };
 
    public:
      using GuardType = HandleGuard<Object>;
 
      static ObjectPtr FromHandle(HandleGuard<Object> &&guard)
      {
        return std::make_shared<Object>(std::move(guard), PrivateTag{});
      }
 
      template <class T>
      static ObjectPtr FromHandle(HandleGuard<Object> &&guard)
      {
        return FromHandle(std::move(guard));
      }


      template <class T>
      static std::shared_ptr<Object> Create(const T &value)
      {
        return CreateImpl(value, SelectCategory<T>{});
      }
 
      template <class T>
      static std::shared_ptr<Object> Create(const std::shared_ptr<T> &value)
      {
        static_assert(Private::IsHandleType<T>::value || Private::CanHandleUpCastType<T>::value
                          || Private::CanHandleDownCastType<T>::value,
                      "T must be a handle type or castable");
 
        return Create(*value);
      }
 
      static ObjectPtr Create(const char *value);
 
      static ObjectPtr Create(const wchar_t *value);


      static ObjectPtr MakeVoidTuple(size_t size);


      template <typename... T>
      static ObjectPtr MakeTuple(T &&...args)
      {
        auto tuple   = MakeVoidTuple(sizeof...(T));
        size_t index = 0;
        tuple->ImplMakeTuple(index, std::forward<T>(args)...);
        return tuple;
      }


      static std::shared_ptr<Object> MakeVoidList(size_t size);
 
      Object(HandleGuard<Object> &&guard, PrivateTag) noexcept
          : handle_(std::move(guard))
      {
      }
      Object(const Object &other)            = delete;
      Object &operator=(const Object &other) = delete;
      Object(Object &&other)                 = delete;
      Object &operator=(Object &&other)      = delete;
      ~Object()                              = default;


      ObjectPtr Attribute(const Cvb::String &attributeName)
      {
        return Internal::DoResCallShareOut<Object>([this, &attributeName](void *&handle) {
          return CVB_CALL_CAPI(CVPYSObjGetAttributeTyped(handle_.Handle(), attributeName.c_str(), handle));
        });
      }


      ObjectPtr Run(const Object &args)
      {
        return Internal::DoResCallShareOut<Object>([this, &args](void *&handle) {
          return CVB_CALL_CAPI(CVPYSObjRun(handle_.Handle(), args.Handle(), handle));
        });
      }


      ObjectPtr Run()
      {
        return Internal::DoResCallShareOut<Object>(
            [this](void *&handle) { return CVB_CALL_CAPI(CVPYSObjRun(handle_.Handle(), nullptr, handle)); });
      }


      size_t ElementCount() const
      {
        size_t elementCount = 0;
        CVB_CALL_CAPI_CHECKED(CVPYSObjElementCount(handle_.Handle(), elementCount));
        return elementCount;
      }


      void Set(size_t index, const Object &obj)
      {
        CVB_CALL_CAPI_CHECKED(CVPYSObjElementSet(handle_.Handle(), index, obj.Handle()));
      }


      ObjectPtr Get(size_t index) const
      {
        return Internal::DoResCallShareOut<Object>([this, index](void *&handle) {
          return CVB_CALL_CAPI(CVPYSObjElementGet(handle_.Handle(), index, handle));
        });
      }


      template <class T>
      T As() const
      {
        return AsImpl<T>::Run(*this, SelectCategory<T>{});
      }


      void *Handle() const noexcept
      {
        return handle_.Handle();
      }
 
    private:
      template <class LAST>
      void ImplMakeTuple(size_t &index, LAST &&last)
      {
        auto obj = Create(last);
        Set(index, *obj);
      }
 
      template <class FIRST, class... T>
      void ImplMakeTuple(size_t &index, FIRST &&first, T &&...args)
      {
        auto obj = Create(first);
        Set(index, *obj);
        index++;
        ImplMakeTuple(index, std::forward<T>(args)...);
      }
 
      struct PodTag
      {
      };
      struct HandleTag
      {
      };
      struct HandleDownCastTag
      {
      };
      struct HandleUpCastTag
      {
      };
      struct EnumTag
      {
      };
      struct CvbTag
      {
      };
      struct CanCastCvbTag
      {
      };
      struct DefaultTag
      {
      };
 
      // Attention the order partly mattes
      // for casting
      // 1. down cast (HandleDownCastTag)
      // 2. upcast (HandleUpCastTag)
      // 3. direct use (HandleTag)
      template <class T>
      using SelectCategory = typename std::conditional<
          Private::IsPod<T>::value, PodTag,
          typename std::conditional<
              std::is_enum<T>::value, EnumTag,
              typename std::conditional<
                  Private::IsCvbType<T>::value, CvbTag,
                  typename std::conditional<
                      Private::CanCastCvbType<T>::value, CanCastCvbTag,
                      typename std::conditional<
                          Private::CanHandleDownCastType<T>::value, HandleDownCastTag,
                          typename std::conditional<Private::CanHandleUpCastType<T>::value, HandleUpCastTag,
                                                    typename std::conditional<Private::IsHandleType<T>::value,
                                                                              HandleTag, DefaultTag>::type>::type>::
                          type>::type>::type>::type>::type;
 
      // tag dispatch is not enough we need partial specialization
      template <class T>
      struct AsImpl
      {
        static T Run(const Object &object, PodTag)
        {
          CExports::CVPYSObjType type                   = Private::IsPod<T>::TypeId;
          typename Private::IsPod<T>::StorageType value = {};
          size_t size                                   = Private::IsPod<T>::Size;
          CVB_CALL_CAPI_CHECKED(CVPYSObjToBuffer(object.Handle(), type, &value, size));
          return static_cast<T>(value);
        }
 
        static T Run(const Object &object, EnumTag)
        {
          return static_cast<T>(object.As<int64_t>());
        }
 
        static T Run(const Object &object, CvbTag)
        {
          CExports::CVPYSObjType type = Private::IsCvbType<T>::TypeId;
          T value                     = {};
          size_t size                 = sizeof(T);
          CVB_CALL_CAPI_CHECKED(CVPYSObjToBuffer(object.Handle(), type, &value, size));
          return value;
        }
 
        static T Run(const Object &object, CanCastCvbTag)
        {
          return Cvb::Round(AsImpl<typename Private::CanCastCvbType<T>::StorageType>::Run(object, CvbTag{}));
        }
      };
 
      template <class T>
      struct AsImpl<std::shared_ptr<T>>
      {
        static std::shared_ptr<T> Run(const Object &object, DefaultTag)
        {
          static_assert(Private::IsHandleType<T>::value, "T must be a handle type");
          return Internal::DoResCallShareOut<T>([&object](void *&handle) {
            CExports::CVPYSObjType type = Private::IsHandleType<T>::TypeId;
            size_t size                 = sizeof(void *);
            return CVPYSObjToBuffer(object.Handle(), type, &handle, size);
          });
        }
      };
 
 
      template <class T>
      static ObjectPtr CreateImpl(const T &value, PodTag);
 
      template <class T>
      static std::shared_ptr<Object> CreateImpl(const T &value, HandleTag);
 
      template <class T>
      static std::shared_ptr<Object> CreateImpl(const T &value, EnumTag);
 
      template <class T>
      static std::shared_ptr<Object> CreateImpl(const T &value, CvbTag);
 
      template <class T>
      static std::shared_ptr<Object> CreateImpl(const T &value, CanCastCvbTag)
      {
        return CreateImpl(static_cast<typename Private::CanCastCvbType<T>::StorageType>(value), CvbTag{});
      }
 
      template <class T>
      static std::shared_ptr<Object> CreateImpl(const T &value, HandleUpCastTag)
      {
        return CreateImpl(dynamic_cast<const typename Private::CanHandleUpCastType<T>::StorageType &>(value),
                          HandleTag{});
      }
 
      
 
      template <class T>
      static std::shared_ptr<Object> CreateImpl(const T &value, HandleDownCastTag)
      {
        return CreateImpl(value, typename Private::CanHandleDownCastType<T>::List{});
      }
 
      template <class T, class DCT_FIRST, class... DCT_TAIL>
      static std::shared_ptr<Object> CreateImpl(const T &value, Private::DownCastList<DCT_FIRST, DCT_TAIL...>)
      {
        if (auto *ptr = dynamic_cast<const DCT_FIRST *>(&value))
          return CreateImpl(*ptr, HandleTag{});
        else
          return CreateImpl(value, Private::DownCastList<DCT_TAIL...>{});
      }
 
#ifdef _WIN32
#  pragma warning(push)
#  pragma warning(disable : 4702)
#endif
      template <class T, class DCT_LAST>
      static std::shared_ptr<Object> CreateImpl(const T &value, Private::DownCastList<DCT_LAST>)
      {
        // C++ 17 contexpr if would prevent the unreachable code
        // but we want to stay at C++ 14 for now.
        if (auto *ptr = dynamic_cast<const DCT_LAST *>(&value))
          return CreateImpl(*ptr, HandleTag{});
        else
          return CreateImpl(value, HandleUpCastTag{});
      }
#ifdef _WIN32
#  pragma warning(pop)
#endif
 
      HandleGuard<Object> handle_;
    };
 
    template <>
    struct Object::AsImpl<std::shared_ptr<Image>>
    {
      static std::shared_ptr<Image> Run(const Object &object, DefaultTag)
      {
        CExports::CVPYSObjType type = CExports::CVPYSOTY_Image;
        void *handle                = nullptr;
        size_t size                 = sizeof(void *);
        CVB_CALL_CAPI_CHECKED(CVPYSObjToBuffer(object.Handle(), type, &handle, size));
        switch (type)
        {
          default:
            throw std::runtime_error("invalid image");
 
          case CExports::CVPYSOTY_Image:
            return Image::FromHandle<Image>(HandleGuard<Image>(handle));
          case CExports::CVPYSOTY_MultiPartImage:
            return MultiPartImage::FromHandle<MultiPartImage>(HandleGuard<Image>(handle));
        }
      }
    };
 
    template <>
    struct Object::AsImpl<std::shared_ptr<Node>>
    {
      static std::shared_ptr<Node> Run(const Object &object, DefaultTag)
      {
        CExports::CVPYSObjType type = CExports::CVPYSOTY_Node;
        void *handle                = nullptr;
        size_t size                 = sizeof(void *);
        CVB_CALL_CAPI_CHECKED(CVPYSObjToBuffer(object.Handle(), type, &handle, size));
        switch (type)
        {
          default:
            throw std::runtime_error("invalid node");
 
          case CExports::CVPYSOTY_BooleanNode:
            return BooleanNode::FromHandle<BooleanNode>(HandleGuard<Node>(handle));
          case CExports::CVPYSOTY_CategoryNode:
            return CategoryNode::FromHandle<CategoryNode>(HandleGuard<Node>(handle));
          case CExports::CVPYSOTY_CommandNode:
            return CommandNode::FromHandle<CommandNode>(HandleGuard<Node>(handle));
          case CExports::CVPYSOTY_EnumerationNode:
            return EnumerationNode::FromHandle<EnumerationNode>(HandleGuard<Node>(handle));
          case CExports::CVPYSOTY_EnumEntryNode:
            return EnumEntryNode::FromHandle<EnumEntryNode>(HandleGuard<Node>(handle));
          case CExports::CVPYSOTY_FloatRegNode:
            return FloatRegNode::FromHandle<FloatRegNode>(HandleGuard<Node>(handle));
          case CExports::CVPYSOTY_FloatNode:
            return FloatNode::FromHandle<FloatNode>(HandleGuard<Node>(handle));
          case CExports::CVPYSOTY_IntRegNode:
            return IntRegNode::FromHandle<IntRegNode>(HandleGuard<Node>(handle));
          case CExports::CVPYSOTY_IntegerNode:
            return IntegerNode::FromHandle<IntegerNode>(HandleGuard<Node>(handle));
          case CExports::CVPYSOTY_StringRegNode:
            return StringRegNode::FromHandle<StringRegNode>(HandleGuard<Node>(handle));
          case CExports::CVPYSOTY_StringNode:
            return StringNode::FromHandle<StringNode>(HandleGuard<Node>(handle));
        }
      }
    };
 
    template <>
    struct Object::AsImpl<std::shared_ptr<ValueNode>>
    {
      static std::shared_ptr<ValueNode> Run(const Object &object, DefaultTag tag)
      {
        auto node = std::dynamic_pointer_cast<ValueNode>(AsImpl<std::shared_ptr<Node>>::Run(object, tag));
        if (!node)
          throw std::runtime_error("no valid value node");
        return node;
      }
    };
 
    template <>
    struct Object::AsImpl<std::shared_ptr<FloatNode>>
    {
      static std::shared_ptr<FloatNode> Run(const Object &object, DefaultTag tag)
      {
        auto node = std::dynamic_pointer_cast<FloatNode>(AsImpl<std::shared_ptr<Node>>::Run(object, tag));
        if (!node)
          throw std::runtime_error("no valid float node");
        return node;
      }
    };
 
    template <>
    struct Object::AsImpl<std::shared_ptr<IntegerNode>>
    {
      static std::shared_ptr<IntegerNode> Run(const Object &object, DefaultTag tag)
      {
        auto node = std::dynamic_pointer_cast<IntegerNode>(AsImpl<std::shared_ptr<Node>>::Run(object, tag));
        if (!node)
          throw std::runtime_error("no valid integer node");
        return node;
      }
    };
 
    template <>
    struct Object::AsImpl<std::shared_ptr<SelectorNode>>
    {
      static std::shared_ptr<SelectorNode> Run(const Object &object, DefaultTag tag)
      {
        auto node = std::dynamic_pointer_cast<SelectorNode>(AsImpl<std::shared_ptr<Node>>::Run(object, tag));
        if (!node)
          throw std::runtime_error("no valid selector node");
        return node;
      }
    };
 
    template <>
    struct Object::AsImpl<std::shared_ptr<StringNode>>
    {
      static std::shared_ptr<StringNode> Run(const Object &object, DefaultTag tag)
      {
        auto node = std::dynamic_pointer_cast<StringNode>(AsImpl<std::shared_ptr<Node>>::Run(object, tag));
        if (!node)
          throw std::runtime_error("no valid string node");
        return node;
      }
    };
 
    template <>
    struct Object::AsImpl<std::shared_ptr<PointCloud>>
    {
      static std::shared_ptr<PointCloud> Run(const Object &object, DefaultTag)
      {
        CExports::CVPYSObjType type = CExports::CVPYSOTY_PointCloud;
        void *handle                = nullptr;
        size_t size                 = sizeof(void *);
        CVB_CALL_CAPI_CHECKED(CVPYSObjToBuffer(object.Handle(), type, &handle, size));
        switch (type)
        {
          default:
            throw std::runtime_error("invalid point cloud");
 
          case CExports::CVPYSOTY_DensePointCloud:
            return DensePointCloud::FromHandle<DensePointCloud>(HandleGuard<PointCloud>(handle));
          case CExports::CVPYSOTY_SparsePointCloud:
            return SparsePointCloud::FromHandle<SparsePointCloud>(HandleGuard<PointCloud>(handle));
        }
      }
    };
 
    // will never be called but needed for code generation
    template <>
    [[noreturn]] inline std::shared_ptr<Object> Object::CreateImpl<Node>(const Node &value, HandleUpCastTag)
    {
      (void)value;
      throw std::runtime_error("cannot create from Cvb::Node");
    }
 
    // will never be called but needed for code generation
    template <>
    [[noreturn]] inline std::shared_ptr<Object> Object::CreateImpl<ValueNode>(const ValueNode &value, HandleUpCastTag)
    {
      (void)value;
      throw std::runtime_error("cannot create from Cvb::ValueNode");
    }
 
    // will never be called but needed for code generation
    template <>
    [[noreturn]] inline std::shared_ptr<Object> Object::CreateImpl<SelectorNode>(const SelectorNode &value,
                                                                                 HandleUpCastTag)
    {
      (void)value;
      throw std::runtime_error("cannot create from Cvb::SelectorNode");
    }
 
    // will never be called but needed for code generation
    template <>
    [[noreturn]] inline std::shared_ptr<Object> Object::CreateImpl<PointCloud>(const PointCloud &value, HandleUpCastTag)
    {
      (void)value;
      throw std::runtime_error("cannot create from Cvb::PointClouds");
    }
 
  }  // namespace PyScript
  CVB_END_INLINE_NS
 
}  // namespace Cvb