Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r54620 - in sandbox/cloneable: boost/cloneable boost/cloneable/detail libs/cloneable/test
From: christian.schladetsch_at_[hidden]
Date: 2009-07-03 18:35:51


Author: cschladetsch
Date: 2009-07-03 18:35:50 EDT (Fri, 03 Jul 2009)
New Revision: 54620
URL: http://svn.boost.org/trac/boost/changeset/54620

Log:
added associative_container_base<>

Added:
   sandbox/cloneable/boost/cloneable/detail/associative_container_base.hpp (contents, props changed)
   sandbox/cloneable/boost/cloneable/detail/sequence_container_base.hpp (contents, props changed)
Text files modified:
   sandbox/cloneable/boost/cloneable/detail/container_base.hpp | 193 +--------------------------------------
   sandbox/cloneable/boost/cloneable/list.hpp | 20 +--
   sandbox/cloneable/boost/cloneable/map.hpp | 107 +++++++++------------
   sandbox/cloneable/boost/cloneable/set.hpp | 89 ++++++++----------
   sandbox/cloneable/boost/cloneable/vector.hpp | 19 +--
   sandbox/cloneable/libs/cloneable/test/cloneable.vcproj | 8 +
   6 files changed, 122 insertions(+), 314 deletions(-)

Added: sandbox/cloneable/boost/cloneable/detail/associative_container_base.hpp
==============================================================================
--- (empty file)
+++ sandbox/cloneable/boost/cloneable/detail/associative_container_base.hpp 2009-07-03 18:35:50 EDT (Fri, 03 Jul 2009)
@@ -0,0 +1,109 @@
+// Copyright (C) 2009 Christian Schladetsch
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_CLONEABLE_DETAIL_ASSOCIATIVE_CONTAINER_BASE_HPP
+#define BOOST_CLONEABLE_DETAIL_ASSOCIATIVE_CONTAINER_BASE_HPP
+
+#include <boost/cloneable/detail/prefix.hpp>
+#include <boost/cloneable/detail/container_base.hpp>
+#include <boost/cloneable/base.hpp>
+
+namespace boost
+{
+ namespace cloneable
+ {
+ namespace detail
+ {
+ template <class Cont, class Pred, class Base, class Alloc>
+ struct associative_container_base
+ : container_base<Cont,Base,Alloc>
+ {
+ typedef container_base<Cont,Base,Alloc> parent_type;
+ typedef Pred predicate_type;
+
+ using parent_type::container_type;
+ using parent_type::base_type;
+ using parent_type::abstract_base_type;
+ using parent_type::allocator_type;
+ using parent_type::validate;
+ using parent_type::new_instance;
+ using parent_type::instance;
+
+ using parent_type::iterator;
+ using parent_type::const_iterator;
+ using parent_type::reference;
+ using parent_type::const_reference;
+ using parent_type::value_type;
+
+ private:
+ predicate_type predicate;
+ container_type container;
+
+ protected:
+ const container_type &impl() const
+ {
+ return container;
+ }
+ container_type &impl()
+ {
+ return container;
+ }
+
+ public:
+ associative_container_base()
+ {
+ }
+ associative_container_base(predicate_type p)
+ : predicate(p), container(p)
+ {
+ }
+ associative_container_base(allocator_type &a)
+ : parent_type(a), container(a)
+ {
+ }
+ associative_container_base(predicate_type p, allocator_type &a)
+ : parent_type(a), predicate(p), container(p,a)
+ {
+ }
+
+ size_t size() const
+ {
+ return impl().size();
+ }
+ bool empty() const
+ {
+ return impl().empty();
+ }
+
+ iterator begin()
+ {
+ return impl().begin();
+ }
+ iterator end()
+ {
+ return impl().end();
+ }
+ const_iterator begin() const
+ {
+ return impl().begin();
+ }
+ const_iterator end() const
+ {
+ return impl().end();
+ }
+
+ };
+
+ } // namespace detail
+
+ } // namespace cloneable
+
+} // namespace boost
+
+#include <boost/cloneable/detail/suffix.hpp>
+
+#endif // BOOST_CLONEABLE_DETAIL_ASSOCIATIVE_CONTAINER_BASE_HPP
+
+//EOF

Modified: sandbox/cloneable/boost/cloneable/detail/container_base.hpp
==============================================================================
--- sandbox/cloneable/boost/cloneable/detail/container_base.hpp (original)
+++ sandbox/cloneable/boost/cloneable/detail/container_base.hpp 2009-07-03 18:35:50 EDT (Fri, 03 Jul 2009)
@@ -18,14 +18,21 @@
                 namespace detail
                 {
                         /// common functionality for all containers using the given base and allocator types
- template <class Base, class Alloc>
+ template <class Cont, class Base, class Alloc>
                         struct container_base
                         {
+ typedef Cont container_type;
                                 typedef Base base_type;
                                 typedef abstract_base<base_type> abstract_base_type;
                                 typedef typename detail::make_clone_allocator<Alloc>::type allocator_type;
                                 typedef instance_base<Base, allocator_type> instance_base_type;
 
+ typedef typename container_type::value_type value_type;
+ typedef typename container_type::reference reference;
+ typedef typename container_type::const_reference const_reference;
+ typedef typename container_type::iterator iterator;
+ typedef typename container_type::const_iterator const_iterator;
+
                                 /// ensures that the given type T is a valid type for this container.
                                 /// this provides better information from errors than otherwise.
                                 template <class T>
@@ -61,6 +68,7 @@
                                 allocator_type alloc;
 
                         protected:
+
                                 template <class U>
                                 instance<U> new_instance()
                                 {
@@ -95,193 +103,10 @@
                                 {
                                         return alloc;
                                 }
- };
 
- template <class Cont, class Base, class Alloc>
- struct sequence_container_base : container_base<Base,Alloc>
- {
- typedef Cont container_type;
- typedef container_base<Base,Alloc> parent_type;
- using parent_type::base_type;
- using parent_type::abstract_base_type;
- using parent_type::allocator_type;
- using parent_type::validate;
- using parent_type::new_instance;
- using parent_type::instance;
- typedef typename container_type::value_type value_type;
- typedef typename container_type::reference reference;
- typedef typename container_type::const_reference const_reference;
- typedef typename container_type::iterator iterator;
- typedef typename container_type::const_iterator const_iterator;
-
- private:
- container_type container;
-
- protected:
- const container_type &impl() const
- {
- return container;
- }
- container_type &impl()
- {
- return container;
- }
-
- public:
- sequence_container_base()
- : container(get_allocator())
- {
- }
- sequence_container_base(allocator_type &a)
- : parent_type(a), container(get_allocator())
- {
- }
-
- size_t size() const
- {
- return container.size();
- }
-
- template <class Ty, class Fun>
- Fun for_each(Fun fun)
- {
- BOOST_FOREACH(base_type &b, *this)
- {
- if (Ty *ptr = dynamic_cast<Ty *>(&b))
- {
- fun(*ptr);
- }
- }
- return fun;
- }
-
- template <class Ty, class Fun>
- Fun for_each(Fun fun) const
- {
- BOOST_FOREACH(const base_type &base, *this)
- {
- if (Ty *ptr = dynamic_cast<Ty *>(&base))
- {
- fun(*ptr);
- }
- }
- return fun;
- }
-
- bool empty() const
- {
- return impl().empty();
- }
-
- iterator begin()
- {
- return impl().begin();
- }
- iterator end()
- {
- return impl().end();
- }
- const_iterator begin() const
- {
- return impl().begin();
- }
- const_iterator end() const
- {
- return impl().end();
- }
-
- reference back()
- {
- return impl().back();
- }
- const_reference back() const
- {
- return impl().back();
- }
- reference front()
- {
- return impl().front();
- }
- const_reference front() const
- {
- return impl().front();
- }
-
- template <class Other>
- Other &back_as()
- {
- BOOST_STATIC_ASSERT(is_cloneable<Other>::value);
- Other *ptr = dynamic_cast<Other *>(back());
- if (ptr == 0)
- throw std::bad_cast();
- return *ptr;
- }
- template <class Other>
- Other &front_as()
- {
- BOOST_STATIC_ASSERT(is_cloneable<Other>::value);
- Other *ptr = dynamic_cast<Other *>(front());
- if (ptr == 0)
- throw std::bad_cast();
- return *ptr;
- }
-
- // TODO: use variadic arguments or BOOST_PP to pass ctor args
- template <class U>
- void push_back()
- {
- impl().push_back(new_instance<typename validate<U>::type>().to_abstract());
- }
- template <class U, class A0>
- void push_back(A0 a0)
- {
- impl().push_back(new_instance<typename validate<U>::type>(a0).to_abstract());
- }
- template <class U, class A0, class A1>
- void push_back(A0 a0, A1 a1)
- {
- impl().push_back(new_instance<typename validate<U>::type>(a0,a1).to_abstract());
- }
- template <class U, class A0, class A1, class A2>
- void push_back(A0 a0, A1 a1, A2 a2)
- {
- impl().push_back(new_instance<typename validate<U>::type>(a0,a1,a2).to_abstract());
- }
-
-
- template <class U>
- void push_front()
- {
- impl().push_front(new_instance<typename validate<U>::type>().to_abstract());
- }
- template <class U, class A0>
- void push_front(A0 a0)
- {
- impl().push_front(new_instance<typename validate<U>::type>(a0).to_abstract());
- }
- template <class U, class A0, class A1>
- void push_front(A0 a0, A1 a1)
- {
- impl().push_front(new_instance<typename validate<U>::type>(a0,a1).to_abstract());
- }
- template <class U, class A0, class A1, class A2>
- void push_front(A0 a0, A1 a1, A2 a2)
- {
- impl().push_front(new_instance<typename validate<U>::type>(a0,a1,a2).to_abstract());
- }
                         };
 
- template <class Cont, class Base, class Alloc>
- bool operator==(const sequence_container_base<Cont,Base,Alloc> &left, const sequence_container_base<Cont,Base,Alloc> &right)
- {
- return left.size() == right.size() && std::equal(left.begin(), left.end(), right.begin());
- }
 
- template <class Cont, class Base, class Alloc>
- bool operator<(const sequence_container_base<Cont,Base,Alloc> &left, const sequence_container_base<Cont,Base,Alloc> &right)
- {
- return std::lexicographical_compare(left.begin(), left.end(), right.begin(), right.end());
- }
                 } // namespace detail
 
         } // namespace cloneable

