aboutsummaryrefslogtreecommitdiff
path: root/odb/lazy-ptr.txx
blob: 5611b2c5d309587d7284db177140d02344667e94 (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
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-2013 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

}