aboutsummaryrefslogtreecommitdiff
path: root/odb/result.hxx
diff options
context:
space:
mode:
Diffstat (limited to 'odb/result.hxx')
-rw-r--r--odb/result.hxx170
1 files changed, 167 insertions, 3 deletions
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
{