Added: sandbox/cloneable/boost/cloneable/detail/sequence_container_base.hpp
==============================================================================
--- (empty file)
+++ sandbox/cloneable/boost/cloneable/detail/sequence_container_base.hpp 2009-07-03 18:35:50 EDT (Fri, 03 Jul 2009)
@@ -0,0 +1,215 @@
+// Copyright (C) 2009 Christian Schladetsch
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_CLONEABLE_DETAIL_SEQUENCE_CONTAINER_BASE_HPP
+#define BOOST_CLONEABLE_DETAIL_SEQUENCE_CONTAINER_BASE_HPP
+
+#include <boost/cloneable/detail/prefix.hpp>
+#include <boost/cloneable/detail/container_base.hpp>
+#include <boost/cloneable/base.hpp>
+
+namespace boost
+{
+ namespace cloneable
+ {
+ namespace detail
+ {
+ template <class Cont, class Base, class Alloc>
+ struct sequence_container_base : container_base<Cont,Base,Alloc>
+ {
+ typedef Cont container_type;
+ typedef container_base<Cont,Base,Alloc> parent_type;
+ using parent_type::base_type;
+ using parent_type::abstract_base_type;
+ using parent_type::allocator_type;
+ using parent_type::validate;
+ using parent_type::new_instance;
+ using parent_type::instance;
+
+ using parent_type::iterator;
+ using parent_type::const_iterator;
+ using parent_type::reference;
+ using parent_type::const_reference;
+ using parent_type::value_type;
+
+ private:
+ container_type container;
+
+ protected:
+ const container_type &impl() const
+ {
+ return container;
+ }
+ container_type &impl()
+ {
+ return container;
+ }
+
+ public:
+ sequence_container_base()
+ {
+ }
+ sequence_container_base(allocator_type &a)
+ : container(a)
+ {
+ }
+
+ size_t size() const
+ {
+ return container.size();
+ }
+
+ template <class Ty, class Fun>
+ Fun for_each(Fun fun)
+ {
+ BOOST_FOREACH(base_type &b, *this)
+ {
+ if (Ty *ptr = dynamic_cast<Ty *>(&b))
+ {
+ fun(*ptr);
+ }
+ }
+ return fun;
+ }
+
+ template <class Ty, class Fun>
+ Fun for_each(Fun fun) const
+ {
+ BOOST_FOREACH(const base_type &base, *this)
+ {
+ if (Ty *ptr = dynamic_cast<Ty *>(&base))
+ {
+ fun(*ptr);
+ }
+ }
+ return fun;
+ }
+
+ bool empty() const
+ {
+ return impl().empty();
+ }
+
+ iterator begin()
+ {
+ return impl().begin();
+ }
+ iterator end()
+ {
+ return impl().end();
+ }
+ const_iterator begin() const
+ {
+ return impl().begin();
+ }
+ const_iterator end() const
+ {
+ return impl().end();
+ }
+
+ reference back()
+ {
+ return impl().back();
+ }
+ const_reference back() const
+ {
+ return impl().back();
+ }
+ reference front()
+ {
+ return impl().front();
+ }
+ const_reference front() const
+ {
+ return impl().front();
+ }
+
+ template <class Other>
+ Other &back_as()
+ {
+ BOOST_STATIC_ASSERT(is_cloneable<Other>::value);
+ Other *ptr = dynamic_cast<Other *>(back());
+ if (ptr == 0)
+ throw std::bad_cast();
+ return *ptr;
+ }
+ template <class Other>
+ Other &front_as()
+ {
+ BOOST_STATIC_ASSERT(is_cloneable<Other>::value);
+ Other *ptr = dynamic_cast<Other *>(front());
+ if (ptr == 0)
+ throw std::bad_cast();
+ return *ptr;
+ }
+
+ // TODO: use variadic arguments or BOOST_PP to pass ctor args
+ template <class U>
+ void push_back()
+ {
+ impl().push_back(new_instance<typename validate<U>::type>().to_abstract());
+ }
+ template <class U, class A0>
+ void push_back(A0 a0)
+ {
+ impl().push_back(new_instance<typename validate<U>::type>(a0).to_abstract());
+ }
+ template <class U, class A0, class A1>
+ void push_back(A0 a0, A1 a1)
+ {
+ impl().push_back(new_instance<typename validate<U>::type>(a0,a1).to_abstract());
+ }
+ template <class U, class A0, class A1, class A2>
+ void push_back(A0 a0, A1 a1, A2 a2)
+ {
+ impl().push_back(new_instance<typename validate<U>::type>(a0,a1,a2).to_abstract());
+ }
+
+
+ template <class U>
+ void push_front()
+ {
+ impl().push_front(new_instance<typename validate<U>::type>().to_abstract());
+ }
+ template <class U, class A0>
+ void push_front(A0 a0)
+ {
+ impl().push_front(new_instance<typename validate<U>::type>(a0).to_abstract());
+ }
+ template <class U, class A0, class A1>
+ void push_front(A0 a0, A1 a1)
+ {
+ impl().push_front(new_instance<typename validate<U>::type>(a0,a1).to_abstract());
+ }
+ template <class U, class A0, class A1, class A2>
+ void push_front(A0 a0, A1 a1, A2 a2)
+ {
+ impl().push_front(new_instance<typename validate<U>::type>(a0,a1,a2).to_abstract());
+ }
+ };
+
+
+ template <class Cont, class Base, class Alloc>
+ bool operator==(const sequence_container_base<Cont,Base,Alloc> &left, const sequence_container_base<Cont,Base,Alloc> &right)
+ {
+ return left.size() == right.size() && std::equal(left.begin(), left.end(), right.begin());
+ }
+
+ template <class Cont, class Base, class Alloc>
+ bool operator<(const sequence_container_base<Cont,Base,Alloc> &left, const sequence_container_base<Cont,Base,Alloc> &right)
+ {
+ return std::lexicographical_compare(left.begin(), left.end(), right.begin(), right.end());
+ }
+ } // namespace detail
+
+ } // namespace cloneable
+
+} // namespace boost
+
+#include <boost/cloneable/detail/suffix.hpp>
+
+#endif // BOOST_CLONEABLE_DETAIL_SEQUENCE_CONTAINER_BASE_HPP
+
+//EOF

