aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--odb/details/wrapper-p.hxx40
-rw-r--r--odb/nullable.hxx199
-rw-r--r--odb/tr1/wrapper-traits.hxx63
-rw-r--r--odb/wrapper-traits.hxx153
4 files changed, 455 insertions, 0 deletions
diff --git a/odb/details/wrapper-p.hxx b/odb/details/wrapper-p.hxx
new file mode 100644
index 0000000..7736fc9
--- /dev/null
+++ b/odb/details/wrapper-p.hxx
@@ -0,0 +1,40 @@
+// file : odb/details/wrapper-p.hxx
+// author : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC
+// license : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_DETAILS_WRAPPER_P_HXX
+#define ODB_DETAILS_WRAPPER_P_HXX
+
+#include <odb/pre.hxx>
+
+#include <odb/wrapper-traits.hxx>
+
+#include <odb/details/meta/answer.hxx>
+
+namespace odb
+{
+ namespace details
+ {
+ // GCC doesn't like these to be inside wrapper_p.
+ //
+ template <typename T>
+ meta::no
+ wrapper_p_test (...);
+
+ template <typename T>
+ meta::yes
+ wrapper_p_test (typename wrapper_traits<T>::wrapped_type*);
+
+ template <typename T>
+ struct wrapper_p
+ {
+ static const bool r =
+ sizeof (wrapper_p_test<T> (0)) == sizeof (meta::yes);
+ };
+ }
+}
+
+#include <odb/post.hxx>
+
+#endif // ODB_DETAILS_WRAPPER_P_HXX
diff --git a/odb/nullable.hxx b/odb/nullable.hxx
new file mode 100644
index 0000000..4b33564
--- /dev/null
+++ b/odb/nullable.hxx
@@ -0,0 +1,199 @@
+// file : odb/nullable.hxx
+// author : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC
+// license : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_NULLABLE_HXX
+#define ODB_NULLABLE_HXX
+
+#include <odb/pre.hxx>
+
+namespace odb
+{
+ template <typename T>
+ class nullable
+ {
+ public:
+ typedef T value_type;
+
+ nullable ();
+ nullable (const T&);
+ nullable (const nullable&);
+ template <typename Y> explicit nullable (const nullable<Y>&);
+
+ nullable& operator= (const T&);
+ nullable& operator= (const nullable&);
+ template <typename Y> nullable& operator= (const nullable<Y>&);
+
+ void swap (nullable&);
+
+ bool null () const;
+
+ T& get ();
+ const T& get () const;
+
+ T* operator-> ();
+ const T* operator-> () const;
+
+ T& operator* ();
+ const T& operator* () const;
+
+ typedef void (nullable::*bool_convertible) ();
+ operator bool_convertible () const
+ {
+ return null_ ? 0 : &nullable<T>::true_value;
+ }
+
+ void reset ();
+
+ private:
+ void true_value () {};
+
+ T value_;
+ bool null_;
+ };
+
+ namespace core
+ {
+ using odb::nullable;
+ }
+
+ template <typename T>
+ inline nullable<T>::
+ nullable ()
+ : null_ (true)
+ {
+ }
+
+ template <typename T>
+ inline nullable<T>::
+ nullable (const T& v)
+ : value_ (v), null_ (false)
+ {
+ }
+
+ template <typename T>
+ inline nullable<T>::
+ nullable (const nullable& y)
+ : value_ (y.value_), null_ (y.null_)
+ {
+ }
+
+ template <typename T>
+ template <typename Y>
+ inline nullable<T>::
+ nullable (const nullable<Y>& y)
+ : value_ (y.value_), null_ (y.null_)
+ {
+ }
+
+ template <typename T>
+ inline nullable<T>& nullable<T>::
+ operator= (const T& v)
+ {
+ value_ = v;
+ null_ = false;
+ return *this;
+ }
+
+ template <typename T>
+ inline nullable<T>& nullable<T>::
+ operator= (const nullable& y)
+ {
+ if (this != &y)
+ {
+ if (!y.null_)
+ value_ = y.value_;
+
+ null_ = y.null_;
+ }
+
+ return *this;
+ }
+
+ template <typename T>
+ template <typename Y>
+ inline nullable<T>& nullable<T>::
+ operator= (const nullable<Y>& y)
+ {
+ if (!y.null_)
+ value_ = y.value_;
+
+ null_ = y.null_;
+ return *this;
+ }
+
+ template <typename T>
+ inline void nullable<T>::
+ swap (nullable& y)
+ {
+ T v (value_);
+ bool n (null_);
+
+ value_ = y.value_;
+ null_ = y.null_;
+
+ y.value_ = v;
+ y.null_ = n;
+ }
+
+ template <typename T>
+ inline bool nullable<T>::
+ null () const
+ {
+ return null_;
+ }
+
+ template <typename T>
+ inline T& nullable<T>::
+ get ()
+ {
+ return value_;
+ }
+
+ template <typename T>
+ inline const T& nullable<T>::
+ get () const
+ {
+ return value_;
+ }
+
+ template <typename T>
+ inline T* nullable<T>::
+ operator-> ()
+ {
+ return null_ ? 0 : &value_;
+ }
+
+ template <typename T>
+ inline const T* nullable<T>::
+ operator-> () const
+ {
+ return null_ ? 0 : &value_;
+ }
+
+ template <typename T>
+ inline T& nullable<T>::
+ operator* ()
+ {
+ return value_;
+ }
+
+ template <typename T>
+ inline const T& nullable<T>::
+ operator* () const
+ {
+ return value_;
+ }
+
+ template <typename T>
+ inline void nullable<T>::
+ reset ()
+ {
+ null_ = true;
+ }
+}
+
+#include <odb/post.hxx>
+
+#endif // ODB_NULLABLE_HXX
diff --git a/odb/tr1/wrapper-traits.hxx b/odb/tr1/wrapper-traits.hxx
new file mode 100644
index 0000000..e65e2d7
--- /dev/null
+++ b/odb/tr1/wrapper-traits.hxx
@@ -0,0 +1,63 @@
+// file : odb/tr1/wrapper-traits.hxx
+// author : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC
+// license : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_TR1_WRAPPER_TRAITS_HXX
+#define ODB_TR1_WRAPPER_TRAITS_HXX
+
+#include <odb/pre.hxx>
+
+//
+// This header assumes that the necessary TR1 header has already
+// been included.
+//
+
+#include <odb/wrapper-traits.hxx>
+
+namespace odb
+{
+ // Specialization for std::tr1::shared_ptr.
+ //
+ template <typename T>
+ class wrapper_traits< std::tr1::shared_ptr<T> >
+ {
+ public:
+ typedef T wrapped_type;
+ typedef std::tr1::shared_ptr<T> wrapper_type;
+
+ static const bool null_handler = true;
+ static const bool null_default = false;
+
+ static bool
+ get_null (const wrapper_type& p)
+ {
+ return !p;
+ }
+
+ static void
+ set_null (wrapper_type& p)
+ {
+ p.reset ();
+ }
+
+ static const wrapped_type&
+ get_ref (const wrapper_type& p)
+ {
+ return *p;
+ }
+
+ static wrapped_type&
+ set_ref (wrapper_type& p)
+ {
+ if (!p)
+ p.reset (new wrapped_type);
+
+ return *p;
+ }
+ };
+}
+
+#include <odb/post.hxx>
+
+#endif // ODB_TR1_WRAPPER_TRAITS_HXX
diff --git a/odb/wrapper-traits.hxx b/odb/wrapper-traits.hxx
new file mode 100644
index 0000000..fdfb872
--- /dev/null
+++ b/odb/wrapper-traits.hxx
@@ -0,0 +1,153 @@
+// file : odb/wrapper-traits.hxx
+// author : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2009-2011 Code Synthesis Tools CC
+// license : GNU GPL v2; see accompanying LICENSE file
+
+#ifndef ODB_WRAPPER_TRAITS_HXX
+#define ODB_WRAPPER_TRAITS_HXX
+
+#include <odb/pre.hxx>
+
+#include <memory> // std::auto_ptr
+
+#include <odb/nullable.hxx>
+
+namespace odb
+{
+ template <typename T>
+ class wrapper_traits;
+
+ // Sample specialization for raw pointers. It is not enabled by default
+ // since it makes many assumptions that may not always hold true (such
+ // as that instances are allocated with new and freed with delete).
+ // This makes it too dangerous to be enable unconditionally. If you
+ // need this functionality, you can copy the below code into your
+ // application. Also consider changing it to only specialize for
+ // specific types instead of for any pointer (it will almost always
+ // do the wrong thing for char*).
+ //
+#if 0
+ template <typename T>
+ class wrapper_traits<T*>
+ {
+ public:
+ typedef T wrapped_type;
+ typedef T* wrapper_type;
+
+ static const bool null_handler = true;
+ static const bool null_default = false;
+
+ static bool
+ get_null (const wrapper_type& p)
+ {
+ return p == 0;
+ }
+
+ static void
+ set_null (wrapper_type& p)
+ {
+ delete p;
+ p = 0;
+ }
+
+ static const type&
+ get_ref (const wrapper_type& p)
+ {
+ return *p;
+ }
+
+ static type&
+ set_ref (wrapper_type& p)
+ {
+ if (p == 0)
+ p = new type;
+
+ return *p;
+ }
+ };
+#endif
+
+ // Specialization for std::auto_ptr.
+ //
+ template <typename T>
+ class wrapper_traits< std::auto_ptr<T> >
+ {
+ public:
+ typedef T wrapped_type;
+ typedef std::auto_ptr<T> wrapper_type;
+
+ static const bool null_handler = true;
+ static const bool null_default = false;
+
+ static bool
+ get_null (const wrapper_type& p)
+ {
+ return p.get () == 0;
+ }
+
+ static void
+ set_null (wrapper_type& p)
+ {
+ p.reset ();
+ }
+
+ static const wrapped_type&
+ get_ref (const wrapper_type& p)
+ {
+ return *p;
+ }
+
+ static wrapped_type&
+ set_ref (wrapper_type& p)
+ {
+ if (p.get () == 0)
+ p.reset (new wrapped_type);
+
+ return *p;
+ }
+ };
+
+ // Specialization for odb::nullable.
+ //
+ template <typename T>
+ class wrapper_traits< nullable<T> >
+ {
+ public:
+ typedef T wrapped_type;
+ typedef nullable<T> wrapper_type;
+
+ static const bool null_handler = true;
+ static const bool null_default = true;
+
+ static bool
+ get_null (const wrapper_type& n)
+ {
+ return n.null ();
+ }
+
+ static void
+ set_null (wrapper_type& n)
+ {
+ n.reset ();
+ }
+
+ static const wrapped_type&
+ get_ref (const wrapper_type& n)
+ {
+ return *n;
+ }
+
+ static wrapped_type&
+ set_ref (wrapper_type& n)
+ {
+ if (n.null ())
+ n = T ();
+
+ return *n;
+ }
+ };
+}
+
+#include <odb/post.hxx>
+
+#endif // ODB_WRAPPER_TRAITS_HXX
generated by cgit v1.1 at 2024-11-14 23:59:19 +0000