Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
Greenplum
Opencv
提交
461c98fa
O
Opencv
项目概览
Greenplum
/
Opencv
大约 1 年 前同步成功
通知
7
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
O
Opencv
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
461c98fa
编写于
8月 13, 2013
作者:
R
Roman Donchenko
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
Replaced Ptr with my new implementation.
上级
ecc51817
变更
2
隐藏空白更改
内联
并排
Showing
2 changed file
with
490 addition
and
213 deletion
+490
-213
modules/core/include/opencv2/core/cvstd.hpp
modules/core/include/opencv2/core/cvstd.hpp
+152
-213
modules/core/include/opencv2/core/ptr.inl.hpp
modules/core/include/opencv2/core/ptr.inl.hpp
+338
-0
未找到文件。
modules/core/include/opencv2/core/cvstd.hpp
浏览文件 @
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 counte
r
template
<
typename
Y
>
friend
struct
Ptr
;
// have to do this for the cross-type copy constructo
r
};
/* 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
浏览文件 @
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%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录