Modified: sandbox/cloneable/boost/cloneable/list.hpp
==============================================================================
--- sandbox/cloneable/boost/cloneable/list.hpp (original)
+++ sandbox/cloneable/boost/cloneable/list.hpp 2009-07-03 18:35:50 EDT (Fri, 03 Jul 2009)
@@ -9,10 +9,8 @@
 #include <boost/ptr_container/ptr_list.hpp>
 #include <boost/foreach.hpp>
 
-#include <boost/cloneable/detail/container_base.hpp>
-#include <boost/cloneable/base.hpp>
-#include <boost/cloneable/instance.hpp>
 #include <boost/cloneable/detail/prefix.hpp>
+#include <boost/cloneable/detail/sequence_container_base.hpp>
 
 namespace boost
 {
@@ -38,16 +36,16 @@
                                         , Base
                                         , Alloc>
                                 parent_type;
- typedef typename parent_type::base_type base_type;
- typedef typename parent_type::abstract_base_type abstract_base_type;
- typedef typename parent_type::allocator_type allocator_type;
+ using parent_type::base_type;
+ using parent_type::abstract_base_type;
+ using parent_type::allocator_type;
                         using parent_type::validate;
                         using parent_type::new_instance;
- typedef typename parent_type::value_type value_type;
- typedef typename parent_type::reference reference;
- typedef typename parent_type::const_reference const_reference;
- typedef typename parent_type::iterator iterator;
- typedef typename parent_type::const_iterator const_iterator;
+ using parent_type::value_type;
+ using parent_type::reference;
+ using parent_type::const_reference;
+ using parent_type::iterator;
+ using parent_type::const_iterator;
 
                 public:
                         list()

Modified: sandbox/cloneable/boost/cloneable/map.hpp
==============================================================================
--- sandbox/cloneable/boost/cloneable/map.hpp (original)
+++ sandbox/cloneable/boost/cloneable/map.hpp 2009-07-03 18:35:50 EDT (Fri, 03 Jul 2009)
@@ -10,7 +10,7 @@
 #include <boost/foreach.hpp>
 
 #include <boost/cloneable/detail/make_clone_allocator.hpp>
-#include <boost/cloneable/detail/container_base.hpp>
+#include <boost/cloneable/detail/associative_container_base.hpp>
 
 namespace boost
 {
@@ -20,51 +20,66 @@
                 // TODO: move to boost/heterogenous/map
                 template <class Base, class Pred, class Alloc>
                 struct map
- : detail::container_base<Base, Alloc>
+ : detail::associative_container_base<
+ ptr_map<
+ abstract_base<Base>
+ , abstract_base<Base>
+ , Pred
+ , allocator
+ , typename detail::make_clone_allocator<Alloc>::type>
+ , Pred
+ , Base
+ , Alloc>
                 {
- typedef detail::container_base<Base,Alloc> parent_type;
+ typedef detail::associative_container_base<
+ ptr_map<
+ abstract_base<Base>
+ , abstract_base<Base>
+ , Pred
+ , allocator
+ , typename detail::make_clone_allocator<Alloc>::type>
+ , Pred
+ , Base
+ , Alloc>
+ parent_type;
+
+ typedef typename parent_type::container_type container_type;
                         typedef typename parent_type::base_type base_type;
                         typedef typename parent_type::abstract_base_type abstract_base_type;
                         typedef typename parent_type::allocator_type allocator_type;
- using parent_type::validate;
- using parent_type::new_instance;
+ typedef typename parent_type::value_type value_type;
+ typedef typename parent_type::reference reference;
+ typedef typename parent_type::const_reference const_reference;
+ typedef typename parent_type::iterator iterator;
+ typedef typename parent_type::const_iterator const_iterator;
 
- typedef Pred predicate_type;
- typedef ptr_map<abstract_base_type, abstract_base_type, Pred, allocator, allocator_type> implementation;
+ using parent_type::new_instance;
+ using parent_type::validate;
 
- typedef typename implementation::value_type value_type;
- typedef typename implementation::reference reference;
- typedef typename implementation::const_reference const_reference;
- typedef typename implementation::iterator iterator;
- typedef typename implementation::const_iterator const_iterator;
- typedef typename implementation::key_type key_type;
- typedef typename implementation::mapped_type mapped_type;
+ typedef typename container_type::key_type key_type;
+ typedef typename container_type::mapped_type mapped_type;
 
                         typedef map<Base, Pred, Alloc> this_type;
 
- private:
- implementation impl;
-
                 public:
                         map()
- : impl(predicate_type(), get_allocator())
                         {
                         }
                         map(allocator_type &a)
- : parent_type(a), impl(predicate_type(), get_allocator())
+ : parent_type(a)
                         {
                         }
 
- template <class II>
- map(II F, II L)
- : impl(F,L, get_allocator())
- {
- }
- template <class II>
- map(II F, II L, allocator_type &a)
- : parent_type(a), impl(F,L, get_allocator())
- {
- }
+ //template <class II>
+ //map(II F, II L)
+ // : impl(F,L, get_allocator())
+ //{
+ //}
+ //template <class II>
+ //map(II F, II L, allocator_type &a)
+ // : parent_type(a), impl(F,L, get_allocator())
+ //{
+ //}
 
                 private:
                         typedef std::pair<iterator, bool> map_insert_result;
@@ -133,11 +148,11 @@
                         template <class A, class B>
                         map_insert_result insert(A a, B b)
                         {
- return map_insert_result();// impl.insert(std::make_pair(a, b));
+ return map_insert_result();// impl().insert(std::make_pair(a, b));
                         }
                         void insert(value_type x)
                         {
- impl.insert(x);
+ impl().insert(x);
                         }
 
                 public:
@@ -199,32 +214,6 @@
                                 return fun;
                         }
 
- size_t size() const
- {
- return impl.size();
- }
- bool empty() const
- {
- return impl.empty();
- }
-
- iterator begin()
- {
- return impl.begin();
- }
- iterator end()
- {
- return impl.end();
- }
- const_iterator begin() const
- {
- return impl.begin();
- }
- const_iterator end() const
- {
- return impl.end();
- }
-
                         template <class K>
                         iterator find()
                         {
@@ -234,7 +223,7 @@
                                         k.release();
                                 }
                                 BOOST_SCOPE_EXIT_END
- return impl.find(k.to_abstract());
+ return impl().find(k.to_abstract());
                         }
 
                         template <class K, class A0>
@@ -246,7 +235,7 @@
                                         k.release();
                                 }
                                 BOOST_SCOPE_EXIT_END
