From 1896d36996ab48ed7271e855d7e32b4e61f64896 Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Mon, 23 Apr 2012 16:48:00 +0200
Subject: Polymorphic inheritance support

---
 odb/no-id-object-result.hxx | 191 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 191 insertions(+)
 create mode 100644 odb/no-id-object-result.hxx

(limited to 'odb/no-id-object-result.hxx')

diff --git a/odb/no-id-object-result.hxx b/odb/no-id-object-result.hxx
new file mode 100644
index 0000000..8893e7a
--- /dev/null
+++ b/odb/no-id-object-result.hxx
@@ -0,0 +1,191 @@
+// file      : odb/no-id-object-result.hxx
+// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+// license   : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_NO_ID_OBJECT_RESULT_HXX
+#define ODB_NO_ID_OBJECT_RESULT_HXX
+
+#include <odb/pre.hxx>
+
+#include <cstddef>  // std::size_t
+#include <utility>  // std::move
+
+#include <odb/forward.hxx>
+#include <odb/traits.hxx>
+#include <odb/result.hxx>
+#include <odb/object-result.hxx>
+#include <odb/pointer-traits.hxx>
+
+#include <odb/details/config.hxx>     // ODB_CXX11
+#include <odb/details/shared-ptr.hxx>
+
+namespace odb
+{
+  // Implementation for objects without object id (always non-polymorphic).
+  //
+  template <typename T>
+  class no_id_object_result_impl: public details::shared_base
+  {
+  public:
+    virtual
+    ~no_id_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::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, void, false>;
+    friend class object_result_iterator<const T, void, false>;
+
+  protected:
+    no_id_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 ()
+    {
+      if (pointer_traits::null_ptr (current_) && !end_)
+        load ();
+
+      return 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 void
+    next () = 0;
+
+    virtual void
+    cache () = 0;
+
+    virtual std::size_t
+    size () = 0;
+
+  protected:
+#ifdef ODB_CXX11
+    void
+    current (pointer_type& p)
+    {
+      current_ = std::move (p);
+      guard_.reset (current_);
+    }
+
+    void
+    current (pointer_type&& p)
+    {
+      current (p);
+    }
+#else
+    void
+    current (pointer_type p)
+    {
+      current_ = p;
+      guard_.reset (current_);
+    }
+#endif
+
+    bool begin_;
+    bool end_;
+
+  private:
+    void
+    load ();
+
+  private:
+    database_type& db_;
+    pointer_type current_;
+    typename pointer_traits::guard guard_;
+  };
+
+  template <typename T>
+  class object_result_iterator<T, void, false>
+  {
+  public:
+    // T can be const T while object_type is always non-const.
+    //
+    typedef typename object_traits<T>::object_type object_type;
+
+    typedef no_id_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& obj)
+    {
+      // Objects without ids are not stored in session cache.
+      //
+      if (!res_->end ())
+        res_->load (obj);
+    }
+
+  protected:
+    result_impl_type* res_;
+  };
+}
+
+#include <odb/no-id-object-result.txx>
+
+#include <odb/post.hxx>
+
+#endif // ODB_NO_ID_OBJECT_RESULT_HXX
-- 
cgit v1.1