Subject: [Boost-commit] svn:boost r54598 - sandbox/cloneable/boost/cloneable/detail
From: christian.schladetsch_at_[hidden]
Date: 2009-07-02 18:22:32
Author: cschladetsch
Date: 2009-07-02 18:22:32 EDT (Thu, 02 Jul 2009)
New Revision: 54598
URL: http://svn.boost.org/trac/boost/changeset/54598
Log:
renamed to instance
Text files modified:
sandbox/cloneable/boost/cloneable/detail/pointer.hpp | 110 ++++++++++++++++++++++++++-------------
1 files changed, 72 insertions(+), 38 deletions(-)
Modified: sandbox/cloneable/boost/cloneable/detail/pointer.hpp
==============================================================================
--- sandbox/cloneable/boost/cloneable/detail/pointer.hpp (original)
+++ sandbox/cloneable/boost/cloneable/detail/pointer.hpp 2009-07-02 18:22:32 EDT (Thu, 02 Jul 2009)
@@ -8,51 +8,85 @@
#include <boost/cloneable/detail/prefix.hpp>
#include <boost/cloneable/base.hpp>
+#include <boost/cloneable/allocator.hpp>
namespace boost
{
namespace cloneable
{
- namespace detail
+ /// a pointer store that can retrieve pointers from up and down
+ /// the inheritance tree. stores the allocator that made it.
+ template <class U, class B, class Alloc>
+ struct instance
{
- /// a pointer store that can retrieve pointers from up and down
- /// the inheritance tree.
- template <class U, class B>
- struct pointer
- {
- typedef U derived_type;
- typedef B base_type;
- typedef base<derived_type, base_type> cloneable_type;
- typedef typename cloneable_type::abstract_base_type abstract_base_type;
-
- private:
- cloneable_type *ptr;
-
- public:
- pointer(derived_type *p = 0) : ptr(dynamic_cast<cloneable_type *>(p))
- {
- }
- abstract_base_type *to_abstract() const
- {
- return ptr;
- }
- base_type *to_base() const
- {
- return ptr;
- }
- cloneable_type *to_cloneable() const
- {
- return ptr;
- }
- derived_type *to_derived() const
- {
- if (!ptr)
- return 0;
- return ptr->cloneable_type::self_ptr;
- }
- };
+ typedef U derived_type;
+ typedef B base_type;
+ typedef Alloc allocator_type;
+ typedef base<derived_type, base_type> cloneable_type;
+ typedef typename cloneable_type::abstract_base_type abstract_base_type;
+
+ private:
+ cloneable_type *ptr;
+ allocator_type *alloc;
- } // namespace detail
+ public:
+ instance() : ptr(0), alloc(0) { }
+
+ instance(allocator_type &al) : ptr(0), alloc(&al)
+ {
+ allocate();
+ }
+ template <class A0>
+ instance(allocator_type &al, A0 a0) : ptr(0), alloc(&al)
+ {
+ allocate();
+ new (to_derived()) U(a0);
+ }
+ template <class A0, class A1>
+ instance(allocator_type &al, A0 a0, A1 a1) : ptr(0), alloc(&al)
+ {
+ allocate();
+ new (to_derived()) U(a0, a1);
+ }
+ template <class A0, class A1, class A2>
+ instance(allocator_type &al, A0 a0, A1 a1, A2 a2) : ptr(0), alloc(&al)
+ {
+ allocate();
+ new (to_derived()) U(a0, a1);
+ }
+
+ void allocate()
+ {
+ if (!alloc)
+ return;
+ ptr = cloneable::allocate<U>(*alloc);
+ }
+ void release()
+ {
+ if (!alloc)
+ return;
+ cloneable::release(ptr, *alloc);
+ ptr = 0;
+ }
+ abstract_base_type *to_abstract() const
+ {
+ return ptr;
+ }
+ base_type *to_base() const
+ {
+ return ptr;
+ }
+ cloneable_type *to_cloneable() const
+ {
+ return ptr;
+ }
+ derived_type *to_derived() const
+ {
+ if (!ptr)
+ return 0;
+ return ptr->cloneable_type::self_ptr;
+ }
+ };
} // namespace cloneable