Download include/opencv2/core/cvstd_wrapper.hpp from dlxjj/opencv: direct link, hf CLI and curl.
- Browser
- Download file 5.73 kB
-
https://huggingface.co/datasets/dlxjj/opencv/resolve/main/include/opencv2/core/cvstd_wrapper.hpp
- Command line
-
hf download hf://datasets/dlxjj/opencv/include/opencv2/core/cvstd_wrapper.hpp
-
curl -L -o cvstd_wrapper.hpp https://huggingface.co/datasets/dlxjj/opencv/resolve/main/include/opencv2/core/cvstd_wrapper.hpp
5.73 kB
| // This file is part of OpenCV project. | |
| // It is subject to the license terms in the LICENSE file found in the top-level directory | |
| // of this distribution and at http://opencv.org/license.html. | |
| namespace cv { | |
| using std::nullptr_t; | |
| //! @addtogroup core_basic | |
| //! @{ | |
| template <typename _Tp> using Ptr = std::shared_ptr<_Tp>; // In ideal world it should look like this, but we need some compatibility workarounds below | |
| template<typename _Tp, typename ... A1> static inline | |
| Ptr<_Tp> makePtr(const A1&... a1) { return std::make_shared<_Tp>(a1...); } | |
| // It should be defined for C-API types only. | |
| // C++ types should use regular "delete" operator. | |
| template<typename Y> struct DefaultDeleter; | |
| { | |
| void operator()(Y* p) const; | |
| }; | |
| namespace sfinae { | |
| template<typename C, typename Ret, typename... Args> | |
| struct has_parenthesis_operator | |
| { | |
| private: | |
| template<typename T> | |
| static CV_CONSTEXPR std::true_type has_parenthesis_operator_check(typename std::is_same<typename std::decay<decltype(std::declval<T>().operator()(std::declval<Args>()...))>::type, Ret>::type*); | |
| template<typename> static CV_CONSTEXPR std::false_type has_parenthesis_operator_check(...); | |
| typedef decltype(has_parenthesis_operator_check<C>(0)) type; | |
| public: | |
| static CV_CONSTEXPR bool value = type::value; | |
| // support MSVS 2013 | |
| static const int value = type::value; | |
| }; | |
| } // namespace sfinae | |
| template <typename T, typename = void> | |
| struct has_custom_delete | |
| : public std::false_type {}; | |
| // Force has_custom_delete to std::false_type when NVCC is compiling CUDA source files | |
| template <typename T> | |
| struct has_custom_delete<T, typename std::enable_if< sfinae::has_parenthesis_operator<DefaultDeleter<T>, void, T*>::value >::type > | |
| : public std::true_type {}; | |
| template<typename T> | |
| struct Ptr : public std::shared_ptr<T> | |
| { | |
| using std::shared_ptr<T>::shared_ptr; // GCC 5.x can't handle this | |
| inline Ptr() CV_NOEXCEPT : std::shared_ptr<T>() {} | |
| inline Ptr(nullptr_t) CV_NOEXCEPT : std::shared_ptr<T>(nullptr) {} | |
| template<typename Y, typename D> inline Ptr(Y* p, D d) : std::shared_ptr<T>(p, d) {} | |
| template<typename D> inline Ptr(nullptr_t, D d) : std::shared_ptr<T>(nullptr, d) {} | |
| template<typename Y> inline Ptr(const Ptr<Y>& r, T* ptr) CV_NOEXCEPT : std::shared_ptr<T>(r, ptr) {} | |
| inline Ptr(const Ptr<T>& o) CV_NOEXCEPT : std::shared_ptr<T>(o) {} | |
| inline Ptr(Ptr<T>&& o) CV_NOEXCEPT : std::shared_ptr<T>(std::move(o)) {} | |
| template<typename Y> inline Ptr(const Ptr<Y>& o) CV_NOEXCEPT : std::shared_ptr<T>(o) {} | |
| template<typename Y> inline Ptr(Ptr<Y>&& o) CV_NOEXCEPT : std::shared_ptr<T>(std::move(o)) {} | |
| inline Ptr(const std::shared_ptr<T>& o) CV_NOEXCEPT : std::shared_ptr<T>(o) {} | |
| inline Ptr(std::shared_ptr<T>&& o) CV_NOEXCEPT : std::shared_ptr<T>(std::move(o)) {} | |
| // Overload with custom DefaultDeleter: Ptr<IplImage>(...) | |
| template<typename Y> | |
| inline Ptr(const std::true_type&, Y* ptr) : std::shared_ptr<T>(ptr, DefaultDeleter<Y>()) {} | |
| // Overload without custom deleter: Ptr<std::string>(...); | |
| template<typename Y> | |
| inline Ptr(const std::false_type&, Y* ptr) : std::shared_ptr<T>(ptr) {} | |
| template<typename Y = T> | |
| inline Ptr(Y* ptr) : Ptr(has_custom_delete<Y>(), ptr) {} | |
| // Overload with custom DefaultDeleter: Ptr<IplImage>(...) | |
| template<typename Y> | |
| inline void reset(const std::true_type&, Y* ptr) { std::shared_ptr<T>::reset(ptr, DefaultDeleter<Y>()); } | |
| // Overload without custom deleter: Ptr<std::string>(...); | |
| template<typename Y> | |
| inline void reset(const std::false_type&, Y* ptr) { std::shared_ptr<T>::reset(ptr); } | |
| template<typename Y> | |
| inline void reset(Y* ptr) { Ptr<T>::reset(has_custom_delete<Y>(), ptr); } | |
| template<class Y, class Deleter> | |
| void reset(Y* ptr, Deleter d) { std::shared_ptr<T>::reset(ptr, d); } | |
| void reset() CV_NOEXCEPT { std::shared_ptr<T>::reset(); } | |
| Ptr& operator=(const Ptr& o) { std::shared_ptr<T>::operator =(o); return *this; } | |
| template<typename Y> inline Ptr& operator=(const Ptr<Y>& o) { std::shared_ptr<T>::operator =(o); return *this; } | |
| T* operator->() const CV_NOEXCEPT { return std::shared_ptr<T>::get();} | |
| typename std::add_lvalue_reference<T>::type operator*() const CV_NOEXCEPT { return *std::shared_ptr<T>::get(); } | |
| // OpenCV 3.x methods (not a part of standard C++ library) | |
| inline void release() { std::shared_ptr<T>::reset(); } | |
| inline operator T* () const { return std::shared_ptr<T>::get(); } | |
| inline bool empty() const { return std::shared_ptr<T>::get() == nullptr; } | |
| template<typename Y> inline | |
| Ptr<Y> staticCast() const CV_NOEXCEPT { return std::static_pointer_cast<Y>(*this); } | |
| template<typename Y> inline | |
| Ptr<Y> constCast() const CV_NOEXCEPT { return std::const_pointer_cast<Y>(*this); } | |
| template<typename Y> inline | |
| Ptr<Y> dynamicCast() const CV_NOEXCEPT { return std::dynamic_pointer_cast<Y>(*this); } | |
| }; | |
| template<typename _Tp, typename ... A1> static inline | |
| Ptr<_Tp> makePtr(const A1&... a1) | |
| { | |
| static_assert( !has_custom_delete<_Tp>::value, "Can't use this makePtr with custom DefaultDeleter"); | |
| return (Ptr<_Tp>)std::make_shared<_Tp>(a1...); | |
| } | |
| //! @} core_basic | |
| } // cv | |