From f1c2a621ac2695dfe4a3bc71dbc9ce3079008d2f Mon Sep 17 00:00:00 2001 From: Boris Kolpackov Date: Fri, 4 Feb 2011 13:56:09 +0200 Subject: Add support for smart-ptr, unordered, and date_time (basic) --- odb/boost/smart-ptr/lazy-ptr.hxx | 237 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 237 insertions(+) create mode 100644 odb/boost/smart-ptr/lazy-ptr.hxx (limited to 'odb/boost/smart-ptr/lazy-ptr.hxx') diff --git a/odb/boost/smart-ptr/lazy-ptr.hxx b/odb/boost/smart-ptr/lazy-ptr.hxx new file mode 100644 index 0000000..4dbf9bf --- /dev/null +++ b/odb/boost/smart-ptr/lazy-ptr.hxx @@ -0,0 +1,237 @@ +// file : odb/boost/smart-ptr/lazy-ptr.hxx +// author : Boris Kolpackov +// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef ODB_BOOST_SMART_PTR_LAZY_PTR_HXX +#define ODB_BOOST_SMART_PTR_LAZY_PTR_HXX + +#include + +#include // std::auto_ptr + +#include +#include + +#include // odb::database +#include +#include + +namespace odb +{ + namespace boost + { + template + class lazy_weak_ptr; + + // + // + template + class lazy_shared_ptr + { + // The standard shared_ptr interface. + // + public: + typedef T element_type; + + lazy_shared_ptr (); + template explicit lazy_shared_ptr (Y*); + template lazy_shared_ptr (Y*, D); + template lazy_shared_ptr (Y*, D, A); + + lazy_shared_ptr (const lazy_shared_ptr&); + template lazy_shared_ptr (const lazy_shared_ptr&); + template explicit lazy_shared_ptr (const lazy_weak_ptr&); + template explicit lazy_shared_ptr (std::auto_ptr&); + + ~lazy_shared_ptr (); + + lazy_shared_ptr& operator= (const lazy_shared_ptr&); + template lazy_shared_ptr& operator= (const lazy_shared_ptr&); + template lazy_shared_ptr& operator= (std::auto_ptr&); + + void swap (lazy_shared_ptr&); + void reset (); + template void reset (Y*); + template void reset (Y*, D); + template void reset (Y*, D, A); + + T& operator* () const; + T* operator-> () const; + T* get () const; + + bool unique () const; + long use_count () const; + + typedef ::boost::shared_ptr lazy_shared_ptr::*unspecified_bool_type; + operator unspecified_bool_type () const + { + return (p_ || i_) ? &lazy_shared_ptr::p_ : 0; + } + + // Initialization/assignment from shared_ptr and weak_ptr. + // + public: + template lazy_shared_ptr (const ::boost::shared_ptr&); + template explicit lazy_shared_ptr (const ::boost::weak_ptr&); + + template lazy_shared_ptr& operator= (const ::boost::shared_ptr&); + + // Lazy loading interface. + // + public: + typedef odb::database database_type; + + bool loaded () const; + ::boost::shared_ptr load () const; + + // Unload the pointer. For transient objects this function is + // equivalent to reset(). + // + 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 ::boost::shared_ptr&); + template lazy_shared_ptr (database_type&, const ::boost::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&, const std::auto_ptr&); + template void reset (database_type&, const ::boost::shared_ptr&); + + template + typename object_traits::id_type object_id () const; + + database_type& database () const; + + // Helpers. + // + public: + template bool equal (const lazy_shared_ptr&) const; + + private: + template friend class lazy_shared_ptr; + template friend class lazy_weak_ptr; + + mutable ::boost::shared_ptr p_; + mutable lazy_ptr_impl i_; + }; + + // operator< and operator<< are not provided. + // + template + bool operator== (const lazy_shared_ptr&, const lazy_shared_ptr&); + + template + bool operator!= (const lazy_shared_ptr&, const lazy_shared_ptr&); + + template void swap (lazy_shared_ptr&, lazy_shared_ptr&); + + template + D* get_deleter (const lazy_shared_ptr&); + + // + // + template + class lazy_weak_ptr + { + // The standard weak_ptr interface. + // + public: + typedef T element_type; + + lazy_weak_ptr (); + template lazy_weak_ptr (const lazy_shared_ptr&); + lazy_weak_ptr (const lazy_weak_ptr&); + template lazy_weak_ptr (const lazy_weak_ptr&); + + ~lazy_weak_ptr (); + + lazy_weak_ptr& operator= (const lazy_weak_ptr&); + template lazy_weak_ptr& operator= (const lazy_weak_ptr&); + template lazy_weak_ptr& operator= (const lazy_shared_ptr&); + + void swap (lazy_weak_ptr&); + void reset (); + + long use_count () const; + bool expired () const; + + lazy_shared_ptr lock () const; + + // Initialization/assignment from shared_ptr and weak_ptr. + // + public: + template lazy_weak_ptr (const ::boost::weak_ptr&); + template lazy_weak_ptr (const ::boost::shared_ptr&); + + template lazy_weak_ptr& operator= (const ::boost::weak_ptr&); + template lazy_weak_ptr& operator= (const ::boost::shared_ptr&); + + // Lazy loading interface. + // + public: + typedef odb::database database_type; + + // expired() loaded() + // + // true true expired pointer to transient object + // false true valid pointer to persistent object + // true false expired pointer to persistent object + // false false valid pointer to transiend object + // + bool loaded () const; + + // Performs both lock and load. + // + ::boost::shared_ptr load () const; + + // Unload the pointer. For transient objects this function is + // equivalent to reset(). + // + void unload () const; + + template lazy_weak_ptr (database_type&, const ID&); + template lazy_weak_ptr (database_type&, const ::boost::shared_ptr&); + template lazy_weak_ptr (database_type&, const ::boost::weak_ptr&); + + template void reset (database_type&, const ID&); + template void reset (database_type&, const ::boost::shared_ptr&); + template void reset (database_type&, const ::boost::weak_ptr&); + + // The object_id() function can only be called when the object is + // persistent, or: expired() XOR loaded() (can use != for XOR). + // + template + typename object_traits::id_type object_id () const; + + database_type& database () const; + + private: + template friend class lazy_shared_ptr; + template friend class lazy_weak_ptr; + + mutable ::boost::weak_ptr p_; + mutable lazy_ptr_impl i_; + }; + + // operator< is not provided. + // + template void swap (lazy_weak_ptr&, lazy_weak_ptr&); + } +} + +#include +#include + +#include + +#include + +#endif // ODB_BOOST_SMART_PTR_LAZY_PTR_HXX -- cgit v1.1