- return impl.find(k.to_abstract());
+ return impl().find(k.to_abstract());
                         }
 
                         //reference operator[](key_type const &key)

Modified: sandbox/cloneable/boost/cloneable/set.hpp
==============================================================================
--- sandbox/cloneable/boost/cloneable/set.hpp (original)
+++ sandbox/cloneable/boost/cloneable/set.hpp 2009-07-03 18:35:50 EDT (Fri, 03 Jul 2009)
@@ -21,38 +21,52 @@
                 // TODO: move to boost/heterogenous/set.hpp, or boost/cloneable/containers/set.hpp
                 template <class Base, class Pred, class Alloc>
                 struct set
- : detail::container_base<Base, Alloc>
+ : detail::associative_container_base<
+ ptr_set<
+ abstract_base<Base>
+ , Pred
+ , allocator
+ , typename detail::make_clone_allocator<Alloc>::type>
+ , Pred
+ , Base
+ , Alloc>
                 {
- typedef detail::container_base<Base,Alloc> parent_type;
+ typedef detail::associative_container_base<
+ ptr_set<
+ abstract_base<Base>
+ , Pred
+ , allocator
+ , typename detail::make_clone_allocator<Alloc>::type>
+ , Pred
+ , Base
+ , Alloc>
+ parent_type;
+
+ typedef typename parent_type::container_type container_type;
                         typedef typename parent_type::base_type base_type;
                         typedef typename parent_type::abstract_base_type abstract_base_type;
                         typedef typename parent_type::allocator_type allocator_type;
- using parent_type::validate;
- using parent_type::new_instance;
+ typedef typename parent_type::value_type value_type;
+ typedef typename parent_type::reference reference;
+ typedef typename parent_type::const_reference const_reference;
+ typedef typename parent_type::iterator iterator;
+ typedef typename parent_type::const_iterator const_iterator;
 
- typedef Pred predicate_type;
- typedef ptr_set<abstract_base_type, predicate_type, allocator, allocator_type> implementation;
+ using parent_type::new_instance;
+ using parent_type::validate;
 
- typedef typename implementation::value_type value_type;
- typedef typename implementation::reference reference;
- typedef typename implementation::const_reference const_reference;
- typedef typename implementation::iterator iterator;
- typedef typename implementation::const_iterator const_iterator;
                         typedef set<Base, Pred, Alloc> this_type;
 
- private:
- implementation impl;
-
                 public:
                         set()
- : impl(predicate_type(), get_allocator())
                         {
                         }
                         set(allocator_type &a)
- : parent_type(a), impl(predicate_type(), get_allocator())
+ : parent_type(a)
                         {
                         }
 
+ /*
                         template <class II>
                         set(II F, II L)
                                 : impl(F, L, get_allocator())
@@ -64,6 +78,7 @@
                                 : parent_type(a), impl(F, L, get_allocator())
                         {
                         }
+ */
 
                 public:
                         typedef std::pair<iterator, bool> insert_result;
@@ -83,7 +98,7 @@
                         template <class U>
                         emplace_result<U> emplace(instance<U> value)
                         {
- insert_result result = impl.insert(value.to_abstract());
+ insert_result result = impl().insert(value.to_abstract());
                                 if (!result.second)
                                         value.release();
                                 return emplace_result<U>(value, result);
@@ -120,33 +135,7 @@
                                 }
                         }
 
