diff options
| -rw-r--r-- | odb/cache-traits.hxx | 127 | ||||
| -rw-r--r-- | odb/database.txx | 20 | ||||
| -rw-r--r-- | odb/object-result.hxx | 262 | ||||
| -rw-r--r-- | odb/object-result.txx | 41 | ||||
| -rw-r--r-- | odb/result.hxx | 5 | ||||
| -rw-r--r-- | odb/view-result.hxx | 10 | ||||
| -rw-r--r-- | odb/view-result.txx | 10 |
7 files changed, 398 insertions, 77 deletions
diff --git a/odb/cache-traits.hxx b/odb/cache-traits.hxx index e4b2495..067812b 100644 --- a/odb/cache-traits.hxx +++ b/odb/cache-traits.hxx @@ -17,8 +17,19 @@ namespace odb { // Caching traits for objects passed by pointer. // - template <typename P, pointer_kind = pointer_traits<P>::kind> - struct pointer_cache_traits + template <typename P, typename ID, pointer_kind kind> + struct pointer_cache_traits_impl; + + template <typename P> + struct pointer_cache_traits: pointer_cache_traits_impl< + P, + typename object_traits<typename pointer_traits<P>::element_type>::id_type, + pointer_traits<P>::kind> + { + }; + + template <typename P, typename ID, pointer_kind kind> + struct pointer_cache_traits_impl { typedef P pointer_type; typedef odb::pointer_traits<pointer_type> pointer_traits; @@ -45,20 +56,36 @@ namespace odb position_type pos_; }; + // We need the insert() overload with explicit id to handle self- + // references. In such cases the object is not yet loaded and the + // id member does not contain the correct id. + // // Qualify the database type to resolve a phony ambiguity in VC 10. // static position_type insert (odb::database& db, const id_type& id, const pointer_type& p) { if (session::has_current ()) + { // Cast away constness if any. // return session::current ().insert<object_type> ( db, id, pointer_traits::cast (p)); + } else return position_type (); } + static position_type + insert (odb::database& db, const pointer_type& p) + { + const id_type& id ( + object_traits<object_type>::id ( + pointer_traits::get_ref (p))); + + return insert (db, id, p); + } + static pointer_type find (odb::database& db, const id_type& id) { @@ -83,10 +110,23 @@ namespace odb } }; + template <typename P, pointer_kind kind> + struct pointer_cache_traits_impl<P, void, kind> + { + typedef P pointer_type; + struct position_type {}; + + static position_type + insert (odb::database&, const pointer_type&) + { + return position_type (); + } + }; + // Unique pointers don't work with the object cache. // - template <typename P> - struct pointer_cache_traits<P, pk_unique> + template <typename P, typename ID> + struct pointer_cache_traits_impl<P, ID, pk_unique> { typedef P pointer_type; typedef typename pointer_traits<pointer_type>::element_type element_type; @@ -110,6 +150,12 @@ namespace odb return position_type (); } + static position_type + insert (odb::database&, const pointer_type&) + { + return position_type (); + } + static pointer_type find (odb::database&, const id_type&) { return pointer_type (); } @@ -120,13 +166,35 @@ namespace odb erase (const position_type&) {} }; + template <typename P> + struct pointer_cache_traits_impl<P, void, pk_unique> + { + typedef P pointer_type; + struct position_type {}; + + static position_type + insert (odb::database&, const pointer_type&) + { + return position_type (); + } + }; + // Caching traits for objects passed by reference. Only if the object // pointer kind is raw do we add the object to the session. // - template <typename T, - pointer_kind = - pointer_traits<typename object_traits<T>::pointer_type>::kind> - struct reference_cache_traits + template <typename T, typename ID, pointer_kind kind> + struct reference_cache_traits_impl; + + template <typename T> + struct reference_cache_traits: reference_cache_traits_impl< + T, + typename object_traits<T>::id_type, + pointer_traits<typename object_traits<T>::pointer_type>::kind> + { + }; + + template <typename T, typename ID, pointer_kind kind> + struct reference_cache_traits_impl { typedef T element_type; typedef typename object_traits<element_type>::pointer_type pointer_type; @@ -152,10 +220,29 @@ namespace odb { return position_type (); } + + static position_type + insert (odb::database&, element_type&) + { + return position_type (); + } }; - template <typename T> - struct reference_cache_traits<T, pk_raw> + template <typename T, pointer_kind kind> + struct reference_cache_traits_impl<T, void, kind> + { + typedef T element_type; + struct position_type {}; + + static position_type + insert (odb::database&, element_type&) + { + return position_type (); + } + }; + + template <typename T, typename ID> + struct reference_cache_traits_impl<T, ID, pk_raw> { typedef T element_type; typedef typename object_traits<element_type>::pointer_type pointer_type; @@ -175,6 +262,26 @@ namespace odb pointer_type p (&obj); return pointer_cache_traits<pointer_type>::insert (db, id, p); } + + static position_type + insert (odb::database& db, element_type& obj) + { + pointer_type p (&obj); + return pointer_cache_traits<pointer_type>::insert (db, p); + } + }; + + template <typename T> + struct reference_cache_traits_impl<T, void, pk_raw> + { + typedef T element_type; + struct position_type {}; + + static position_type + insert (odb::database&, element_type&) + { + return position_type (); + } }; } diff --git a/odb/database.txx b/odb/database.txx index c70697d..42643aa 100644 --- a/odb/database.txx +++ b/odb/database.txx @@ -28,9 +28,9 @@ namespace odb object_traits::persist (*this, obj); object_traits::callback (*this, obj, callback_event::post_persist); - const typename object_traits::id_type& id (object_traits::id (obj)); - reference_cache_traits<T>::insert (*this, id, obj); - return id; + reference_cache_traits<T>::insert (*this, obj); + + return object_traits::id (obj); } template <typename T> @@ -54,9 +54,9 @@ namespace odb object_traits::persist (*this, obj); object_traits::callback (*this, obj, callback_event::post_persist); - const typename object_traits::id_type& id (object_traits::id (obj)); - pointer_cache_traits<pointer_type>::insert (*this, id, pobj); - return id; + pointer_cache_traits<pointer_type>::insert (*this, pobj); + + return object_traits::id (obj); } template <typename T> @@ -139,8 +139,8 @@ namespace odb object_traits::callback (*this, obj,callback_event::pre_update); - // Compiler error pointing here? Perhaps the object is readonly and - // therefore does not provide the update() function? + // Compiler error pointing here? Perhaps the object is readonly or + // doesn't have an object id? Such objects cannot be updated. // object_traits::update (*this, obj); @@ -166,8 +166,8 @@ namespace odb object_traits::callback (*this, obj, callback_event::pre_update); - // Compiler error pointing here? Perhaps the object is readonly and - // therefore does not provide the update() function? + // Compiler error pointing here? Perhaps the object is readonly or + // doesn't have an object id? Such objects cannot be updated. // object_traits::update (*this, obj); diff --git a/odb/object-result.hxx b/odb/object-result.hxx index 4c25962..e4d28ee 100644 --- a/odb/object-result.hxx +++ b/odb/object-result.hxx @@ -20,30 +20,158 @@ namespace odb { template <typename T> - class result_impl<T, class_object>: public details::shared_base + class object_result_impl; + + template <typename T> + class object_result_impl_no_id; + + template <typename T, typename ID> + class object_result_iterator; + + template <typename T, typename ID = typename object_traits<T>::id_type> + struct object_result_impl_selector + { + typedef object_result_impl<T> type; + }; + + template <typename T> + struct object_result_impl_selector<T, void> + { + typedef object_result_impl_no_id<T> type; + }; + + // Implementation for objects with object id. + // + template <typename T> + class object_result_impl: public details::shared_base { public: virtual - ~result_impl (); + ~object_result_impl (); protected: + typedef odb::database database_type; + + // In result_impl, T is always non-const and the same as object_type. + // + typedef T object_type; + typedef odb::object_traits<object_type> object_traits; + typedef typename object_traits::id_type id_type; + + typedef typename object_traits::pointer_type pointer_type; + typedef odb::pointer_traits<pointer_type> pointer_traits; + friend class result<T>; friend class result<const T>; friend class result_iterator<T, class_object>; friend class result_iterator<const T, class_object>; + friend class object_result_iterator<T, id_type>; + friend class object_result_iterator<const T, id_type>; + + protected: + object_result_impl (database_type& db) + : begin_ (true), end_ (false), db_ (db), current_ () + { + } + + database_type& + database () const + { + return db_; + } + + // To make this work with all kinds of pointers (raw, std::auto_ptr, + // shared), we need to make sure we don't make any copies of the + // pointer on the return path. + // + pointer_type& + current (); + + void + release () + { + current_ = pointer_type (); + guard_.release (); + } + + void + begin () + { + if (begin_) + { + next (); + begin_ = false; + } + } + + bool + end () const + { + return end_; + } + + protected: + virtual void + load (object_type&) = 0; + + virtual id_type + load_id () = 0; + + virtual void + next () = 0; + + virtual void + cache () = 0; + + virtual std::size_t + size () = 0; + + protected: + void + current (pointer_type p) + { + current_ = p; + guard_.reset (current_); + } + + bool begin_; + bool end_; + + private: + database_type& db_; + pointer_type current_; + typename pointer_traits::guard guard_; + }; + + // Implementation for objects without object id. + // + template <typename T> + class object_result_impl_no_id: public details::shared_base + { + public: + virtual + ~object_result_impl_no_id (); + protected: typedef odb::database database_type; // In result_impl, T is always non-const and the same as object_type. // typedef T object_type; typedef odb::object_traits<object_type> object_traits; - typedef typename object_traits::id_type id_type; typedef typename object_traits::pointer_type pointer_type; typedef odb::pointer_traits<pointer_type> pointer_traits; - result_impl (database_type& db) + friend class result<T>; + friend class result<const T>; + friend class result_iterator<T, class_object>; + friend class result_iterator<const T, class_object>; + friend class object_result_iterator<T, void>; + friend class object_result_iterator<const T, void>; + + protected: + object_result_impl_no_id (database_type& db) : begin_ (true), end_ (false), db_ (db), current_ () { } @@ -88,9 +216,6 @@ namespace odb virtual void load (object_type&) = 0; - virtual id_type - load_id () = 0; - virtual void next () = 0; @@ -117,8 +242,85 @@ namespace odb typename pointer_traits::guard guard_; }; + // + // result_iterator + // + + template <typename T, typename ID> + class object_result_iterator + { + public: + // T can be const T while object_type is always non-const. + // + typedef typename object_traits<T>::object_type object_type; + typedef typename object_traits<T>::id_type id_type; + + typedef object_result_impl<object_type> result_impl_type; + + public: + object_result_iterator (result_impl_type* res) + : res_ (res) + { + } + + public: + typename object_traits<T>::pointer_type + load () + { + typename object_traits<T>::pointer_type r (res_->current ()); + res_->release (); + return r; + } + + void + load (object_type&); + + protected: + result_impl_type* res_; + }; + template <typename T> - class result_iterator<T, class_object> + class object_result_iterator<T, void> + { + public: + // T can be const T while object_type is always non-const. + // + typedef typename object_traits<T>::object_type object_type; + + typedef object_result_impl_no_id<object_type> result_impl_type; + + public: + object_result_iterator (result_impl_type* res) + : res_ (res) + { + } + + public: + typename object_traits<T>::pointer_type + load () + { + typename object_traits<T>::pointer_type r (res_->current ()); + res_->release (); + return r; + } + + void + load (object_type& obj) + { + // Objects without ids are not stored in session cache. + // + if (!res_->end ()) + res_->load (obj); + } + + protected: + result_impl_type* res_; + }; + + template <typename T> + class result_iterator<T, class_object>: public object_result_iterator< + T, + typename object_traits<T>::id_type> { public: typedef T value_type; @@ -129,15 +331,14 @@ namespace odb // T can be const T while object_type is always non-const. // - typedef typename object_traits<T>::object_type object_type; - typedef typename object_traits<T>::id_type id_type; - - typedef result_impl<object_type, class_object> result_impl_type; + typedef + object_result_iterator<T, typename object_traits<T>::id_type> + base_type; public: explicit - result_iterator (result_impl_type* res = 0) - : res_ (res) + result_iterator (typename base_type::result_impl_type* res = 0) + : base_type (res) { } @@ -147,7 +348,7 @@ namespace odb reference operator* () const { - return pointer_traits::get_ref (res_->current ()); + return pointer_traits::get_ref (this->res_->current ()); } // Our value_type is already a pointer so return it instead of @@ -157,13 +358,13 @@ namespace odb pointer operator-> () const { - return pointer_traits::get_ptr (res_->current ()); + return pointer_traits::get_ptr (this->res_->current ()); } result_iterator& operator++ () { - res_->next (); + this->res_->next (); return *this; } @@ -172,27 +373,16 @@ namespace odb { // All non-end iterators for a result object move together. // - res_->next (); + this->res_->next (); return *this; } public: - typename object_traits<T>::pointer_type - load () - { - typename object_traits<T>::pointer_type r (res_->current ()); - res_->release (); - return r; - } - - void - load (object_type&); - - public: bool equal (result_iterator j) const { - return (res_ ? res_->end () : true) == (j.res_ ? j.res_->end () : true); + return (this->res_ ? this->res_->end () : true) == + (j.res_ ? j.res_->end () : true); } private: @@ -200,10 +390,10 @@ namespace odb // result_impl. // typedef - odb::pointer_traits<typename object_traits<object_type>::pointer_type> + odb::pointer_traits< + typename object_traits< + typename base_type::object_type>::pointer_type> pointer_traits; - - result_impl_type* res_; }; // @@ -217,7 +407,9 @@ namespace odb // T can be const T while object_type is always non-const. // typedef typename object_traits<T>::object_type object_type; - typedef result_impl<object_type, class_object> result_impl_type; + typedef + typename object_result_impl_selector<object_type>::type + result_impl_type; }; } diff --git a/odb/object-result.txx b/odb/object-result.txx index c19e482..843ec59 100644 --- a/odb/object-result.txx +++ b/odb/object-result.txx @@ -9,18 +9,18 @@ namespace odb { // - // result_impl + // object_result_impl // template <typename T> - result_impl<T, class_object>:: - ~result_impl () + object_result_impl<T>:: + ~object_result_impl () { } template <typename T> - typename result_impl<T, class_object>::pointer_type& - result_impl<T, class_object>:: + typename object_result_impl<T>::pointer_type& + object_result_impl<T>:: current () { if (pointer_traits::null_ptr (current_) && !end_) @@ -62,11 +62,38 @@ namespace odb } // - // result_iterator + // object_result_impl_no_id // + template <typename T> + object_result_impl_no_id<T>:: + ~object_result_impl_no_id () + { + } template <typename T> - void result_iterator<T, class_object>:: + typename object_result_impl_no_id<T>::pointer_type& + object_result_impl_no_id<T>:: + current () + { + if (pointer_traits::null_ptr (current_) && !end_) + { + // Objects without ids are not stored in session cache. + // + pointer_type p (object_traits::create ()); + object_type& obj (pointer_traits::get_ref (p)); + current (p); + load (obj); + } + + return current_; + } + + // + // object_result_iterator + // + + template <typename T, typename ID> + void object_result_iterator<T, ID>:: load (object_type& obj) { if (res_->end ()) diff --git a/odb/result.hxx b/odb/result.hxx index 1d4a199..91c1a39 100644 --- a/odb/result.hxx +++ b/odb/result.hxx @@ -18,9 +18,6 @@ namespace odb template <typename T, class_kind kind> class result_base; - template <typename T, class_kind kind> - class result_impl; - template <typename T, class_kind kind = class_traits<T>::kind> class result_iterator; @@ -59,8 +56,6 @@ namespace odb typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; - // T can be const T while result_impl's argument is always non-const. - // typedef typename base::result_impl_type result_impl_type; public: diff --git a/odb/view-result.hxx b/odb/view-result.hxx index a3cebf8..3f5a043 100644 --- a/odb/view-result.hxx +++ b/odb/view-result.hxx @@ -20,11 +20,11 @@ namespace odb { template <typename T> - class result_impl<T, class_view>: public details::shared_base + class view_result_impl: public details::shared_base { public: virtual - ~result_impl (); + ~view_result_impl (); protected: friend class result<T>; @@ -42,7 +42,7 @@ namespace odb typedef typename view_traits::pointer_type pointer_type; typedef odb::pointer_traits<pointer_type> pointer_traits; - result_impl (database_type& db) + view_result_impl (database_type& db) : begin_ (true), end_ (false), db_ (db), current_ () { } @@ -127,7 +127,7 @@ namespace odb // typedef typename view_traits<T>::view_type view_type; - typedef result_impl<view_type, class_view> result_impl_type; + typedef view_result_impl<view_type> result_impl_type; public: explicit @@ -212,7 +212,7 @@ namespace odb // T can be const T while view_type is always non-const. // typedef typename view_traits<T>::view_type view_type; - typedef result_impl<view_type, class_view> result_impl_type; + typedef view_result_impl<view_type> result_impl_type; }; } diff --git a/odb/view-result.txx b/odb/view-result.txx index 95f34e0..afc65b4 100644 --- a/odb/view-result.txx +++ b/odb/view-result.txx @@ -6,18 +6,18 @@ namespace odb { // - // result_impl + // view_result_impl // template <typename T> - result_impl<T, class_view>:: - ~result_impl () + view_result_impl<T>:: + ~view_result_impl () { } template <typename T> - typename result_impl<T, class_view>::pointer_type& - result_impl<T, class_view>:: + typename view_result_impl<T>::pointer_type& + view_result_impl<T>:: current () { if (pointer_traits::null_ptr (current_) && !end_) |