aboutsummaryrefslogtreecommitdiff
path: root/odb/lazy-ptr.txx
blob: 17a7405abd3fc5a60aeb97ba2f9470f01d7a1f3e (plain)
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
// file      : odb/lazy-ptr.txx
// 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> ();
  }
#endif // ODB_CXX11

}