From b9d18e76f95a9a231cc4a8a9aea5bf1bad942c9a Mon Sep 17 00:00:00 2001
From: Boris Kolpackov <boris@codesynthesis.com>
Date: Thu, 22 Sep 2011 11:02:08 +0200
Subject: Make common result implementation instead of separate for views and
 objects

---
 odb/result.hxx | 170 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 167 insertions(+), 3 deletions(-)

(limited to 'odb/result.hxx')

diff --git a/odb/result.hxx b/odb/result.hxx
index a997615..1d4a199 100644
--- a/odb/result.hxx
+++ b/odb/result.hxx
@@ -8,19 +8,183 @@
 
 #include <odb/pre.hxx>
 
+#include <cstddef>  // std::ptrdiff_t, std::size_t
+
 #include <odb/forward.hxx> // result
 #include <odb/traits.hxx>
 
 namespace odb
 {
-  template <typename T, class_kind kind = class_traits<T>::kind>
-  class result;
+  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;
 
+  // Input iterator requirements.
+  //
   template <typename T, class_kind kind>
-  class result_impl;
+  inline bool
+  operator== (result_iterator<T, kind> i, result_iterator<T, kind> j)
+  {
+    return i.equal (j);
+  }
+
+  template <typename T, class_kind kind>
+  inline bool
+  operator!= (result_iterator<T, kind> i, result_iterator<T, kind> j)
+  {
+    return !i.equal (j);
+  }
+
+  template <typename T>
+  class result: result_base<T, class_traits<T>::kind>
+  {
+  public:
+    static const class_kind kind = class_traits<T>::kind;
+
+    typedef result_base<T, kind> base;
+
+    typedef typename base::value_type value_type;
+    typedef value_type*               pointer;
+    typedef const value_type*         const_pointer;
+    typedef value_type&               reference;
+    typedef const value_type&         const_reference;
+
+    typedef result_iterator<T, kind>  iterator;
+
+    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:
+    result ()
+    {
+    }
+
+    explicit
+    result (details::shared_ptr<result_impl_type> impl)
+        : impl_ (impl)
+    {
+    }
+
+    // Copying or assignment of a result instance leads to one instance
+    // being an alias for another. Think of copying a result as copying
+    // a file handle -- the file you access through either of them is
+    // still the same.
+    //
+  public:
+    result (const result& r)
+        : impl_ (r.impl_)
+    {
+    }
+
+    result&
+    operator= (const result& r)
+    {
+      if (impl_ != r.impl_)
+        impl_ = r.impl_;
+
+      return *this;
+    }
+
+    // Conversion from result<T> to result<const T>.
+    //
+    template <typename UT>
+    result (const result<UT>& r)
+        //
+        // If you get a compiler error pointing to the line below saying
+        // that the impl_ member is inaccessible, then you are most likely
+        // trying to perform an illegal result conversion, for example,
+        // from result<const obj> to result<obj>.
+        //
+        : impl_ (r.impl_)
+    {
+    }
+
+    template <typename UT>
+    result&
+    operator= (const result<UT>& r)
+    {
+      // If you get a compiler error pointing to the line below saying
+      // that the impl_ member is inaccessible, then you are most likely
+      // trying to perform an illegal result conversion, for example,
+      // from result<const obj> to result<obj>.
+      //
+      if (impl_ != r.impl_)
+        impl_ = r.impl_;
+
+      return *this;
+    }
+
+    void
+    swap (result& r)
+    {
+      // @@ add swap() to shared_ptr.
+      //
+      details::shared_ptr<result_impl_type> p (impl_);
+      impl_ = r.impl_;
+      r.impl_ = p;
+    }
+
+  public:
+    iterator
+    begin ()
+    {
+      if (impl_)
+        impl_->begin ();
+
+      return iterator (impl_.get ());
+    }
+
+    iterator
+    end ()
+    {
+      return iterator ();
+    }
+
+    // Cache the result instead of fetching the data from the database
+    // one row at a time. This is necessary if you plan on performing
+    // database operations while iterating over the result.
+    //
+  public:
+    void
+    cache ()
+    {
+      if (impl_)
+        impl_->cache ();
+    }
+
+  public:
+    bool
+    empty () const
+    {
+      if (impl_ == 0)
+        return true;
+
+      impl_->begin ();
+      return impl_->end ();
+    }
+
+    // Size is only known in cached results.
+    //
+    size_type
+    size () const
+    {
+      return impl_ ? impl_->size () : 0;
+    }
+
+  private:
+    friend class result<const T>;
+
+    details::shared_ptr<result_impl_type> impl_;
+  };
 
   namespace core
   {
-- 
cgit v1.1