Add support for value wrappers

Wrapper is a class that wraps another type. Examples of wrappers are
various smart pointers, holders, etc. A wrapper can be transparent or
it can handle the NULL semantics.

The new odb::nullable class template is a NULL wrapper that helps
to add the NULL semantics to a value type.

New test: common/wrapper.

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