pghs975uc
/
infer_clone
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Revert "[C++] Move models of smart pointers to custom namespace"

Browse Source 
Reviewed By: jvillard

Differential Revision: D3742748

fbshipit-source-id: 0ca2b7b
master
Andrzej Kotulski 9 years ago committed by Facebook Github Bot 5
parent 3f60f54fbf
commit 761579469e
3 changed files with 117 additions and 158 deletions
Show Stats Download Patch File Download Diff File

124
infer/models/cpp/include/infer_model/shared_ptr.h
Unescape View File

@ -12,72 +12,65 @@
#include <infer_model/common.h>
// define shared_ptr outside of std namespace. It will be aliased as
// std::shared_ptr via 'using' clause later
namespace infer_std_model {
INFER_NAMESPACE_STD_BEGIN
// use inheritance to avoid compilation errors when using
// methods / non-member functions that are not modeled
// WARNING: sizeof(shared_ptr) = 24, not 16 - this may
// lead to compilation errors
template <class T>
class shared_ptr : public std::std__shared_ptr<T> {
class shared_ptr : public std__shared_ptr<T> {
public:
#if INFER_USE_LIBCPP
using std::std__shared_ptr<T>::__ptr_;
using std__shared_ptr<T>::__ptr_;
#define __data __ptr_
#else
using std::__shared_ptr<T>::_M_ptr;
using __shared_ptr<T>::_M_ptr;
#define __data _M_ptr
#endif
// Conversion constructors to allow implicit conversions.
// it's here purely to avoid compilation errors
template <class Y,
typename = typename std::enable_if<
std::is_convertible<Y*, T*>::value>::type>
shared_ptr(const std::std__shared_ptr<Y>& r) {}
typename = typename enable_if<is_convertible<Y*, T*>::value>::type>
shared_ptr(const std__shared_ptr<Y>& r) {}
template <class Y>
shared_ptr(const std::std__shared_ptr<Y>& r, T* p) noexcept {}
shared_ptr(const std__shared_ptr<Y>& r, T* p) noexcept {}
// constructors:
constexpr shared_ptr() noexcept { __data = nullptr; }
shared_ptr(std::nullptr_t) : shared_ptr() {}
shared_ptr(nullptr_t) : shared_ptr() {}
// Extra template argument is used to create constructors/assignment overloads
// for Y types where it's possible to convert Y* to T*.
// typename = typename std::enable_if<std::is_convertible<Y*,
// T*>::value>::type
// typename = typename enable_if<is_convertible<Y*, T*>::value>::type
// thanks to that, clang will not create some functions that would cause
// compilation errors. More info:
// http://en.cppreference.com/w/cpp/language/sfinae
template <class Y,
typename = typename std::enable_if<
std::is_convertible<Y*, T*>::value>::type>
typename = typename enable_if<is_convertible<Y*, T*>::value>::type>
explicit shared_ptr(Y* p) {
__data = p;
}
template <class Y,
class D,
typename = typename std::enable_if<
std::is_convertible<Y*, T*>::value>::type>
typename = typename enable_if<is_convertible<Y*, T*>::value>::type>
shared_ptr(Y* p, D d) : shared_ptr<T>(p) {}
template <class Y,
class D,
class A,
typename = typename std::enable_if<
std::is_convertible<Y*, T*>::value>::type>
typename = typename enable_if<is_convertible<Y*, T*>::value>::type>
shared_ptr(Y* p, D d, A a) : shared_ptr<T>(p) {}
template <class D>
shared_ptr(std::nullptr_t p, D d) : shared_ptr<T>(p) {}
shared_ptr(nullptr_t p, D d) : shared_ptr<T>(p) {}
template <class D, class A>
shared_ptr(std::nullptr_t p, D d, A a) : shared_ptr<T>(p) {}
shared_ptr(nullptr_t p, D d, A a) : shared_ptr<T>(p) {}
template <class Y>
shared_ptr(const shared_ptr<Y>& r, T* p) noexcept {
@ -89,8 +82,7 @@ class shared_ptr : public std::std__shared_ptr<T> {
}
template <class Y,
typename = typename std::enable_if<
std::is_convertible<Y*, T*>::value>::type>
typename = typename enable_if<is_convertible<Y*, T*>::value>::type>
shared_ptr(const shared_ptr<Y>& r) noexcept
: shared_ptr<T>(r.__data) { /* TODO - increase refcount*/
}
@ -100,16 +92,14 @@ class shared_ptr : public std::std__shared_ptr<T> {
}
template <class Y,
typename = typename std::enable_if<
std::is_convertible<Y*, T*>::value>::type>
typename = typename enable_if<is_convertible<Y*, T*>::value>::type>
shared_ptr(shared_ptr<Y>&& r) noexcept : shared_ptr<T>(r.__data) {
r.__data = nullptr;
}
template <class Y,
typename = typename std::enable_if<
std::is_convertible<Y*, T*>::value>::type>
explicit shared_ptr(const std::weak_ptr<Y>& r) {}
typename = typename enable_if<is_convertible<Y*, T*>::value>::type>
explicit shared_ptr(const weak_ptr<Y>& r) {}
/* Because of implementation differences between libc++ and stdlibc++, don't
* define this constructor (it will be defined elsewhere in case of
@ -117,15 +107,14 @@ class shared_ptr : public std::std__shared_ptr<T> {
* converts to T* - otherwise there might be compilation error (out-of-line
* definition).
* No definition here might cause compilation problems if project is
* using std::auto_ptrs with libc++ */
* using auto_ptrs with libc++ */
template <class Y>
shared_ptr(std::auto_ptr<Y>&& r); // {}
shared_ptr(auto_ptr<Y>&& r); // {}
template <class Y,
class D,
typename = typename std::enable_if<
std::is_convertible<Y*, T*>::value>::type>
shared_ptr(std::unique_ptr<Y, D>&& r) : shared_ptr<T>(r.release()) {}
typename = typename enable_if<is_convertible<Y*, T*>::value>::type>
shared_ptr(unique_ptr<Y, D>&& r) : shared_ptr<T>(r.release()) {}
// destructor:
~shared_ptr() { reset((T*)nullptr); }
@ -138,8 +127,7 @@ class shared_ptr : public std::std__shared_ptr<T> {
}
template <class Y,
typename = typename std::enable_if<
std::is_convertible<Y*, T*>::value>::type>
typename = typename enable_if<is_convertible<Y*, T*>::value>::type>
shared_ptr& operator=(const shared_ptr<Y>& r) noexcept {
// shared_ptr<T>(r).swap(*this);
__data = r.__data;
@ -153,8 +141,7 @@ class shared_ptr : public std::std__shared_ptr<T> {
}
template <class Y,
typename = typename std::enable_if<
std::is_convertible<Y*, T*>::value>::type>
typename = typename enable_if<is_convertible<Y*, T*>::value>::type>
shared_ptr& operator=(shared_ptr<Y>&& r) {
// shared_ptr<T>(std::move(r)).swap(*this);
__data = r.__data;
@ -162,15 +149,13 @@ class shared_ptr : public std::std__shared_ptr<T> {
}
template <class Y,
typename = typename std::enable_if<
std::is_convertible<Y*, T*>::value>::type>
shared_ptr& operator=(std::auto_ptr<Y>&& r) { /* ?? */
typename = typename enable_if<is_convertible<Y*, T*>::value>::type>
shared_ptr& operator=(auto_ptr<Y>&& r) { /* ?? */
}
template <class Y,
class D,
typename = typename std::enable_if<
std::is_convertible<Y*, T*>::value>::type>
shared_ptr& operator=(std::unique_ptr<Y, D>&& r) {
typename = typename enable_if<is_convertible<Y*, T*>::value>::type>
shared_ptr& operator=(unique_ptr<Y, D>&& r) {
// shared_ptr<T>(std::move(r)).swap(*this);
return *this;
}
@ -185,8 +170,7 @@ class shared_ptr : public std::std__shared_ptr<T> {
void reset() noexcept { reset((T*)nullptr); }
template <class Y,
typename = typename std::enable_if<
std::is_convertible<Y*, T*>::value>::type>
typename = typename enable_if<is_convertible<Y*, T*>::value>::type>
void reset(Y* p) {
/*
if (unique()) {
@ -199,8 +183,7 @@ class shared_ptr : public std::std__shared_ptr<T> {
template <class Y,
class D,
typename = typename std::enable_if<
std::is_convertible<Y*, T*>::value>::type>
typename = typename enable_if<is_convertible<Y*, T*>::value>::type>
void reset(Y* p, D d) {
reset(p);
}
@ -208,15 +191,14 @@ class shared_ptr : public std::std__shared_ptr<T> {
template <class Y,
class D,
class A,
typename = typename std::enable_if<
std::is_convertible<Y*, T*>::value>::type>
typename = typename enable_if<is_convertible<Y*, T*>::value>::type>
void reset(Y* p, D d, A a) {
reset(p);
}
// observers:
T* get() const noexcept { return __data; }
typename std::add_lvalue_reference<T>::type operator*() const noexcept {
typename add_lvalue_reference<T>::type operator*() const noexcept {
return *__data;
}
T* operator->() const noexcept { return __data; }
@ -228,11 +210,10 @@ class shared_ptr : public std::std__shared_ptr<T> {
return true; /* FIXME - use non-det*/
}
template <class U>
bool owner_before(std::weak_ptr<U> const& b) const {
bool owner_before(weak_ptr<U> const& b) const {
return true; /* FIXME - use non-det */
}
};
template <class _Tp, class _Up>
inline bool operator==(const shared_ptr<_Tp>& __x,
const shared_ptr<_Up>& __y) noexcept {
@ -248,8 +229,8 @@ inline bool operator!=(const shared_ptr<_Tp>& __x,
template <class _Tp, class _Up>
inline bool operator<(const shared_ptr<_Tp>& __x,
const shared_ptr<_Up>& __y) noexcept {
typedef typename std::common_type<_Tp*, _Up*>::type _Vp;
return std::less<_Vp>()(__x.get(), __y.get());
typedef typename common_type<_Tp*, _Up*>::type _Vp;
return less<_Vp>()(__x.get(), __y.get());
}
template <class _Tp, class _Up>
@ -271,71 +252,64 @@ inline bool operator>=(const shared_ptr<_Tp>& __x,
}
template <class _Tp>
inline bool operator==(const shared_ptr<_Tp>& __x, std::nullptr_t) noexcept {
inline bool operator==(const shared_ptr<_Tp>& __x, nullptr_t) noexcept {
return !__x;
}
template <class _Tp>
inline bool operator==(std::nullptr_t, const shared_ptr<_Tp>& __x) noexcept {
inline bool operator==(nullptr_t, const shared_ptr<_Tp>& __x) noexcept {
return !__x;
}
template <class _Tp>
inline bool operator!=(const shared_ptr<_Tp>& __x, std::nullptr_t) noexcept {
inline bool operator!=(const shared_ptr<_Tp>& __x, nullptr_t) noexcept {
return static_cast<bool>(__x);
}
template <class _Tp>
inline bool operator!=(std::nullptr_t, const shared_ptr<_Tp>& __x) noexcept {
inline bool operator!=(nullptr_t, const shared_ptr<_Tp>& __x) noexcept {
return static_cast<bool>(__x);
}
template <class _Tp>
inline bool operator<(const shared_ptr<_Tp>& __x, std::nullptr_t) noexcept {
return std::less<_Tp*>()(__x.get(), nullptr);
inline bool operator<(const shared_ptr<_Tp>& __x, nullptr_t) noexcept {
return less<_Tp*>()(__x.get(), nullptr);
}
template <class _Tp>
inline bool operator<(std::nullptr_t, const shared_ptr<_Tp>& __x) noexcept {
return std::less<_Tp*>()(nullptr, __x.get());
inline bool operator<(nullptr_t, const shared_ptr<_Tp>& __x) noexcept {
return less<_Tp*>()(nullptr, __x.get());
}
template <class _Tp>
inline bool operator>(const shared_ptr<_Tp>& __x, std::nullptr_t) noexcept {
inline bool operator>(const shared_ptr<_Tp>& __x, nullptr_t) noexcept {
return nullptr < __x;
}
template <class _Tp>
inline bool operator>(std::nullptr_t, const shared_ptr<_Tp>& __x) noexcept {
inline bool operator>(nullptr_t, const shared_ptr<_Tp>& __x) noexcept {
return __x < nullptr;
}
template <class _Tp>
inline bool operator<=(const shared_ptr<_Tp>& __x, std::nullptr_t) noexcept {
inline bool operator<=(const shared_ptr<_Tp>& __x, nullptr_t) noexcept {
return !(nullptr < __x);
}
template <class _Tp>
inline bool operator<=(std::nullptr_t, const shared_ptr<_Tp>& __x) noexcept {
inline bool operator<=(nullptr_t, const shared_ptr<_Tp>& __x) noexcept {
return !(__x < nullptr);
}
template <class _Tp>
inline bool operator>=(const shared_ptr<_Tp>& __x, std::nullptr_t) noexcept {
inline bool operator>=(const shared_ptr<_Tp>& __x, nullptr_t) noexcept {
return !(__x < nullptr);
}
template <class _Tp>
inline bool operator>=(std::nullptr_t, const shared_ptr<_Tp>& __x) noexcept {
inline bool operator>=(nullptr_t, const shared_ptr<_Tp>& __x) noexcept {
return !(nullptr < __x);
}
} // namespace infer_std_model
INFER_NAMESPACE_STD_BEGIN
// make std::shared_ptr alias of infer_std_model::shared_ptr
template <class T>
using shared_ptr = infer_std_model::shared_ptr<T>;
template <class T>
struct hash<shared_ptr<T>> : public hash<std__shared_ptr<T>> {};

147
infer/models/cpp/include/infer_model/unique_ptr.h
Unescape View File

@ -11,14 +11,12 @@
#include <infer_model/common.h>
// define unique_ptr outside of std namespace. It will be aliased as
// std::unique_ptr via 'using' clause later
namespace infer_std_model {
INFER_NAMESPACE_STD_BEGIN
// IMPORTANT
// There is specialization of unique_ptr below and it's mosly copy paste.
// When changing model, remember to change it for specialization as well!
template <class _Tp, class _Dp>
template <class _Tp, class _Dp = default_delete<_Tp>>
struct unique_ptr {
// use SFINAE to determine whether _Del::pointer exists
class _Pointer {
@ -28,7 +26,7 @@ struct unique_ptr {
template <typename _Up>
static _Tp* __test(...);
typedef typename std::remove_reference<_Dp>::type _Del;
typedef typename remove_reference<_Dp>::type _Del;
public:
typedef decltype(__test<_Del>(0)) type;
@ -41,45 +39,44 @@ struct unique_ptr {
pointer data;
template <class Y>
unique_ptr(const std::std__unique_ptr<Y>& u) {}
unique_ptr(const std__unique_ptr<Y>& u) {}
constexpr unique_ptr() noexcept : data(nullptr) {}
constexpr unique_ptr(std::nullptr_t) noexcept : unique_ptr<_Tp, _Dp>() {}
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr<_Tp, _Dp>() {}
explicit unique_ptr(pointer ptr) : data(ptr) {}
unique_ptr(pointer ptr,
typename std::conditional<
std::is_reference<deleter_type>::value,
deleter_type,
typename std::add_lvalue_reference<const deleter_type>::type>::type
__d) noexcept : data(ptr) {}
typename conditional<
is_reference<deleter_type>::value,
deleter_type,
typename add_lvalue_reference<const deleter_type>::type>::type
__d) noexcept : data(ptr) {}
unique_ptr(pointer ptr,
typename std::remove_reference<deleter_type>::type&& __d) noexcept
typename remove_reference<deleter_type>::type&& __d) noexcept
: data(ptr) {}
unique_ptr(unique_ptr&& u) noexcept : data(u.data) { u.data = nullptr; }
template <class _Up,
class _Ep,
typename = typename std::enable_if<
!std::is_array<_Up>::value &&
std::is_convertible<typename unique_ptr<_Up, _Ep>::pointer,
pointer>::value &&
std::is_convertible<_Ep, deleter_type>::value &&
(!std::is_reference<deleter_type>::value ||
std::is_same<deleter_type, _Ep>::value)>::type>
typename = typename enable_if<
!is_array<_Up>::value &&
is_convertible<typename unique_ptr<_Up, _Ep>::pointer,
pointer>::value &&
is_convertible<_Ep, deleter_type>::value &&
(!is_reference<deleter_type>::value ||
is_same<deleter_type, _Ep>::value)>::type>
unique_ptr(unique_ptr<_Up, _Ep>&& u) noexcept : data(u.data) {
u.data = nullptr;
}
template <
class _Up,
typename = typename std::enable_if<
std::is_convertible<_Up*, _Tp*>::value>::type>
unique_ptr(std::auto_ptr<_Up>&& __p) noexcept;
typename = typename enable_if<is_convertible<_Up*, _Tp*>::value>::type>
unique_ptr(auto_ptr<_Up>&& __p) noexcept;
~unique_ptr() { reset(); }
@ -90,30 +87,28 @@ struct unique_ptr {
template <class _Up,
class _Ep,
typename = typename std::enable_if<
!std::is_array<_Up>::value &&
std::is_convertible<typename unique_ptr<_Up, _Ep>::pointer,
pointer>::value &&
std::is_assignable<deleter_type&, _Ep&&>::value>::type>
typename = typename enable_if<
!is_array<_Up>::value &&
is_convertible<typename unique_ptr<_Up, _Ep>::pointer,
pointer>::value &&
is_assignable<deleter_type&, _Ep&&>::value>::type>
unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) noexcept {
reset(__u.data);
return *this;
}
unique_ptr& operator=(std::nullptr_t) noexcept {
unique_ptr& operator=(nullptr_t) noexcept {
reset();
return *this;
}
typename std::add_lvalue_reference<_Tp>::type operator*() const {
return *data;
}
typename add_lvalue_reference<_Tp>::type operator*() const { return *data; }
pointer operator->() const { return data; }
pointer get() const { return data; }
typedef typename std::remove_reference<deleter_type>::type& _Dp_reference;
typedef const typename std::remove_reference<deleter_type>::type&
typedef typename remove_reference<deleter_type>::type& _Dp_reference;
typedef const typename remove_reference<deleter_type>::type&
_Dp_const_reference;
_Dp_const_reference get_deleter() const {}
_Dp_reference get_deleter() {}
@ -140,7 +135,7 @@ struct unique_ptr<_Tp[], _Dp> {
template <typename _Up>
static _Tp* __test(...);
typedef typename std::remove_reference<_Dp>::type _Del;
typedef typename remove_reference<_Dp>::type _Del;
public:
typedef decltype(__test<_Del>(0)) type;
@ -155,42 +150,40 @@ struct unique_ptr<_Tp[], _Dp> {
constexpr unique_ptr() noexcept : data(nullptr) {}
constexpr unique_ptr(std::nullptr_t) noexcept : data(nullptr) {}
constexpr unique_ptr(nullptr_t) noexcept : data(nullptr) {}
explicit unique_ptr(pointer ptr) : data(ptr) {}
unique_ptr(
pointer ptr,
typename std::conditional<std::is_reference<deleter_type>::value,
deleter_type,
typename std::add_lvalue_reference<
const deleter_type>::type>::type __d)
typename conditional<
is_reference<deleter_type>::value,
deleter_type,
typename add_lvalue_reference<const deleter_type>::type>::type __d)
: data(ptr) {}
unique_ptr(pointer ptr,
typename std::remove_reference<deleter_type>::type&& __d)
unique_ptr(pointer ptr, typename remove_reference<deleter_type>::type&& __d)
: data(ptr) {}
unique_ptr(unique_ptr&& u) : data(u.data) { u.data = nullptr; }
template <class _Up,
class _Ep,
typename = typename std::enable_if<
std::is_array<_Up>::value &&
std::is_convertible<typename unique_ptr<_Up, _Ep>::pointer,
pointer>::value &&
std::is_convertible<_Ep, deleter_type>::value &&
(!std::is_reference<deleter_type>::value ||
std::is_same<deleter_type, _Ep>::value)>::type>
typename = typename enable_if<
is_array<_Up>::value &&
is_convertible<typename unique_ptr<_Up, _Ep>::pointer,
pointer>::value &&
is_convertible<_Ep, deleter_type>::value &&
(!is_reference<deleter_type>::value ||
is_same<deleter_type, _Ep>::value)>::type>
unique_ptr(unique_ptr<_Up, _Ep>&& u) : data(u.data) {
u.data = nullptr;
}
template <
class _Up,
typename = typename std::enable_if<
std::is_convertible<_Up*, _Tp*>::value>::type>
unique_ptr(std::auto_ptr<_Up>&& __p) noexcept;
typename = typename enable_if<is_convertible<_Up*, _Tp*>::value>::type>
unique_ptr(auto_ptr<_Up>&& __p) noexcept;
~unique_ptr() { reset(); }
@ -201,27 +194,27 @@ struct unique_ptr<_Tp[], _Dp> {
template <class _Up,
class _Ep,
typename = typename std::enable_if<
std::is_array<_Up>::value &&
std::is_convertible<typename unique_ptr<_Up, _Ep>::pointer,
pointer>::value &&
std::is_assignable<deleter_type&, _Ep&&>::value>::type>
typename = typename enable_if<
is_array<_Up>::value &&
is_convertible<typename unique_ptr<_Up, _Ep>::pointer,
pointer>::value &&
is_assignable<deleter_type&, _Ep&&>::value>::type>
unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) {
reset(__u.data);
return *this;
}
unique_ptr& operator=(std::nullptr_t) {
unique_ptr& operator=(nullptr_t) {
reset();
return *this;
}
typename std::add_lvalue_reference<_Tp>::type operator[](size_t i) const {}
typename add_lvalue_reference<_Tp>::type operator[](size_t i) const {}
pointer get() const { return data; }
typedef typename std::remove_reference<deleter_type>::type& _Dp_reference;
typedef const typename std::remove_reference<deleter_type>::type&
typedef typename remove_reference<deleter_type>::type& _Dp_reference;
typedef const typename remove_reference<deleter_type>::type&
_Dp_const_reference;
_Dp_const_reference get_deleter() const {}
_Dp_reference get_deleter() {}
@ -278,74 +271,66 @@ inline bool operator>=(const unique_ptr<_T1, _D1>& __x,
}
template <class _T1, class _D1>
inline bool operator==(const unique_ptr<_T1, _D1>& __x, std::nullptr_t) {
inline bool operator==(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
return !__x;
}
template <class _T1, class _D1>
inline bool operator==(std::nullptr_t, const unique_ptr<_T1, _D1>& __x) {
inline bool operator==(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
return !__x;
}
template <class _T1, class _D1>
inline bool operator!=(const unique_ptr<_T1, _D1>& __x, std::nullptr_t) {
inline bool operator!=(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
return static_cast<bool>(__x);
}
template <class _T1, class _D1>
inline bool operator!=(std::nullptr_t, const unique_ptr<_T1, _D1>& __x) {
inline bool operator!=(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
return static_cast<bool>(__x);
}
template <class _T1, class _D1>
inline bool operator<(const unique_ptr<_T1, _D1>& __x, std::nullptr_t) {
inline bool operator<(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
/*typedef typename unique_ptr<_T1, _D1>::pointer _P1;
return less<_P1>()(__x.get(), nullptr);*/
}
template <class _T1, class _D1>
inline bool operator<(std::nullptr_t, const unique_ptr<_T1, _D1>& __x) {
inline bool operator<(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
/*typedef typename unique_ptr<_T1, _D1>::pointer _P1;
return less<_P1>()(nullptr, __x.get());*/
}
template <class _T1, class _D1>
inline bool operator>(const unique_ptr<_T1, _D1>& __x, std::nullptr_t) {
inline bool operator>(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
return nullptr < __x;
}
template <class _T1, class _D1>
inline bool operator>(std::nullptr_t, const unique_ptr<_T1, _D1>& __x) {
inline bool operator>(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
return __x < nullptr;
}
template <class _T1, class _D1>
inline bool operator<=(const unique_ptr<_T1, _D1>& __x, std::nullptr_t) {
inline bool operator<=(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
return !(nullptr < __x);
}
template <class _T1, class _D1>
inline bool operator<=(std::nullptr_t, const unique_ptr<_T1, _D1>& __x) {
inline bool operator<=(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
return !(__x < nullptr);
}
template <class _T1, class _D1>
inline bool operator>=(const unique_ptr<_T1, _D1>& __x, std::nullptr_t) {
inline bool operator>=(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
return !(__x < nullptr);
}
template <class _T1, class _D1>
inline bool operator>=(std::nullptr_t, const unique_ptr<_T1, _D1>& __x) {
inline bool operator>=(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
return !(nullptr < __x);
}
} // namespace infer_std_model
INFER_NAMESPACE_STD_BEGIN
// make std::unique_ptr alias of infer_std_model::unique_ptr
template <class _Tp, class _Dp = default_delete<_Tp>>
using unique_ptr = infer_std_model::unique_ptr<_Tp, _Dp>;
template <class T, class D>
struct hash<unique_ptr<T, D>> : public hash<std__unique_ptr<T, D>> {

4
infer/src/backend/errdesc.ml
Unescape View File

@ -17,8 +17,8 @@ module F = Format
module DExp = DecompiledExp
let smart_pointers = [
["infer_std_model"; "shared_ptr"];
["infer_std_model"; "unique_ptr"]
["std"; "shared_ptr"];
["std"; "unique_ptr"]
]
let pointer_wrapper_classes = smart_pointers

Write Preview
Loading…
Cancel
Save