From a474f75b6bea51ecd5c3a870696dd575e25b0bc6 Mon Sep 17 00:00:00 2001 From: Boris Kolpackov Date: Mon, 29 Oct 2012 10:08:30 +0200 Subject: Add static multi-database support for lazy pointers A lazy pointer must load the object using the static database interface with which it was initialized. --- odb/lazy-ptr-impl.hxx | 30 ++++--- odb/lazy-ptr-impl.ixx | 117 ++++++++++++++++++++++------ odb/lazy-ptr-impl.txx | 11 ++- odb/lazy-ptr.hxx | 84 ++++++++++---------- odb/lazy-ptr.ixx | 212 ++++++++++++++++++++++++++------------------------ odb/tr1/lazy-ptr.hxx | 36 ++++----- odb/tr1/lazy-ptr.ixx | 86 ++++++++++---------- 7 files changed, 334 insertions(+), 242 deletions(-) diff --git a/odb/lazy-ptr-impl.hxx b/odb/lazy-ptr-impl.hxx index 257cef8..db4d5d6 100644 --- a/odb/lazy-ptr-impl.hxx +++ b/odb/lazy-ptr-impl.hxx @@ -21,6 +21,7 @@ namespace odb { void* id_; database* db_; + void* loader_; void (*free_) (void*); void* (*copy_) (const void*); }; @@ -57,11 +58,6 @@ namespace odb void reset (); - // Reset the id and set the database to the new value. - // - void - reset (database_type&); - // Reset the id. // void @@ -88,7 +84,10 @@ namespace odb // Makes a copy of id. // void - reset_ (database_type*, const void* id, free_func, copy_func); + reset_ (database_type*, + void* loader, + const void* id, + free_func, copy_func); template static void @@ -98,9 +97,14 @@ namespace odb static void* copy (const void*); + template + static typename object_traits::pointer_type + loader (database_type&, const typename object_traits::id_type&); + protected: void* id_; database_type* db_; + void* loader_; private: free_func free_; @@ -113,8 +117,8 @@ namespace odb public: lazy_ptr_impl (); - template - lazy_ptr_impl (database_type&, const ID&); + template + lazy_ptr_impl (DB&, const ID&); lazy_ptr_impl (const lazy_ptr_impl&); @@ -154,9 +158,15 @@ namespace odb using lazy_ptr_base::reset; using lazy_ptr_base::reset_id; - template + template + void + reset (DB&, const ID&); + + // Reset the id and set the database to the new value. + // + template void - reset (database_type&, const ID&); + reset_db (DB&); template void diff --git a/odb/lazy-ptr-impl.ixx b/odb/lazy-ptr-impl.ixx index cd49682..7cfa420 100644 --- a/odb/lazy-ptr-impl.ixx +++ b/odb/lazy-ptr-impl.ixx @@ -10,13 +10,14 @@ namespace odb inline lazy_ptr_base:: lazy_ptr_base () - : id_ (0), db_ (0) + : id_ (0), db_ (0), loader_ (0) { } inline lazy_ptr_base:: lazy_ptr_base (const lazy_ptr_base& r) - : id_ (0), db_ (r.db_), free_ (r.free_), copy_ (r.copy_) + : id_ (0), db_ (r.db_), loader_ (r.loader_), + free_ (r.free_), copy_ (r.copy_) { if (r.id_) id_ = copy_ (r.id_); @@ -24,14 +25,16 @@ namespace odb inline lazy_ptr_base:: lazy_ptr_base (const lazy_ptr_impl_ref& r) - : id_ (r.id_), db_ (r.db_), free_ (r.free_), copy_ (r.copy_) + : id_ (r.id_), db_ (r.db_), loader_ (r.loader_), + free_ (r.free_), copy_ (r.copy_) { } #ifdef ODB_CXX11 inline lazy_ptr_base:: lazy_ptr_base (lazy_ptr_base&& r) - : id_ (r.id_), db_ (r.db_), free_ (r.free_), copy_ (r.copy_) + : id_ (r.id_), db_ (r.db_), loader_ (r.loader_), + free_ (r.free_), copy_ (r.copy_) { r.id_ = 0; } @@ -44,6 +47,7 @@ namespace odb reset_id (); id_ = r.id_; db_ = r.db_; + loader_ = r.loader_; free_ = r.free_; copy_ = r.copy_; @@ -55,16 +59,11 @@ namespace odb #endif inline void lazy_ptr_base:: - reset_id () - { - if (id_) - free_ (id_); - - id_ = 0; - } - - inline void lazy_ptr_base:: - reset_ (database_type* db, const void* id, free_func free, copy_func copy) + reset_ (database_type* db, + void* loader, + const void* id, + free_func free, + copy_func copy) { void* idc (id ? copy (id) : 0); @@ -76,6 +75,7 @@ namespace odb id_ = idc; db_ = db; + loader_ = loader; } inline void lazy_ptr_base:: @@ -83,22 +83,28 @@ namespace odb { reset_id (); db_ = 0; + loader_ = 0; } inline void lazy_ptr_base:: - reset (database_type& db) + reset_id () { - reset_id (); - db_ = &db; + if (id_) + free_ (id_); + + id_ = 0; } inline lazy_ptr_base& lazy_ptr_base:: operator= (const lazy_ptr_base& r) { if (id_ != r.id_) - reset_ (r.db_, r.id_, r.free_, r.copy_); + reset_ (r.db_, r.loader_, r.id_, r.free_, r.copy_); else + { db_ = r.db_; + loader_ = r.loader_; + } return *this; } @@ -115,6 +121,7 @@ namespace odb } db_ = r.db_; + loader_ = r.loader_; return *this; } @@ -130,16 +137,19 @@ namespace odb { void* id (id_); database_type* db (db_); + void* l (loader_); free_func f (free_); copy_func c (copy_); id_ = r.id_; db_ = r.db_; + loader_ = r.loader_; free_ = r.free_; copy_ = r.copy_; r.id_ = id; r.db_ = db; + r.loader_ = l; r.free_ = f; r.copy_ = c; } @@ -156,10 +166,12 @@ namespace odb lazy_ptr_impl_ref r; r.id_ = id_; r.db_ = db_; + r.loader_ = loader_; r.free_ = free_; r.copy_ = copy_; id_ = 0; db_ = 0; + loader_ = 0; return r; } @@ -174,11 +186,13 @@ namespace odb } template - template + template inline lazy_ptr_impl:: - lazy_ptr_impl (database_type& db, const ID& id) + lazy_ptr_impl (DB& db, const ID& id) { typedef typename object_traits::id_type id_type; + typedef typename object_traits::pointer_type pointer_type; + typedef pointer_type (*loader_type) (database_type&, const id_type&); // Make sure that ID and T's object id types are the same // (or implicit-convertible). If you get a compile error @@ -187,7 +201,21 @@ namespace odb // const id_type& r (id); - reset_ (&db, &r, &free, ©); + // Compiler error pointing here? Perhaps db is not an + // odb::::database instance? + // + database_type& bdb (db); + + // For some reason GCC needs this statically-typed pointer in + // order to instantiate the functions. + // + loader_type ldr (&loader); + + reset_ (&bdb, + reinterpret_cast (ldr), + &r, + &free, + ©); } template @@ -277,11 +305,13 @@ namespace odb #endif template - template + template inline void lazy_ptr_impl:: - reset (database_type& db, const ID& id) + reset (DB& db, const ID& id) { typedef typename object_traits::id_type id_type; + typedef typename object_traits::pointer_type pointer_type; + typedef pointer_type (*loader_type) (database_type&, const id_type&); // Make sure that ID and T's object id types are the same // (or implicit-convertible). If you get a compile error @@ -290,7 +320,44 @@ namespace odb // const id_type& r (id); - reset_ (&db, &r, &free, ©); + // Compiler error pointing here? Perhaps db is not an + // odb::::database instance? + // + database_type& bdb (db); + + // For some reason GCC needs this statically-typed pointer in + // order to instantiate the functions. + // + loader_type ldr (&loader); + + reset_ (&bdb, + reinterpret_cast (ldr), + &r, + &free, + ©); + } + + template + template + inline void lazy_ptr_impl:: + reset_db (DB& db) + { + typedef typename object_traits::id_type id_type; + typedef typename object_traits::pointer_type pointer_type; + typedef pointer_type (*loader_type) (database_type&, const id_type&); + + reset_id (); + + // Compiler error pointing here? Perhaps db is not an + // odb::::database instance? + // + db_ = &db; + + // For some reason GCC needs this statically-typed pointer in + // order to instantiate the functions. + // + loader_type ldr (&loader); + loader_ = reinterpret_cast (ldr); } template @@ -307,7 +374,7 @@ namespace odb // const id_type& r (id); - reset_ (db_, &r, &free, ©); + reset_ (db_, loader_, &r, &free, ©); } template diff --git a/odb/lazy-ptr-impl.txx b/odb/lazy-ptr-impl.txx index 91d51d9..c14f349 100644 --- a/odb/lazy-ptr-impl.txx +++ b/odb/lazy-ptr-impl.txx @@ -24,6 +24,13 @@ namespace odb return new T (*static_cast (p)); } + template + typename object_traits::pointer_type lazy_ptr_base:: + loader (database_type& db, const typename object_traits::id_type& id) + { + return static_cast (db).template load (id); + } + // // lazy_ptr_impl // @@ -35,9 +42,11 @@ namespace odb { typedef typename object_traits::id_type id_type; typedef typename object_traits::pointer_type pointer_type; + typedef pointer_type (*loader_type) (database_type&, const id_type&); + loader_type loader (reinterpret_cast (loader_)); const id_type& id (*static_cast (id_)); - pointer_type p (db_->load (id)); + pointer_type p (loader (*db_, id)); if (reset) reset_id (); diff --git a/odb/lazy-ptr.hxx b/odb/lazy-ptr.hxx index 12acbb6..8df47b9 100644 --- a/odb/lazy-ptr.hxx +++ b/odb/lazy-ptr.hxx @@ -72,11 +72,11 @@ namespace odb // void unload () const; - template lazy_ptr (database_type&, const ID&); - template lazy_ptr (database_type&, Y*); + template lazy_ptr (DB&, const ID&); + template lazy_ptr (DB&, Y*); - template void reset (database_type&, const ID&); - template void reset (database_type&, Y*); + template void reset (DB&, const ID&); + template void reset (DB&, Y*); #ifdef ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT template @@ -185,13 +185,13 @@ namespace odb // void unload () const; - template lazy_auto_ptr (database_type&, const ID&); - lazy_auto_ptr (database_type&, T*); - template lazy_auto_ptr (database_type&, std::auto_ptr&); + template lazy_auto_ptr (DB&, const ID&); + template lazy_auto_ptr (DB&, T*); + template lazy_auto_ptr (DB&, std::auto_ptr&); - template void reset (database_type&, const ID&); - void reset (database_type&, T*); - template void reset (database_type&, std::auto_ptr&); + template void reset (DB&, const ID&); + template void reset (DB&, T*); + template void reset (DB&, std::auto_ptr&); #ifdef ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT template @@ -305,17 +305,17 @@ namespace odb // void unload () const; - template lazy_unique_ptr (database_type&, const ID&); - lazy_unique_ptr (database_type&, pointer); - lazy_unique_ptr (database_type&, pointer, const deleter_type&); - lazy_unique_ptr (database_type&, pointer, deleter_type&&); - template lazy_unique_ptr (database_type&, std::unique_ptr&&); - template lazy_unique_ptr (database_type&, std::auto_ptr&&); + template lazy_unique_ptr (DB&, const ID&); + template lazy_unique_ptr (DB&, pointer); + template lazy_unique_ptr (DB&, pointer, const deleter_type&); + template lazy_unique_ptr (DB&, pointer, deleter_type&&); + template lazy_unique_ptr (DB&, std::unique_ptr&&); + template lazy_unique_ptr (DB&, std::auto_ptr&&); - template void reset (database_type&, const ID&); - void reset (database_type&, pointer); - template void reset (database_type&, std::unique_ptr&&); - template void reset (database_type&, std::auto_ptr&&); + template void reset (DB&, const ID&); + template void reset (DB&, pointer); + template void reset (DB&, std::unique_ptr&&); + template void reset (DB&, std::auto_ptr&&); #ifdef ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT template @@ -464,22 +464,22 @@ namespace odb // void unload () const; - template lazy_shared_ptr (database_type&, const ID&); - template lazy_shared_ptr (database_type&, Y*); - template lazy_shared_ptr (database_type&, Y*, D); - template lazy_shared_ptr (database_type&, Y*, D, A); - template lazy_shared_ptr (database_type&, std::auto_ptr&&); - template lazy_shared_ptr (database_type&, const std::shared_ptr&); - template lazy_shared_ptr (database_type&, std::shared_ptr&&); - template lazy_shared_ptr (database_type&, const std::weak_ptr&); - - template void reset (database_type&, const ID&); - template void reset (database_type&, Y*); - template void reset (database_type&, Y*, D); - template void reset (database_type&, Y*, D, A); - template void reset (database_type&, std::auto_ptr&&); - template void reset (database_type&, const std::shared_ptr&); - template void reset (database_type&, std::shared_ptr&&); + template lazy_shared_ptr (DB&, const ID&); + template lazy_shared_ptr (DB&, Y*); + template lazy_shared_ptr (DB&, Y*, D); + template lazy_shared_ptr (DB&, Y*, D, A); + template lazy_shared_ptr (DB&, std::auto_ptr&&); + template lazy_shared_ptr (DB&, const std::shared_ptr&); + template lazy_shared_ptr (DB&, std::shared_ptr&&); + template lazy_shared_ptr (DB&, const std::weak_ptr&); + + template void reset (DB&, const ID&); + template void reset (DB&, Y*); + template void reset (DB&, Y*, D); + template void reset (DB&, Y*, D, A); + template void reset (DB&, std::auto_ptr&&); + template void reset (DB&, const std::shared_ptr&); + template void reset (DB&, std::shared_ptr&&); #ifdef ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT template @@ -593,13 +593,13 @@ namespace odb // void unload () const; - template lazy_weak_ptr (database_type&, const ID&); - template lazy_weak_ptr (database_type&, const std::shared_ptr&); - template lazy_weak_ptr (database_type&, const std::weak_ptr&); + template lazy_weak_ptr (DB&, const ID&); + template lazy_weak_ptr (DB&, const std::shared_ptr&); + template lazy_weak_ptr (DB&, const std::weak_ptr&); - template void reset (database_type&, const ID&); - template void reset (database_type&, const std::shared_ptr&); - template void reset (database_type&, const std::weak_ptr&); + template void reset (DB&, const ID&); + template void reset (DB&, const std::shared_ptr&); + template void reset (DB&, const std::weak_ptr&); // The object_id() function can only be called when the object is // persistent, or: expired() XOR loaded() (can use != for XOR). diff --git a/odb/lazy-ptr.ixx b/odb/lazy-ptr.ixx index 08f3e5e..3318633 100644 --- a/odb/lazy-ptr.ixx +++ b/odb/lazy-ptr.ixx @@ -137,38 +137,38 @@ namespace odb } template - template + template inline lazy_ptr:: - lazy_ptr (database_type& db, const ID& id): p_ (0), i_ (db, id) {} + lazy_ptr (DB& db, const ID& id): p_ (0), i_ (db, id) {} template - template + template inline lazy_ptr:: - lazy_ptr (database_type& db, Y* r) + lazy_ptr (DB& db, Y* r) : p_ (r) { if (p_) - i_.reset (db); + i_.reset_db (db); } template - template + template inline void lazy_ptr:: - reset (database_type& db, const ID& id) + reset (DB& db, const ID& id) { p_ = 0; i_.reset (db, id); } template - template + template inline void lazy_ptr:: - reset (database_type& db, Y* r) + reset (DB& db, Y* r) { p_ = r; if (p_) - i_.reset (db); + i_.reset_db (db); else i_.reset (); } @@ -396,59 +396,61 @@ namespace odb } template - template + template inline lazy_auto_ptr:: - lazy_auto_ptr (database_type& db, const ID& id): i_ (db, id) {} + lazy_auto_ptr (DB& db, const ID& id): i_ (db, id) {} template + template inline lazy_auto_ptr:: - lazy_auto_ptr (database_type& db, T* p) + lazy_auto_ptr (DB& db, T* p) : p_ (p) { if (p) - i_.reset (db); + i_.reset_db (db); } template - template + template inline lazy_auto_ptr:: - lazy_auto_ptr (database_type& db, std::auto_ptr& p) + lazy_auto_ptr (DB& db, std::auto_ptr& p) : p_ (p) { if (p_.get () != 0) - i_.reset (db); + i_.reset_db (db); } template - template + template inline void lazy_auto_ptr:: - reset (database_type& db, const ID& id) + reset (DB& db, const ID& id) { p_.reset (); i_.reset (db, id); } template + template inline void lazy_auto_ptr:: - reset (database_type& db, T* p) + reset (DB& db, T* p) { p_.reset (p); if (p) - i_.reset (db); + i_.reset_db (db); else i_.reset (); } template - template + template inline void lazy_auto_ptr:: - reset (database_type& db, std::auto_ptr& p) + reset (DB& db, std::auto_ptr& p) { p_ = p; if (p_.get () != 0) - i_.reset (db); + i_.reset_db (db); else i_.reset (); } @@ -665,100 +667,104 @@ namespace odb } template - template + template inline lazy_unique_ptr:: - lazy_unique_ptr (database_type& db, const ID& id): i_ (db, id) {} + lazy_unique_ptr (DB& db, const ID& id): i_ (db, id) {} template + template inline lazy_unique_ptr:: - lazy_unique_ptr (database_type& db, T* p) + lazy_unique_ptr (DB& db, T* p) : p_ (p) { if (p_) - i_.reset (db); + i_.reset_db (db); } template + template inline lazy_unique_ptr:: - lazy_unique_ptr (database_type& db, T* p, const deleter_type& d) + lazy_unique_ptr (DB& db, T* p, const deleter_type& d) : p_ (p, d) { if (p_) - i_.reset (db); + i_.reset_db (db); } template + template inline lazy_unique_ptr:: - lazy_unique_ptr (database_type& db, T* p, deleter_type&& d) + lazy_unique_ptr (DB& db, T* p, deleter_type&& d) : p_ (p, std::move (d)) { if (p_) - i_.reset (db); + i_.reset_db (db); } template - template + template inline lazy_unique_ptr:: - lazy_unique_ptr (database_type& db, std::unique_ptr&& p) + lazy_unique_ptr (DB& db, std::unique_ptr&& p) : p_ (std::move (p)) { if (p_) - i_.reset (db); + i_.reset_db (db); } template - template + template inline lazy_unique_ptr:: - lazy_unique_ptr (database_type& db, std::auto_ptr&& p) + lazy_unique_ptr (DB& db, std::auto_ptr&& p) : p_ (std::move (p)) { if (p_) - i_.reset (db); + i_.reset_db (db); } template - template + template inline void lazy_unique_ptr:: - reset (database_type& db, const ID& id) + reset (DB& db, const ID& id) { p_.reset (); i_.reset (db, id); } template + template inline void lazy_unique_ptr:: - reset (database_type& db, T* p) + reset (DB& db, T* p) { p_.reset (p); if (p) - i_.reset (db); + i_.reset_db (db); else i_.reset (); } template - template + template inline void lazy_unique_ptr:: - reset (database_type& db, std::unique_ptr&& p) + reset (DB& db, std::unique_ptr&& p) { p_ = std::move (p); if (p_) - i_.reset (db); + i_.reset_db (db); else i_.reset (); } template - template + template inline void lazy_unique_ptr:: - reset (database_type& db, std::auto_ptr&& p) + reset (DB& db, std::auto_ptr&& p) { p_ = std::unique_ptr (std::move (p)); if (p_) - i_.reset (db); + i_.reset_db (db); else i_.reset (); } @@ -1144,163 +1150,163 @@ namespace odb } template - template + template inline lazy_shared_ptr:: - lazy_shared_ptr (database_type& db, const ID& id): i_ (db, id) {} + lazy_shared_ptr (DB& db, const ID& id): i_ (db, id) {} template - template + template inline lazy_shared_ptr:: - lazy_shared_ptr (database_type& db, Y* p) + lazy_shared_ptr (DB& db, Y* p) : p_ (p) { if (p_) - i_.reset (db); + i_.reset_db (db); } template - template + template inline lazy_shared_ptr:: - lazy_shared_ptr (database_type& db, Y* p, D d) + lazy_shared_ptr (DB& db, Y* p, D d) : p_ (p, d) { if (p_) - i_.reset (db); + i_.reset_db (db); } template - template + template inline lazy_shared_ptr:: - lazy_shared_ptr (database_type& db, Y* p, D d, A a) + lazy_shared_ptr (DB& db, Y* p, D d, A a) : p_ (p, d, a) { if (p_) - i_.reset (db); + i_.reset_db (db); } template - template + template inline lazy_shared_ptr:: - lazy_shared_ptr (database_type& db, std::auto_ptr&& r) + lazy_shared_ptr (DB& db, std::auto_ptr&& r) : p_ (std::move (r)) { if (p_) - i_.reset (db); + i_.reset_db (db); } template - template + template inline lazy_shared_ptr:: - lazy_shared_ptr (database_type& db, const std::shared_ptr& r) + lazy_shared_ptr (DB& db, const std::shared_ptr& r) : p_ (r) { if (p_) - i_.reset (db); + i_.reset_db (db); } template - template + template inline lazy_shared_ptr:: - lazy_shared_ptr (database_type& db, std::shared_ptr&& r) + lazy_shared_ptr (DB& db, std::shared_ptr&& r) : p_ (std::move (r)) { if (p_) - i_.reset (db); + i_.reset_db (db); } template - template + template inline lazy_shared_ptr:: - lazy_shared_ptr (database_type& db, const std::weak_ptr& r) + lazy_shared_ptr (DB& db, const std::weak_ptr& r) : p_ (r) { if (p_) - i_.reset (db); + i_.reset_db (db); } template - template + template inline void lazy_shared_ptr:: - reset (database_type& db, const ID& id) + reset (DB& db, const ID& id) { p_.reset (); i_.reset (db, id); } template - template + template inline void lazy_shared_ptr:: - reset (database_type& db, Y* p) + reset (DB& db, Y* p) { p_.reset (p); if (p_) - i_.reset (db); + i_.reset_db (db); else i_.reset (); } template - template + template inline void lazy_shared_ptr:: - reset (database_type& db, Y* p, D d) + reset (DB& db, Y* p, D d) { p_.reset (p, d); if (p_) - i_.reset (db); + i_.reset_db (db); else i_.reset (); } template - template + template inline void lazy_shared_ptr:: - reset (database_type& db, Y* p, D d, A a) + reset (DB& db, Y* p, D d, A a) { p_.reset (p, d, a); if (p_) - i_.reset (db); + i_.reset_db (db); else i_.reset (); } template - template + template inline void lazy_shared_ptr:: - reset (database_type& db, std::auto_ptr&& r) + reset (DB& db, std::auto_ptr&& r) { p_ = std::move (r); if (p_) - i_.reset (db); + i_.reset_db (db); else i_.reset (); } template - template + template inline void lazy_shared_ptr:: - reset (database_type& db, const std::shared_ptr& r) + reset (DB& db, const std::shared_ptr& r) { p_ = r; if (p_) - i_.reset (db); + i_.reset_db (db); else i_.reset (); } template - template + template inline void lazy_shared_ptr:: - reset (database_type& db, std::shared_ptr&& r) + reset (DB& db, std::shared_ptr&& r) { p_ = std::move (r); if (p_) - i_.reset (db); + i_.reset_db (db); else i_.reset (); } @@ -1529,14 +1535,14 @@ namespace odb } template - template + template inline lazy_weak_ptr:: - lazy_weak_ptr (database_type& db, const ID& id): i_ (db, id) {} + lazy_weak_ptr (DB& db, const ID& id): i_ (db, id) {} template - template + template inline lazy_weak_ptr:: - lazy_weak_ptr (database_type& db, const std::shared_ptr& r) + lazy_weak_ptr (DB& db, const std::shared_ptr& r) : p_ (r) { typedef typename object_traits::object_type object_type; @@ -1546,9 +1552,9 @@ namespace odb } template - template + template inline lazy_weak_ptr:: - lazy_weak_ptr (database_type& db, const std::weak_ptr& r) + lazy_weak_ptr (DB& db, const std::weak_ptr& r) : p_ (r) { typedef typename object_traits::object_type object_type; @@ -1560,18 +1566,18 @@ namespace odb } template - template + template inline void lazy_weak_ptr:: - reset (database_type& db, const ID& id) + reset (DB& db, const ID& id) { p_.reset (); i_.reset (db, id); } template - template + template inline void lazy_weak_ptr:: - reset (database_type& db, const std::shared_ptr& r) + reset (DB& db, const std::shared_ptr& r) { typedef typename object_traits::object_type object_type; @@ -1584,9 +1590,9 @@ namespace odb } template - template + template inline void lazy_weak_ptr:: - reset (database_type& db, const std::weak_ptr& r) + reset (DB& db, const std::weak_ptr& r) { typedef typename object_traits::object_type object_type; diff --git a/odb/tr1/lazy-ptr.hxx b/odb/tr1/lazy-ptr.hxx index 01a7b36..85b43bf 100644 --- a/odb/tr1/lazy-ptr.hxx +++ b/odb/tr1/lazy-ptr.hxx @@ -98,18 +98,18 @@ namespace odb // void unload () const; - template lazy_shared_ptr (database_type&, const ID&); - template lazy_shared_ptr (database_type&, Y*); - template lazy_shared_ptr (database_type&, Y*, D); - template lazy_shared_ptr (database_type&, std::auto_ptr&); - template lazy_shared_ptr (database_type&, const std::tr1::shared_ptr&); - template lazy_shared_ptr (database_type&, const std::tr1::weak_ptr&); - - template void reset (database_type&, const ID&); - template void reset (database_type&, Y*); - template void reset (database_type&, Y*, D); - template void reset (database_type&, std::auto_ptr&); - template void reset (database_type&, const std::tr1::shared_ptr&); + template lazy_shared_ptr (DB&, const ID&); + template lazy_shared_ptr (DB&, Y*); + template lazy_shared_ptr (DB&, Y*, D); + template lazy_shared_ptr (DB&, std::auto_ptr&); + template lazy_shared_ptr (DB&, const std::tr1::shared_ptr&); + template lazy_shared_ptr (DB&, const std::tr1::weak_ptr&); + + template void reset (DB&, const ID&); + template void reset (DB&, Y*); + template void reset (DB&, Y*, D); + template void reset (DB&, std::auto_ptr&); + template void reset (DB&, const std::tr1::shared_ptr&); #ifdef ODB_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGUMENT template @@ -207,13 +207,13 @@ namespace odb // void unload () const; - template lazy_weak_ptr (database_type&, const ID&); - template lazy_weak_ptr (database_type&, const std::tr1::shared_ptr&); - template lazy_weak_ptr (database_type&, const std::tr1::weak_ptr&); + template lazy_weak_ptr (DB&, const ID&); + template lazy_weak_ptr (DB&, const std::tr1::shared_ptr&); + template lazy_weak_ptr (DB&, const std::tr1::weak_ptr&); - template void reset (database_type&, const ID&); - template void reset (database_type&, const std::tr1::shared_ptr&); - template void reset (database_type&, const std::tr1::weak_ptr&); + template void reset (DB&, const ID&); + template void reset (DB&, const std::tr1::shared_ptr&); + template void reset (DB&, const std::tr1::weak_ptr&); // The object_id() function can only be called when the object is // persistent, or: expired() XOR loaded() (can use != for XOR). diff --git a/odb/tr1/lazy-ptr.ixx b/odb/tr1/lazy-ptr.ixx index a29eaad..ad2d659 100644 --- a/odb/tr1/lazy-ptr.ixx +++ b/odb/tr1/lazy-ptr.ixx @@ -207,117 +207,117 @@ namespace odb } template - template + template inline lazy_shared_ptr:: - lazy_shared_ptr (database_type& db, const ID& id): i_ (db, id) {} + lazy_shared_ptr (DB& db, const ID& id): i_ (db, id) {} template - template + template inline lazy_shared_ptr:: - lazy_shared_ptr (database_type& db, Y* p) + lazy_shared_ptr (DB& db, Y* p) : p_ (p) { if (p_) - i_.reset (db); + i_.reset_db (db); } template - template + template inline lazy_shared_ptr:: - lazy_shared_ptr (database_type& db, Y* p, D d) + lazy_shared_ptr (DB& db, Y* p, D d) : p_ (p, d) { if (p_) - i_.reset (db); + i_.reset_db (db); } template - template + template inline lazy_shared_ptr:: - lazy_shared_ptr (database_type& db, std::auto_ptr& r) + lazy_shared_ptr (DB& db, std::auto_ptr& r) : p_ (r) { if (p_) - i_.reset (db); + i_.reset_db (db); } template - template + template inline lazy_shared_ptr:: - lazy_shared_ptr (database_type& db, const std::tr1::shared_ptr& r) + lazy_shared_ptr (DB& db, const std::tr1::shared_ptr& r) : p_ (r) { if (p_) - i_.reset (db); + i_.reset_db (db); } template - template + template inline lazy_shared_ptr:: - lazy_shared_ptr (database_type& db, const std::tr1::weak_ptr& r) + lazy_shared_ptr (DB& db, const std::tr1::weak_ptr& r) : p_ (r) { if (p_) - i_.reset (db); + i_.reset_db (db); } template - template + template inline void lazy_shared_ptr:: - reset (database_type& db, const ID& id) + reset (DB& db, const ID& id) { p_.reset (); i_.reset (db, id); } template - template + template inline void lazy_shared_ptr:: - reset (database_type& db, Y* p) + reset (DB& db, Y* p) { p_.reset (p); if (p_) - i_.reset (db); + i_.reset_db (db); else i_.reset (); } template - template + template inline void lazy_shared_ptr:: - reset (database_type& db, Y* p, D d) + reset (DB& db, Y* p, D d) { p_.reset (p, d); if (p_) - i_.reset (db); + i_.reset_db (db); else i_.reset (); } template - template + template inline void lazy_shared_ptr:: - reset (database_type& db, std::auto_ptr& r) + reset (DB& db, std::auto_ptr& r) { p_ = r; if (p_) - i_.reset (db); + i_.reset_db (db); else i_.reset (); } template - template + template inline void lazy_shared_ptr:: - reset (database_type& db, const std::tr1::shared_ptr& r) + reset (DB& db, const std::tr1::shared_ptr& r) { p_ = r; if (p_) - i_.reset (db); + i_.reset_db (db); else i_.reset (); } @@ -517,14 +517,14 @@ namespace odb } template - template + template inline lazy_weak_ptr:: - lazy_weak_ptr (database_type& db, const ID& id): i_ (db, id) {} + lazy_weak_ptr (DB& db, const ID& id): i_ (db, id) {} template - template + template inline lazy_weak_ptr:: - lazy_weak_ptr (database_type& db, const std::tr1::shared_ptr& r) + lazy_weak_ptr (DB& db, const std::tr1::shared_ptr& r) : p_ (r) { typedef typename object_traits::object_type object_type; @@ -534,9 +534,9 @@ namespace odb } template - template + template inline lazy_weak_ptr:: - lazy_weak_ptr (database_type& db, const std::tr1::weak_ptr& r) + lazy_weak_ptr (DB& db, const std::tr1::weak_ptr& r) : p_ (r) { typedef typename object_traits::object_type object_type; @@ -548,18 +548,18 @@ namespace odb } template - template + template inline void lazy_weak_ptr:: - reset (database_type& db, const ID& id) + reset (DB& db, const ID& id) { p_.reset (); i_.reset (db, id); } template - template + template inline void lazy_weak_ptr:: - reset (database_type& db, const std::tr1::shared_ptr& r) + reset (DB& db, const std::tr1::shared_ptr& r) { typedef typename object_traits::object_type object_type; @@ -572,9 +572,9 @@ namespace odb } template - template + template inline void lazy_weak_ptr:: - reset (database_type& db, const std::tr1::weak_ptr& r) + reset (DB& db, const std::tr1::weak_ptr& r) { typedef typename object_traits::object_type object_type; -- cgit v1.1