Skip to content

O
opencv
Commit 461c98fa authored by Roman Donchenko's avatar Roman Donchenko
Browse files
Options

Replaced Ptr with my new implementation.

parent ecc51817
Hide whitespace changes
Inline Side-by-side
Showing with 490 additions and 213 deletions
modules/core/include/opencv2/core/cvstd.hpp
View file @ 461c98fa
......@@ -158,69 +158,176 @@ public:
size_type max_size() const { return cv::max(static_cast<_Tp>(-1)/sizeof(_Tp), 1); }
};
namespace detail
{
// Metafunction to avoid taking a reference to void.
template<typename T>
struct RefOrVoid { typedef T& type; };
//////////////////// generic_type ref-counting pointer class for C/C++ objects ////////////////////////
template<>
struct RefOrVoid<void>{ typedef void type; };
/*!
Smart pointer to dynamically allocated objects.
template<>
struct RefOrVoid<const void>{ typedef const void type; };
This is template pointer-wrapping class that stores the associated reference counter along with the
object pointer. The class is similar to std::smart_ptr<> from the recent addons to the C++ standard,
but is shorter to write :) and self-contained (i.e. does add any dependency on the compiler or an external library).
template<>
struct RefOrVoid<volatile void>{ typedef volatile void type; };
Basically, you can use "Ptr<MyObjectType> ptr" (or faster "const Ptr<MyObjectType>& ptr" for read-only access)
everywhere instead of "MyObjectType* ptr", where MyObjectType is some C structure or a C++ class.
To make it all work, you need to specialize Ptr<>::delete_obj(), like:
template<>
struct RefOrVoid<const volatile void>{ typedef const volatile void type; };
\code
template<> CV_EXPORTS void Ptr<MyObjectType>::delete_obj() { call_destructor_func(obj); }
\endcode
// This class would be private to Ptr, if it didn't have to be a non-template.
struct PtrOwner;
}
template<typename Y>
struct DefaultDeleter
{
void operator () (Y* p) const;
};
\note{if MyObjectType is a C++ class with a destructor, you do not need to specialize delete_obj(),
since the default implementation calls "delete obj;"}
/*
A smart shared pointer class with reference counting.
\note{Another good property of the class is that the operations on the reference counter are atomic,
i.e. it is safe to use the class in multi-threaded applications}
A Ptr<T> stores a pointer and owns a (potentially different) pointer.
The stored pointer has type T and is the one returned by get() et al,
while the owned pointer can have any type and is the one deleted
when there are no more Ptrs that own it. You can't directly obtain the
owned pointer.
The interface of this class is mostly a subset of that of C++11's
std::shared_ptr.
*/
template<typename _Tp> class Ptr
template<typename T>
struct Ptr
{
public:
//! empty constructor
/* Generic programming support. */
typedef T element_type;
/* Ptr that owns NULL and stores NULL. */
Ptr();
//! take ownership of the pointer. The associated reference counter is allocated and set to 1
Ptr(_Tp* _obj);
//! calls release()
/* Ptr that owns p and stores p. The owned pointer will be deleted with
DefaultDeleter<Y>. Y must be a complete type and Y* must be
convertible to T*. */
template<typename Y>
explicit Ptr(Y* p);
/* Ptr that owns p and stores p. The owned pointer will be deleted by
calling d(p). Y* must be convertible to T*. */
template<typename Y, typename D>
Ptr(Y* p, D d);
/* Same as the constructor below; it exists to suppress the generation
of the implicit copy constructor. */
Ptr(const Ptr& o);
/* Ptr that owns the same pointer as o and stores the same pointer as o,
converted to T*. Naturally, Y* must be convertible to T*. */
template<typename Y>
Ptr(const Ptr<Y>& o);
/* Ptr that owns same pointer as o, and stores p. Useful for casts and
creating non-owning Ptrs. */
template<typename Y>
Ptr(const Ptr<Y>& o, T* p);
/* Equivalent to release(). */
~Ptr();
//! copy constructor. Copies the members and calls addref()
Ptr(const Ptr& ptr);
template<typename _Tp2> Ptr(const Ptr<_Tp2>& ptr);
//! copy operator. Calls ptr.addref() and release() before copying the members
Ptr& operator = (const Ptr& ptr);
//! increments the reference counter
void addref();
//! decrements the reference counter. If it reaches 0, delete_obj() is called
/* Same as assignment below; exists to suppress the generation of the
implicit assignment operator. */
Ptr& operator = (const Ptr& o);
template<typename Y>
Ptr& operator = (const Ptr<Y>& o);
/* Resets both the owned and stored pointers to NULL. Deletes the owned
pointer with the associated deleter if it's not owned by any other
Ptr and is non-zero. It's called reset() in std::shared_ptr; here
it is release() for compatibility with old OpenCV versions. */
void release();
//! deletes the object. Override if needed
void delete_obj();
//! returns true iff obj==NULL
/* Equivalent to assigning from Ptr<T>(p). */
template<typename Y>
void reset(Y* p);
/* Equivalent to assigning from Ptr<T>(p, d). */
template<typename Y, typename D>
void reset(Y* p, D d);
/* Swaps the stored and owned pointers of this and o. */
void swap(Ptr& o);
/* Returns the stored pointer. */
T* get() const;
/* Ordinary pointer emulation. */
typename detail::RefOrVoid<T>::type operator * () const;
T* operator -> () const;
/* Equivalent to get(). */
operator T* () const;
/* Equivalent to !*this. */
bool empty() const;
//! cast pointer to another type
template<typename _Tp2> Ptr<_Tp2> ptr();
template<typename _Tp2> const Ptr<_Tp2> ptr() const;
/* Returns a Ptr that owns the same pointer as this, and stores the same
pointer as this, except converted via static_cast to Y*. */
template<typename Y>
Ptr<Y> staticCast() const;
/* Ditto for const_cast. */
template<typename Y>
Ptr<Y> constCast() const;
//! helper operators making "Ptr<T> ptr" use very similar to "T* ptr".
_Tp* operator -> ();
const _Tp* operator -> () const;
/* Ditto for dynamic_cast. */
template<typename Y>
Ptr<Y> dynamicCast() const;
operator _Tp* ();
operator const _Tp*() const;
private:
detail::PtrOwner* owner;
T* stored;
_Tp* obj; //< the object pointer.
int* refcount; //< the associated reference counter
template<typename Y>
friend struct Ptr; // have to do this for the cross-type copy constructor
};
/* Overload of the generic swap. */
template<typename T>
void swap(Ptr<T>& ptr1, Ptr<T>& ptr2);
/* Obvious comparisons. */
template<typename T>
bool operator == (const Ptr<T>& ptr1, const Ptr<T>& ptr2);
template<typename T>
bool operator != (const Ptr<T>& ptr1, const Ptr<T>& ptr2);
/* Convenience creation functions. In the far future, there may be variadic templates here. */
template<typename T>
Ptr<T> makePtr();
template<typename T, typename A1>
Ptr<T> makePtr(const A1& a1);
template<typename T, typename A1, typename A2>
Ptr<T> makePtr(const A1& a1, const A2& a2);
template<typename T, typename A1, typename A2, typename A3>
Ptr<T> makePtr(const A1& a1, const A2& a2, const A3& 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);
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);
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);
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);
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);
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);
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);
//////////////////////////////// string class ////////////////////////////////
......@@ -324,176 +431,6 @@ private:
};
/////////////////////////// cv::Ptr implementation ///////////////////////////
template<typename _Tp> inline
Ptr<_Tp>::Ptr()
: obj(0), refcount(0) {}
template<typename _Tp> inline
Ptr<_Tp>::Ptr(_Tp* _obj)
: obj(_obj)
{
if(obj)
{
refcount = (int*)fastMalloc(sizeof(*refcount));
*refcount = 1;
}
else
refcount = 0;
}
template<typename _Tp> template<typename _Tp2>
Ptr<_Tp>::Ptr(const Ptr<_Tp2>& p)
: obj(0), refcount(0)
{
if (p.empty())
return;
_Tp* p_casted = dynamic_cast<_Tp*>(p.obj);
if (!p_casted)
return;
obj = p_casted;
refcount = p.refcount;
addref();
}
template<typename _Tp> inline
Ptr<_Tp>::~Ptr()
{
release();
}
template<typename _Tp> inline
void Ptr<_Tp>::addref()
{
if( refcount )
CV_XADD(refcount, 1);
}
template<typename _Tp> inline
void Ptr<_Tp>::release()
{
if( refcount && CV_XADD(refcount, -1) == 1 )
{
delete_obj();
fastFree(refcount);
}
refcount = 0;
obj = 0;
}
template<typename _Tp> inline
void Ptr<_Tp>::delete_obj()
{
if( obj )
delete obj;
}
template<typename _Tp> inline
Ptr<_Tp>::Ptr(const Ptr<_Tp>& _ptr)
{
obj = _ptr.obj;
refcount = _ptr.refcount;
addref();
}
template<typename _Tp> inline
Ptr<_Tp>& Ptr<_Tp>::operator = (const Ptr<_Tp>& _ptr)
{
int* _refcount = _ptr.refcount;
if( _refcount )
CV_XADD(_refcount, 1);
release();
obj = _ptr.obj;
refcount = _refcount;
return *this;
}
template<typename _Tp> inline
_Tp* Ptr<_Tp>::operator -> ()
{
return obj;
}
template<typename _Tp> inline
const _Tp* Ptr<_Tp>::operator -> () const
{
return obj;
}
template<typename _Tp> inline
Ptr<_Tp>::operator _Tp* ()
{
return obj;
}
template<typename _Tp> inline
Ptr<_Tp>::operator const _Tp*() const
{
return obj;
}
template<typename _Tp> inline
bool Ptr<_Tp>::empty() const
{
return obj == 0;
}
template<typename _Tp> template<typename _Tp2> inline
Ptr<_Tp2> Ptr<_Tp>::ptr()
{
Ptr<_Tp2> p;
if( !obj )
return p;
_Tp2* obj_casted = dynamic_cast<_Tp2*>(obj);
if (!obj_casted)
return p;
if( refcount )
CV_XADD(refcount, 1);
p.obj = obj_casted;
p.refcount = refcount;
return p;
}
template<typename _Tp> template<typename _Tp2> inline
const Ptr<_Tp2> Ptr<_Tp>::ptr() const
{
Ptr<_Tp2> p;
if( !obj )
return p;
_Tp2* obj_casted = dynamic_cast<_Tp2*>(obj);
if (!obj_casted)
return p;
if( refcount )
CV_XADD(refcount, 1);
p.obj = obj_casted;
p.refcount = refcount;
return p;
}
template<class _Tp, class _Tp2> static inline
bool operator == (const Ptr<_Tp>& a, const Ptr<_Tp2>& b)
{
return a.refcount == b.refcount;
}
template<class _Tp, class _Tp2> static inline
bool operator != (const Ptr<_Tp>& a, const Ptr<_Tp2>& b)
{
return a.refcount != b.refcount;
}
////////////////////////// cv::String implementation /////////////////////////
inline
......@@ -940,4 +877,6 @@ namespace cv
}
}
#include "opencv2/core/ptr.inl.hpp"
#endif //__OPENCV_CORE_CVSTD_HPP__
modules/core/include/opencv2/core/ptr.inl.hpp 0 → 100644
View file @ 461c98fa
/*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>
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 : PtrOwner
{
PtrOwnerImpl(Y* p, D d) : owned(p), deleter(d)
{}
void deleteSelf()
{
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>
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));
}
} // namespace cv
#endif // __OPENCV_CORE_PTR_INL_HPP__
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment