Changeset 54665


Ignore:
Timestamp:
Jul 5, 2009, 6:32:27 AM (9 years ago)
Author:
cschladetsch
Message:

added cloneable/exception.hpp
added cloneable/heterogenous_map.hpp (TODO: rename to iso_map)

Location:
sandbox/cloneable
Files:
2 added
14 edited

Legend:

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

    r54601 r54665  
    1414        namespace cloneable
    1515        {
     16                namespace impl
     17                {
     18                        template <bool is_class>
     19                        struct allocator
     20                        {
     21                                template <class Object, class Alloc>
     22                                static Object *allocate_clone(const Object &orig, Alloc &alloc)
     23                                {
     24                                        typename Alloc::template rebind<Object>::other al(alloc);
     25                                        ptr *clone = al.allocate(1);
     26                                        new (clone) (orig);
     27                                        return clone;
     28                                }
     29                                template <class Object, class Alloc>
     30                                static void deallocate_clone(const Object *ptr, Alloc &alloc)
     31                                {
     32                                        if (!ptr)
     33                                                return;
     34                                        typename Alloc::template rebind<Object>::other al(alloc);
     35                                        al.deallocate(const_cast<Object *>(ptr), 1);
     36                                }
     37                        };
     38                        template <>
     39                        struct allocator<true>
     40                        {
     41                                template <class Object, class Alloc>
     42                                static Object *allocate_clone(const Object &orig, Alloc &alloc)
     43                                {
     44                                        return orig.clone(alloc);
     45                                }
     46
     47                                template <class Object, class Alloc>
     48                                static void deallocate_clone(const Object *ptr, Alloc &alloc)
     49                                {
     50                                        const_cast<Object *>(ptr)->deallocate(alloc);
     51                                }
     52                        };
     53                }
     54
    1655                /// a cloning allocator
    1756                struct allocator
    1857                {
    1958                        template <class Base>
    20                         static Base* allocate_clone( const Base& object )
     59                        static Base* allocate_clone(const Base& orig)
    2160                        {
    22                                 // use default allocator
    23                                 return object.clone();
     61                                make_clone_allocator<default_allocator> alloc;
     62                                return impl::allocator<boost::is_class<Base>::value>::allocate_clone(orig, alloc);
    2463                        }
    2564
    2665                        template <class Base>
    27                         static void deallocate_clone( const Base* clone )
     66                        static void deallocate_clone(const Base* clone)
    2867                        {
    29                                 if (!object)
     68                                if (!clone)
    3069                                        return;
    31                                 // use default allocator
    32                                 return const_cast<Base *>(object->deallocate());
     70                                impl::allocator<boost::is_class<Base>::value>::deallocate_clone(clone, alloc);
    3371                        }
    3472
     
    3674                        static Base* allocate_clone(const Base& object, Alloc &alloc )
    3775                        {
    38                                 return object.clone(alloc);
     76                                return impl::allocator<boost::is_class<Base>::value>::allocate_clone(object, alloc);
    3977                        }
    4078
     
    4280                        static void deallocate_clone(const Base *object, Alloc &alloc )
    4381                        {
    44                                 if (!object)
    45                                         return;
    46                                 const_cast<Base &>(*object).deallocate(alloc);
     82                                impl::allocator<boost::is_class<Base>::value>::deallocate_clone(object, alloc);
    4783                        }
    4884                };
  • sandbox/cloneable/boost/cloneable/base.hpp

    r54656 r54665  
    5050
    5151                                template <class T>
    52                                 struct get_default_construction_tag : if_<is_nil<T>, default_construction, T> { };
     52                                struct get_default_construction_tag : if_<is_nil<T>, default_construction_tag, T> { };
    5353
    5454                                typedef is_convertible<A *, detail::ctag *> a_is_tag;
  • sandbox/cloneable/boost/cloneable/clone.hpp

    r54656 r54665  
    141141                }
    142142
    143                 /// TODO: add to cloneable/exceptions.hpp
    144                 struct not_cloneable { };
    145 
    146143                template <class Base>
    147144                Base *create_new(const Base &base)
  • sandbox/cloneable/boost/cloneable/detail/associative_container_base.hpp

    r54622 r54665  
    6969                                {
    7070                                }
     71                                template <class II>
     72                                associative_container_base(II F, II L, predicate_type pred = predicate_type())
     73                                        : predicate(pred), container(F,L)
     74                                {
     75                                }
     76
     77                                template <class II>
     78                                associative_container_base(II F, II L, allocator_type &a)
     79                                        : parent_type(a), container(F,L)
     80                                {
     81                                }
     82                                template <class II>
     83                                associative_container_base(II F, II L, predicate_type pred, allocator_type &a)
     84                                        : parent_type(a), predicate(pred), container(F,L)
     85                                {
     86                                }
    7187
    7288                                size_t size() const
     
    96112                                }
    97113
     114                                template <class Fun>
     115                                Fun for_each(Fun fun)
     116                                {
     117                                        BOOST_FOREACH(value_type &value, *this)
     118                                        {
     119                                                fun(value);
     120                                        }
     121                                }
     122
    98123                        };
    99124
  • sandbox/cloneable/boost/cloneable/detail/create_new.hpp

    r54623 r54665  
    3030                        };
    3131                        template <class Derived>
    32                         struct create_new<Derived, no_default_construction>
     32                        struct create_new<Derived, no_default_construction_tag>
    3333                        {
    3434                                template <class Self, class Alloc>
  • sandbox/cloneable/boost/cloneable/forward_declarations.hpp

    r54623 r54665  
    1313#include <boost/pointee.hpp>
    1414#include <boost/cloneable/detail/prefix.hpp>
     15#include <boost/cloneable/exception.hpp>
    1516
    1617namespace boost
     
    3233
    3334                /// {@ tags to inform about default-constructability
    34                 struct default_construction : detail::ctag, mpl::true_ {};
    35                 struct no_default_construction : detail::ctag, mpl::false_ {};
    36                 struct unknown_construction : detail::ctag {};
     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 {};
    3738                /// @}
    3839
     
    5152                        class Derived
    5253                        , class Base = base_type
    53                         , class DefaultConstructionTag = default_construction
     54                        , class DefaultConstructionTag = default_construction_tag
    5455                        //, class Base = nil//base_type
    5556                        //, class DefaultConstructionTag = nil//default_construction
     
    101102                };
    102103
    103                 /// a mapping of heterogenous objects to heterogenous objects
     104                /// a mapping of Key to heterogenous object
     105                template
     106                <
     107                        class Key
     108                        , class Base = base_type
     109                        , class Pred = std::less<Key>
     110                        , class Alloc = monotonic::allocator<int>
     111                >
     112                struct map;
     113
     114                /// a mapping of heterogenous object to heterogenous object
    104115                template
    105116                <
     
    108119                        , class Alloc = monotonic::allocator<int>
    109120                >
    110                 struct map;
     121                struct heterogenous_map;
    111122
    112123                /// a set of heterogenous objects
  • sandbox/cloneable/boost/cloneable/instance.hpp

    r54624 r54665  
    1515        namespace cloneable
    1616        {
     17                /// common for all instances of the given base and allocator type
    1718                template <class Base, class Alloc>
    1819                struct instance_base
     
    2021                        typedef Base base_type;
    2122                        typedef Alloc allocator_type;
     23                        typedef instance_base<Base,Alloc> this_type;
    2224
    2325                private:
     
    3436                        {
    3537                                if (!alloc)
    36                                         throw std::exception("empty allocator");
     38                                        throw empty_allocator(typeid(this_type).name());
    3739                                return *alloc;
    3840                        }
     
    4951                };
    5052
     53                /// common for all instances
    5154                template <class Abstract, class Derived, class Base, class Alloc>
    5255                struct instance_common : instance_base<Base,Alloc>
     
    109112                                return ptr;//->is_derived_type::self_ptr;
    110113                        }
     114
     115                        derived_type &derived_ref()
     116                        {
     117                                ptr = to_derived();
     118                                if (ptr == 0)
     119                                        throw empty_object();
     120                                return *ptr;
     121                        }
     122
     123                        derived_type *operator->()
     124                        {
     125                                return &derived_ref();
     126                        }
     127                        derived_type &operator*()
     128                        {
     129                                return derived_ref();
     130                        }
    111131                };
    112132
    113                 /// a pointer store that can retrieve pointers from up and down
    114                 /// the inheritance tree. stores the allocator that made it.
     133                /// a pointer to a general instance
    115134                template <class Derived, class Base, class Alloc, class Ctor>
    116135                struct instance : instance_common<base<Derived,Base,Ctor>, Derived, Base, Alloc>
     
    131150                        instance(allocator_type &al)
    132151                                : parent_type(al
    133                                         , detail::create_new<Derived, Ctor>::given(to_abstract(), get_allocator(), abstract_type::alignment))
     152                                        , detail::create_new<Derived, Ctor>::given(to_abstract(), al, abstract_type::alignment))
    134153                        {
    135154                        }
  • sandbox/cloneable/boost/cloneable/map.hpp

    r54620 r54665  
    1717        namespace cloneable
    1818        {
    19                 /// a vector of heterogenous objects
    20                 // TODO: move to boost/heterogenous/map
    21                 template <class Base, class Pred, class Alloc>
    22                 struct map
    23                         : detail::associative_container_base<
    24                                 ptr_map<
    25                                         abstract_base<Base>
    26                                         , abstract_base<Base>
    27                                         , Pred
    28                                         , allocator
    29                                         , typename detail::make_clone_allocator<Alloc>::type>
    30                                 , Pred
    31                                 , Base
    32                                 , Alloc>
    33                 {
    34                         typedef detail::associative_container_base<
     19                //namespace heterogenous
     20                //{
     21                        /// a vector of heterogenous objects
     22                        // TODO: move to boost/heterogenous/map
     23                        template <class Key, class Base, class Pred, class Alloc>
     24                        struct map
     25                                : detail::associative_container_base<
    3526                                        ptr_map<
    36                                                 abstract_base<Base>
     27                                                Key
    3728                                                , abstract_base<Base>
    3829                                                , Pred
     
    4233                                        , Base
    4334                                        , Alloc>
    44                                 parent_type;
    45                        
    46                         typedef typename parent_type::container_type container_type;
    47                         typedef typename parent_type::base_type base_type;
    48                         typedef typename parent_type::abstract_base_type abstract_base_type;
    49                         typedef typename parent_type::allocator_type allocator_type;
    50                         typedef typename parent_type::value_type value_type;
    51                         typedef typename parent_type::reference reference;
    52                         typedef typename parent_type::const_reference const_reference;
    53                         typedef typename parent_type::iterator iterator;
    54                         typedef typename parent_type::const_iterator const_iterator;
     35                        {
     36                                typedef detail::associative_container_base<
     37                                        ptr_map<
     38                                                        Key
     39                                                        , abstract_base<Base>
     40                                                        , Pred
     41                                                        , allocator
     42                                                        , typename detail::make_clone_allocator<Alloc>::type>
     43                                                , Pred
     44                                                , Base
     45                                                , Alloc>
     46                                        parent_type;
     47                               
     48                                typedef typename parent_type::container_type container_type;
     49                                typedef typename parent_type::base_type base_type;
     50                                typedef typename parent_type::abstract_base_type abstract_base_type;
     51                                typedef typename parent_type::allocator_type allocator_type;
     52                                typedef typename parent_type::value_type value_type;
     53                                typedef typename parent_type::reference reference;
     54                                typedef typename parent_type::const_reference const_reference;
     55                                typedef typename parent_type::iterator iterator;
     56                                typedef typename parent_type::const_iterator const_iterator;
    5557
    56                         using parent_type::new_instance;
    57                         using parent_type::validate;
     58                                using parent_type::new_instance;
     59                                using parent_type::validate;
    5860
    59                         typedef typename container_type::key_type key_type;
    60                         typedef typename container_type::mapped_type mapped_type;
     61                                typedef typename container_type::key_type key_type;
     62                                typedef typename container_type::mapped_type mapped_type;
    6163
    62                         typedef map<Base, Pred, Alloc> this_type;
    63 
    64                 public:
    65                         map()
    66                         {
    67                         }
    68                         map(allocator_type &a)
    69                                 : parent_type(a)
    70                         {
    71                         }
    72 
    73                         //template <class II>
    74                         //map(II F, II L)
    75                         //      : impl(F,L, get_allocator())
    76                         //{
    77                         //}
    78                         //template <class II>
    79                         //map(II F, II L, allocator_type &a)
    80                         //      : parent_type(a), impl(F,L, get_allocator())
    81                         //{
    82                         //}
    83 
    84                 private:
    85                         typedef std::pair<iterator, bool> map_insert_result;
    86 
    87                         template <class K, class V>
    88                         struct insert_result
    89                         {
    90                                 //TODO: typedef const_instance<K> key_type;
    91                                 typedef instance<K> key_type;
    92                                 typedef instance<V> value_type;
    93 
    94                                 key_type key;
    95                                 value_type value;
    96                                 iterator where;
    97                                 bool inserted;
    98 
    99                                 insert_result() : inserted(false) { }
    100                                 insert_result(const key_type &K, const value_type &V, const map_insert_result &R)
    101                                         : key(K), value(V), where(R.first), inserted(R.second) { }
    102                         };
    103 
    104                         template <class K>
    105                         struct value_adder
    106                         {
    107                         private:
    108                                 typedef instance<K> key_type;
    109                                 this_type *parent;
    110                                 key_type key;
     64                                typedef map<Base, Pred, Alloc> this_type;
    11165
    11266                        public:
    113                                 value_adder(this_type &P, const key_type &K)
    114                                         : parent(&P), key(K) { }
     67                                map()
     68                                {
     69                                }
     70                                map(allocator_type &a)
     71                                        : parent_type(a)
     72                                {
     73                                }
     74
     75                                //template <class II>
     76                                //map(II F, II L)
     77                                //      : impl(F,L, get_allocator())
     78                                //{
     79                                //}
     80                                //template <class II>
     81                                //map(II F, II L, allocator_type &a)
     82                                //      : parent_type(a), impl(F,L, get_allocator())
     83                                //{
     84                                //}
     85
     86
     87                        public:
     88                                typedef std::pair<iterator, bool> map_insert_result;
    11589
    11690                                template <class V>
    117                                 insert_result<K,V> value()
     91                                map_insert_result insert(key_type key)
    11892                                {
    119                                         return insert(parent->new_instance<V>());
     93                                        return impl().insert(key, new_instance<V>().to_abstract());
     94                                }
     95                                template <class V, class A0>
     96                                map_insert_result insert(key_type key, A0 a0)
     97                                {
     98                                        return impl().insert(key, new_instance<V>(a0).to_abstract());
     99                                }
     100                                template <class K, class A0, class A1>
     101                                map_insert_result insert(key_type key, A0 a0, A1 a1)
     102                                {
     103                                        return impl().insert(key, new_instance<V>(a0,a1).to_abstract());
     104                                }
     105                                template <class K, class A0, class A1, class A2>
     106                                map_insert_result insert(key_type key, A0 a0, A1 a1, A2 a2)
     107                                {
     108                                        return impl().insert(key, new_instance<V>(a0,a1,a2).to_abstract());
    120109                                }
    121110
    122                                 template <class V, class A0>
    123                                 insert_result<K,V> value(A0 a0)
     111                                template <class Fun>
     112                                Fun for_each_key(Fun fun)
    124113                                {
    125                                         return insert(parent->new_instance<V>(a0));
    126                                 }
    127                                 template <class V, class A0, class A1>
    128                                 insert_result<K,V> value(A0 a0, A1 a1)
    129                                 {
    130                                         return insert(parent->new_instance<V>(a0,a1));
     114                                        BOOST_FOREACH(value_type &val, *this)
     115                                        {
     116                                                fun(val.first);
     117                                        }
     118                                        return fun;
    131119                                }
    132120
    133                         private:
    134                                 template <class V>
    135                                 insert_result<K,V> insert(instance<V> &value)
     121                                template <class Ty, class Fun>
     122                                Fun for_each_mapped(Fun fun) const
    136123                                {
    137                                         map_insert_result result = parent->insert(key.to_abstract(), value.to_abstract());
    138                                         if (!result.second)
     124                                        BOOST_FOREACH(value_type const &value, *this)
    139125                                        {
    140                                                 key.release();
    141                                                 value.release();
     126                                                if (Ty *ptr = dynamic_cast<Ty *>(&val.second))
     127                                                {
     128                                                        fun(*ptr);
     129                                                }
    142130                                        }
    143                                         return insert_result<K,V>(key, value, result);
     131                                        return fun;
     132                                }
     133
     134                                iterator find(key_type const &key)
     135                                {
     136                                        return impl().find(key);
     137                                }
     138
     139                                const_iterator find(key_type const &key) const
     140                                {
     141                                        return impl().find(key);
    144142                                }
    145143                        };
     144               
     145                //} // namespace heterogenous
    146146
    147                         // TODO: make this private
    148                         template <class A, class B>
    149                         map_insert_result insert(A a, B b)
    150                         {
    151                                 return map_insert_result();// impl().insert(std::make_pair(a, b));
    152                         }
    153                         void insert(value_type x)
    154                         {
    155                                 impl().insert(x);
    156                         }
    157 
    158                 public:
    159                         template <class K>
    160                         value_adder<K> key()
    161                         {
    162                                 return value_adder<K>(*this, new_instance<K>());
    163                         }
    164 
    165                         // TODO: use variadic arguments or BOOST_PP to pass ctor args
    166                         template <class K, class A0>
    167                         value_adder<K> key(A0 a0)
    168                         {
    169                                 return value_adder<K>(*this, new_instance<K>(a0));
    170                         }
    171                         template <class K, class A0, class A1>
    172                         value_adder<K> key(A0 a0, A1 a1)
    173                         {
    174                                 return value_adder<K>(*this, new_instance<K>(a0,a1));
    175                         }
    176                         template <class K, class A0, class A1, class A2>
    177                         value_adder<K> key(A0 a0, A1 a1, A2 a2)
    178                         {
    179                                 return value_adder<K>(*this, new_instance<K>(a0,a1,a2));
    180                         }
    181 
    182                         template <class Fun>
    183                         Fun for_each(Fun fun)
    184                         {
    185                                 BOOST_FOREACH(value_type &value, *this)
    186                                 {
    187                                         fun(value);
    188                                 }
    189                         }
    190 
    191                         template <class Ty, class Fun>
    192                         Fun for_each_key(Fun fun)
    193                         {
    194                                 //BOOST_FOREACH(base_type &b, *this)
    195                                 //{
    196                                 //      if (Ty *ptr = dynamic_cast<Ty *>(&b))
    197                                 //      {
    198                                 //              fun(*ptr);
    199                                 //      }
    200                                 //}
    201                                 return fun;
    202                         }
    203 
    204                         template <class Ty, class Fun>
    205                         Fun for_each_mapped(Fun fun) const
    206                         {
    207                                 //BOOST_FOREACH(const common_base &base, *this)
    208                                 //{
    209                                 //      if (Ty *ptr = dynamic_cast<Ty *>(&base))
    210                                 //      {
    211                                 //              fun(*ptr);
    212                                 //      }
    213                                 //}
    214                                 return fun;
    215                         }
    216 
    217                         template <class K>
    218                         iterator find()
    219                         {
    220                                 instance<K> k(get_allocator());
    221                                 BOOST_SCOPE_EXIT((k))
    222                                 {
    223                                         k.release();
    224                                 }
    225                                 BOOST_SCOPE_EXIT_END
    226                                 return impl().find(k.to_abstract());
    227                         }
    228 
    229                         template <class K, class A0>
    230                         iterator find(A0 a0)
    231                         {
    232                                 instance<K> k(get_allocator(), a0);
    233                                 BOOST_SCOPE_EXIT((k))
    234                                 {
    235                                         k.release();
    236                                 }
    237                                 BOOST_SCOPE_EXIT_END
    238                                 return impl().find(k.to_abstract());
    239                         }
    240 
    241                         //reference operator[](key_type const &key)
    242                         //{
    243                         //      return impl[n];
    244                         //}
    245                         //const_reference operator[](key_type const &key) const
    246                         //{
    247                         //      return impl[n];
    248                         //}
    249 
    250                 };
    251        
    252         } // namespace heterogenous
     147        } // namespace cloneable
    253148
    254149} // namespace boost
     
    256151#include <boost/cloneable/detail/suffix.hpp>
    257152
    258 #endif // BOOST_HETEROGENOUS_MAP_HPP
     153#endif // BOOST_CLONEABLE_MAP_HPP
    259154
    260155//EOF
  • sandbox/cloneable/boost/cloneable/set.hpp

    r54620 r54665  
    6767                        }
    6868
    69                         /*
     69                        set(predicate_type pred)
     70                                : parnet_type(pred)
     71                        {
     72                        }
     73                        set(predicate_type pred, allocator_type &a)
     74                                : parent_type(pred, a)
     75                        {
     76                        }
     77
    7078                        template <class II>
    71                         set(II F, II L)
    72                                 : impl(F, L, get_allocator())
     79                        set(II F, II L, predicate_type pred = predicate_type())
     80                                : parent_type(F, L, pred)
    7381                        {
    7482                        }
     
    7684                        template <class II>
    7785                        set(II F, II L, allocator_type &a)
    78                                 : parent_type(a), impl(F, L, get_allocator())
    79                         {
    80                         }
    81                         */
     86                                : parent_type(F, L, a)
     87                        {
     88                        }
     89                        template <class II>
     90                        set(II F, II L, predicate_type pred, allocator_type &a)
     91                                : parent_type(F, L, pred, a)
     92                        {
     93                        }
    8294
    8395                public:
     
    125137                        {
    126138                                return emplace(new_instance<U>(a0, a1, a2));
    127                         }
    128 
    129                         template <class Fun>
    130                         Fun for_each(Fun fun)
    131                         {
    132                                 BOOST_FOREACH(value_type &value, *this)
    133                                 {
    134                                         fun(value);
    135                                 }
    136139                        }
    137140
  • sandbox/cloneable/boost/cloneable/traits.hpp

    r54606 r54665  
    2929                        {
    3030                                BOOST_STATIC_CONSTANT(bool, is_cloneable = true);
    31                                 typedef is_convertible<T *, default_construction *> has_default_ctor_type;
    32                                 typedef is_convertible<T *, no_default_construction *> has_no_default_ctor_type;
    33                                 // T is default constructable only if it is convertibel to def_constr and
    34                                 // it is also not convertible to no_def_constr. This ensures that a type
    35                                 // that inherits from a type that is not default constructible, is also not
    36                                 // default constructible no matter what.
     31                                typedef is_convertible<T *, default_construction_tag *> has_default_ctor_type;
     32                                typedef is_convertible<T *, no_default_construction_tag *> has_no_default_ctor_type;
     33                                /// T is default constructable only if it is convertibel to def_constr and
     34                                /// it is also not convertible to no_def_constr. This ensures that a type
     35                                /// that inherits from a type that is not default constructible, is also not
     36                                /// default constructible no matter what.
    3737                                BOOST_STATIC_CONSTANT(bool, has_default_ctor = has_default_ctor_type::value || !has_no_default_ctor_type::value);
    3838                                typedef typename mpl::if_<mpl::bool_<has_default_ctor>
    39                                                 , default_construction
    40                                                 , no_default_construction>
     39                                                , default_construction_tag
     40                                                , no_default_construction_tag>
    4141                                        ::type construction_tag;
    4242                        };
  • sandbox/cloneable/boost/ptr_container/ptr_map.hpp

    r54601 r54665  
    3232    >
    3333    class ptr_map :
    34         public ptr_map_adapter<T,std::map<Key *,void*,
     34        public ptr_map_adapter<T,std::map<Key,void*,
    3535                               Compare,Allocator>,CloneAllocator>
    3636    {
    37         typedef ptr_map_adapter<T,std::map<Key *,void*,
     37        typedef ptr_map_adapter<T,std::map<Key,void*,
    3838                                Compare,Allocator>,CloneAllocator>
    3939            base_type;
  • sandbox/cloneable/boost/ptr_container/ptr_map_adapter.hpp

    r54606 r54665  
    211211            {
    212212                eraser e(&this->base(),key);      // nothrow
     213                                // CJS: why oh use `new T()` !!
    213214                mapped_type res = new T();        // strong
    214215                ref = res;                        // nothrow
  • sandbox/cloneable/libs/cloneable/test/cloneable.vcproj

    r54656 r54665  
    286286                                </File>
    287287                                <File
     288                                        RelativePath="..\..\..\boost\cloneable\exception.hpp"
     289                                        >
     290                                </File>
     291                                <File
    288292                                        RelativePath="..\..\..\boost\cloneable\forward_declarations.hpp"
    289293                                        >
     
    328332                                        Name="containers"
    329333                                        >
     334                                        <File
     335                                                RelativePath="..\..\..\boost\cloneable\heterogenous_map.hpp"
     336                                                >
     337                                        </File>
    330338                                        <File
    331339                                                RelativePath="..\..\..\boost\cloneable\list.hpp"
  • sandbox/cloneable/libs/cloneable/test/tests.cpp

    r54660 r54665  
    2727#include <boost/cloneable/map.hpp>
    2828#include <boost/cloneable/set.hpp>
     29#include <boost/cloneable/heterogenous_map.hpp>
    2930
    3031#include <boost/cloneable/adaptor.hpp>
     
    282283namespace no_default_ctor_test
    283284{
    284         struct T0 : base<T0, base_type, no_default_construction>
     285        struct T0 : base<T0, base_type, no_default_construction_tag>
    285286        {
    286287                T0(int) { }
     
    370371{
    371372        struct T0 : base<T0> { };
    372         struct T1 : base<T1, base_type, no_default_construction> { };
     373        struct T1 : base<T1, base_type, no_default_construction_tag> { };
    373374        struct T2 { };
    374375}
     
    548549        };
    549550
    550         struct L0 : base<L0, list_test_base, no_default_construction>
     551        struct L0 : base<L0, list_test_base, no_default_construction_tag>
    551552        {
    552553                L0(int n) : list_test_base(n) { }
    553554        };
    554         struct L1 : base<L1, list_test_base, no_default_construction>
     555        struct L1 : base<L1, list_test_base, no_default_construction_tag>
    555556        {
    556557                L1(string s, int n) : list_test_base(n) { }
    557558        };
    558         struct L2 : base<L2, list_test_base, no_default_construction>
     559        struct L2 : base<L2, list_test_base, no_default_construction_tag>
    559560        {
    560561                L2(float f, int n, string s) : list_test_base(n) { }
     
    616617        {
    617618                string str;
    618                 M1() { }
    619                 M1(const char *s) : str(s) { }
     619                M1(int n = 1) : my_base(n) { }
     620                M1(const char *s, int n = 1) : my_base(n), str(s) { }
    620621        };
    621622
    622623        struct M2 : base<M2, my_base>
    623624        {
     625                M2(int n = 2) : my_base(n) { }
    624626        };
    625627
    626628        struct M3 : base<M3, my_base>
    627629        {
    628         };
    629 
    630 }
    631 
    632 struct wtf_less
    633 {
    634         template <class A, class B>
    635         bool operator()(A const &a, B const &b) const
    636         {
    637                 return a->number < b->number;
    638         }
    639 };
     630                M3(int n = 3) : my_base(n) { }
     631        };
     632}
    640633
    641634BOOST_AUTO_TEST_CASE(test_map)
    642635{
    643         //return;
    644636        using namespace map_test;
    645         M2 m2;
    646         const abstract_base<map_test::my_base> &ab2 = m2;
    647         const map_test::my_base &b2 = ab2;
    648         std::less<map_test::my_base> less;
    649         less(ab2,ab2);
    650 
    651 
    652         typedef cloneable::map<map_test::my_base> Map;
     637        typedef cloneable::map<int, map_test::my_base> Map;
    653638        Map map;
    654         map.key<M2>().value<M3>();
    655         BOOST_ASSERT(map.size() == 1);
    656         Map::iterator a = map.find<M2>();
    657         BOOST_ASSERT(a != map.end());
    658 
    659         map.key<M0>(42).value<M1>("foo");
    660         BOOST_ASSERT(map.size() == 2);
    661 
    662         Map::iterator iter = map.find<M0>(42);
    663         BOOST_ASSERT(iter!= map.end());
    664 
    665         map.key<M2>().value<M3>();
     639        map.insert<M0>(1);
     640        map.insert<M1>(2, "foo");
     641        map.insert<M3>(3, 42);
     642
     643        // the preacher - prior to bill hicks?
     644
     645        // deep copy
     646        Map copy = map;
     647        BOOST_ASSERT(copy == map);
     648
     649        Map::iterator i3 = copy.find(3);
     650        BOOST_ASSERT(i3 != copy.end());
     651        BOOST_ASSERT(typeid(*i3->second) == typeid(M3));
     652        M3 *m3_clone = i3->second->clone_as<M3>();
     653        BOOST_ASSERT(m3_clone != 0);
     654
     655        delete m3_clone;
     656}
     657
     658BOOST_AUTO_TEST_CASE(test_heterogenous_map)
     659{
     660        //using namespace map_test;
     661        //typedef cloneable::heterogenous_map<map_test::my_base> Map;
     662        //Map map;
     663        //map.key<M2>().value<M3>();
     664        //BOOST_ASSERT(map.size() == 1);
     665        //Map::iterator a = map.find<M2>();
     666        //BOOST_ASSERT(a != map.end());
     667
     668        //map.key<M0>(42).value<M1>("foo");
     669        //BOOST_ASSERT(map.size() == 2);
     670
     671        //Map::iterator iter = map.find<M0>(42);
     672        //BOOST_ASSERT(iter!= map.end());
     673
     674        //map.key<M2>().value<M3>();
    666675
    667676//      Map copy = map;
Note: See TracChangeset for help on using the changeset viewer.