/usr/include/odb/lazy-ptr.txx is in libodb-dev 2.4.0-1build1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 | // file : odb/lazy-ptr.txx
// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC
// license : GNU GPL v2; see accompanying LICENSE file
namespace odb
{
//
// lazy_ptr
//
template <class T>
template <class Y>
bool lazy_ptr<T>::
equal (const lazy_ptr<Y>& r) const
{
bool t1 ((p_ == 0) == loaded ());
bool t2 ((r.p_ == 0) == r.loaded ());
// If both are transient, then compare the underlying pointers.
//
if (t1 && t2)
return p_ == r.p_;
// If one is transient and the other is persistent, then compare
// the underlying pointers but only if they are non NULL. Note
// that an unloaded persistent object is always unequal to a
// transient object.
//
if (t1 || t2)
return p_ == r.p_ && p_ != 0;
// If both objects are persistent, then we compare databases and
// object ids.
//
typedef typename object_traits<T>::object_type object_type1;
typedef typename object_traits<Y>::object_type object_type2;
return i_.database () == r.i_.database () &&
object_id<object_type1> () == r.template object_id<object_type2> ();
}
#ifdef ODB_CXX11
//
// lazy_unique_ptr
//
template <class T, class D>
template <class T1, class D1>
bool lazy_unique_ptr<T, D>::
equal (const lazy_unique_ptr<T1, D1>& r) const
{
bool t1 (!p_ == loaded ());
bool t2 (!r.p_ == r.loaded ());
// If both are transient, then compare the underlying pointers.
//
if (t1 && t2)
return p_ == r.p_;
// If one is transient and the other is persistent, then compare
// the underlying pointers but only if they are non NULL. Note
// that an unloaded persistent object is always unequal to a
// transient object.
//
if (t1 || t2)
return p_ == r.p_ && p_;
// If both objects are persistent, then we compare databases and
// object ids.
//
typedef typename object_traits<T>::object_type object_type1;
typedef typename object_traits<T1>::object_type object_type2;
return i_.database () == r.i_.database () &&
object_id<object_type1> () == r.template object_id<object_type2> ();
}
//
// lazy_shared_ptr
//
template <class T>
template <class Y>
bool lazy_shared_ptr<T>::
equal (const lazy_shared_ptr<Y>& r) const
{
bool t1 (!p_ == loaded ());
bool t2 (!r.p_ == r.loaded ());
// If both are transient, then compare the underlying pointers.
//
if (t1 && t2)
return p_ == r.p_;
// If one is transient and the other is persistent, then compare
// the underlying pointers but only if they are non NULL. Note
// that an unloaded persistent object is always unequal to a
// transient object.
//
if (t1 || t2)
return p_ == r.p_ && p_;
// If both objects are persistent, then we compare databases and
// object ids.
//
typedef typename object_traits<T>::object_type object_type1;
typedef typename object_traits<Y>::object_type object_type2;
return i_.database () == r.i_.database () &&
object_id<object_type1> () == r.template object_id<object_type2> ();
}
//
// lazy_weak_ptr
//
template <class T>
lazy_shared_ptr<T> lazy_weak_ptr<T>::
lock () const
{
std::shared_ptr<T> sp (p_.lock ());
if (sp)
{
if (database_type* db = i_.database ())
return lazy_shared_ptr<T> (*db, sp);
else
return lazy_shared_ptr<T> (sp);
}
else
{
if (i_)
return lazy_shared_ptr<T> (
*i_.database (), i_.template object_id<T> ());
else
return lazy_shared_ptr<T> ();
}
}
#endif // ODB_CXX11
}
|