- size_t size() const
- {
- return impl.size();
- }
- bool empty() const
- {
- return impl.empty();
- }
-
- iterator begin()
- {
- return impl.begin();
- }
- iterator end()
- {
- return impl.end();
- }
- const_iterator begin() const
- {
- return impl.begin();
- }
- const_iterator end() const
- {
- return impl.end();
- }
-
- struct impl
+ struct detail
                         {
                                 template <class U>
                                 struct find
@@ -190,12 +179,12 @@
                                         template <class A0>
                                         static iterator given(this_type *cont, A0 a0)
                                         {
- return cont->impl.find(default_key(base_type(a0)));
+ return cont->impl().find(default_key(base_type(a0)));
                                         }
                                         template <class A0, class A1>
                                         static iterator given(this_type *cont, A0 a0, A1 a1)
                                         {
- return cont->impl.find(default_key(base_type(a0, a1)));
+ return cont->impl().find(default_key(base_type(a0, a1)));
                                         }
                                 };
                         };
@@ -204,19 +193,19 @@
                         {
                                 if (!value.exists())
                                         return end();
- iterator found = impl.find(*value.to_abstract());
- if (found == impl.end())
+ iterator found = impl().find(*value.to_abstract());
+ if (found == impl().end())
                                         return found;
                                 std::type_info const &found_type = found->get_type();
                                 if (found_type == typeid(U))
                                         return found;
- return impl.end();
+ return impl().end();
                         }
 
                         template <class U, class A0>
                         iterator find(A0 a0)
                         {
- return impl::find<U>::given(this, a0);
+ return detail::find<U>::given(this, a0);
                         }
 
                 };

