From 9ac9bb98f307156c02fa19ea747cf5eb1d2dcadf Mon Sep 17 00:00:00 2001 From: Boris Kolpackov Date: Thu, 4 Aug 2011 13:29:42 +0200 Subject: 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. --- odb/details/wrapper-p.hxx | 40 +++++++++ odb/nullable.hxx | 199 +++++++++++++++++++++++++++++++++++++++++++++ odb/tr1/wrapper-traits.hxx | 63 ++++++++++++++ odb/wrapper-traits.hxx | 153 ++++++++++++++++++++++++++++++++++ 4 files changed, 455 insertions(+) create mode 100644 odb/details/wrapper-p.hxx create mode 100644 odb/nullable.hxx create mode 100644 odb/tr1/wrapper-traits.hxx create mode 100644 odb/wrapper-traits.hxx 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 +// 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 + +#include + +#include + +namespace odb +{ + namespace details + { + // GCC doesn't like these to be inside wrapper_p. + // + template + meta::no + wrapper_p_test (...); + + template + meta::yes + wrapper_p_test (typename wrapper_traits::wrapped_type*); + + template + struct wrapper_p + { + static const bool r = + sizeof (wrapper_p_test (0)) == sizeof (meta::yes); + }; + } +} + +#include + +#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 +// 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 + +namespace odb +{ + template + class nullable + { + public: + typedef T value_type; + + nullable (); + nullable (const T&); + nullable (const nullable&); + template explicit nullable (const nullable&); + + nullable& operator= (const T&); + nullable& operator= (const nullable&); + template nullable& operator= (const nullable&); + + 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::true_value; + } + + void reset (); + + private: + void true_value () {}; + + T value_; + bool null_; + }; + + namespace core + { + using odb::nullable; + } + + template + inline nullable:: + nullable () + : null_ (true) + { + } + + template + inline nullable:: + nullable (const T& v) + : value_ (v), null_ (false) + { + } + + template + inline nullable:: + nullable (const nullable& y) + : value_ (y.value_), null_ (y.null_) + { + } + + template + template + inline nullable:: + nullable (const nullable& y) + : value_ (y.value_), null_ (y.null_) + { + } + + template + inline nullable& nullable:: + operator= (const T& v) + { + value_ = v; + null_ = false; + return *this; + } + + template + inline nullable& nullable:: + operator= (const nullable& y) + { + if (this != &y) + { + if (!y.null_) + value_ = y.value_; + + null_ = y.null_; + } + + return *this; + } + + template + template + inline nullable& nullable:: + operator= (const nullable& y) + { + if (!y.null_) + value_ = y.value_; + + null_ = y.null_; + return *this; + } + + template + inline void nullable:: + swap (nullable& y) + { + T v (value_); + bool n (null_); + + value_ = y.value_; + null_ = y.null_; + + y.value_ = v; + y.null_ = n; + } + + template + inline bool nullable:: + null () const + { + return null_; + } + + template + inline T& nullable:: + get () + { + return value_; + } + + template + inline const T& nullable:: + get () const + { + return value_; + } + + template + inline T* nullable:: + operator-> () + { + return null_ ? 0 : &value_; + } + + template + inline const T* nullable:: + operator-> () const + { + return null_ ? 0 : &value_; + } + + template + inline T& nullable:: + operator* () + { + return value_; + } + + template + inline const T& nullable:: + operator* () const + { + return value_; + } + + template + inline void nullable:: + reset () + { + null_ = true; + } +} + +#include + +#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 +// 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 + +// +// This header assumes that the necessary TR1 header has already +// been included. +// + +#include + +namespace odb +{ + // Specialization for std::tr1::shared_ptr. + // + template + class wrapper_traits< std::tr1::shared_ptr > + { + public: + typedef T wrapped_type; + typedef std::tr1::shared_ptr 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 + +#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 +// 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 + +#include // std::auto_ptr + +#include + +namespace odb +{ + template + 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 + class wrapper_traits + { + 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 + class wrapper_traits< std::auto_ptr > + { + public: + typedef T wrapped_type; + typedef std::auto_ptr 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 + class wrapper_traits< nullable > + { + public: + typedef T wrapped_type; + typedef nullable 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 + +#endif // ODB_WRAPPER_TRAITS_HXX -- cgit v1.1