core: replace cv::Ptr implementation => std::shared_ptr

modules/core/include/opencv2/core/cvstd_wrapper.hpp

+// 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.
+
+#ifndef OPENCV_CORE_CVSTD_WRAPPER_HPP
+#define OPENCV_CORE_CVSTD_WRAPPER_HPP
+
+#include "opencv2/core/cvdef.h"
+
+#include <string>
+#include <memory>  // std::shared_ptr
+#include <type_traits>  // std::enable_if
+
+namespace cv {
+
+using std::nullptr_t;
+
+//! @addtogroup core_basic
+//! @{
+
+#ifdef CV_DOXYGEN
+
+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...); }
+
+#else  // cv::Ptr with compatibility workarounds
+
+template<typename Y>
+struct DefaultDeleter
+{
+#ifndef _MSC_VER
+    void operator()(Y* p) const = delete;  // not available by default; enabled for specializations only
+#else
+    void operator()(Y* p) const { delete p; }
+#endif
+};
+
+namespace sfinae {
+template<typename C, typename Ret, typename... Args>
+struct has_parenthesis_operator
+{
+private:
+    template<typename T>
+    static constexpr std::true_type check(typename std::is_same<typename std::decay<decltype(std::declval<T>().operator()(std::declval<Args>()...))>::type, Ret>::type*);
+
+    template<typename> static constexpr std::false_type check(...);
+
+    typedef decltype(check<C>(0)) type;
+
+public:
+    static constexpr bool value = type::value;
+};
+} // namespace sfinae
+
+template <typename Y> using has_custom_delete = sfinae::has_parenthesis_operator<DefaultDeleter<Y>, void, Y*>;
+
+template<typename T>
+struct Ptr : public std::shared_ptr<T>
+{
+#if 0
+    using std::shared_ptr<T>::shared_ptr;  // GCC 5.x can't handle this
+#else
+    inline Ptr() noexcept : std::shared_ptr<T>() {}
+    inline Ptr(nullptr_t) 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) noexcept : std::shared_ptr<T>(r, ptr) {}
+
+    inline Ptr(const Ptr<T>& o) noexcept : std::shared_ptr<T>(o) {}
+    inline Ptr(Ptr<T>&& o) noexcept : std::shared_ptr<T>(std::move(o)) {}
+
+    template<typename Y> inline Ptr(const Ptr<Y>& o) noexcept : std::shared_ptr<T>(o) {}
+    template<typename Y> inline Ptr(Ptr<Y>&& o) noexcept : std::shared_ptr<T>(std::move(o)) {}
+#endif
+    inline Ptr(const std::shared_ptr<T>& o) noexcept : std::shared_ptr<T>(o) {}
+    inline Ptr(std::shared_ptr<T>&& o) noexcept : std::shared_ptr<T>(std::move(o)) {}
+
+#ifndef _MSC_VER
+    // Overload with custom DefaultDeleter: Ptr<IplImage>(...)
+    template<typename Y = T, class = typename std::enable_if< has_custom_delete<Y>::value >::type>
+    inline Ptr(Y* ptr) : std::shared_ptr<T>(ptr, DefaultDeleter<Y>()) {}
+
+    // Overload without custom deleter: Ptr<std::string>(...);
+    template<typename Y = T, int = sizeof(typename std::enable_if< !has_custom_delete<Y>::value, int >::type) >
+    inline Ptr(Y* ptr) : std::shared_ptr<T>(ptr) {}
+
+    // Overload with custom DefaultDeleter: Ptr<IplImage>(...)
+    template<typename Y, class = typename std::enable_if< has_custom_delete<Y>::value >::type>
+    inline void reset(Y* ptr) { std::shared_ptr<T>::reset(ptr, DefaultDeleter<Y>()); }
+
+    // Overload without custom deleter: Ptr<std::string>(...);
+    template<typename Y, int = sizeof(typename std::enable_if< !has_custom_delete<Y>::value, int >::type) >
+    inline void reset(Y* ptr) { std::shared_ptr<T>::reset(ptr); }
+#else
+    template<typename Y>
+    inline Ptr(Y* ptr) : std::shared_ptr<T>(ptr, DefaultDeleter<Y>()) {}
+
+    template<typename Y>
+    inline void reset(Y* ptr) { std::shared_ptr<T>::reset(ptr, DefaultDeleter<Y>()); }
+#endif
+
+    template<class Y, class Deleter>
+    void reset(Y* ptr, Deleter d) { std::shared_ptr<T>::reset(ptr, d); }
+
+    void reset() 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 noexcept { return std::shared_ptr<T>::get();}
+    typename std::add_lvalue_reference<T>::type operator*() const noexcept { return *std::shared_ptr<T>::get(); }
+
+    // OpenCV 3.x methods (not a part of standart 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() == NULL; }
+
+    template<typename Y> inline
+    Ptr<Y> staticCast() const noexcept { return std::static_pointer_cast<Y>(*this); }
+
+    template<typename Y> inline
+    Ptr<Y> constCast() const noexcept { return std::const_pointer_cast<Y>(*this); }
+
+    template<typename Y> inline
+    Ptr<Y> dynamicCast() const noexcept { return std::dynamic_pointer_cast<Y>(*this); }
+};
+
+template<typename _Tp, typename ... A1> static inline
+Ptr<_Tp> makePtr(const A1&... a1)
+{
+#ifndef _MSC_VER
+    static_assert( !has_custom_delete<_Tp>::value, "Can't use this makePtr with custom DefaultDeleter");
+    return (Ptr<_Tp>)std::make_shared<_Tp>(a1...);
+#else
+    return Ptr<_Tp>(new _Tp(a1...), DefaultDeleter<_Tp>());
+#endif
+}
+
+#endif // CV_DOXYGEN
+
+//! @} core_basic
+} // cv
+
+#endif //OPENCV_CORE_CVSTD_WRAPPER_HPP

modules/core/include/opencv2/core/ptr.inl.hpp

-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2013, NVIDIA Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the copyright holders or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_CORE_PTR_INL_HPP
-#define OPENCV_CORE_PTR_INL_HPP
-
-#include <algorithm>
-
-//! @cond IGNORED
-
-namespace cv {
-
-template<typename Y>
-void DefaultDeleter<Y>::operator () (Y* p) const
-{
-    delete p;
-}
-
-namespace detail
-{
-
-struct PtrOwner
-{
-    PtrOwner() : refCount(1)
-    {}
-
-    void incRef()
-    {
-        CV_XADD(&refCount, 1);
-    }
-
-    void decRef()
-    {
-        if (CV_XADD(&refCount, -1) == 1) deleteSelf();
-    }
-
-protected:
-    /* This doesn't really need to be virtual, since PtrOwner is never deleted
-       directly, but it doesn't hurt and it helps avoid warnings. */
-    virtual ~PtrOwner()
-    {}
-
-    virtual void deleteSelf() = 0;
-
-private:
-    unsigned int refCount;
-
-    // noncopyable
-    PtrOwner(const PtrOwner&);
-    PtrOwner& operator = (const PtrOwner&);
-};
-
-template<typename Y, typename D>
-struct PtrOwnerImpl CV_FINAL : PtrOwner
-{
-    PtrOwnerImpl(Y* p, D d) : owned(p), deleter(d)
-    {}
-
-    void deleteSelf() CV_OVERRIDE
-    {
-        deleter(owned);
-        delete this;
-    }
-
-private:
-    Y* owned;
-    D deleter;
-};
-
-
-}
-
-template<typename T>
-Ptr<T>::Ptr() : owner(NULL), stored(NULL)
-{}
-
-template<typename T>
-template<typename Y>
-Ptr<T>::Ptr(Y* p)
-  : owner(p
-      ? new detail::PtrOwnerImpl<Y, DefaultDeleter<Y> >(p, DefaultDeleter<Y>())
-      : NULL),
-    stored(p)
-{}
-
-template<typename T>
-template<typename Y, typename D>
-Ptr<T>::Ptr(Y* p, D d)
-  : owner(p
-      ? new detail::PtrOwnerImpl<Y, D>(p, d)
-      : NULL),
-    stored(p)
-{}
-
-template<typename T>
-Ptr<T>::Ptr(const Ptr& o) : owner(o.owner), stored(o.stored)
-{
-    if (owner) owner->incRef();
-}
-
-template<typename T>
-template<typename Y>
-Ptr<T>::Ptr(const Ptr<Y>& o) : owner(o.owner), stored(o.stored)
-{
-    if (owner) owner->incRef();
-}
-
-template<typename T>
-template<typename Y>
-Ptr<T>::Ptr(const Ptr<Y>& o, T* p) : owner(o.owner), stored(p)
-{
-    if (owner) owner->incRef();
-}
-
-template<typename T>
-Ptr<T>::~Ptr()
-{
-    release();
-}
-
-template<typename T>
-Ptr<T>& Ptr<T>::operator = (const Ptr<T>& o)
-{
-    Ptr(o).swap(*this);
-    return *this;
-}
-
-template<typename T>
-template<typename Y>
-Ptr<T>& Ptr<T>::operator = (const Ptr<Y>& o)
-{
-    Ptr(o).swap(*this);
-    return *this;
-}
-
-template<typename T>
-void Ptr<T>::release()
-{
-    if (owner) owner->decRef();
-    owner = NULL;
-    stored = NULL;
-}
-
-template<typename T>
-template<typename Y>
-void Ptr<T>::reset(Y* p)
-{
-    Ptr(p).swap(*this);
-}
-
-template<typename T>
-template<typename Y, typename D>
-void Ptr<T>::reset(Y* p, D d)
-{
-    Ptr(p, d).swap(*this);
-}
-
-template<typename T>
-void Ptr<T>::swap(Ptr<T>& o)
-{
-    std::swap(owner, o.owner);
-    std::swap(stored, o.stored);
-}
-
-template<typename T>
-T* Ptr<T>::get() const
-{
-    return stored;
-}
-
-template<typename T>
-typename detail::RefOrVoid<T>::type Ptr<T>::operator * () const
-{
-    return *stored;
-}
-
-template<typename T>
-T* Ptr<T>::operator -> () const
-{
-    return stored;
-}
-
-template<typename T>
-Ptr<T>::operator T* () const
-{
-    return stored;
-}
-
-
-template<typename T>
-bool Ptr<T>::empty() const
-{
-    return !stored;
-}
-
-template<typename T>
-template<typename Y>
-Ptr<Y> Ptr<T>::staticCast() const
-{
-    return Ptr<Y>(*this, static_cast<Y*>(stored));
-}
-
-template<typename T>
-template<typename Y>
-Ptr<Y> Ptr<T>::constCast() const
-{
-    return Ptr<Y>(*this, const_cast<Y*>(stored));
-}
-
-template<typename T>
-template<typename Y>
-Ptr<Y> Ptr<T>::dynamicCast() const
-{
-    return Ptr<Y>(*this, dynamic_cast<Y*>(stored));
-}
-
-template<typename T>
-Ptr<T>::Ptr(Ptr&& o) : owner(o.owner), stored(o.stored)
-{
-    o.owner = NULL;
-    o.stored = NULL;
-}
-
-template<typename T>
-Ptr<T>& Ptr<T>::operator = (Ptr<T>&& o)
-{
-    if (this == &o)
-        return *this;
-
-    release();
-    owner = o.owner;
-    stored = o.stored;
-    o.owner = NULL;
-    o.stored = NULL;
-    return *this;
-}
-
-
-template<typename T>
-void swap(Ptr<T>& ptr1, Ptr<T>& ptr2){
-    ptr1.swap(ptr2);
-}
-
-template<typename T>
-bool operator == (const Ptr<T>& ptr1, const Ptr<T>& ptr2)
-{
-    return ptr1.get() == ptr2.get();
-}
-
-template<typename T>
-bool operator != (const Ptr<T>& ptr1, const Ptr<T>& ptr2)
-{
-    return ptr1.get() != ptr2.get();
-}
-
-template<typename T>
-Ptr<T> makePtr()
-{
-    return Ptr<T>(new T());
-}
-
-template<typename T, typename A1>
-Ptr<T> makePtr(const A1& a1)
-{
-    return Ptr<T>(new T(a1));
-}
-
-template<typename T, typename A1, typename A2>
-Ptr<T> makePtr(const A1& a1, const A2& a2)
-{
-    return Ptr<T>(new T(a1, a2));
-}
-
-template<typename T, typename A1, typename A2, typename A3>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3)
-{
-    return Ptr<T>(new T(a1, a2, a3));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4, typename A5>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4, a5));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4, a5, a6));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4, a5, a6, a7));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4, a5, a6, a7, a8));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4, a5, a6, a7, a8, a9));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10, const A11& a11)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11));
-}
-
-template<typename T, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename A9, typename A10, typename A11, typename A12>
-Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10, const A11& a11, const A12& a12)
-{
-    return Ptr<T>(new T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12));
-}
-} // namespace cv
-
-//! @endcond
-
-#endif // OPENCV_CORE_PTR_INL_HPP