Changeset 54666


Ignore:
Timestamp:
Jul 5, 2009, 8:31:59 AM (9 years ago)
Author:
cschladetsch
Message:

about to refactor instance<>

Location:
sandbox/cloneable
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • sandbox/cloneable/boost/cloneable/base.hpp

    r54665 r54666  
    3131                                typedef Derived derived_type;
    3232                                typedef Base base_type;
    33                                 typedef DefaultCtorTag default_constructable_type;
     33                                typedef DefaultCtorTag default_constructable_type, construction_tag_type;
    3434                                typedef base<derived_type, base_type, default_constructable_type> this_type;
    3535
    3636                                virtual this_type *create_new(abstract_allocator &alloc) const
    3737                                {
     38                                        // TODO: deal with conversion from bases with unknown_construction_tag
    3839                                        return detail::create_new<Derived, DefaultCtorTag>::given(this, alloc, alignment);
    3940                                }
     
    5253                                struct get_default_construction_tag : if_<is_nil<T>, default_construction_tag, T> { };
    5354
    54                                 typedef is_convertible<A *, detail::ctag *> a_is_tag;
    55                                 typedef is_convertible<B *, detail::ctag *> b_is_tag;
     55                                typedef is_convertible<A *, detail::tag *> a_is_tag;
     56                                typedef is_convertible<B *, detail::tag *> b_is_tag;
    5657
    5758                                typedef typename if_<
  • sandbox/cloneable/boost/cloneable/detail/create_new.hpp

    r54665 r54666  
    3838                                }
    3939                        };
     40                       
     41                        // TODO: deal with conversion from bases with unknown_construction_tag
    4042
     43                        template <class Derived>
     44                        struct create_new<Derived, unknown_construction_tag>
     45                        {
     46                                template <class Self, class Alloc>
     47                                static Derived *given(Self *self, Alloc &alloc, size_t alignment)
     48                                {
     49                                        abstract_allocator::pointer bytes = alloc.allocate_bytes(sizeof(Derived), alignment);
     50                                        Derived *ptr = reinterpret_cast<Derived *>(bytes);
     51                                        ptr->Self::self_ptr = ptr;
     52                                        new (ptr->Self::self_ptr) Derived(Derived());
     53                                        return ptr;
     54                                }
     55                        };
    4156                } // namespace detail
    4257
  • sandbox/cloneable/boost/cloneable/detail/make_clone_allocator.hpp

    r54547 r54666  
    9292                using detail::make_clone_allocator;
    9393
     94                typedef make_clone_allocator<default_allocator> default_clone_allocator;
     95
    9496        } // namespace cloneable
    9597
  • sandbox/cloneable/boost/cloneable/forward_declarations.hpp

    r54665 r54666  
    3030                struct base_type;
    3131
    32                 namespace detail { struct ctag { }; }
     32                typedef base_type default_base_type;
     33
     34                namespace detail
     35                {
     36                        struct tag { };
     37
     38                        template <size_t N>
     39                        struct bit_tag : tag
     40                        {
     41                                BOOST_STATIC_CONSTANT(size_t, bit = (1<<N));
     42                        };
     43                }
     44
     45                struct any_derived_tag : detail::bit_tag<0> { };
     46                struct any_base_tag : detail::bit_tag<1> { };
    3347
    3448                /// {@ tags to inform about default-constructability
    35                 struct default_construction_tag : detail::ctag, mpl::true_ {};
    36                 struct no_default_construction_tag : detail::ctag, mpl::false_ {};
    37                 struct unknown_construction_tag : detail::ctag {};
     49                struct default_construction_tag : detail::bit_tag<2> {};
     50                struct no_default_construction_tag : detail::bit_tag<3> {};
     51                struct unknown_construction_tag : detail::bit_tag<4> {};
    3852                /// @}
    3953
     
    5771                >
    5872                struct base;
     73
     74                template <
     75                        class Derived = any_derived_tag
     76                        , class Base = typename Derived::base_type
     77                        , class Alloc = default_allocator
     78                        , class Ctor = typename Derived::construction_tag_type
     79                >
     80                struct instance;
     81
    5982
    6083                /// an adaptor for an existing class.
  • sandbox/cloneable/boost/cloneable/instance.hpp

    r54665 r54666  
    2727
    2828                public:
    29                         instance_base(allocator_type *al = 0) : alloc(al) { }
     29                        instance_base(allocator_type *al = 0)
     30                                : alloc(al) { }
    3031
    3132                        bool has_allocator() const
     
    6364                        typedef Derived derived_type;
    6465                        typedef detail::mixin<derived_type, base_type> is_derived_type;
     66                        typedef instance_common<Abstract, Derived, Base, Alloc> this_type;
    6567
    6668                protected:
     
    7072                        instance_common(derived_type *p = 0) : ptr(p) { }
    7173                        instance_common(allocator_type &a, derived_type *p = 0) : parent_type(&a), ptr(p) { }
     74
     75                        this_type clone() const
     76                        {
     77                                if (empty())
     78                                        return this_type(get_allocator());
     79                                return this_type(get_allocator(), to_abstract()->clone_as<derived_type>(get_allocator()));
     80                        }
     81
     82                        template <class Ty>
     83                        instance_common<base<Ty,Base, unknown_construction_tag>, Derived, Base, Alloc> clone() const
     84                        {
     85                                typedef instance_common<base<Ty,Base, unknown_construction_tag>, Derived, Base, Alloc> that_type;
     86                                if (empty())
     87                                        return that_type(get_allocator());
     88                                return that_type(get_allocator(), to_abstract()->clone_as<Ty>(get_allocator()));
     89                        }
    7290
    7391                        void allocate()
     
    88106                                ptr = 0;
    89107                        }
     108                        template <class A0>
     109                        void construct(A0 a0)
     110                        {
     111                                allocate();
     112                                new (to_derived()) derived_type(a0);
     113                        }
     114                        template <class A0, class A1>
     115                        void construct(A0 a0, A1 a1)
     116                        {
     117                                allocate();
     118                                new (to_derived()) derived_type(a0, a1);
     119                        }
     120                        template <class A0, class A1, class A2>
     121                        void construct(A0 a0, A1 a1, A2 a2)
     122                        {
     123                                allocate();
     124                                new (to_derived()) derived_type(a0, a1, a2);
     125                        }
    90126
    91127                        const std::type_info &get_type() const
     
    93129                                return typeid(derived_type);
    94130                        }
     131
    95132                        bool exists() const
    96133                        {
     
    98135                        }
    99136
     137                        bool empty() const
     138                        {
     139                                return ptr == 0;
     140                        }
     141
    100142                        base_type *to_base() const
    101143                        {
     
    108150                        derived_type *to_derived() const
    109151                        {
    110                                 if (!ptr)
    111                                         return 0;
    112                                 return ptr;//->is_derived_type::self_ptr;
     152                                return ptr;
    113153                        }
    114154
     
    135175                struct instance : instance_common<base<Derived,Base,Ctor>, Derived, Base, Alloc>
    136176                {
    137                         typedef base<Derived,Base,Ctor> abstract_type;
     177                        typedef abstract_base<Base> abstract_base_type;
     178                        typedef base<Derived,Base,Ctor> base_type;
    138179                        typedef instance_common<abstract_type, Derived, Base, Alloc> parent_type;
     180                        typedef instance<Derived, Base, Alloc, Ctor> this_type;
    139181
    140182                public:
    141183                        instance() { }
     184
     185                        instance(allocator_type &al)
     186                                : parent_type(al
     187                                        , detail::create_new<Derived, Ctor>::given(to_abstract(), al, abstract_type::alignment))
     188                        {
     189                        }
    142190
    143191                        template <class Other, class Ctor2>
     
    148196                                        parent_type::set_allocator(other.get_allocator());
    149197                        }
    150                         instance(allocator_type &al)
    151                                 : parent_type(al
    152                                         , detail::create_new<Derived, Ctor>::given(to_abstract(), al, abstract_type::alignment))
     198
     199                        instance(base_type *ptr)
     200                                : parent_type(dynamic_cast<derived_type *>(ptr))
     201                        {
     202                        }
     203                        instance(abstract_base_type *ptr)
     204                                : parent_type(dynamic_cast<derived_type *>(ptr))
     205                        {
     206                        }
     207                        instance(abstract_base_type *abst, allocator_type &al)
     208                                : parent_type(al, dynamic_cast<derived_type *>(abst))
    153209                        {
    154210                        }
     
    171227                                new (to_derived()) derived_type(a0, a1, a2);
    172228                        }
    173 
     229                        this_type clone() const
     230                        {
     231                                if (empty())
     232                                        return this_type(get_allocator());
     233                                return this_type(get_allocator(), to_abstract()->clone_as<derived_type>(get_allocator()));
     234                        }
    174235                };
    175236
  • sandbox/cloneable/libs/cloneable/test/tests.cpp

    r54665 r54666  
    472472};
    473473
     474BOOST_AUTO_TEST_CASE(test_instance)
     475{
     476        //make_clone_allocator<std::allocator<char> > alloc;
     477        //instance<T2> ins(alloc, 3.14f, 42, "spam");
     478        //instance<T2> copy = ins.clone();
     479        //BOOST_ASSERT(ins.exists() && ins->str == "spam");
     480        //BOOST_ASSERT(copy.exists() && copy->str == "spam");
     481}
     482
    474483BOOST_AUTO_TEST_CASE(test_vector)
    475484{
Note: See TracChangeset for help on using the changeset viewer.