Modified: sandbox/cloneable/boost/cloneable/vector.hpp
==============================================================================
--- sandbox/cloneable/boost/cloneable/vector.hpp (original)
+++ sandbox/cloneable/boost/cloneable/vector.hpp 2009-07-03 18:35:50 EDT (Fri, 03 Jul 2009)
@@ -10,8 +10,7 @@
 #include <boost/foreach.hpp>
 
 #include <boost/cloneable/detail/prefix.hpp>
-#include <boost/cloneable/detail/container_base.hpp>
-#include <boost/cloneable/base.hpp>
+#include <boost/cloneable/detail/sequence_container_base.hpp>
 
 namespace boost
 {
@@ -34,16 +33,16 @@
                                         , Base
                                         , Alloc>
                                 parent_type;
- typedef typename parent_type::base_type base_type;
- typedef typename parent_type::abstract_base_type abstract_base_type;
- typedef typename parent_type::allocator_type allocator_type;
+ using parent_type::base_type;
+ using parent_type::abstract_base_type;
+ using parent_type::allocator_type;
                         using parent_type::validate;
                         using parent_type::new_instance;
- typedef typename parent_type::value_type value_type;
- typedef typename parent_type::reference reference;
- typedef typename parent_type::const_reference const_reference;
- typedef typename parent_type::iterator iterator;
- typedef typename parent_type::const_iterator const_iterator;
+ using parent_type::value_type;
+ using parent_type::reference;
+ using parent_type::const_reference;
+ using parent_type::iterator;
+ using parent_type::const_iterator;
 
                 public:
 

Modified: sandbox/cloneable/libs/cloneable/test/cloneable.vcproj
==============================================================================
--- sandbox/cloneable/libs/cloneable/test/cloneable.vcproj (original)
+++ sandbox/cloneable/libs/cloneable/test/cloneable.vcproj 2009-07-03 18:35:50 EDT (Fri, 03 Jul 2009)
@@ -335,9 +335,17 @@
                                                 Name="detail"
>
                                                 <File
+ RelativePath="..\..\..\boost\cloneable\detail\associative_container_base.hpp"
+ >
+ </File>
+ <File
                                                         RelativePath="..\..\..\boost\cloneable\detail\container_base.hpp"
>
                                                 </File>
+ <File
+ RelativePath="..\..\..\boost\cloneable\detail\sequence_container_base.hpp"
+ >
+ </File>
                                         </Filter>
                                 </Filter>
                         </Filter>


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk