From ec355c48c49074bebeb597f6e5dcedfeb9d52fae Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Thu, 9 Dec 2010 10:36:15 +0200
Subject: Add lazy pointer support

Built-in support is provided for raw, auto, and tr1 shared/weak pointers.
New test: common/lazy-ptr.
---
 odb/tr1/lazy-pointer-traits.hxx |  63 ++++
 odb/tr1/lazy-ptr.hxx            | 239 +++++++++++++++
 odb/tr1/lazy-ptr.ixx            | 649 ++++++++++++++++++++++++++++++++++++++++
 odb/tr1/lazy-ptr.txx            |  59 ++++
 4 files changed, 1010 insertions(+)
 create mode 100644 odb/tr1/lazy-pointer-traits.hxx
 create mode 100644 odb/tr1/lazy-ptr.hxx
 create mode 100644 odb/tr1/lazy-ptr.ixx
 create mode 100644 odb/tr1/lazy-ptr.txx

(limited to 'odb/tr1')

diff --git a/odb/tr1/lazy-pointer-traits.hxx b/odb/tr1/lazy-pointer-traits.hxx
new file mode 100644
index 0000000..74276c5
--- /dev/null
+++ b/odb/tr1/lazy-pointer-traits.hxx
@@ -0,0 +1,63 @@
+// file      : odb/tr1/lazy-pointer-traits.hxx
+// author    : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2009-2010 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_TR1_LAZY_POINTER_TRAITS_HXX
+#define ODB_TR1_LAZY_POINTER_TRAITS_HXX
+
+#include <odb/pre.hxx>
+
+#include <odb/pointer-traits.hxx>
+#include <odb/tr1/lazy-ptr.hxx>
+
+namespace odb
+{
+  template <typename T>
+  class pointer_traits< tr1::lazy_shared_ptr<T> >
+  {
+  public:
+    static pointer_kind const kind = pk_shared;
+    static bool const lazy = true;
+
+    typedef T element_type;
+    typedef tr1::lazy_shared_ptr<element_type> pointer_type;
+    typedef std::tr1::shared_ptr<element_type> eager_pointer_type;
+
+    static bool
+    null_ptr (const pointer_type& p)
+    {
+      return !p;
+    }
+
+    template <class O /* = T */>
+    static typename object_traits<O>::id_type
+    object_id (const pointer_type& p)
+    {
+      return p.object_id<O> ();
+    }
+  };
+
+  template <typename T>
+  class pointer_traits< tr1::lazy_weak_ptr<T> >
+  {
+  public:
+    static pointer_kind const kind = pk_weak;
+    static bool const lazy = true;
+
+    typedef T element_type;
+    typedef tr1::lazy_weak_ptr<element_type> pointer_type;
+    typedef tr1::lazy_shared_ptr<element_type> strong_pointer_type;
+    typedef std::tr1::weak_ptr<element_type> eager_pointer_type;
+
+    static strong_pointer_type
+    lock (const pointer_type& p)
+    {
+      return p.lock ();
+    }
+  };
+}
+
+#include <odb/post.hxx>
+
+#endif // ODB_TR1_LAZY_POINTER_TRAITS_HXX
diff --git a/odb/tr1/lazy-ptr.hxx b/odb/tr1/lazy-ptr.hxx
new file mode 100644
index 0000000..ea9bf78
--- /dev/null
+++ b/odb/tr1/lazy-ptr.hxx
@@ -0,0 +1,239 @@
+// file      : odb/tr1/lazy-ptr.hxx
+// author    : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2009-2010 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_TR1_LAZY_PTR_HXX
+#define ODB_TR1_LAZY_PTR_HXX
+
+#include <odb/pre.hxx>
+
+//
+// This header assumes that the necessary TR1 header has already
+// been included.
+//
+
+#include <memory> // std::auto_ptr
+
+#include <odb/forward.hxx> // odb::database
+#include <odb/traits.hxx>
+#include <odb/lazy-ptr-impl.hxx>
+
+namespace odb
+{
+  namespace tr1
+  {
+    template <class T>
+    class lazy_weak_ptr;
+
+    //
+    //
+    template <class T>
+    class lazy_shared_ptr
+    {
+      // The standard shared_ptr interface.
+      //
+    public:
+      typedef T element_type;
+
+      lazy_shared_ptr ();
+      template <class Y> explicit lazy_shared_ptr (Y*);
+      template <class Y, class D> lazy_shared_ptr (Y*, D);
+      template <class Y, class D, class A> lazy_shared_ptr (Y*, D, A);
+
+      lazy_shared_ptr (const lazy_shared_ptr&);
+      template <class Y> lazy_shared_ptr (const lazy_shared_ptr<Y>&);
+      template <class Y> explicit lazy_shared_ptr (const lazy_weak_ptr<Y>&);
+      template <class Y> explicit lazy_shared_ptr (std::auto_ptr<Y>&);
+
+      ~lazy_shared_ptr ();
+
+      lazy_shared_ptr& operator= (const lazy_shared_ptr&);
+      template <class Y> lazy_shared_ptr& operator= (const lazy_shared_ptr<Y>&);
+      template <class Y> lazy_shared_ptr& operator= (std::auto_ptr<Y>&);
+
+      void swap (lazy_shared_ptr&);
+      void reset ();
+      template <class Y> void reset (Y*);
+      template <class Y, class D> void reset (Y*, D);
+      template <class Y, class D, class A> void reset (Y*, D, A);
+
+      T& operator* () const;
+      T* operator-> () const;
+      T* get () const;
+
+      bool unique () const;
+      long use_count () const;
+
+      typedef std::tr1::shared_ptr<T> 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 <class Y> lazy_shared_ptr (const std::tr1::shared_ptr<Y>&);
+      template <class Y> explicit lazy_shared_ptr (const std::tr1::weak_ptr<Y>&);
+
+      template <class Y> lazy_shared_ptr& operator= (const std::tr1::shared_ptr<Y>&);
+
+      // Lazy loading interface.
+      //
+    public:
+      typedef odb::database database_type;
+
+      bool loaded () const;
+      std::tr1::shared_ptr<T> load () const;
+
+      // Unload the pointer. For transient objects this function is
+      // equivalent to reset().
+      //
+      void unload () const;
+
+      template <class ID> lazy_shared_ptr (database_type&, const ID&);
+      template <class Y> lazy_shared_ptr (database_type&, Y*);
+      template <class Y, class D> lazy_shared_ptr (database_type&, Y*, D);
+      template <class Y, class D, class A> lazy_shared_ptr (database_type&, Y*, D, A);
+      template <class Y> lazy_shared_ptr (database_type&, std::auto_ptr<Y>&);
+      template <class Y> lazy_shared_ptr (database_type&, const std::tr1::shared_ptr<Y>&);
+      template <class Y> lazy_shared_ptr (database_type&, const std::tr1::weak_ptr<Y>&);
+
+      template <class ID> void reset (database_type&, const ID&);
+      template <class Y> void reset (database_type&, Y*);
+      template <class Y, class D> void reset (database_type&, Y*, D);
+      template <class Y, class D, class A> void reset (database_type&, Y*, D, A);
+      template <class Y> void reset (database_type&, const std::auto_ptr<Y>&);
+      template <class Y> void reset (database_type&, const std::tr1::shared_ptr<Y>&);
+
+      template <class O /* = T */>
+      typename object_traits<O>::id_type object_id () const;
+
+      database_type& database () const;
+
+      // Helpers.
+      //
+    public:
+      template <class Y> bool equal (const lazy_shared_ptr<Y>&) const;
+
+    private:
+      template <class Y> friend class lazy_shared_ptr;
+      template <class Y> friend class lazy_weak_ptr;
+
+      mutable std::tr1::shared_ptr<T> p_;
+      mutable lazy_ptr_impl<T> i_;
+    };
+
+    // operator< and operator<< are not provided.
+    //
+    template<class T, class Y>
+    bool operator== (const lazy_shared_ptr<T>&, const lazy_shared_ptr<Y>&);
+
+    template<class T, class Y>
+    bool operator!= (const lazy_shared_ptr<T>&, const lazy_shared_ptr<Y>&);
+
+    template<class T> void swap (lazy_shared_ptr<T>&, lazy_shared_ptr<T>&);
+
+    template<class D, class T>
+    D* get_deleter (const lazy_shared_ptr<T>&);
+
+    //
+    //
+    template <class T>
+    class lazy_weak_ptr
+    {
+      // The standard weak_ptr interface.
+      //
+    public:
+      typedef T element_type;
+
+      lazy_weak_ptr ();
+      template <class Y> lazy_weak_ptr (const lazy_shared_ptr<Y>&);
+      lazy_weak_ptr (const lazy_weak_ptr&);
+      template <class Y> lazy_weak_ptr (const lazy_weak_ptr<Y>&);
+
+      ~lazy_weak_ptr ();
+
+      lazy_weak_ptr& operator= (const lazy_weak_ptr&);
+      template <class Y> lazy_weak_ptr& operator= (const lazy_weak_ptr<Y>&);
+      template <class Y> lazy_weak_ptr& operator= (const lazy_shared_ptr<Y>&);
+
+      void swap (lazy_weak_ptr<T>&);
+      void reset ();
+
+      long use_count () const;
+      bool expired () const;
+
+      lazy_shared_ptr<T> lock () const;
+
+      // Initialization/assignment from shared_ptr and weak_ptr.
+      //
+    public:
+      template <class Y> lazy_weak_ptr (const std::tr1::weak_ptr<Y>&);
+      template <class Y> lazy_weak_ptr (const std::tr1::shared_ptr<Y>&);
+
+      template <class Y> lazy_weak_ptr& operator= (const std::tr1::weak_ptr<Y>&);
+      template <class Y> lazy_weak_ptr& operator= (const std::tr1::shared_ptr<Y>&);
+
+      // 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.
+      //
+      std::tr1::shared_ptr<T> load () const;
+
+      // Unload the pointer. For transient objects this function is
+      // equivalent to reset().
+      //
+      void unload () const;
+
+      template <class ID> lazy_weak_ptr (database_type&, const ID&);
+      template <class Y> lazy_weak_ptr (database_type&, const std::tr1::shared_ptr<Y>&);
+      template <class Y> lazy_weak_ptr (database_type&, const std::tr1::weak_ptr<Y>&);
+
+      template <class ID> void reset (database_type&, const ID&);
+      template <class Y> void reset (database_type&, const std::tr1::shared_ptr<Y>&);
+      template <class Y> void reset (database_type&, const std::tr1::weak_ptr<Y>&);
+
+      // The object_id() function can only be called when the object is
+      // persistent, or: expired() XOR loaded() (can use != for XOR).
+      //
+      template <class O /* = T */>
+      typename object_traits<O>::id_type object_id () const;
+
+      database_type& database () const;
+
+    private:
+      template <class Y> friend class lazy_shared_ptr;
+      template <class Y> friend class lazy_weak_ptr;
+
+      mutable std::tr1::weak_ptr<T> p_;
+      mutable lazy_ptr_impl<T> i_;
+    };
+
+    // operator< is not provided.
+    //
+    template<class T> void swap (lazy_weak_ptr<T>&, lazy_weak_ptr<T>&);
+  }
+}
+
+#include <odb/tr1/lazy-ptr.ixx>
+#include <odb/tr1/lazy-ptr.txx>
+
+#include <odb/tr1/lazy-pointer-traits.hxx>
+
+#include <odb/post.hxx>
+
+#endif // ODB_TR1_LAZY_PTR_HXX
diff --git a/odb/tr1/lazy-ptr.ixx b/odb/tr1/lazy-ptr.ixx
new file mode 100644
index 0000000..3e217b1
--- /dev/null
+++ b/odb/tr1/lazy-ptr.ixx
@@ -0,0 +1,649 @@
+// file      : odb/tr1/lazy-ptr.ixx
+// author    : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2009-2010 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+namespace odb
+{
+  namespace tr1
+  {
+    //
+    // lazy_shared_ptr
+    //
+
+    template <class T>
+    inline lazy_shared_ptr<T>::
+    lazy_shared_ptr () {}
+
+    template <class T>
+    template <class Y>
+    inline lazy_shared_ptr<T>::
+    lazy_shared_ptr (Y* p): p_ (p) {}
+
+    template <class T>
+    template <class Y, class D>
+    inline lazy_shared_ptr<T>::
+    lazy_shared_ptr (Y* p, D d): p_ (p, d) {}
+
+    template <class T>
+    template <class Y, class D, class A>
+    inline lazy_shared_ptr<T>::
+    lazy_shared_ptr (Y* p, D d, A a): p_ (p, d, a) {}
+
+    template <class T>
+    inline lazy_shared_ptr<T>::
+    lazy_shared_ptr (const lazy_shared_ptr& r): p_ (r.p_), i_ (r.i_) {}
+
+    template <class T>
+    template <class Y>
+    inline lazy_shared_ptr<T>::
+    lazy_shared_ptr (const lazy_shared_ptr<Y>& r): p_ (r.p_), i_ (r.i_) {}
+
+    template <class T>
+    template <class Y>
+    inline lazy_shared_ptr<T>::
+    lazy_shared_ptr (const lazy_weak_ptr<Y>& r): i_ (r.i_)
+    {
+      // If the pointer has expired but can be re-loaded, then don't throw.
+      //
+      p_ = r.lock ();
+
+      if (!p_ && !i_)
+        throw std::tr1::bad_weak_ptr ();
+    }
+
+    template <class T>
+    template <class Y>
+    inline lazy_shared_ptr<T>::
+    lazy_shared_ptr (std::auto_ptr<Y>& r): p_ (r) {}
+
+    template <class T>
+    inline lazy_shared_ptr<T>::
+    ~lazy_shared_ptr () {}
+
+    template <class T>
+    inline lazy_shared_ptr<T>& lazy_shared_ptr<T>::
+    operator= (const lazy_shared_ptr& r)
+    {
+      p_ = r.p_;
+      i_ = r.i_;
+      return *this;
+    }
+
+    template <class T>
+    template <class Y>
+    inline lazy_shared_ptr<T>& lazy_shared_ptr<T>::
+    operator= (const lazy_shared_ptr<Y>& r)
+    {
+      p_ = r.p_;
+      i_ = r.i_;
+      return *this;
+    }
+
+    template <class T>
+    template <class Y>
+    inline lazy_shared_ptr<T>& lazy_shared_ptr<T>::
+    operator= (std::auto_ptr<Y>& r)
+    {
+      p_ = r;
+      i_.reset ();
+      return *this;
+    }
+
+    template <class T>
+    inline void lazy_shared_ptr<T>::
+    swap (lazy_shared_ptr& b)
+    {
+      p_.swap (b.p_);
+      i_.swap (b.i_);
+    }
+
+    template <class T>
+    inline void lazy_shared_ptr<T>::
+    reset ()
+    {
+      p_.reset ();
+      i_.reset ();
+    }
+
+    template <class T>
+    template <class Y>
+    inline void lazy_shared_ptr<T>::
+    reset (Y* p)
+    {
+      p_.reset (p);
+      i_.reset ();
+    }
+
+    template <class T>
+    template <class Y, class D>
+    inline void lazy_shared_ptr<T>::
+    reset (Y* p, D d)
+    {
+      p_.reset (p, d);
+      i_.reset ();
+    }
+
+    template <class T>
+    template <class Y, class D, class A>
+    inline void lazy_shared_ptr<T>::
+    reset (Y* p, D d, A a)
+    {
+      p_.reset (p, d, a);
+      i_.reset ();
+    }
+
+    template <class T>
+    inline T& lazy_shared_ptr<T>::
+    operator* () const
+    {
+      return *p_;
+    }
+
+    template <class T>
+    inline T* lazy_shared_ptr<T>::
+    operator-> () const
+    {
+      return p_.operator-> ();
+    }
+
+    template <class T>
+    inline T* lazy_shared_ptr<T>::
+    get () const
+    {
+      return p_.get ();
+    }
+
+    template <class T>
+    inline bool lazy_shared_ptr<T>::
+    unique () const
+    {
+      return p_.unique ();
+    }
+
+    template <class T>
+    inline long lazy_shared_ptr<T>::
+    use_count () const
+    {
+      return p_.use_count ();
+    }
+
+    template <class T>
+    template <class Y>
+    inline lazy_shared_ptr<T>::
+    lazy_shared_ptr (const std::tr1::shared_ptr<Y>& r): p_ (r) {}
+
+    template <class T>
+    template <class Y>
+    inline lazy_shared_ptr<T>::
+    lazy_shared_ptr (const std::tr1::weak_ptr<Y>& r): p_ (r) {}
+
+    template <class T>
+    template <class Y>
+    inline lazy_shared_ptr<T>& lazy_shared_ptr<T>::
+    operator= (const std::tr1::shared_ptr<Y>& r)
+    {
+      p_ = r;
+      i_.reset ();
+      return *this;
+    }
+
+    template <class T>
+    inline bool lazy_shared_ptr<T>::
+    loaded () const
+    {
+      return p_ || !i_;
+    }
+
+    template <class T>
+    inline std::tr1::shared_ptr<T> lazy_shared_ptr<T>::
+    load () const
+    {
+      if (!loaded ())
+        p_ = i_.template load<T> (true); // Reset id.
+
+      return p_;
+    }
+
+    template <class T>
+    inline void lazy_shared_ptr<T>::
+    unload () const
+    {
+      typedef typename object_traits<T>::object_type object_type;
+
+      if (p_)
+      {
+        if (i_.database () != 0)
+          i_.reset_id (object_traits<object_type>::id (*p_));
+
+        p_.reset ();
+      }
+    }
+
+    template <class T>
+    template <class ID>
+    inline lazy_shared_ptr<T>::
+    lazy_shared_ptr (database_type& db, const ID& id): i_ (db, id) {}
+
+    template <class T>
+    template <class Y>
+    inline lazy_shared_ptr<T>::
+    lazy_shared_ptr (database_type& db, Y* p)
+        : p_ (p)
+    {
+      if (p_)
+        i_.reset (db);
+    }
+
+    template <class T>
+    template <class Y, class D>
+    inline lazy_shared_ptr<T>::
+    lazy_shared_ptr (database_type& db, Y* p, D d)
+        : p_ (p, d)
+    {
+      if (p_)
+        i_.reset (db);
+    }
+
+    template <class T>
+    template <class Y, class D, class A>
+    inline lazy_shared_ptr<T>::
+    lazy_shared_ptr (database_type& db, Y* p, D d, A a)
+        : p_ (p, d, a)
+    {
+      if (p_)
+        i_.reset (db);
+    }
+
+    template <class T>
+    template <class Y>
+    inline lazy_shared_ptr<T>::
+    lazy_shared_ptr (database_type& db, std::auto_ptr<Y>& r)
+        : p_ (r)
+    {
+      if (p_)
+        i_.reset (db);
+    }
+
+    template <class T>
+    template <class Y>
+    inline lazy_shared_ptr<T>::
+    lazy_shared_ptr (database_type& db, const std::tr1::shared_ptr<Y>& r)
+        : p_ (r)
+    {
+      if (p_)
+        i_.reset (db);
+    }
+
+    template <class T>
+    template <class Y>
+    inline lazy_shared_ptr<T>::
+    lazy_shared_ptr (database_type& db, const std::tr1::weak_ptr<Y>& r)
+        : p_ (r)
+    {
+      if (p_)
+        i_.reset (db);
+    }
+
+    template <class T>
+    template <class ID>
+    inline void lazy_shared_ptr<T>::
+    reset (database_type& db, const ID& id)
+    {
+      p_.reset ();
+      i_.reset (db, id);
+    }
+
+    template <class T>
+    template <class Y>
+    inline void lazy_shared_ptr<T>::
+    reset (database_type& db, Y* p)
+    {
+      p_.reset (p);
+
+      if (p_)
+        i_.reset (db);
+      else
+        i_.reset ();
+    }
+
+    template <class T>
+    template <class Y, class D>
+    inline void lazy_shared_ptr<T>::
+    reset (database_type& db, Y* p, D d)
+    {
+      p_.reset (p, d);
+
+      if (p_)
+        i_.reset (db);
+      else
+        i_.reset ();
+    }
+
+    template <class T>
+    template <class Y, class D, class A>
+    inline void lazy_shared_ptr<T>::
+    reset (database_type& db, Y* p, D d, A a)
+    {
+      p_.reset (p, d, a);
+
+      if (p_)
+        i_.reset (db);
+      else
+        i_.reset ();
+    }
+
+    template <class T>
+    template <class Y>
+    inline void lazy_shared_ptr<T>::
+    reset (database_type& db, const std::auto_ptr<Y>& r)
+    {
+      p_ = r;
+
+      if (p_)
+        i_.reset (db);
+      else
+        i_.reset ();
+    }
+
+    template <class T>
+    template <class Y>
+    inline void lazy_shared_ptr<T>::
+    reset (database_type& db, const std::tr1::shared_ptr<Y>& r)
+    {
+      p_ = r;
+
+      if (p_)
+        i_.reset (db);
+      else
+        i_.reset ();
+    }
+
+    template <class T>
+    template <class O>
+    inline typename object_traits<O>::id_type lazy_shared_ptr<T>::
+    object_id () const
+    {
+      typedef typename object_traits<T>::object_type object_type;
+
+      return p_ ? object_traits<object_type>::id (*p_) : i_.object_id<O> ();
+    }
+
+    template <class T>
+    inline typename lazy_shared_ptr<T>::database_type& lazy_shared_ptr<T>::
+    database () const
+    {
+      return *i_.database ();
+    }
+
+    template<class T, class Y>
+    inline bool
+    operator== (const lazy_shared_ptr<T>& a, const lazy_shared_ptr<Y>& b)
+    {
+      return a.equal (b);
+    }
+
+    template<class T, class Y>
+    inline bool
+    operator!= (const lazy_shared_ptr<T>& a, const lazy_shared_ptr<Y>& b)
+    {
+      return !a.equal (b);
+    }
+
+    template<class T>
+    inline void
+    swap (lazy_shared_ptr<T>& a, lazy_shared_ptr<T>& b)
+    {
+      a.swap (b);
+    }
+
+    template<class D, class T>
+    inline D*
+    get_deleter (const lazy_shared_ptr<T>& p)
+    {
+      return std::tr1::get_deleter<D> (p.p_);
+    }
+
+
+    //
+    // lazy_weak_ptr
+    //
+
+    template <class T>
+    inline lazy_weak_ptr<T>::
+    lazy_weak_ptr () {}
+
+    template <class T>
+    template <class Y>
+    inline lazy_weak_ptr<T>::
+    lazy_weak_ptr (const lazy_shared_ptr<Y>& r): p_ (r.p_), i_ (r.i_) {}
+
+    template <class T>
+    inline lazy_weak_ptr<T>::
+    lazy_weak_ptr (const lazy_weak_ptr& r): p_ (r.p_), i_ (r.i_) {}
+
+    template <class T>
+    template <class Y>
+    inline lazy_weak_ptr<T>::
+    lazy_weak_ptr (const lazy_weak_ptr<Y>& r): p_ (r.p_), i_ (r.i_) {}
+
+    template <class T>
+    inline lazy_weak_ptr<T>::
+    ~lazy_weak_ptr () {}
+
+    template <class T>
+    inline lazy_weak_ptr<T>& lazy_weak_ptr<T>::
+    operator= (const lazy_weak_ptr& r)
+    {
+      p_ = r.p_;
+      i_ = r.i_;
+      return *this;
+    }
+
+    template <class T>
+    template <class Y>
+    inline lazy_weak_ptr<T>& lazy_weak_ptr<T>::
+    operator= (const lazy_weak_ptr<Y>& r)
+    {
+      p_ = r.p_;
+      i_ = r.i_;
+      return *this;
+    }
+
+    template <class T>
+    template <class Y>
+    inline lazy_weak_ptr<T>& lazy_weak_ptr<T>::
+    operator= (const lazy_shared_ptr<Y>& r)
+    {
+      p_ = r.p_;
+      i_ = r.i_;
+      return *this;
+    }
+
+    template <class T>
+    inline void lazy_weak_ptr<T>::
+    swap (lazy_weak_ptr<T>& r)
+    {
+      p_.swap (r.p_);
+      i_.swap (r.i_);
+    }
+
+    template <class T>
+    inline void lazy_weak_ptr<T>::
+    reset ()
+    {
+      p_.reset ();
+      i_.reset ();
+    }
+
+    template <class T>
+    inline long lazy_weak_ptr<T>::
+    use_count () const
+    {
+      return p_.use_count ();
+    }
+
+    template <class T>
+    inline bool lazy_weak_ptr<T>::
+    expired () const
+    {
+      return p_.expired ();
+    }
+
+    template <class T>
+    template <class Y>
+    inline lazy_weak_ptr<T>::
+    lazy_weak_ptr (const std::tr1::weak_ptr<Y>& r): p_ (r) {}
+
+    template <class T>
+    template <class Y>
+    inline lazy_weak_ptr<T>::
+    lazy_weak_ptr (const std::tr1::shared_ptr<Y>& r): p_ (r) {}
+
+    template <class T>
+    template <class Y>
+    inline lazy_weak_ptr<T>& lazy_weak_ptr<T>::
+    operator= (const std::tr1::weak_ptr<Y>& r)
+    {
+      p_ = r;
+      i_.reset ();
+      return this;
+    }
+
+    template <class T>
+    template <class Y>
+    inline lazy_weak_ptr<T>& lazy_weak_ptr<T>::
+    operator= (const std::tr1::shared_ptr<Y>& r)
+    {
+      p_ = r;
+      i_.reset ();
+      return this;
+    }
+
+    template <class T>
+    inline bool lazy_weak_ptr<T>::
+    loaded () const
+    {
+      return !expired () || !i_;
+    }
+
+    template <class T>
+    inline std::tr1::shared_ptr<T> lazy_weak_ptr<T>::
+    load () const
+    {
+      std::tr1::shared_ptr<T> r (p_.lock ());
+
+      if (r || !i_)
+        return r;
+
+      r = i_.template load<T> (false); // Keep id.
+      p_ = r;
+      return r;
+    }
+
+    template <class T>
+    inline void lazy_weak_ptr<T>::
+    unload () const
+    {
+      // With weak pointer we always keep i_ up to date.
+      //
+      p_.reset ();
+    }
+
+    template <class T>
+    template <class ID>
+    inline lazy_weak_ptr<T>::
+    lazy_weak_ptr (database_type& db, const ID& id): i_ (db, id) {}
+
+    template <class T>
+    template <class Y>
+    inline lazy_weak_ptr<T>::
+    lazy_weak_ptr (database_type& db, const std::tr1::shared_ptr<Y>& r)
+        : p_ (r)
+    {
+      typedef typename object_traits<T>::object_type object_type;
+
+      if (r)
+        i_.reset (db, object_traits<object_type>::id (*r));
+    }
+
+    template <class T>
+    template <class Y>
+    inline lazy_weak_ptr<T>::
+    lazy_weak_ptr (database_type& db, const std::tr1::weak_ptr<Y>& r)
+        : p_ (r)
+    {
+      typedef typename object_traits<T>::object_type object_type;
+
+      std::tr1::shared_ptr<T> sp (p_.lock ());
+
+      if (sp)
+        i_.reset (db, object_traits<object_type>::id (*sp));
+    }
+
+    template <class T>
+    template <class ID>
+    inline void lazy_weak_ptr<T>::
+    reset (database_type& db, const ID& id)
+    {
+      p_.reset ();
+      i_.reset (db, id);
+    }
+
+    template <class T>
+    template <class Y>
+    inline void lazy_weak_ptr<T>::
+    reset (database_type& db, const std::tr1::shared_ptr<Y>& r)
+    {
+      typedef typename object_traits<T>::object_type object_type;
+
+      p_ = r;
+
+      if (r)
+        i_.reset (db, object_traits<object_type>::id (*r));
+      else
+        i_.reset ();
+    }
+
+    template <class T>
+    template <class Y>
+    inline void lazy_weak_ptr<T>::
+    reset (database_type& db, const std::tr1::weak_ptr<Y>& r)
+    {
+      typedef typename object_traits<T>::object_type object_type;
+
+      p_ = r;
+      std::tr1::shared_ptr<T> sp (p_.lock ());
+
+      if (sp)
+        i_.reset (db, object_traits<object_type>::id (*sp));
+      else
+        i_.reset ();
+    }
+
+    template <class T>
+    template <class O>
+    inline typename object_traits<O>::id_type lazy_weak_ptr<T>::
+    object_id () const
+    {
+      typedef typename object_traits<T>::object_type object_type;
+
+      std::tr1::shared_ptr<T> sp (p_.lock ());
+      return sp ? object_traits<object_type>::id (*sp) : i_.object_id<O> ();
+    }
+
+    template <class T>
+    inline typename lazy_weak_ptr<T>::database_type& lazy_weak_ptr<T>::
+    database () const
+    {
+      return *i_.database ();
+    }
+
+    template<class T>
+    inline void
+    swap (lazy_weak_ptr<T>& a, lazy_weak_ptr<T>& b)
+    {
+      a.swap (b);
+    }
+  }
+}
diff --git a/odb/tr1/lazy-ptr.txx b/odb/tr1/lazy-ptr.txx
new file mode 100644
index 0000000..b7b5bc5
--- /dev/null
+++ b/odb/tr1/lazy-ptr.txx
@@ -0,0 +1,59 @@
+// file      : odb/tr1/lazy-ptr.txx
+// author    : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2009-2010 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+namespace odb
+{
+  namespace tr1
+  {
+    //
+    // lazy_shared_ptr
+    //
+
+    template <class T>
+    template <class Y>
+    bool lazy_shared_ptr<T>::
+    equal (const lazy_shared_ptr<Y>& r) const
+    {
+      if (loaded () && r.loaded ())
+        return p_ == r.p_;
+
+      // If one of the object is not loaded, then we compare databases and
+      // object ids. Note that NULL pointers cannot have non-NULL databases
+      // and if both of them are NULL, we wouldn't have gotten here.
+      //
+      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.object_id<object_type2> ();
+    }
+
+    //
+    // lazy_weak_ptr
+    //
+
+    template <class T>
+    lazy_shared_ptr<T> lazy_weak_ptr<T>::
+    lock () const
+    {
+      std::tr1::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_.object_id<T> ());
+        else
+          return lazy_shared_ptr<T> ();
+      }
+    }
+  }
+}
-- 
cgit v1.1