Common ODB Runtime Library
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
lazy-ptr.hxx
Go to the documentation of this file.
1 // file : odb/lazy-ptr.hxx
2 // copyright : Copyright (c) 2009-2013 Code Synthesis Tools CC
3 // license : GNU GPL v2; see accompanying LICENSE file
4 
5 #ifndef ODB_LAZY_PTR_HXX
6 #define ODB_LAZY_PTR_HXX
7 
8 #include <odb/pre.hxx>
9 
10 #include <memory> // std::auto_ptr, std::shared_ptr/weak_ptr
11 #include <utility> // std::move
12 
13 #include <odb/forward.hxx> // odb::core, odb::database
14 #include <odb/traits.hxx>
15 #include <odb/lazy-ptr-impl.hxx>
16 #include <odb/details/config.hxx> // ODB_CXX11
17 
18 namespace odb
19 {
20  // Raw pointer lazy version.
21  //
22  template <class T>
23  class lazy_ptr
24  {
25  // Pointer interface.
26  //
27  public:
28  typedef T element_type;
29 
30  lazy_ptr ();
31  template <class Y> lazy_ptr (Y*);
32 
33  lazy_ptr (const lazy_ptr&);
34  template <class Y> lazy_ptr (const lazy_ptr<Y>&);
35 
36  lazy_ptr& operator= (const lazy_ptr&);
37  template <class Y> lazy_ptr& operator= (Y*);
38  template <class Y> lazy_ptr& operator= (const lazy_ptr<Y>&);
39 
40  void swap (lazy_ptr&);
41  void reset ();
42  template <class Y> void reset (Y*);
43 
44  T& operator* () const;
45  T* operator-> () const;
46  T* get () const;
47 
48  typedef T* lazy_ptr::*unspecified_bool_type;
49  operator unspecified_bool_type () const
50  {
51  return (p_ || i_) ? &lazy_ptr::p_ : 0;
52  }
53 
54  // Lazy loading interface.
55  //
56  public:
57  typedef odb::database database_type;
58 
59  // NULL loaded()
60  //
61  // true true NULL pointer to transient object
62  // false true valid pointer to persistent object
63  // true false unloaded pointer to persistent object
64  // false false valid pointer to transient object
65  //
66  bool loaded () const;
67 
68  T* load () const;
69 
70  // Unload the pointer. For transient objects this function is
71  // equivalent to reset().
72  //
73  void unload () const;
74 
75  // Get the underlying eager pointer. If this is an unloaded pointer
76  // to a persistent object, then the returned pointer will be NULL.
77  //
78  T* get_eager () const;
79 
80  template <class DB, class ID> lazy_ptr (DB&, const ID&);
81  template <class DB, class Y> lazy_ptr (DB&, Y*);
82 
83  template <class DB, class ID> void reset (DB&, const ID&);
84  template <class DB, class Y> void reset (DB&, Y*);
85 
86 #ifdef ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT
87  template <class O = T>
88 #else
89  template <class O /* = T */>
90 #endif
91  typename object_traits<O>::id_type object_id () const;
92 
93  database_type& database () const;
94 
95  // Helpers.
96  //
97  public:
98  template <class Y> bool equal (const lazy_ptr<Y>&) const;
99 
100  private:
101  template <class Y> friend class lazy_ptr;
102 
103  mutable T* p_;
104  mutable lazy_ptr_impl<T> i_;
105  };
106 
107  // operator< and operator<< are not provided.
108  //
109  template <class T, class Y>
110  bool operator== (const lazy_ptr<T>&, const lazy_ptr<Y>&);
111 
112  template <class T, class Y>
113  bool operator!= (const lazy_ptr<T>&, const lazy_ptr<Y>&);
114 
115  template <class T> void swap (lazy_ptr<T>&, lazy_ptr<T>&);
116 
117  // std::auto_ptr lazy version.
118  //
119  template <class T>
120  struct lazy_auto_ptr_ref
121  {
122  explicit lazy_auto_ptr_ref (T*, const lazy_ptr_impl_ref&);
123 
124  T* p_;
125  lazy_ptr_impl_ref i_;
126  };
127 
128  template <class T>
129  class lazy_auto_ptr
130  {
131  // Standard auto_ptr interface.
132  //
133  public:
134  typedef T element_type;
135 
136  explicit lazy_auto_ptr (T* = 0);
137  lazy_auto_ptr (lazy_auto_ptr&);
138  template <class Y> lazy_auto_ptr (lazy_auto_ptr<Y>&);
139 
140  lazy_auto_ptr& operator= (lazy_auto_ptr&);
141  template <class Y> lazy_auto_ptr& operator= (lazy_auto_ptr<Y>&);
142 
143  T& operator* () const;
144  T* operator-> () const;
145  T* get () const;
146  T* release ();
147  void reset (T* = 0);
148 
149  lazy_auto_ptr (const lazy_auto_ptr_ref<T>&);
150  lazy_auto_ptr& operator= (const lazy_auto_ptr_ref<T>&);
151  template <class Y> operator lazy_auto_ptr_ref<Y> ();
152  template <class Y> operator lazy_auto_ptr<Y> ();
153 
154  // Extension: conversion to bool.
155  //
156  public:
157  typedef std::auto_ptr<T> lazy_auto_ptr::*unspecified_bool_type;
158  operator unspecified_bool_type () const
159  {
160  return (p_.get () != 0 || i_) ? &lazy_auto_ptr::p_ : 0;
161  }
162 
163  // Initialization/assignment from auto_ptr.
164  //
165  public:
166  template <class Y> lazy_auto_ptr (std::auto_ptr<Y>&);
167  lazy_auto_ptr (std::auto_ptr_ref<T>);
168 
169  template <class Y> lazy_auto_ptr& operator= (std::auto_ptr<Y>&);
170  lazy_auto_ptr& operator= (std::auto_ptr_ref<T>);
171 
172  // Lazy loading interface.
173  //
174  public:
175  typedef odb::database database_type;
176 
177  // NULL loaded()
178  //
179  // true true NULL pointer to transient object
180  // false true valid pointer to persistent object
181  // true false unloaded pointer to persistent object
182  // false false valid pointer to transient object
183  //
184  bool loaded () const;
185 
186  std::auto_ptr<T>& load () const;
187 
188  // Unload the pointer. For transient objects this function is
189  // equivalent to reset().
190  //
191  void unload () const;
192 
193  // Get the underlying eager pointer. If this is an unloaded pointer
194  // to a persistent object, then the returned pointer will be NULL.
195  //
196  std::auto_ptr<T>& get_eager () const;
197 
198  template <class DB, class ID> lazy_auto_ptr (DB&, const ID&);
199  template <class DB> lazy_auto_ptr (DB&, T*);
200  template <class DB, class Y> lazy_auto_ptr (DB&, std::auto_ptr<Y>&);
201 
202  template <class DB, class ID> void reset (DB&, const ID&);
203  template <class DB> void reset (DB&, T*);
204  template <class DB, class Y> void reset (DB&, std::auto_ptr<Y>&);
205 
206 #ifdef ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT
207  template <class O = T>
208 #else
209  template <class O /* = T */>
210 #endif
211  typename object_traits<O>::id_type object_id () const;
212 
213  database_type& database () const;
214 
215  private:
216  template <class Y> friend class lazy_auto_ptr;
217 
218  // Note that it is possible to have a situation where p_ is NULL,
219  // i_.id is NULL and i_.db is not NULL. This will happen if the
220  // auto_ptr reference returned by load() is transferred to another
221  // pointer or reset.
222  //
223  mutable std::auto_ptr<T> p_;
224  mutable lazy_ptr_impl<T> i_;
225  };
226 
227 #ifdef ODB_CXX11
228 
229  // C++11 std::unique_ptr lazy version.
230  //
231  template <class T, class D = std::default_delete<T>>
232  class lazy_unique_ptr
233  {
234  // Standard lazy_unique_ptr interface.
235  //
236  public:
237  typedef T* pointer; // For now assume it is T*.
238  typedef T element_type;
239  typedef D deleter_type;
240 
241  /*constexpr*/ lazy_unique_ptr () /*noexcept*/;
242 #ifdef ODB_CXX11_NULLPTR
243  /*constexpr*/ lazy_unique_ptr (std::nullptr_t) /*noexcept*/;
244 #endif
245  explicit lazy_unique_ptr (pointer) /*noexcept*/;
246 
247  // For now assume D is non-reference.
248  //
249  lazy_unique_ptr (pointer, const deleter_type&) /*noexcept*/;
250  lazy_unique_ptr (pointer, deleter_type&&) /*noexcept*/;
251 
252  lazy_unique_ptr (lazy_unique_ptr&&) /*noexcept*/;
253  template <class T1, class D1> lazy_unique_ptr (lazy_unique_ptr<T1, D1>&&) /*noexcept*/;
254  template <class T1> lazy_unique_ptr (std::auto_ptr<T1>&&) /*noexcept*/;
255 
256 #ifdef ODB_CXX11_NULLPTR
257  lazy_unique_ptr& operator= (std::nullptr_t) /*noexcept*/;
258 #endif
259  lazy_unique_ptr& operator= (lazy_unique_ptr&&) /*noexcept*/;
260  template <class T1, class D1> lazy_unique_ptr& operator= (lazy_unique_ptr<T1, D1>&&) /*noexcept*/;
261 
262  T& operator* () const;
263  pointer operator-> () const /*noexcept*/;
264  pointer get () const /*noexcept*/;
265 #ifdef ODB_CXX11_EXPLICIT_CONVERSION_OPERATOR
266  explicit operator bool() const /*noexcept*/;
267 #else
268  typedef std::unique_ptr<T, D> lazy_unique_ptr::*unspecified_bool_type;
269  operator unspecified_bool_type () const
270  {
271  return (p_ || i_) ? &lazy_unique_ptr::p_ : 0;
272  }
273 #endif
274 
275  pointer release () /*noexcept*/;
276  void reset (pointer = pointer ()) /*noexcept*/;
277  void swap (lazy_unique_ptr&) /*noexcept*/;
278 
279  deleter_type& get_deleter () /*noexcept*/;
280  const deleter_type& get_deleter () const /*noexcept*/;
281 
282 #ifdef ODB_CXX11_DELETED_FUNCTION
283  lazy_unique_ptr (const lazy_unique_ptr&) = delete;
284  lazy_unique_ptr& operator= (const lazy_unique_ptr&) = delete;
285 #else
286  private:
287  lazy_unique_ptr (const lazy_unique_ptr&);
288  lazy_unique_ptr& operator= (const lazy_unique_ptr&);
289 #endif
290 
291  // Initialization/assignment from unique_ptr.
292  //
293  public:
294  template <class T1, class D1> lazy_unique_ptr (std::unique_ptr<T1, D1>&&) /*noexcept*/;
295  template <class T1, class D1> lazy_unique_ptr& operator= (std::unique_ptr<T1, D1>&&) /*noexcept*/;
296 
297  // Lazy loading interface.
298  //
299  public:
300  typedef odb::database database_type;
301 
302  // NULL loaded()
303  //
304  // true true NULL pointer to transient object
305  // false true valid pointer to persistent object
306  // true false unloaded pointer to persistent object
307  // false false valid pointer to transient object
308  //
309  bool loaded () const;
310 
311  std::unique_ptr<T, D>& load () const;
312 
313  // Unload the pointer. For transient objects this function is
314  // equivalent to reset().
315  //
316  void unload () const;
317 
318  // Get the underlying eager pointer. If this is an unloaded pointer
319  // to a persistent object, then the returned pointer will be NULL.
320  //
321  std::unique_ptr<T, D>& get_eager () const;
322 
323  template <class DB, class ID> lazy_unique_ptr (DB&, const ID&);
324  template <class DB> lazy_unique_ptr (DB&, pointer);
325  template <class DB> lazy_unique_ptr (DB&, pointer, const deleter_type&);
326  template <class DB> lazy_unique_ptr (DB&, pointer, deleter_type&&);
327  template <class DB, class T1, class D1> lazy_unique_ptr (DB&, std::unique_ptr<T1, D1>&&);
328  template <class DB, class T1> lazy_unique_ptr (DB&, std::auto_ptr<T1>&&);
329 
330  template <class DB, class ID> void reset (DB&, const ID&);
331  template <class DB> void reset (DB&, pointer);
332  template <class DB, class T1, class D1> void reset (DB&, std::unique_ptr<T1, D1>&&);
333  template <class DB, class T1> void reset (DB&, std::auto_ptr<T1>&&);
334 
335 #ifdef ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT
336  template <class O = T>
337 #else
338  template <class O /*= T*/>
339 #endif
340  typename object_traits<O>::id_type object_id () const;
341 
342  database_type& database () const;
343 
344  // Helpers.
345  //
346  public:
347  template <class T1, class D1> bool equal (const lazy_unique_ptr<T1, D1>&) const;
348 
349  private:
350  template <class T1, class D1> friend class lazy_unique_ptr;
351 
352  // Note that it is possible to have a situation where p_ is NULL,
353  // i_.id is NULL and i_.db is not NULL. This will happen if the
354  // unique_ptr reference returned by load() is transferred to
355  // another pointer or reset.
356  //
357  mutable std::unique_ptr<T, D> p_;
358  mutable lazy_ptr_impl<T> i_;
359  };
360 
361  template <class T> void swap (lazy_unique_ptr<T>&, lazy_unique_ptr<T>&) /*noexcept*/;
362 
363  // operator< and operator<< are not provided.
364  //
365  template <class T1, class D1, class T2, class D2>
366  bool operator== (const lazy_unique_ptr<T1, D1>&, const lazy_unique_ptr<T2, D2>&);
367 
368  template <class T1, class D1, class T2, class D2>
369  bool operator!= (const lazy_unique_ptr<T1, D1>&, const lazy_unique_ptr<T2, D2>&);
370 
371 #ifdef ODB_CXX11_NULLPTR
372  template <class T, class D>
373  bool operator== (const lazy_unique_ptr<T, D>&, std::nullptr_t) /*noexcept*/;
374 
375  template <class T, class D>
376  bool operator== (std::nullptr_t, const lazy_unique_ptr<T, D>&) /*noexcept*/;
377 
378  template <class T, class D>
379  bool operator!= (const lazy_unique_ptr<T, D>&, std::nullptr_t) /*noexcept*/;
380 
381  template <class T, class D>
382  bool operator!= (std::nullptr_t, const lazy_unique_ptr<T, D>&) /*noexcept*/;
383 #endif
384 
385  // C++11 std::shared_ptr lazy version.
386  //
387  template <class T>
388  class lazy_weak_ptr;
389 
390  template <class T>
391  class lazy_shared_ptr
392  {
393  // The standard shared_ptr interface.
394  //
395  public:
396  typedef T element_type;
397 
398  /*constexpr*/ lazy_shared_ptr () /*noexcept*/;
399 #ifdef ODB_CXX11_NULLPTR
400  /*constexpr*/ lazy_shared_ptr (std::nullptr_t) /*noexcept*/;
401 #endif
402  template <class Y> explicit lazy_shared_ptr (Y*);
403  template <class Y, class D> lazy_shared_ptr (Y*, D);
404  template <class Y, class D, class A> lazy_shared_ptr (Y*, D, A);
405 #ifdef ODB_CXX11_NULLPTR
406  template <class D> lazy_shared_ptr (std::nullptr_t, D);
407  template <class D, class A> lazy_shared_ptr (std::nullptr_t, D, A);
408 #endif
409  template <class Y> lazy_shared_ptr (const lazy_shared_ptr<Y>&, T*) /*noexcept*/;
410 
411  lazy_shared_ptr (const lazy_shared_ptr&) /*noexcept*/;
412  template <class Y> lazy_shared_ptr (const lazy_shared_ptr<Y>&) /*noexcept*/;
413  lazy_shared_ptr (lazy_shared_ptr&&) /*noexcept*/;
414  template <class Y> lazy_shared_ptr (lazy_shared_ptr<Y>&&) /*noexcept*/;
415  template <class Y> explicit lazy_shared_ptr (const lazy_weak_ptr<Y>&);
416  template <class Y> explicit lazy_shared_ptr (std::auto_ptr<Y>&&);
417  template <class Y, class D> lazy_shared_ptr (std::unique_ptr<Y, D>&&);
418 
419  ~lazy_shared_ptr ();
420 
421  lazy_shared_ptr& operator= (const lazy_shared_ptr&) /*noexcept*/;
422  template <class Y> lazy_shared_ptr& operator= (const lazy_shared_ptr<Y>&) /*noexcept*/;
423  lazy_shared_ptr& operator= (lazy_shared_ptr&&) /*noexcept*/;
424  template <class Y> lazy_shared_ptr& operator= (lazy_shared_ptr<Y>&&) /*noexcept*/;
425  template <class Y> lazy_shared_ptr& operator= (std::auto_ptr<Y>&&);
426  template <class Y, class D> lazy_shared_ptr& operator= (std::unique_ptr<Y, D>&&);
427 
428  void swap (lazy_shared_ptr&) /*noexcept*/;
429  void reset () /*noexcept*/;
430  template <class Y> void reset (Y*);
431  template <class Y, class D> void reset (Y*, D);
432  template <class Y, class D, class A> void reset (Y*, D, A);
433 
434  T* get () const /*noexcept*/;
435  T& operator* () const /*noexcept*/;
436  T* operator-> () const /*noexcept*/;
437  long use_count () const /*noexcept*/;
438  bool unique () const /*noexcept*/;
439 #ifdef ODB_CXX11_EXPLICIT_CONVERSION_OPERATOR
440  explicit operator bool () const /*noexcept*/;
441 #else
442  typedef std::shared_ptr<T> lazy_shared_ptr::*unspecified_bool_type;
443  operator unspecified_bool_type () const
444  {
445  return (p_ || i_) ? &lazy_shared_ptr::p_ : 0;
446  }
447 #endif
448 
449  // owner_before () is not provded.
450 
451  // Initialization/assignment from shared_ptr and weak_ptr.
452  //
453  public:
454  template <class Y> lazy_shared_ptr (const std::shared_ptr<Y>&);
455  template <class Y> lazy_shared_ptr (std::shared_ptr<Y>&&);
456  template <class Y> explicit lazy_shared_ptr (const std::weak_ptr<Y>&);
457 
458  template <class Y> lazy_shared_ptr& operator= (const std::shared_ptr<Y>&);
459  template <class Y> lazy_shared_ptr& operator= (std::shared_ptr<Y>&&);
460 
461  // Lazy loading interface.
462  //
463  public:
464  typedef odb::database database_type;
465 
466  // NULL loaded()
467  //
468  // true true NULL pointer to transient object
469  // false true valid pointer to persistent object
470  // true false unloaded pointer to persistent object
471  // false false valid pointer to transient object
472  //
473  bool loaded () const;
474 
475  std::shared_ptr<T> load () const;
476 
477  // Unload the pointer. For transient objects this function is
478  // equivalent to reset().
479  //
480  void unload () const;
481 
482  // Get the underlying eager pointer. If this is an unloaded pointer
483  // to a persistent object, then the returned pointer will be NULL.
484  //
485  std::shared_ptr<T> get_eager () const;
486 
487  template <class DB, class ID> lazy_shared_ptr (DB&, const ID&);
488  template <class DB, class Y> lazy_shared_ptr (DB&, Y*);
489  template <class DB, class Y, class D> lazy_shared_ptr (DB&, Y*, D);
490  template <class DB, class Y, class D, class A> lazy_shared_ptr (DB&, Y*, D, A);
491  template <class DB, class Y> lazy_shared_ptr (DB&, std::auto_ptr<Y>&&);
492  template <class DB, class Y> lazy_shared_ptr (DB&, const std::shared_ptr<Y>&);
493  template <class DB, class Y> lazy_shared_ptr (DB&, std::shared_ptr<Y>&&);
494  template <class DB, class Y> lazy_shared_ptr (DB&, const std::weak_ptr<Y>&);
495 
496  template <class DB, class ID> void reset (DB&, const ID&);
497  template <class DB, class Y> void reset (DB&, Y*);
498  template <class DB, class Y, class D> void reset (DB&, Y*, D);
499  template <class DB, class Y, class D, class A> void reset (DB&, Y*, D, A);
500  template <class DB, class Y> void reset (DB&, std::auto_ptr<Y>&&);
501  template <class DB, class Y> void reset (DB&, const std::shared_ptr<Y>&);
502  template <class DB, class Y> void reset (DB&, std::shared_ptr<Y>&&);
503 
504 #ifdef ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT
505  template <class O = T>
506 #else
507  template <class O /*= T*/>
508 #endif
509  typename object_traits<O>::id_type object_id () const;
510 
511  database_type& database () const;
512 
513  // Helpers.
514  //
515  public:
516  template <class Y> bool equal (const lazy_shared_ptr<Y>&) const;
517 
518  private:
519  template <class Y> friend class lazy_shared_ptr;
520  template <class Y> friend class lazy_weak_ptr;
521 
522  mutable std::shared_ptr<T> p_;
523  mutable lazy_ptr_impl<T> i_;
524  };
525 
526  template <class T> void swap (lazy_shared_ptr<T>&, lazy_shared_ptr<T>&) /*noexcept*/;
527 
528  template <class D, class T>
529  D* get_deleter (const lazy_shared_ptr<T>&) /*noexcept*/;
530 
531  // operator< and operator<< are not provided.
532  //
533  template <class T, class Y>
534  bool operator== (const lazy_shared_ptr<T>&, const lazy_shared_ptr<Y>&) /*noexcept*/;
535 
536  template <class T, class Y>
537  bool operator!= (const lazy_shared_ptr<T>&, const lazy_shared_ptr<Y>&) /*noexcept*/;
538 
539 #ifdef ODB_CXX11_NULLPTR
540  template <class T>
541  bool operator== (const lazy_shared_ptr<T>&, std::nullptr_t) /*noexcept*/;
542 
543  template <class T>
544  bool operator== (std::nullptr_t, const lazy_shared_ptr<T>&) /*noexcept*/;
545 
546  template <class T>
547  bool operator!= (const lazy_shared_ptr<T>&, std::nullptr_t) /*noexcept*/;
548 
549  template <class T>
550  bool operator!= (std::nullptr_t, const lazy_shared_ptr<T>&) /*noexcept*/;
551 #endif
552 
553  // C++11 std::weak_ptr lazy version.
554  //
555  template <class T>
556  class lazy_weak_ptr
557  {
558  // The standard weak_ptr interface.
559  //
560  public:
561  typedef T element_type;
562 
563  /*constexpr*/ lazy_weak_ptr () /*noexcept*/;
564  template <class Y> lazy_weak_ptr (const lazy_shared_ptr<Y>&) /*noexcept*/;
565  lazy_weak_ptr (const lazy_weak_ptr&) /*noexcept*/;
566  template <class Y> lazy_weak_ptr (const lazy_weak_ptr<Y>&) /*noexcept*/;
567 
568  ~lazy_weak_ptr ();
569 
570  lazy_weak_ptr& operator= (const lazy_weak_ptr&) /*noexcept*/;
571  template <class Y> lazy_weak_ptr& operator= (const lazy_weak_ptr<Y>&) /*noexcept*/;
572  template <class Y> lazy_weak_ptr& operator= (const lazy_shared_ptr<Y>&) /*noexcept*/;
573 
574  void swap (lazy_weak_ptr<T>&) /*noexcept*/;
575  void reset () /*noexcept*/;
576 
577  long use_count () const /*noexcept*/;
578  bool expired () const /*noexcept*/;
579 
580  lazy_shared_ptr<T> lock () const /*noexcept*/;
581 
582  // owner_before () is not provded.
583 
584  // Initialization/assignment from shared_ptr and weak_ptr.
585  //
586  public:
587  template <class Y> lazy_weak_ptr (const std::weak_ptr<Y>&);
588  template <class Y> lazy_weak_ptr (const std::shared_ptr<Y>&);
589 
590  template <class Y> lazy_weak_ptr& operator= (const std::weak_ptr<Y>&);
591  template <class Y> lazy_weak_ptr& operator= (const std::shared_ptr<Y>&);
592 
593  // Lazy loading interface.
594  //
595  public:
596  typedef odb::database database_type;
597 
598  // expired() loaded()
599  //
600  // true true expired pointer to transient object
601  // false true valid pointer to persistent object
602  // true false expired pointer to persistent object
603  // false false valid pointer to transient object
604  //
605  bool loaded () const;
606 
607  // Performs both lock and load.
608  //
609  std::shared_ptr<T> load () const;
610 
611  // Unload the pointer. For transient objects this function is
612  // equivalent to reset().
613  //
614  void unload () const;
615 
616  // Get the underlying eager pointer. If this is an unloaded pointer
617  // to a persistent object, then the returned pointer will be NULL.
618  //
619  std::weak_ptr<T> get_eager () const;
620 
621  template <class DB, class ID> lazy_weak_ptr (DB&, const ID&);
622  template <class DB, class Y> lazy_weak_ptr (DB&, const std::shared_ptr<Y>&);
623  template <class DB, class Y> lazy_weak_ptr (DB&, const std::weak_ptr<Y>&);
624 
625  template <class DB, class ID> void reset (DB&, const ID&);
626  template <class DB, class Y> void reset (DB&, const std::shared_ptr<Y>&);
627  template <class DB, class Y> void reset (DB&, const std::weak_ptr<Y>&);
628 
629  // The object_id() function can only be called when the object is
630  // persistent, or: expired() XOR loaded() (can use != for XOR).
631  //
632 #ifdef ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT
633  template <class O = T>
634 #else
635  template <class O /*= T*/>
636 #endif
637  typename object_traits<O>::id_type object_id () const;
638 
639  database_type& database () const;
640 
641  private:
642  template <class Y> friend class lazy_shared_ptr;
643  template <class Y> friend class lazy_weak_ptr;
644 
645  mutable std::weak_ptr<T> p_;
646  mutable lazy_ptr_impl<T> i_;
647  };
648 
649  // operator< is not provided.
650  //
651  template <class T> void swap (lazy_weak_ptr<T>&, lazy_weak_ptr<T>&);
652 
653 #endif // ODB_CXX11
654 
655  namespace common
656  {
657  using odb::lazy_ptr;
658  using odb::lazy_auto_ptr;
659 
660 #ifdef ODB_CXX11
661  using odb::lazy_unique_ptr;
662  using odb::lazy_shared_ptr;
663  using odb::lazy_weak_ptr;
664 #endif
665  }
666 }
667 
668 #include <odb/lazy-ptr.ixx>
669 #include <odb/lazy-ptr.txx>
670 
671 #include <odb/lazy-pointer-traits.hxx>
672 
673 #include <odb/post.hxx>
674 
675 #endif // ODB_LAZY_PTR_HXX
odb::lazy_ptr
Definition: lazy-ptr.hxx:23
odb::lazy_auto_ptr::load
std::auto_ptr< T > & load() const
odb::lazy_ptr::unload
void unload() const
odb::lazy_ptr_impl
Definition: lazy-ptr-impl.hxx:115
odb::lazy_auto_ptr::operator*
T & operator*() const
odb::lazy_ptr::load
T * load() const
odb::lazy_ptr::loaded
bool loaded() const
odb::lazy_auto_ptr::object_id
object_traits< O >::id_type object_id() const
odb::lazy_ptr::unspecified_bool_type
T *lazy_ptr::* unspecified_bool_type
Definition: lazy-ptr.hxx:48
odb::lazy_auto_ptr::database_type
odb::database database_type
Definition: lazy-ptr.hxx:175
odb::lazy_auto_ptr::get_eager
std::auto_ptr< T > & get_eager() const
odb::lazy_ptr::operator*
T & operator*() const
odb::lazy_auto_ptr::operator=
lazy_auto_ptr & operator=(lazy_auto_ptr &)
odb::lazy_auto_ptr_ref::p_
T * p_
Definition: lazy-ptr.hxx:124
odb::lazy_auto_ptr::operator->
T * operator->() const
odb::lazy_ptr::database
database_type & database() const
odb::lazy_ptr::lazy_ptr
lazy_ptr()
odb::object_traits
Definition: forward.hxx:123
odb::lazy_ptr::get_eager
T * get_eager() const
odb::lazy_auto_ptr::release
T * release()
odb::lazy_ptr::operator=
lazy_ptr & operator=(const lazy_ptr &)
odb::lazy_auto_ptr_ref
Definition: lazy-ptr.hxx:120
odb::lazy_ptr::element_type
T element_type
Definition: lazy-ptr.hxx:28
odb::lazy_auto_ptr_ref::i_
lazy_ptr_impl_ref i_
Definition: lazy-ptr.hxx:125
odb::operator!=
bool operator!=(const lazy_ptr< T > &, const lazy_ptr< Y > &)
odb::lazy_auto_ptr::lazy_auto_ptr
friend class lazy_auto_ptr
Definition: lazy-ptr.hxx:216
odb::lazy_auto_ptr::loaded
bool loaded() const
odb::lazy_auto_ptr::unspecified_bool_type
std::auto_ptr< T > lazy_auto_ptr::* unspecified_bool_type
Definition: lazy-ptr.hxx:157
odb::lazy_ptr::equal
bool equal(const lazy_ptr< Y > &) const
odb::lazy_ptr_impl_ref
Definition: lazy-ptr-impl.hxx:20
odb::lazy_auto_ptr::unload
void unload() const
odb::database
Definition: database.hxx:38
odb::lazy_auto_ptr
Definition: lazy-ptr.hxx:129
odb::lazy_auto_ptr_ref::lazy_auto_ptr_ref
lazy_auto_ptr_ref(T *, const lazy_ptr_impl_ref &)
odb::lazy_ptr::database_type
odb::database database_type
Definition: lazy-ptr.hxx:57
odb::swap
void swap(lazy_ptr< T > &, lazy_ptr< T > &)
odb::lazy_auto_ptr::reset
void reset(T *=0)
odb::lazy_ptr::swap
void swap(lazy_ptr &)
odb::tr1::get_deleter
D * get_deleter(const lazy_shared_ptr< T > &)
odb::lazy_auto_ptr::element_type
T element_type
Definition: lazy-ptr.hxx:134
odb::lazy_ptr::operator->
T * operator->() const
odb::operator==
bool operator==(const lazy_ptr< T > &, const lazy_ptr< Y > &)
post.hxx
odb::lazy_ptr::object_id
object_traits< O >::id_type object_id() const
odb::lazy_ptr::reset
void reset()
odb::lazy_auto_ptr::database
database_type & database() const
Generated on Fri Jul 25 2014 07:57:01 for Common ODB Runtime Library by   doxygen 1.8.7