Boost-Commit :

Date view	Thread view	Subject view	Author view

From: eric_at_[hidden]
Date: 2008-06-01 21:10:10

Next message: chintanraoh_at_[hidden]: "[Boost-commit] svn:boost r46036 - sandbox/SOC/2008/digital_searching/dsearch/boost/dsearch"
Previous message: ockham_at_[hidden]: "[Boost-commit] svn:boost r46034 - sandbox/SOC/2006/tree/trunk/boost/tree"

Author: eric_niebler
Date: 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
New Revision: 46035
URL: http://svn.boost.org/trac/boost/changeset/46035

Log:
lazy stl container and algorithm functions
Added:
   branches/proto/v4/boost/phoenix/stl/
   branches/proto/v4/boost/phoenix/stl.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/
   branches/proto/v4/boost/phoenix/stl/algorithm.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/begin.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/decay_array.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/end.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_equal_range.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_find.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_lower_bound.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_remove.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_remove_if.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_reverse.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_sort.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_unique.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_upper_bound.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/is_std_hash_map.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/is_std_hash_set.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/is_std_list.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/is_std_map.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/is_std_set.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/std_hash_map_fwd.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/std_hash_set_fwd.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/std_list_fwd.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/std_map_fwd.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/detail/std_set_fwd.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/iteration.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/querying.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/algorithm/transformation.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/container/
   branches/proto/v4/boost/phoenix/stl/container.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/container/container.hpp (contents, props changed)
   branches/proto/v4/boost/phoenix/stl/container/detail/
   branches/proto/v4/boost/phoenix/stl/container/detail/container.hpp (contents, props changed)
Text files modified:
   branches/proto/v4/boost/phoenix/core/argument.hpp | 14 ++++++++++++++
   branches/proto/v4/boost/phoenix/core/limits.hpp | 6 +++++-
   branches/proto/v4/libs/phoenix/test/Jamfile.v2 | 1 +
   branches/proto/v4/libs/phoenix/test/algorithm/querying2.cpp | 2 +-
   branches/proto/v4/libs/phoenix/test/algorithm/transformation3.cpp | 2 +-
   branches/proto/v4/libs/phoenix/test/algorithm/transformation4.cpp | 2 +-
   branches/proto/v4/libs/phoenix/test/container/container_tests.hpp | 2 +-
   7 files changed, 24 insertions(+), 5 deletions(-)

Modified: branches/proto/v4/boost/phoenix/core/argument.hpp
==============================================================================
--- branches/proto/v4/boost/phoenix/core/argument.hpp (original)
+++ branches/proto/v4/boost/phoenix/core/argument.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -8,6 +8,7 @@
#define BOOST_PHOENIX_ARGUMENT_HPP_EAN_2008_05_10

#include <iosfwd>
+#include <boost/preprocessor.hpp>
#include <boost/config.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/next_prior.hpp>
@@ -101,13 +102,26 @@
 ////////////////////////////////////////////////////////////////////////////////////////////
 namespace arg_names
 {
+ // Phoenix style names
 actor<argument<0> > const arg1 = {{{{}}}};
 actor<argument<1> > const arg2 = {{{{}}}};
 actor<argument<2> > const arg3 = {{{{}}}};

+ // BLL style names
 actor<argument<0> > const _1 = {{{{}}}};
 actor<argument<1> > const _2 = {{{{}}}};
 actor<argument<2> > const _3 = {{{{}}}};
+
+ // Bring in the rest or the Phoenix style arguments (arg4 .. argN+1)
+ // and BLL style arguments (_4 .. _N+1), using PP
+ #define PHOENIX_DECLARE_ARG(Z, N, DATA) \
+ actor<argument<N> > const BOOST_PP_CAT(arg, BOOST_PP_INC(N)) = {{{{}}}}; \
+ actor<argument<N> > const BOOST_PP_CAT(_, BOOST_PP_INC(N)) = {{{{}}}}; \
+ /**/
+
+ BOOST_PP_REPEAT_FROM_TO(3, PHOENIX_ARG_LIMIT, PHOENIX_DECLARE_ARG, _)
+
+ #undef PHOENIX_DECLARE_ARG
 }

}}

Modified: branches/proto/v4/boost/phoenix/core/limits.hpp
==============================================================================
--- branches/proto/v4/boost/phoenix/core/limits.hpp (original)
+++ branches/proto/v4/boost/phoenix/core/limits.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -11,6 +11,10 @@
# define PHOENIX_LIMIT 10
#endif

+#if !defined(PHOENIX_ARG_LIMIT)
+# define PHOENIX_ARG_LIMIT PHOENIX_LIMIT
+#endif
+
#if !defined(PHOENIX_PERFECT_FORWARD_LIMIT)
# define PHOENIX_PERFECT_FORWARD_LIMIT 3
#endif
@@ -28,7 +32,7 @@
#endif

#if !defined(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY)
-# define BOOST_PROTO_MAX_FUNCTION_CALL_ARITY 5
+# define BOOST_PROTO_MAX_FUNCTION_CALL_ARITY 6
#endif

#if defined(BOOST_PROTO_MAX_ARITY)

Added: branches/proto/v4/boost/phoenix/stl.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,15 @@
+/*=============================================================================
+ Copyright (c) 2006 Daniel Wallin
+ Copyright (c) 2005 Dan Marsden
+ Copyright (c) 2007 Joel de Guzman
+
+ 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 PHOENIX_ALGORITHM_HPP
+#define PHOENIX_ALGORITHM_HPP
+
+#include <boost/phoenix/stl/algorithm.hpp>
+#include <boost/phoenix/stl/container.hpp>
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,17 @@
+/*=============================================================================
+ Copyright (c) 2004 Angus Leeming
+ Copyright (c) 2006 Daniel Wallin
+ Copyright (c) 2005 Dan Marsden
+ Copyright (c) 2007 Joel de Guzman
+
+ 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 PHOENIX_STL_ALGORITHM_HPP
+#define PHOENIX_STL_ALGORITHM_HPP
+
+#include <boost/phoenix/stl/algorithm/iteration.hpp>
+#include <boost/phoenix/stl/algorithm/querying.hpp>
+#include <boost/phoenix/stl/algorithm/transformation.hpp>
+
+#endif // PHOENIX_STL_ALGORITHM_HPP

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/begin.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/begin.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,28 @@
+// Copyright 2005 Daniel Wallin.
+// Copyright 2005 Joel de Guzman.
+//
+// Use, modification and distribution is subject to 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)
+//
+// Modeled after range_ex, Copyright 2004 Eric Niebler
+
+#ifndef PHOENIX_ALGORITHM_DETAIL_BEGIN_HPP
+#define PHOENIX_ALGORITHM_DETAIL_BEGIN_HPP
+
+#include <boost/range/result_iterator.hpp>
+#include <boost/range/begin.hpp>
+
+namespace boost { namespace phoenix {
+namespace detail
+{
+ template<class R>
+ typename range_result_iterator<R>::type
+ begin_(R& r)
+ {
+ return boost::begin(r);
+ }
+}
+}}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/decay_array.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/decay_array.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,31 @@
+// Copyright 2005 Daniel Wallin.
+// Copyright 2005 Joel de Guzman.
+//
+// Use, modification and distribution is subject to 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)
+//
+// Modeled after range_ex, Copyright 2004 Eric Niebler
+
+#ifndef PHOENIX_ALGORITHM_DETAIL_DECAY_ARRAY_HPP
+#define PHOENIX_ALGORITHM_DETAIL_DECAY_ARRAY_HPP
+
+#include <boost/type_traits/remove_const.hpp>
+
+namespace boost { namespace phoenix {
+namespace detail
+{
+ template<typename T>
+ struct decay_array
+ : remove_const<T>
+ {};
+
+ template<typename T, int N>
+ struct decay_array<T[N]>
+ {
+ typedef T* type;
+ };
+}
+}}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/end.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/end.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,28 @@
+// Copyright 2005 Daniel Wallin.
+// Copyright 2005 Joel de Guzman.
+//
+// Use, modification and distribution is subject to 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)
+//
+// Modeled after range_ex, Copyright 2004 Eric Niebler
+
+#ifndef PHOENIX_ALGORITHM_DETAIL_END_HPP
+#define PHOENIX_ALGORITHM_DETAIL_END_HPP
+
+#include <boost/range/result_iterator.hpp>
+#include <boost/range/end.hpp>
+
+namespace boost { namespace phoenix {
+namespace detail
+{
+ template<class R>
+ typename range_result_iterator<R>::type
+ end_(R& r)
+ {
+ return boost::end(r);
+ }
+}
+}}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_equal_range.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_equal_range.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,43 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// has_equal_range.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+#pragma once
+#endif
+
+#ifndef HAS_EQUAL_RANGE_EN_14_12_2004
+#define HAS_EQUAL_RANGE_EN_14_12_2004
+
+#include <boost/mpl/or.hpp>
+#include "./is_std_map.hpp"
+#include "./is_std_set.hpp"
+#include "./is_std_hash_map.hpp"
+#include "./is_std_hash_set.hpp"
+
+namespace boost
+{
+ // Specialize this for user-defined types
+ template<typename T>
+ struct has_equal_range
+ : boost::mpl::or_<
+ boost::mpl::or_<
+ is_std_map<T>
+ , is_std_multimap<T>
+ , is_std_set<T>
+ , is_std_multiset<T>
+ >
+ , boost::mpl::or_<
+ is_std_hash_map<T>
+ , is_std_hash_multimap<T>
+ , is_std_hash_set<T>
+ , is_std_hash_multiset<T>
+ >
+ >
+ {
+ };
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_find.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_find.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,43 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// has_find.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+#pragma once
+#endif
+
+#ifndef HAS_FIND_EN_14_12_2004
+#define HAS_FIND_EN_14_12_2004
+
+#include <boost/mpl/or.hpp>
+#include "./is_std_map.hpp"
+#include "./is_std_set.hpp"
+#include "./is_std_hash_map.hpp"
+#include "./is_std_hash_set.hpp"
+
+namespace boost
+{
+ // Specialize this for user-defined types
+ template<typename T>
+ struct has_find
+ : boost::mpl::or_<
+ boost::mpl::or_<
+ is_std_map<T>
+ , is_std_multimap<T>
+ , is_std_set<T>
+ , is_std_multiset<T>
+ >
+ , boost::mpl::or_<
+ is_std_hash_map<T>
+ , is_std_hash_multimap<T>
+ , is_std_hash_set<T>
+ , is_std_hash_multiset<T>
+ >
+ >
+ {
+ };
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_lower_bound.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_lower_bound.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,43 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// has_lower_bound.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+#pragma once
+#endif
+
+#ifndef HAS_LOWER_BOUND_EN_14_12_2004
+#define HAS_LOWER_BOUND_EN_14_12_2004
+
+#include <boost/mpl/or.hpp>
+#include "./is_std_map.hpp"
+#include "./is_std_set.hpp"
+#include "./is_std_hash_map.hpp"
+#include "./is_std_hash_set.hpp"
+
+namespace boost
+{
+ // Specialize this for user-defined types
+ template<typename T>
+ struct has_lower_bound
+ : boost::mpl::or_<
+ boost::mpl::or_<
+ is_std_map<T>
+ , is_std_multimap<T>
+ , is_std_set<T>
+ , is_std_multiset<T>
+ >
+ , boost::mpl::or_<
+ is_std_hash_map<T>
+ , is_std_hash_multimap<T>
+ , is_std_hash_set<T>
+ , is_std_hash_multiset<T>
+ >
+ >
+ {
+ };
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_remove.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_remove.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,26 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// has_remove.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+#pragma once
+#endif
+
+#ifndef HAS_REMOVE_EN_14_12_2004
+#define HAS_REMOVE_EN_14_12_2004
+
+#include "./is_std_list.hpp"
+
+namespace boost
+{
+ // Specialize this for user-defined types
+ template<typename T>
+ struct has_remove
+ : is_std_list<T>
+ {
+ };
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_remove_if.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_remove_if.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,26 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// has_remove_if.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+#pragma once
+#endif
+
+#ifndef HAS_REMOVE_IF_EN_14_12_2004
+#define HAS_REMOVE_IF_EN_14_12_2004
+
+#include "./is_std_list.hpp"
+
+namespace boost
+{
+ // Specialize this for user-defined types
+ template<typename T>
+ struct has_remove_if
+ : is_std_list<T>
+ {
+ };
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_reverse.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_reverse.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,26 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// has_reverse.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+#pragma once
+#endif
+
+#ifndef HAS_REVERSE_EN_14_12_2004
+#define HAS_REVERSE_EN_14_12_2004
+
+#include "./is_std_list.hpp"
+
+namespace boost
+{
+ // Specialize this for user-defined types
+ template<typename T>
+ struct has_reverse
+ : is_std_list<T>
+ {
+ };
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_sort.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_sort.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,26 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// has_sort.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+#pragma once
+#endif
+
+#ifndef HAS_SORT_EN_14_12_2004
+#define HAS_SORT_EN_14_12_2004
+
+#include "./is_std_list.hpp"
+
+namespace boost
+{
+ // Specialize this for user-defined types
+ template<typename T>
+ struct has_sort
+ : is_std_list<T>
+ {
+ };
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_unique.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_unique.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,26 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// has_unique.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+#pragma once
+#endif
+
+#ifndef HAS_UNIQUE_EN_14_12_2004
+#define HAS_UNIQUE_EN_14_12_2004
+
+#include "./is_std_list.hpp"
+
+namespace boost
+{
+ // Specialize this for user-defined types
+ template<typename T>
+ struct has_unique
+ : is_std_list<T>
+ {
+ };
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_upper_bound.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/has_upper_bound.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,43 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// has_upper_bound.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+#pragma once
+#endif
+
+#ifndef HAS_UPPER_BOUND_EN_14_12_2004
+#define HAS_UPPER_BOUND_EN_14_12_2004
+
+#include <boost/mpl/or.hpp>
+#include "./is_std_map.hpp"
+#include "./is_std_set.hpp"
+#include "./is_std_hash_map.hpp"
+#include "./is_std_hash_set.hpp"
+
+namespace boost
+{
+ // Specialize this for user-defined types
+ template<typename T>
+ struct has_upper_bound
+ : boost::mpl::or_<
+ boost::mpl::or_<
+ is_std_map<T>
+ , is_std_multimap<T>
+ , is_std_set<T>
+ , is_std_multiset<T>
+ >
+ , boost::mpl::or_<
+ is_std_hash_map<T>
+ , is_std_hash_multimap<T>
+ , is_std_hash_set<T>
+ , is_std_hash_multiset<T>
+ >
+ >
+ {
+ };
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/is_std_hash_map.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/is_std_hash_map.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,48 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// is_std_hash_map.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+# pragma once
+#endif
+
+#ifndef IS_STD_HASH_MAP_EN_16_12_2004
+#define IS_STD_HASH_MAP_EN_16_12_2004
+
+#include <boost/mpl/bool.hpp>
+#include "./std_hash_map_fwd.hpp"
+
+namespace boost
+{
+ template<class T>
+ struct is_std_hash_map
+ : boost::mpl::false_
+ {};
+
+ template<
+ class Kty
+ , class Tr
+ , class Alloc
+ >
+ struct is_std_hash_map< ::stdext::hash_map<Kty,Tr,Alloc> >
+ : boost::mpl::true_
+ {};
+
+ template<class T>
+ struct is_std_hash_multimap
+ : boost::mpl::false_
+ {};
+
+ template<
+ class Kty
+ , class Tr
+ , class Alloc
+ >
+ struct is_std_hash_multimap< ::stdext::hash_multimap<Kty,Tr,Alloc> >
+ : boost::mpl::true_
+ {};
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/is_std_hash_set.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/is_std_hash_set.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,48 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// is_std_hash_set.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+# pragma once
+#endif
+
+#ifndef IS_STD_HASH_SET_EN_16_12_2004
+#define IS_STD_HASH_SET_EN_16_12_2004
+
+#include <boost/mpl/bool.hpp>
+#include "./std_hash_set_fwd.hpp"
+
+namespace boost
+{
+ template<class T>
+ struct is_std_hash_set
+ : boost::mpl::false_
+ {};
+
+ template<
+ class Kty
+ , class Tr
+ , class Alloc
+ >
+ struct is_std_hash_set< ::stdext::hash_set<Kty,Tr,Alloc> >
+ : boost::mpl::true_
+ {};
+
+ template<class T>
+ struct is_std_hash_multiset
+ : boost::mpl::false_
+ {};
+
+ template<
+ class Kty
+ , class Tr
+ , class Alloc
+ >
+ struct is_std_hash_multiset< ::stdext::hash_multiset<Kty,Tr,Alloc> >
+ : boost::mpl::true_
+ {};
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/is_std_list.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/is_std_list.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,33 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// is_std_list.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+# pragma once
+#endif
+
+#ifndef IS_STD_LIST_EN_16_12_2004
+#define IS_STD_LIST_EN_16_12_2004
+
+#include <boost/mpl/bool.hpp>
+#include "./std_list_fwd.hpp"
+
+namespace boost
+{
+ template<class T>
+ struct is_std_list
+ : boost::mpl::false_
+ {};
+
+ template<
+ class Ty
+ , class Alloc
+ >
+ struct is_std_list< ::std::list<Ty,Alloc> >
+ : boost::mpl::true_
+ {};
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/is_std_map.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/is_std_map.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,50 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// is_std_map.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+# pragma once
+#endif
+
+#ifndef IS_STD_MAP_EN_16_12_2004
+#define IS_STD_MAP_EN_16_12_2004
+
+#include <boost/mpl/bool.hpp>
+#include "./std_map_fwd.hpp"
+
+namespace boost
+{
+ template<class T>
+ struct is_std_map
+ : boost::mpl::false_
+ {};
+
+ template<
+ class Kty
+ , class Ty
+ , class Pr
+ , class Alloc
+ >
+ struct is_std_map< ::std::map<Kty,Ty,Pr,Alloc> >
+ : boost::mpl::true_
+ {};
+
+ template<class T>
+ struct is_std_multimap
+ : boost::mpl::false_
+ {};
+
+ template<
+ class Kty
+ , class Ty
+ , class Pr
+ , class Alloc
+ >
+ struct is_std_multimap< ::std::multimap<Kty,Ty,Pr,Alloc> >
+ : boost::mpl::true_
+ {};
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/is_std_set.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/is_std_set.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,48 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// is_std_set.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+# pragma once
+#endif
+
+#ifndef IS_STD_SET_EN_16_12_2004
+#define IS_STD_SET_EN_16_12_2004
+
+#include <boost/mpl/bool.hpp>
+#include "./std_set_fwd.hpp"
+
+namespace boost
+{
+ template<class T>
+ struct is_std_set
+ : boost::mpl::false_
+ {};
+
+ template<
+ class Kty
+ , class Pr
+ , class Alloc
+ >
+ struct is_std_set< ::std::set<Kty,Pr,Alloc> >
+ : boost::mpl::true_
+ {};
+
+ template<class T>
+ struct is_std_multiset
+ : boost::mpl::false_
+ {};
+
+ template<
+ class Kty
+ , class Pr
+ , class Alloc
+ >
+ struct is_std_multiset< ::std::multiset<Kty,Pr,Alloc> >
+ : boost::mpl::true_
+ {};
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/std_hash_map_fwd.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/std_hash_map_fwd.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,31 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// std_hash_map_fwd.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+# pragma once
+#endif
+
+#ifndef STD_HASH_MAP_FWD_EN_16_12_2004
+#define STD_HASH_MAP_FWD_EN_16_12_2004
+
+namespace stdext
+{
+ template<
+ class Kty
+ , class Tr
+ , class Alloc
+ >
+ class hash_map;
+
+ template<
+ class Kty
+ , class Tr
+ , class Alloc
+ >
+ class hash_multimap;
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/std_hash_set_fwd.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/std_hash_set_fwd.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,31 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// std_hash_set_fwd.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+# pragma once
+#endif
+
+#ifndef STD_HASH_SET_FWD_EN_16_12_2004
+#define STD_HASH_SET_FWD_EN_16_12_2004
+
+namespace stdext
+{
+ template<
+ class Kty
+ , class Tr
+ , class Alloc
+ >
+ class hash_set;
+
+ template<
+ class Kty
+ , class Tr
+ , class Alloc
+ >
+ class hash_multiset;
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/std_list_fwd.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/std_list_fwd.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,23 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// std_list_fwd.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+# pragma once
+#endif
+
+#ifndef STD_LIST_FWD_EN_16_12_2004
+#define STD_LIST_FWD_EN_16_12_2004
+
+namespace std
+{
+ template<
+ class Ty
+ , class Alloc
+ >
+ class list;
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/std_map_fwd.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/std_map_fwd.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,33 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// std_map_fwd.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+# pragma once
+#endif
+
+#ifndef STD_MAP_FWD_EN_16_12_2004
+#define STD_MAP_FWD_EN_16_12_2004
+
+namespace std
+{
+ template<
+ class Kty
+ , class Ty
+ , class Pr
+ , class Alloc
+ >
+ class map;
+
+ template<
+ class Kty
+ , class Ty
+ , class Pr
+ , class Alloc
+ >
+ class multimap;
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/detail/std_set_fwd.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/detail/std_set_fwd.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,31 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// std_set_fwd.hpp
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+# pragma once
+#endif
+
+#ifndef STD_SET_FWD_EN_16_12_2004
+#define STD_SET_FWD_EN_16_12_2004
+
+namespace std
+{
+ template<
+ class Kty
+ , class Pr
+ , class Alloc
+ >
+ class set;
+
+ template<
+ class Kty
+ , class Pr
+ , class Alloc
+ >
+ class multiset;
+}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/iteration.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/iteration.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,89 @@
+// Copyright 2005 Daniel Wallin.
+// Copyright 2005 Joel de Guzman.
+// Copyright 2005 Dan Marsden.
+//
+// Use, modification and distribution is subject to 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)
+//
+// Modeled after range_ex, Copyright 2004 Eric Niebler
+
+#ifndef PHOENIX_ALGORITHM_ITERATION_HPP
+#define PHOENIX_ALGORITHM_ITERATION_HPP
+
+#include <algorithm>
+#include <numeric>
+
+#include <boost/phoenix/stl/algorithm/detail/begin.hpp>
+#include <boost/phoenix/stl/algorithm/detail/end.hpp>
+
+#include <boost/phoenix/function/function.hpp>
+
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+namespace boost { namespace phoenix {
+namespace impl
+{
+ struct for_each
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class F>
+ struct result<This(R, F)>
+ {
+ typedef
+ typename remove_const<
+ typename remove_reference<F>::type
+ >::type
+ type;
+ };
+
+ template<class R, class F>
+ F operator()(R& r, F fn) const
+ {
+ return std::for_each(detail::begin_(r), detail::end_(r), fn);
+ }
+ };
+
+ struct accumulate
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class I>
+ struct result<This(R, I)>
+ {
+ typedef
+ typename remove_const<
+ typename remove_reference::type
+ >::type
+ type;
+ };
+
+ template<class This, class R, class I, class C>
+ struct result<This(R, I, C)>
+ : result<This(R, I)>
+ {};
+
+ template<class R, class I>
+ I operator()(R& r, I i) const
+ {
+ return std::accumulate(detail::begin_(r), detail::end_(r), i);
+ }
+
+ template<class R, class I, class C>
+ I operator()(R& r, I i, C c) const
+ {
+ return std::accumulate(detail::begin_(r), detail::end_(r), i, c);
+ }
+ };
+}
+
+function<impl::for_each> const for_each = {};
+function<impl::accumulate> const accumulate = {};
+
+}}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/querying.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/querying.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,654 @@
+// Copyright 2005 Daniel Wallin.
+// Copyright 2005 Joel de Guzman.
+// Copyright 2005 Dan Marsden.
+// Copyright 2008 Hartmut Kaiser.
+//
+// Use, modification and distribution is subject to 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)
+//
+// Modeled after range_ex, Copyright 2004 Eric Niebler
+
+#ifndef PHOENIX_ALGORITHM_QUERYING_HPP
+#define PHOENIX_ALGORITHM_QUERYING_HPP
+
+#include <algorithm>
+
+#include <boost/phoenix/stl/algorithm/detail/has_find.hpp>
+#include <boost/phoenix/stl/algorithm/detail/has_lower_bound.hpp>
+#include <boost/phoenix/stl/algorithm/detail/has_upper_bound.hpp>
+#include <boost/phoenix/stl/algorithm/detail/has_equal_range.hpp>
+
+#include <boost/phoenix/stl/algorithm/detail/begin.hpp>
+#include <boost/phoenix/stl/algorithm/detail/end.hpp>
+#include <boost/phoenix/stl/algorithm/detail/decay_array.hpp>
+
+#include <boost/phoenix/function/function.hpp>
+
+#include <boost/range/result_iterator.hpp>
+#include <boost/range/difference_type.hpp>
+
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+namespace boost { namespace phoenix {
+namespace impl
+{
+ struct find
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class T>
+ struct result<This(R, T)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class R, class T>
+ typename range_result_iterator<R>::type
+ execute(R& r, T const& x, mpl::true_) const
+ {
+ return r.find(x);
+ }
+
+ template<class R, class T>
+ typename range_result_iterator<R>::type
+ execute(R& r, T const& x, mpl::false_) const
+ {
+ return std::find(detail::begin_(r), detail::end_(r), x);
+ }
+
+ template<class R, class T>
+ typename range_result_iterator<R>::type
+ operator()(R& r, T const& x) const
+ {
+ return this->execute(r, x, has_find<R>());
+ }
+ };
+
+ struct find_if
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class P>
+ struct result<This(R, P)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class R, class P>
+ typename range_result_iterator<R>::type
+ operator()(R& r, P p) const
+ {
+ return std::find_if(detail::begin_(r), detail::end_(r), p);
+ }
+ };
+
+ struct find_end
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class R2>
+ struct result<This(R, R2)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class This, class R, class R2, class P>
+ struct result<This(R, R2, P)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class R, class R2>
+ typename range_result_iterator<R>::type
+ operator()(R& r, R2& r2) const
+ {
+ return std::find_end(
+ detail::begin_(r)
+ , detail::end_(r)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ );
+ }
+
+ template<class R, class R2, class P>
+ typename range_result_iterator<R>::type
+ operator()(R& r, R2& r2, P p) const
+ {
+ return std::find_end(
+ detail::begin_(r)
+ , detail::end_(r)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ , p
+ );
+ }
+ };
+
+ struct find_first_of
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class R2>
+ struct result<This(R, R2)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class This, class R, class R2, class P>
+ struct result<This(R, R2, P)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class R, class R2>
+ typename range_result_iterator<R>::type
+ operator()(R& r, R2& r2) const
+ {
+ return std::find_first_of(
+ detail::begin_(r)
+ , detail::end_(r)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ );
+ }
+
+ template<class R, class R2, class P>
+ typename range_result_iterator<R>::type
+ operator()(R& r, R2& r2, P p) const
+ {
+ return std::find_first_of(
+ detail::begin_(r)
+ , detail::end_(r)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ , p
+ );
+ }
+ };
+
+ struct adjacent_find
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R>
+ struct result<This(R)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class This, class R, class P>
+ struct result<This(R, P)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class R>
+ typename range_result_iterator<R>::type
+ operator()(R& r) const
+ {
+ return std::adjacent_find(detail::begin_(r), detail::end_(r));
+ }
+
+ template<class R, class P>
+ typename range_result_iterator<R>::type
+ operator()(R& r, P p) const
+ {
+ return std::adjacent_find(detail::begin_(r), detail::end_(r), p);
+ }
+ };
+
+ struct count
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class T>
+ struct result<This(R, T)>
+ : range_difference<typename remove_reference<R>::type>
+ {};
+
+ template<class R, class T>
+ typename range_difference<R>::type
+ operator()(R& r, T const& x) const
+ {
+ return std::count(detail::begin_(r), detail::end_(r), x);
+ }
+ };
+
+ struct count_if
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class P>
+ struct result<This(R, P)>
+ : range_difference<typename remove_reference<R>::type>
+ {};
+
+ template<class R, class P>
+ typename range_difference<R>::type
+ operator()(R& r, P p) const
+ {
+ return std::count_if(detail::begin_(r), detail::end_(r), p);
+ }
+ };
+
+ struct distance
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R>
+ struct result<This(R)>
+ : range_difference<typename remove_reference<R>::type>
+ {};
+
+ template<class R>
+ typename range_difference<R>::type
+ operator()(R& r) const
+ {
+ return std::distance(detail::begin_(r), detail::end_(r));
+ }
+ };
+
+ struct equal
+ {
+ typedef bool result_type;
+
+ template<class R, class I>
+ bool operator()(R& r, I i) const
+ {
+ return std::equal(detail::begin_(r), detail::end_(r), i);
+ }
+
+ template<class R, class I, class P>
+ bool operator()(R& r, I i, P p) const
+ {
+ return std::equal(detail::begin_(r), detail::end_(r), i, p);
+ }
+ };
+
+ struct search
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class R2>
+ struct result<This(R, R2)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class This, class R, class R2, class P>
+ struct result<This(R, R2, P)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class R, class R2>
+ typename range_result_iterator<R>::type
+ operator()(R& r, R2& r2) const
+ {
+ return std::search(
+ detail::begin_(r)
+ , detail::end_(r)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ );
+ }
+
+ template<class R, class R2, class P>
+ typename range_result_iterator<R>::type
+ operator()(R& r, R2& r2, P p) const
+ {
+ return std::search(
+ detail::begin_(r)
+ , detail::end_(r)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ , p
+ );
+ }
+ };
+
+ struct lower_bound
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class T>
+ struct result<This(R, T)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class This, class R, class T, class C>
+ struct result<This(R, T, C)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class R, class T>
+ typename range_result_iterator<R>::type
+ execute(R& r, T const& val, mpl::true_) const
+ {
+ return r.lower_bound(val);
+ }
+
+ template<class R, class T>
+ typename range_result_iterator<R>::type
+ execute(R& r, T const& val, mpl::false_) const
+ {
+ return std::lower_bound(detail::begin_(r), detail::end_(r), val);
+ }
+
+ template<class R, class T>
+ typename range_result_iterator<R>::type
+ operator()(R& r, T const& val) const
+ {
+ return this->execute(r, val, has_lower_bound<R>());
+ }
+
+ template<class R, class T, class C>
+ typename range_result_iterator<R>::type
+ operator()(R& r, T const& val, C c) const
+ {
+ return std::lower_bound(detail::begin_(r), detail::end_(r), val, c);
+ }
+ };
+
+ struct upper_bound
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class T>
+ struct result<This(R, T)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class This, class R, class T, class C>
+ struct result<This(R, T, C)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class R, class T>
+ typename range_result_iterator<R>::type
+ execute(R& r, T const& val, mpl::true_) const
+ {
+ return r.upper_bound(val);
+ }
+
+ template<class R, class T>
+ typename range_result_iterator<R>::type
+ execute(R& r, T const& val, mpl::false_) const
+ {
+ return std::upper_bound(detail::begin_(r), detail::end_(r), val);
+ }
+
+ template<class R, class T>
+ typename range_result_iterator<R>::type
+ operator()(R& r, T const& val) const
+ {
+ return this->execute(r, val, has_upper_bound<R>());
+ }
+
+ template<class R, class T, class C>
+ typename range_result_iterator<R>::type
+ operator()(R& r, T const& val, C c) const
+ {
+ return std::upper_bound(detail::begin_(r), detail::end_(r), val, c);
+ }
+ };
+
+ struct equal_range
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class T>
+ struct result<This(R, T)>
+ {
+ typedef
+ std::pair<
+ typename range_result_iterator<typename remove_reference<R>::type>::type
+ , typename range_result_iterator<typename remove_reference<R>::type>::type
+ >
+ type;
+ };
+
+ template<class This, class R, class T, class C>
+ struct result<This(R, T, C)>
+ {
+ typedef
+ std::pair<
+ typename range_result_iterator<typename remove_reference<R>::type>::type
+ , typename range_result_iterator<typename remove_reference<R>::type>::type
+ >
+ type;
+ };
+
+ template<class R, class T>
+ std::pair<typename range_result_iterator<R>::type, typename range_result_iterator<R>::type>
+ execute(R& r, T const& val, mpl::true_) const
+ {
+ return r.equal_range(val);
+ }
+
+ template<class R, class T>
+ std::pair<typename range_result_iterator<R>::type, typename range_result_iterator<R>::type>
+ execute(R& r, T const& val, mpl::false_) const
+ {
+ return std::equal_range(detail::begin_(r), detail::end_(r), val);
+ }
+
+ template<class R, class T>
+ std::pair<typename range_result_iterator<R>::type, typename range_result_iterator<R>::type>
+ operator()(R& r, T const& val) const
+ {
+ return this->execute(r, val, has_equal_range<R>());
+ }
+
+ template<class R, class T, class C>
+ std::pair<typename range_result_iterator<R>::type, typename range_result_iterator<R>::type>
+ operator()(R& r, T const& val, C c) const
+ {
+ return std::equal_range(detail::begin_(r), detail::end_(r), val, c);
+ }
+ };
+
+ struct mismatch
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class I>
+ struct result<This(R, I)>
+ {
+ typedef
+ std::pair<
+ typename range_result_iterator<typename remove_reference<R>::type>::type
+ , typename detail::decay_array<typename remove_reference::type>::type
+ >
+ type;
+ };
+
+ template<class This, class R, class I, class C>
+ struct result<This(R, I, C)>
+ {
+ typedef
+ std::pair<
+ typename range_result_iterator<typename remove_reference<R>::type>::type
+ , typename detail::decay_array<typename remove_reference::type>::type
+ >
+ type;
+ };
+
+ template<class R, class I>
+ std::pair<typename range_result_iterator<R>::type, I>
+ operator()(R& r, I i) const
+ {
+ return std::mismatch(detail::begin_(r), detail::end_(r), i);
+ }
+
+ template<class R, class I, class P>
+ std::pair<typename range_result_iterator<R>::type, I>
+ operator()(R& r, I i, P p) const
+ {
+ return std::mismatch(detail::begin_(r), detail::end_(r), i, p);
+ }
+ };
+
+ struct binary_search
+ {
+ typedef bool result_type;
+
+ template<class R, class T>
+ bool operator()(R& r, T const& val) const
+ {
+ return std::binary_search(detail::begin_(r), detail::end_(r), val);
+ }
+
+ template<class R, class T, class C>
+ bool operator()(R& r, T const& val, C c) const
+ {
+ return std::binary_search(detail::begin_(r), detail::end_(r), val, c);
+ }
+ };
+
+ struct includes
+ {
+ typedef bool result_type;
+
+ template<class R1, class R2>
+ bool operator()(R1& r1, R2& r2) const
+ {
+ return std::includes(
+ detail::begin_(r1)
+ , detail::end_(r1)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ );
+ }
+
+ template<class R1, class R2, class C>
+ bool operator()(R1& r1, R2& r2, C c) const
+ {
+ return std::includes(
+ detail::begin_(r1)
+ , detail::end_(r1)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ , c
+ );
+ }
+ };
+
+ struct min_element
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R>
+ struct result<This(R)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class This, class R, class P>
+ struct result<This(R, P)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class R>
+ typename range_result_iterator<R>::type
+ operator()(R& r) const
+ {
+ return std::min_element(detail::begin_(r), detail::end_(r));
+ }
+
+ template<class R, class P>
+ typename range_result_iterator<R>::type
+ operator()(R& r, P p) const
+ {
+ return std::min_element(detail::begin_(r), detail::end_(r), p);
+ }
+ };
+
+ struct max_element
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R>
+ struct result<This(R)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class This, class R, class P>
+ struct result<This(R, P)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class R>
+ typename range_result_iterator<R>::type
+ operator()(R& r) const
+ {
+ return std::max_element(detail::begin_(r), detail::end_(r));
+ }
+
+ template<class R, class P>
+ typename range_result_iterator<R>::type
+ operator()(R& r, P p) const
+ {
+ return std::max_element(detail::begin_(r), detail::end_(r), p);
+ }
+ };
+
+ struct lexicographical_compare
+ {
+ typedef bool result_type;
+
+ template<class R1, class R2>
+ bool operator()(R1& r1, R2& r2) const
+ {
+ return std::lexicographical_compare(
+ detail::begin_(r1)
+ , detail::end_(r1)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ );
+ }
+
+ template<class R1, class R2, class P>
+ bool operator()(R1& r1, R2& r2, P p) const
+ {
+ return std::lexicographical_compare(
+ detail::begin_(r1)
+ , detail::end_(r1)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ , p
+ );
+ }
+ };
+
+}
+
+function<impl::find> const find = {};
+function<impl::find_if> const find_if = {};
+function<impl::find_end> const find_end = {};
+function<impl::find_first_of> const find_first_of = {};
+function<impl::adjacent_find> const adjacent_find = {};
+function<impl::count> const count = {};
+function<impl::count_if> const count_if = {};
+function<impl::distance> const distance = {};
+function<impl::equal> const equal = {};
+function<impl::search> const search = {};
+function<impl::lower_bound> const lower_bound = {};
+function<impl::upper_bound> const upper_bound = {};
+function<impl::equal_range> const equal_range = {};
+function<impl::mismatch> const mismatch = {};
+function<impl::binary_search> const binary_search = {};
+function<impl::includes> const includes = {};
+function<impl::min_element> const min_element = {};
+function<impl::max_element> const max_element = {};
+function<impl::lexicographical_compare> const lexicographical_compare = {};
+
+}}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/algorithm/transformation.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/algorithm/transformation.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,1204 @@
+// Copyright 2005 Daniel Wallin.
+// Copyright 2005 Joel de Guzman.
+// Copyright 2005 Dan Marsden.
+//
+// Use, modification and distribution is subject to 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)
+//
+// Modeled after range_ex, Copyright 2004 Eric Niebler
+
+#ifndef PHOENIX_ALGORITHM_TRANSFORMATION_HPP
+#define PHOENIX_ALGORITHM_TRANSFORMATION_HPP
+
+#include <algorithm>
+#include <numeric>
+
+#include <boost/phoenix/stl/algorithm/detail/has_sort.hpp>
+#include <boost/phoenix/stl/algorithm/detail/has_remove.hpp>
+#include <boost/phoenix/stl/algorithm/detail/has_remove_if.hpp>
+#include <boost/phoenix/stl/algorithm/detail/has_unique.hpp>
+#include <boost/phoenix/stl/algorithm/detail/has_reverse.hpp>
+#include <boost/phoenix/stl/algorithm/detail/has_sort.hpp>
+
+#include <boost/phoenix/stl/algorithm/detail/begin.hpp>
+#include <boost/phoenix/stl/algorithm/detail/end.hpp>
+#include <boost/phoenix/stl/algorithm/detail/decay_array.hpp>
+
+#include <boost/phoenix/function/function.hpp>
+
+#include <boost/range/result_iterator.hpp>
+#include <boost/range/difference_type.hpp>
+
+#include <boost/mpl/if.hpp>
+
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+namespace boost { namespace phoenix { namespace impl
+{
+ struct swap
+ {
+ typedef void result_type;
+
+ template <class A, class B>
+ void operator()(A& a, B& b) const
+ {
+ using std::swap;
+ swap(a, b);
+ }
+ };
+
+ struct copy
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class I>
+ struct result<This(R, I)>
+ : detail::decay_array<typename remove_reference::type>
+ {};
+
+ template<class R, class I>
+ I operator()(R& r, I i) const
+ {
+ return std::copy(detail::begin_(r), detail::end_(r), i);
+ }
+ };
+
+ struct copy_backward
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class I>
+ struct result<This(R, I)>
+ {
+ typedef
+ typename remove_const<
+ typename remove_reference::type
+ >::type
+ type;
+ };
+
+ template<class R, class I>
+ I operator()(R& r, I i) const
+ {
+ return std::copy_backward(detail::begin_(r), detail::end_(r), i);
+ }
+ };
+
+ struct transform
+ {
+ template<typename Sig>
+ struct result;
+
+ template<typename This, class R, class O, class F>
+ struct result<This(R, O, F)>
+ {
+ typedef
+ typename detail::decay_array<
+ typename remove_reference<O>::type
+ >::type
+ type;
+ };
+
+ template<typename This, class R, class I, class O, class F>
+ struct result<This(R, I, O, F)>
+ {
+ typedef
+ typename detail::decay_array<
+ typename remove_reference<O>::type
+ >::type
+ type;
+ };
+
+ template<class R, class O, class F>
+ O operator()(R& r, O o, F f) const
+ {
+ return std::transform(detail::begin_(r), detail::end_(r), o, f);
+ }
+
+ template<class R, class I, class O, class F>
+ O operator()(R& r, I i, O o, F f) const
+ {
+ return std::transform(detail::begin_(r), detail::end_(r), i, o, f);
+ }
+ };
+
+ struct replace
+ {
+ typedef void result_type;
+
+ template<class R, class T>
+ void operator()(R& r, T const& what, T const& with) const
+ {
+ std::replace(detail::begin_(r), detail::end_(r), what, with);
+ }
+ };
+
+ struct replace_if
+ {
+ typedef void result_type;
+
+ template<class R, class P, class T>
+ void operator()(R& r, P p, T const& with) const
+ {
+ std::replace_if(detail::begin_(r), detail::end_(r), p, with);
+ }
+ };
+
+ struct replace_copy
+ {
+ template<typename Sig>
+ struct result;
+
+ template<class This, class R, class O, class T, class T2>
+ struct result<This(R, O, T, T2)>
+ {
+ typedef
+ typename detail::decay_array<
+ typename remove_reference<O>::type
+ >::type
+ type;
+ };
+
+ template<class R, class O, class T>
+ O operator()(R& r, O o, T const& what, T const& with) const
+ {
+ return std::replace_copy(detail::begin_(r), detail::end_(r), o, what, with);
+ }
+ };
+
+ struct replace_copy_if
+ {
+ template<typename Sig>
+ struct result;
+
+ template<class This, class R, class O, class P, class T>
+ struct result<This(R, O, P, T)>
+ {
+ typedef
+ typename detail::decay_array<
+ typename remove_reference<O>::type
+ >::type
+ type;
+ };
+
+ template<class R, class O, class P, class T>
+ O operator()(R& r, O o, P p, T const& with) const
+ {
+ return std::replace_copy_if(detail::begin_(r), detail::end_(r), o, p, with);
+ }
+ };
+
+ struct fill
+ {
+ typedef void result_type;
+
+ template<class R, class T>
+ void operator()(R& r, T const& x) const
+ {
+ std::fill(detail::begin_(r), detail::end_(r), x);
+ }
+ };
+
+ struct fill_n
+ {
+ typedef void result_type;
+
+ template<class R, class N, class T>
+ void operator()(R& r, N n, T const& x) const
+ {
+ std::fill_n(detail::begin_(r), n, x);
+ }
+ };
+
+ struct generate
+ {
+ typedef void result_type;
+
+ template<class R, class G>
+ void operator()(R& r, G g) const
+ {
+ std::generate(detail::begin_(r), detail::end_(r), g);
+ }
+ };
+
+ struct generate_n
+ {
+ typedef void result_type;
+
+ template<class R, class N, class G>
+ void operator()(R& r, N n, G g) const
+ {
+ std::generate_n(detail::begin_(r), n, g);
+ }
+ };
+
+ struct remove
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class T>
+ struct result<This(R, T)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class R, class T>
+ typename range_result_iterator<R>::type
+ execute(R& r, T const& x, mpl::true_) const
+ {
+ r.remove(x);
+ return detail::end_(r);
+ }
+
+ template<class R, class T>
+ typename range_result_iterator<R>::type
+ execute(R& r, T const& x, mpl::false_) const
+ {
+ return std::remove(detail::begin_(r), detail::end_(r), x);
+ }
+
+ template<class R, class T>
+ typename range_result_iterator<R>::type
+ operator()(R& r, T const& x) const
+ {
+ return this->execute(r, x, has_remove<R>());
+ }
+ };
+
+ struct remove_if
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class P>
+ struct result<This(R, P)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class R, class P>
+ typename range_result_iterator<R>::type
+ execute(R& r, P p, mpl::true_) const
+ {
+ r.remove_if(p);
+ return detail::end_(r);
+ }
+
+ template<class R, class P>
+ typename range_result_iterator<R>::type
+ execute(R& r, P p, mpl::false_) const
+ {
+ return std::remove_if(detail::begin_(r), detail::end_(r), p);
+ }
+
+ template<class R, class P>
+ typename range_result_iterator<R>::type
+ operator()(R& r, P p) const
+ {
+ return this->execute(r, p, has_remove_if<R>());
+ }
+ };
+
+ struct remove_copy
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class O, class T>
+ struct result<This(R, O, T)>
+ : detail::decay_array<typename remove_reference<O>::type>
+ {};
+
+ template<class R, class O, class T>
+ O operator()(R& r, O o, T const& x) const
+ {
+ return std::remove_copy(detail::begin_(r), detail::end_(r), o, x);
+ }
+ };
+
+ struct remove_copy_if
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class O, class P>
+ struct result<This(R, O, P)>
+ : detail::decay_array<typename remove_reference<O>::type>
+ {};
+
+ template<class R, class O, class P>
+ O operator()(R& r, O o, P p) const
+ {
+ return std::remove_copy_if(detail::begin_(r), detail::end_(r), o, p);
+ }
+ };
+
+ struct unique
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R>
+ struct result<This(R)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class This, class R, class P>
+ struct result<This(R, P)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class R>
+ typename range_result_iterator<R>::type
+ execute(R& r, mpl::true_) const
+ {
+ r.unique();
+ return detail::end_(r);
+ }
+
+ template<class R>
+ typename range_result_iterator<R>::type
+ execute(R& r, mpl::false_) const
+ {
+ return std::unique(detail::begin_(r), detail::end_(r));
+ }
+
+ template<class R>
+ typename range_result_iterator<R>::type
+ operator()(R& r) const
+ {
+ return this->execute(r, has_unique<R>());
+ }
+
+ template<class R, class P>
+ typename range_result_iterator<R>::type
+ execute(R& r, P p, mpl::true_) const
+ {
+ r.unique(p);
+ return detail::end_(r);
+ }
+
+ template<class R, class P>
+ typename range_result_iterator<R>::type
+ execute(R& r, P p, mpl::false_) const
+ {
+ return std::unique(detail::begin_(r), detail::end_(r), p);
+ }
+
+ template<class R, class P>
+ typename range_result_iterator<R>::type
+ operator()(R& r, P p) const
+ {
+ return this->execute(r, p, has_unique<R>());
+ }
+ };
+
+ struct unique_copy
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class O>
+ struct result<This(R, O)>
+ : detail::decay_array<typename remove_reference<O>::type>
+ {};
+
+ template<class This, class R, class O, class P>
+ struct result<This(R, O, P)>
+ : detail::decay_array<typename remove_reference<O>::type>
+ {};
+
+ template<class R, class O>
+ O operator()(R& r, O o) const
+ {
+ return std::unique_copy(
+ detail::begin_(r)
+ , detail::end_(r)
+ , o
+ );
+ }
+
+ template<class R, class O, class P>
+ O operator()(R& r, O o, P p) const
+ {
+ return std::unique_copy(
+ detail::begin_(r)
+ , detail::end_(r)
+ , o
+ , p
+ );
+ }
+ };
+
+ struct reverse
+ {
+ typedef void result_type;
+
+ template<class R>
+ void execute(R& r, mpl::true_) const
+ {
+ r.reverse();
+ }
+
+ template<class R>
+ void execute(R& r, mpl::false_) const
+ {
+ std::reverse(detail::begin_(r), detail::end_(r));
+ }
+
+ template<class R>
+ void operator()(R& r) const
+ {
+ this->execute(r, has_reverse<R>());
+ }
+ };
+
+ struct reverse_copy
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class O>
+ struct result<This(R, O)>
+ : detail::decay_array<typename remove_reference<O>::type>
+ {};
+
+ template<class R, class O>
+ O operator()(R& r, O o) const
+ {
+ return std::reverse_copy(
+ detail::begin_(r)
+ , detail::end_(r)
+ , o
+ );
+ }
+ };
+
+ struct rotate
+ {
+ typedef void result_type;
+
+ template<class R, class M>
+ void operator()(R& r, M m) const
+ {
+ std::rotate(
+ detail::begin_(r)
+ , m
+ , detail::end_(r)
+ );
+ }
+ };
+
+ struct rotate_copy
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class M, class O>
+ struct result<This(R, M, O)>
+ : detail::decay_array<typename remove_reference<O>::type>
+ {};
+
+ template<class R, class M, class O>
+ O operator()(R& r, M m, O o) const
+ {
+ return std::rotate_copy(
+ detail::begin_(r)
+ , m
+ , detail::end_(r)
+ , o
+ );
+ }
+ };
+
+ struct random_shuffle
+ {
+ typedef void result_type;
+
+ template<class R>
+ void operator()(R& r) const
+ {
+ return std::random_shuffle(detail::begin_(r), detail::end_(r));
+ }
+
+ template<class R, class G>
+ void operator()(R& r, G g) const
+ {
+ return std::random_shuffle(detail::begin_(r), detail::end_(r), g);
+ }
+ };
+
+ struct partition
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class P>
+ struct result<This(R, P)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class R, class P>
+ typename range_result_iterator<R>::type
+ operator()(R& r, P p) const
+ {
+ return std::partition(detail::begin_(r), detail::end_(r), p);
+ }
+ };
+
+ struct stable_partition
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class P>
+ struct result<This(R, P)>
+ : range_result_iterator<typename remove_reference<R>::type>
+ {};
+
+ template<class R, class P>
+ typename range_result_iterator<R>::type
+ operator()(R& r, P p) const
+ {
+ return std::stable_partition(detail::begin_(r), detail::end_(r), p);
+ }
+ };
+
+ struct sort
+ {
+ typedef void result_type;
+
+ template<class R>
+ void execute(R& r, mpl::true_) const
+ {
+ r.sort();
+ }
+
+ template<class R>
+ void execute(R& r, mpl::false_) const
+ {
+ std::sort(detail::begin_(r), detail::end_(r));
+ }
+
+ template<class R>
+ void operator()(R& r) const
+ {
+ this->execute(r, has_sort<R>());
+ }
+
+ template<class R, class C>
+ void execute(R& r, C c, mpl::true_) const
+ {
+ r.sort(c);
+ }
+
+ template<class R, class C>
+ void execute(R& r, C c, mpl::false_) const
+ {
+ std::sort(detail::begin_(r), detail::end_(r), c);
+ }
+
+ template<class R, class C>
+ void operator()(R& r, C c) const
+ {
+ this->execute(r, c, has_sort<R>());
+ }
+ };
+
+ struct stable_sort
+ {
+ typedef void result_type;
+
+ template<class R>
+ void operator()(R& r) const
+ {
+ std::stable_sort(detail::begin_(r), detail::end_(r));
+ }
+
+ template<class R, class C>
+ void operator()(R& r, C c) const
+ {
+ std::stable_sort(detail::begin_(r), detail::end_(r), c);
+ }
+ };
+
+ struct partial_sort
+ {
+ typedef void result_type;
+
+ template<class R, class M>
+ void operator()(R& r, M m) const
+ {
+ std::partial_sort(detail::begin_(r), m, detail::end_(r));
+ }
+
+ template<class R, class M, class C>
+ void operator()(R& r, M m, C c) const
+ {
+ std::partial_sort(detail::begin_(r), m, detail::end_(r), c);
+ }
+ };
+
+ struct partial_sort_copy
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R1, class R2>
+ struct result<This(R1, R2)>
+ : range_result_iterator<typename remove_reference<R2>::type>
+ {};
+
+ template<class This, class R1, class R2, class C>
+ struct result<This(R1, R2, C)>
+ : range_result_iterator<typename remove_reference<R2>::type>
+ {};
+
+ template<class R1, class R2>
+ typename range_result_iterator<R2>::type
+ operator()(R1& r1, R2& r2) const
+ {
+ return std::partial_sort_copy(
+ detail::begin_(r1)
+ , detail::end_(r1)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ );
+ }
+
+ template<class R1, class R2, class C>
+ typename range_result_iterator<R2>::type
+ operator()(R1& r1, R2& r2, C c) const
+ {
+ return std::partial_sort_copy(
+ detail::begin_(r1)
+ , detail::end_(r1)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ , c
+ );
+ }
+ };
+
+ struct nth_element
+ {
+ typedef void result_type;
+
+ template<class R, class N>
+ void operator()(R& r, N n) const
+ {
+ std::nth_element(detail::begin_(r), n, detail::end_(r));
+ }
+
+ template<class R, class N, class C>
+ void operator()(R& r, N n, C c) const
+ {
+ std::nth_element(detail::begin_(r), n, detail::end_(r), c);
+ }
+ };
+
+ struct merge
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R1, class R2, class O>
+ struct result<This(R1, R2, O)>
+ : detail::decay_array<typename remove_reference<O>::type>
+ {};
+
+ template<class This, class R1, class R2, class O, class C>
+ struct result<This(R1, R2, O, C)>
+ : detail::decay_array<typename remove_reference<O>::type>
+ {};
+
+ template<class R1, class R2, class O>
+ O operator()(R1& r1, R2& r2, O o) const
+ {
+ return std::merge(
+ detail::begin_(r1)
+ , detail::end_(r1)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ , o
+ );
+ }
+
+ template<class R1, class R2, class O, class C>
+ O operator()(R1& r1, R2& r2, O o, C c) const
+ {
+ return std::merge(
+ detail::begin_(r1)
+ , detail::end_(r1)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ , o
+ , c
+ );
+ }
+ };
+
+ struct inplace_merge
+ {
+ typedef void result_type;
+
+ template<class R, class M>
+ void operator()(R& r, M m) const
+ {
+ std::inplace_merge(detail::begin_(r), m, detail::end_(r));
+ }
+
+ template<class R, class M, class C>
+ void operator()(R& r, M m, C c) const
+ {
+ std::inplace_merge(detail::begin_(r), m, detail::end_(r), c);
+ }
+ };
+
+ struct next_permutation
+ {
+ typedef bool result_type;
+
+ template<class R>
+ bool operator()(R& r) const
+ {
+ return std::next_permutation(detail::begin_(r), detail::end_(r));
+ }
+
+ template<class R, class C>
+ bool operator()(R& r, C c) const
+ {
+ return std::next_permutation(detail::begin_(r), detail::end_(r), c);
+ }
+ };
+
+ struct prev_permutation
+ {
+ typedef bool result_type;
+
+ template<class R>
+ bool operator()(R& r) const
+ {
+ return std::prev_permutation(detail::begin_(r), detail::end_(r));
+ }
+
+ template<class R, class C>
+ bool operator()(R& r, C c) const
+ {
+ return std::prev_permutation(detail::begin_(r), detail::end_(r), c);
+ }
+ };
+
+
+ struct inner_product
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class I, class T>
+ struct result<This(R, I, T)>
+ {
+ typedef
+ typename remove_const<
+ typename remove_reference<T>::type
+ >::type
+ type;
+ };
+
+ template<class This, class R, class I, class T, class C1, class C2>
+ struct result<This(R, I, T, C1, C2)>
+ {
+ typedef
+ typename remove_const<
+ typename remove_reference<T>::type
+ >::type
+ type;
+ };
+
+ template<class R, class I, class T>
+ T operator()(R& r, I i, T t) const
+ {
+ return std::inner_product(
+ detail::begin_(r)
+ , detail::end_(r)
+ , i
+ , t
+ );
+ }
+
+ template<class R, class I, class T, class C1, class C2>
+ T operator()(R& r, I i, T t, C1 c1, C2 c2) const
+ {
+ return std::inner_product(
+ detail::begin_(r)
+ , detail::end_(r)
+ , i
+ , t
+ , c1
+ , c2
+ );
+ }
+ };
+
+ struct partial_sum
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class I>
+ struct result<This(R, I)>
+ : detail::decay_array<typename remove_reference::type>
+ {};
+
+ template<class This, class R, class I, class C>
+ struct result<This(R, I, C)>
+ : detail::decay_array<typename remove_reference::type>
+ {};
+
+ template<class R, class I>
+ I operator()(R& r, I i) const
+ {
+ return std::partial_sum(
+ detail::begin_(r)
+ , detail::end_(r)
+ , i
+ );
+ }
+
+ template<class R, class I, class C>
+ I operator()(R& r, I i, C c) const
+ {
+ return std::partial_sum(
+ detail::begin_(r)
+ , detail::end_(r)
+ , i
+ , c
+ );
+ }
+ };
+
+ struct adjacent_difference
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R, class I>
+ struct result<This(R, I)>
+ : detail::decay_array<typename remove_reference::type>
+ {};
+
+ template<class This, class R, class I, class C>
+ struct result<This(R, I, C)>
+ : detail::decay_array<typename remove_reference::type>
+ {};
+
+ template<class R, class I>
+ I operator()(R& r, I i) const
+ {
+ return std::adjacent_difference(
+ detail::begin_(r)
+ , detail::end_(r)
+ , i
+ );
+ }
+
+ template<class R, class I, class C>
+ I operator()(R& r, I i, C c) const
+ {
+ return std::adjacent_difference(
+ detail::begin_(r)
+ , detail::end_(r)
+ , i
+ , c
+ );
+ }
+ };
+
+ struct push_heap
+ {
+ typedef void result_type;
+
+ template<class R>
+ void operator()(R& r) const
+ {
+ std::push_heap(detail::begin_(r), detail::end_(r));
+ }
+
+ template<class R, class C>
+ void operator()(R& r, C c) const
+ {
+ std::push_heap(detail::begin_(r), detail::end_(r), c);
+ }
+ };
+
+ struct pop_heap
+ {
+ typedef void result_type;
+
+ template<class R>
+ void operator()(R& r) const
+ {
+ std::pop_heap(detail::begin_(r), detail::end_(r));
+ }
+
+ template<class R, class C>
+ void operator()(R& r, C c) const
+ {
+ std::pop_heap(detail::begin_(r), detail::end_(r), c);
+ }
+ };
+
+ struct make_heap
+ {
+ typedef void result_type;
+
+ template<class R>
+ void operator()(R& r) const
+ {
+ std::make_heap(detail::begin_(r), detail::end_(r));
+ }
+
+ template<class R, class C>
+ void operator()(R& r, C c) const
+ {
+ std::make_heap(detail::begin_(r), detail::end_(r), c);
+ }
+ };
+
+ struct sort_heap
+ {
+ typedef void result_type;
+
+ template<class R>
+ void operator()(R& r) const
+ {
+ std::sort_heap(detail::begin_(r), detail::end_(r));
+ }
+
+ template<class R, class C>
+ void operator()(R& r, C c) const
+ {
+ std::sort_heap(detail::begin_(r), detail::end_(r), c);
+ }
+ };
+
+ struct set_union
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R1, class R2, class O>
+ struct result<This(R1, R2, O)>
+ : detail::decay_array<typename remove_reference<O>::type>
+ {};
+
+ template<class This, class R1, class R2, class O, class C>
+ struct result<This(R1, R2, O, C)>
+ : detail::decay_array<typename remove_reference<O>::type>
+ {};
+
+ template<class R1, class R2, class O>
+ O operator()(R1& r1, R2& r2, O o) const
+ {
+ return std::set_union(
+ detail::begin_(r1)
+ , detail::end_(r1)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ , o
+ );
+ }
+
+ template<class R1, class R2, class O, class C>
+ O operator()(R1& r1, R2& r2, O o, C c) const
+ {
+ return std::set_union(
+ detail::begin_(r1)
+ , detail::end_(r1)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ , o
+ , c
+ );
+ }
+ };
+
+ struct set_intersection
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R1, class R2, class O>
+ struct result<This(R1, R2, O)>
+ : detail::decay_array<typename remove_reference<O>::type>
+ {};
+
+ template<class This, class R1, class R2, class O, class C>
+ struct result<This(R1, R2, O, C)>
+ : detail::decay_array<typename remove_reference<O>::type>
+ {};
+
+ template<class R1, class R2, class O>
+ O operator()(R1& r1, R2& r2, O o) const
+ {
+ return std::set_intersection(
+ detail::begin_(r1)
+ , detail::end_(r1)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ , o
+ );
+ }
+
+ template<class R1, class R2, class O, class C>
+ O operator()(R1& r1, R2& r2, O o, C c) const
+ {
+ return std::set_intersection(
+ detail::begin_(r1)
+ , detail::end_(r1)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ , o
+ , c
+ );
+ }
+ };
+
+ struct set_difference
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R1, class R2, class O>
+ struct result<This(R1, R2, O)>
+ : detail::decay_array<typename remove_reference<O>::type>
+ {};
+
+ template<class This, class R1, class R2, class O, class C>
+ struct result<This(R1, R2, O, C)>
+ : detail::decay_array<typename remove_reference<O>::type>
+ {};
+
+ template<class R1, class R2, class O>
+ O operator()(R1& r1, R2& r2, O o) const
+ {
+ return std::set_difference(
+ detail::begin_(r1)
+ , detail::end_(r1)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ , o
+ );
+ }
+
+ template<class R1, class R2, class O, class C>
+ O operator()(R1& r1, R2& r2, O o, C c) const
+ {
+ return std::set_difference(
+ detail::begin_(r1)
+ , detail::end_(r1)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ , o
+ , c
+ );
+ }
+ };
+
+ struct set_symmetric_difference
+ {
+ template<class Sig>
+ struct result;
+
+ template<class This, class R1, class R2, class O>
+ struct result<This(R1, R2, O)>
+ : detail::decay_array<typename remove_reference<O>::type>
+ {};
+
+ template<class This, class R1, class R2, class O, class C>
+ struct result<This(R1, R2, O, C)>
+ : detail::decay_array<typename remove_reference<O>::type>
+ {};
+
+ template<class R1, class R2, class O>
+ O operator()(R1& r1, R2& r2, O o) const
+ {
+ return std::set_symmetric_difference(
+ detail::begin_(r1)
+ , detail::end_(r1)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ , o
+ );
+ }
+
+ template<class R1, class R2, class O, class C>
+ O operator()(R1& r1, R2& r2, O o, C c) const
+ {
+ return std::set_symmetric_difference(
+ detail::begin_(r1)
+ , detail::end_(r1)
+ , detail::begin_(r2)
+ , detail::end_(r2)
+ , o
+ , c
+ );
+ }
+ };
+
+}}} // boost::phoenix::impl
+
+namespace boost { namespace phoenix
+{
+ function<impl::swap> const swap = {};
+ function<impl::copy> const copy = {};
+ function<impl::copy_backward> const copy_backward = {};
+ function<impl::transform> const transform = {};
+ function<impl::replace> const replace = {};
+ function<impl::replace_if> const replace_if = {};
+ function<impl::replace_copy> const replace_copy = {};
+ function<impl::replace_copy_if> const replace_copy_if = {};
+ function<impl::fill> const fill = {};
+ function<impl::fill_n> const fill_n = {};
+ function<impl::generate> const generate = {};
+ function<impl::generate_n> const generate_n = {};
+ function<impl::remove> const remove = {};
+ function<impl::remove_if> const remove_if = {};
+ function<impl::remove_copy> const remove_copy = {};
+ function<impl::remove_copy_if> const remove_copy_if = {};
+ function<impl::unique> const unique = {};
+ function<impl::unique_copy> const unique_copy = {};
+ function<impl::reverse> const reverse = {};
+ function<impl::reverse_copy> const reverse_copy = {};
+ function<impl::rotate> const rotate = {};
+ function<impl::rotate_copy> const rotate_copy = {};
+ function<impl::random_shuffle> const random_shuffle = {};
+ function<impl::partition> const partition = {};
+ function<impl::stable_partition> const stable_partition = {};
+ function<impl::sort> const sort = {};
+ function<impl::stable_sort> const stable_sort = {};
+ function<impl::partial_sort> const partial_sort = {};
+ function<impl::partial_sort_copy> const partial_sort_copy = {};
+ function<impl::nth_element> const nth_element = {};
+ function<impl::merge> const merge = {};
+ function<impl::inplace_merge> const inplace_merge = {};
+ function<impl::next_permutation> const next_permutation = {};
+ function<impl::prev_permutation> const prev_permutation = {};
+ function<impl::inner_product> const inner_product = {};
+ function<impl::partial_sum> const partial_sum = {};
+ function<impl::adjacent_difference> const adjacent_difference = {};
+ function<impl::push_heap> const push_heap = {};
+ function<impl::pop_heap> const pop_heap = {};
+ function<impl::make_heap> const make_heap = {};
+ function<impl::sort_heap> const sort_heap = {};
+ function<impl::set_union> const set_union = {};
+ function<impl::set_intersection> const set_intersection = {};
+ function<impl::set_difference> const set_difference = {};
+ function<impl::set_symmetric_difference> const set_symmetric_difference = {};
+}}
+
+#endif

Added: branches/proto/v4/boost/phoenix/stl/container.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/container.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,13 @@
+/*=============================================================================
+ Copyright (c) 2004 Angus Leeming
+ Copyright (c) 2007 Joel de Guzman
+
+ 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 PHOENIX_STL_CONTAINER_HPP
+#define PHOENIX_STL_CONTAINER_HPP
+
+#include <boost/phoenix/stl/container/container.hpp>
+
+#endif // PHOENIX_STL_CONTAINER_HPP

Added: branches/proto/v4/boost/phoenix/stl/container/container.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/container/container.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,752 @@
+/*=============================================================================
+ Copyright (c) 2004 Angus Leeming
+ Copyright (c) 2004 Joel de Guzman
+
+ 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 PHOENIX_STL_CONTAINER_CONTAINER_HPP
+#define PHOENIX_STL_CONTAINER_CONTAINER_HPP
+
+#include <boost/phoenix/core/limits.hpp>
+
+#if (PHOENIX_LIMIT < 5)
+# error "PHOENIX_LIMIT is set too low"
+#endif
+
+#include <boost/phoenix/stl/container/detail/container.hpp>
+#include <boost/phoenix/function/function.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+namespace boost { namespace phoenix
+{
+///////////////////////////////////////////////////////////////////////////////
+//
+// STL container member functions
+//
+// Lazy functions for STL container member functions
+//
+// These functions provide a mechanism for the lazy evaluation of the
+// public member functions of the STL containers. For an overview of
+// what is meant by 'lazy evaluation', see the comments in operators.hpp
+// and functions.hpp.
+//
+// Lazy functions are provided for all of the member functions of the
+// following containers:
+//
+// deque · list · map · multimap · vector.
+//
+// Indeed, should *your* class have member functions with the same names
+// and signatures as those listed below, then it will automatically be
+// supported. To summarize, lazy functions are provided for member
+// functions:
+//
+// assign · at · back · begin · capacity · clear · empty · end ·
+// erase · front · get_allocator · insert · key_comp · max_size ·
+// pop_back · pop_front · push_back · push_front · rbegin · rend ·
+// reserve · resize . size · splice · value_comp.
+//
+// The lazy functions' names are the same as the corresponding member
+// function. Sample usage:
+//
+// "Normal" version "Lazy" version
+// ---------------- --------------
+// my_vector.at(5) phoenix::at(arg1, 5)
+// my_list.size() phoenix::size(arg1)
+// my_vector1.swap(my_vector2) phoenix::swap(arg1, arg2)
+//
+// Notice that member functions with names that clash with a
+// function in stl algorithms are absent. This will be provided
+// in Phoenix's algorithm module.
+//
+// No support is provided here for lazy versions of operator+=,
+// operator[] etc. Such operators are not specific to STL containers and
+// lazy versions can therefore be found in operators.hpp.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Lazy member function implementaions.
+//
+// The structs below provide the guts of the implementation. Thereafter,
+// the corresponding lazy function itself is simply:
+//
+// function<stl::assign> const assign = {};
+//
+// The structs provide a nested "result" class template whose
+// "type" typedef enables the lazy function to ascertain the type
+// to be returned when it is invoked.
+//
+// They also provide operator() member functions with signatures
+// corresponding to those of the underlying member function of
+// the STL container.
+//
+///////////////////////////////////////////////////////////////////////////////
+ namespace stl
+ {
+ struct assign
+ {
+ template<typename Sig>
+ struct result;
+
+ template <typename This, typename C, typename Arg1>
+ struct result<This(C, Arg1)>
+ {
+ typedef typename add_reference<C>::type type;
+ };
+
+ template <typename This, typename C, typename Arg1, typename Arg2>
+ struct result<This(C, Arg1, Arg2)>
+ {
+ typedef typename add_reference<C>::type type;
+ };
+
+ template <typename This, typename C, typename Arg1, typename Arg2, typename Arg3>
+ struct result<This(C, Arg1, Arg2, Arg3)>
+ {
+ typedef typename add_reference<C>::type type;
+ };
+
+ template <typename C, typename Arg1>
+ C& operator()(C& c, Arg1 const& arg1) const
+ {
+ c.assign(arg1);
+ return c;
+ }
+
+ template <typename C, typename Arg1, typename Arg2>
+ C& operator()(C& c, Arg1 const& arg1, Arg2 const& arg2) const
+ {
+ c.assign(arg1, arg2);
+ return c;
+ }
+
+ template <typename C, typename Arg1, typename Arg2, typename Arg3>
+ C& operator()(C& c, Arg1 const& arg1, Arg2 const& arg2, Arg3 const& arg3) const
+ {
+ return c.assign(arg1, arg2, arg3);
+ }
+ };
+
+ struct at
+ {
+ template <typename Sig>
+ struct result;
+
+ template <typename This, typename C, typename Index>
+ struct result<This(C, Index)>
+ {
+ typedef
+ typename const_qualified_reference_of<
+ typename remove_reference<C>::type
+ >::type
+ type;
+ };
+
+ template <typename C, typename Index>
+ typename const_qualified_reference_of<C>::type
+ operator()(C& c, Index const& i) const
+ {
+ return c.at(i);
+ }
+ };
+
+ struct front
+ {
+ template <typename Sig>
+ struct result;
+
+ template <typename This, typename C>
+ struct result<This(C)>
+ {
+ typedef
+ typename const_qualified_reference_of<
+ typename remove_reference<C>::type
+ >::type
+ type;
+ };
+
+ template <typename C>
+ typename const_qualified_reference_of<C>::type
+ operator()(C& c) const
+ {
+ return c.front();
+ }
+ };
+
+ struct back
+ {
+ template <typename Sig>
+ struct result;
+
+ template <typename This, typename C>
+ struct result<This(C)>
+ {
+ typedef
+ typename const_qualified_reference_of<
+ typename remove_reference<C>::type
+ >::type
+ type;
+ };
+
+ template <typename C>
+ typename const_qualified_reference_of<C>::type
+ operator()(C& c) const
+ {
+ return c.back();
+ }
+ };
+
+ struct begin
+ {
+ template <typename Sig>
+ struct result;
+
+ template <typename This, typename C>
+ struct result<This(C)>
+ {
+ typedef
+ typename const_qualified_iterator_of<
+ typename remove_reference<C>::type
+ >::type
+ type;
+ };
+
+ template <typename C>
+ typename const_qualified_iterator_of<C>::type
+ operator()(C& c) const
+ {
+ return c.begin();
+ }
+ };
+
+ struct end
+ {
+ template <typename Sig>
+ struct result;
+
+ template <typename This, typename C>
+ struct result<This(C)>
+ {
+ typedef
+ typename const_qualified_iterator_of<
+ typename remove_reference<C>::type
+ >::type
+ type;
+ };
+
+ template <typename C>
+ typename const_qualified_iterator_of<C>::type
+ operator()(C& c) const
+ {
+ return c.end();
+ }
+ };
+
+ struct capacity
+ {
+ template <typename Sig>
+ struct result;
+
+ template <typename This, typename C>
+ struct result<This(C)>
+ {
+ typedef
+ typename size_type_of<
+ typename remove_reference<C>::type
+ >::type
+ type;
+ };
+
+ template <typename C>
+ typename size_type_of<C>::type
+ operator()(C const& c) const
+ {
+ return c.capacity();
+ }
+ };
+
+ struct clear
+ {
+ typedef void result_type;
+
+ template <typename C>
+ void operator()(C& c) const
+ {
+ return c.clear();
+ }
+ };
+
+ struct empty
+ {
+ typedef bool result_type;
+
+ template <typename C>
+ bool operator()(C const& c) const
+ {
+ return c.empty();
+ }
+ };
+
+ struct erase
+ {
+ // This mouthful can differentiate between the generic erase
+ // functions (Container == std::deque, std::list, std::vector) and
+ // that specific to the two map-types, std::map and std::multimap.
+ //
+ // where C is a std::deque, std::list, std::vector:
+ //
+ // 1) iterator C::erase(iterator where);
+ // 2) iterator C::erase(iterator first, iterator last);
+ //
+ // where M is a std::map or std::multimap:
+ //
+ // 3) size_type M::erase(const Key& keyval);
+ // 4) void M::erase(iterator where);
+ // 5) void M::erase(iterator first, iterator last);
+ template<typename Sig>
+ struct result;
+
+ template <typename This, typename C, typename Arg1>
+ struct result<This(C, Arg1)>
+ {
+ // BOOST_MSVC #if branch here in map_erase_result non-
+ // standard behavior. The return type should be void but
+ // VC7.1 prefers to return iterator_of<C>. As a result,
+ // VC7.1 complains of error C2562:
+ // boost::phoenix::stl::erase::operator() 'void' function
+ // returning a value. Oh well... :*
+
+ typedef typename remove_reference<C>::type container;
+ typedef typename remove_const<typename remove_reference<Arg1>::type>::type arg1;
+
+ typedef
+ boost::mpl::eval_if<
+ boost::is_same<arg1, typename iterator_of<container>::type>
+#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1400)
+ , iterator_of<container>
+#else
+ , boost::mpl::identity<void>
+#endif
+ , size_type_of<container>
+ >
+ map_erase_result;
+
+ typedef typename
+ boost::mpl::eval_if<
+ has_mapped_type<container>
+ , map_erase_result
+ , iterator_of<container>
+ >::type
+ type;
+ };
+
+ template <typename This, typename C, typename Arg1, typename Arg2>
+ struct result<This(C, Arg1, Arg2)>
+ : result<This(C, Arg1)>
+ {};
+
+ template <typename C, typename Arg1>
+ typename result<erase(C, Arg1)>::type
+ operator()(C& c, Arg1 const& arg1) const
+ {
+ return c.erase(arg1);
+ }
+
+ template <typename C, typename Arg1, typename Arg2>
+ typename result<erase(C, Arg1, Arg2)>::type
+ operator()(C& c, Arg1 const& arg1, Arg2 const& arg2) const
+ {
+ return c.erase(arg1, arg2);
+ }
+ };
+
+ struct get_allocator
+ {
+ template<typename Sig>
+ struct result;
+
+ template <typename This, typename C>
+ struct result<This(C)>
+ {
+ typedef
+ typename allocator_type_of<
+ typename remove_reference<C>::type
+ >::type
+ type;
+ };
+
+ template <typename C>
+ typename allocator_type_of<C>::type
+ operator()(C const& c) const
+ {
+ return c.get_allocator();
+ }
+ };
+
+ struct insert
+ {
+ // This mouthful can differentiate between the generic insert
+ // functions (Container == deque, list, vector) and those
+ // specific to the two map-types, std::map and std::multimap.
+ //
+ // where C is a std::deque, std::list, std::vector:
+ //
+ // 1) iterator C::insert(iterator where, value_type value);
+ // 2) void C::insert(
+ // iterator where, size_type count, value_type value);
+ // 3) template <typename Iter>
+ // void C::insert(iterator where, Iter first, Iter last);
+ //
+ // where M is a std::map and MM is a std::multimap:
+ //
+ // 4) pair<iterator, bool> M::insert(value_type const&);
+ // 5) iterator MM::insert(value_type const&);
+ //
+ // where M is a std::map or std::multimap:
+ //
+ // 6) template <typename Iter>
+ // void M::insert(Iter first, Iter last);
+
+ template<typename Sig>
+ struct result;
+
+ template <typename This, typename C, typename Arg1>
+ struct result<This(C, Arg1)>
+ {
+ typedef typename remove_const<typename remove_reference<C>::type>::type container;
+ typedef typename remove_const<typename remove_reference<Arg1>::type>::type arg1;
+
+ struct pair_iterator_bool
+ {
+ typedef std::pair<typename container::iterator, bool> type;
+ };
+
+ typedef
+ typename boost::mpl::eval_if<
+ map_insert_returns_pair<container>
+ , pair_iterator_bool
+ , iterator_of<container>
+ >::type
+ type;
+ };
+
+ template <typename This, typename C, typename Arg1, typename Arg2>
+ struct result<This(C, Arg1, Arg2)>
+ {
+ typedef typename remove_reference<C>::type container;
+ typedef typename remove_const<typename remove_reference<Arg1>::type>::type arg1;
+ typedef typename remove_const<typename remove_reference<Arg2>::type>::type arg2;
+
+ typedef typename
+ boost::mpl::eval_if<
+ boost::is_same<arg1, arg2>
+ , boost::mpl::identity<void>
+ , iterator_of<container>
+ >::type
+ type;
+ };
+
+ template <typename This, typename C, typename Arg1, typename Arg2, typename Arg3>
+ struct result<This(C, Arg1, Arg2, Arg3)>
+ {
+ typedef void type;
+ };
+
+ template <typename C, typename Arg1>
+ typename result<insert(C, Arg1)>::type
+ operator()(C& c, Arg1 const& arg1) const
+ {
+ return c.insert(arg1);
+ }
+
+ template <typename C, typename Arg1, typename Arg2>
+ typename result<insert(C, Arg1, Arg2)>::type
+ operator()(C& c, Arg1 const& arg1, Arg2 const& arg2) const
+ {
+ return c.insert(arg1, arg2);
+ }
+
+ template <typename C, typename Arg1, typename Arg2, typename Arg3>
+ typename result<insert(C, Arg1, Arg2, Arg3)>::type
+ operator()(C& c, Arg1 const& arg1, Arg2 const& arg2, Arg3 const& arg3) const
+ {
+ return c.insert(arg1, arg2, arg3);
+ }
+ };
+
+ struct key_comp
+ {
+ template <typename C>
+ struct result;
+
+ template <typename This, typename C>
+ struct result<This(C)>
+ {
+ typedef
+ typename key_compare_of<
+ typename remove_reference<C>::type
+ >::type
+ type;
+ };
+
+ template <typename C>
+ typename key_compare_of<C>::type
+ operator()(C const& c) const
+ {
+ return c.key_comp();
+ }
+ };
+
+ struct max_size
+ {
+ template <typename C>
+ struct result;
+
+ template <typename This, typename C>
+ struct result<This(C)>
+ {
+ typedef
+ typename size_type_of<
+ typename remove_reference<C>::type
+ >::type
+ type;
+ };
+
+ template <typename C>
+ typename size_type_of<C>::type
+ operator()(C const& c) const
+ {
+ return c.max_size();
+ }
+ };
+
+ struct pop_back
+ {
+ typedef void result_type;
+
+ template <typename C>
+ void operator()(C& c) const
+ {
+ return c.pop_back();
+ }
+ };
+
+ struct pop_front
+ {
+ typedef void result_type;
+
+ template <typename C>
+ void operator()(C& c) const
+ {
+ return c.pop_front();
+ }
+ };
+
+ struct push_back
+ {
+ typedef void result_type;
+
+ template <typename C, typename Arg>
+ void operator()(C& c, Arg const& data) const
+ {
+ return c.push_back(data);
+ }
+ };
+
+ struct push_front
+ {
+ typedef void result_type;
+
+ template <typename C, typename Arg>
+ void operator()(C& c, Arg const& data) const
+ {
+ return c.push_front(data);
+ }
+ };
+
+ struct rbegin
+ {
+ template <typename Sig>
+ struct result;
+
+ template <typename This, typename C>
+ struct result<This(C)>
+ {
+ typedef
+ typename const_qualified_reverse_iterator_of<
+ typename remove_reference<C>::type
+ >::type
+ type;
+ };
+
+ template <typename C>
+ typename const_qualified_reverse_iterator_of<C>::type
+ operator()(C& c) const
+ {
+ return c.rbegin();
+ }
+ };
+
+ struct rend
+ {
+ template <typename Sig>
+ struct result;
+
+ template <typename This, typename C>
+ struct result<This(C)>
+ {
+ typedef
+ typename const_qualified_reverse_iterator_of<
+ typename remove_reference<C>::type
+ >::type
+ type;
+ };
+
+ template <typename C>
+ typename const_qualified_reverse_iterator_of<C>::type
+ operator()(C& c) const
+ {
+ return c.rend();
+ }
+ };
+
+ struct reserve
+ {
+ typedef void result_type;
+
+ template <typename C, typename Arg>
+ void operator()(C& c, Arg const& count) const
+ {
+ return c.reserve(count);
+ }
+ };
+
+ struct resize
+ {
+ typedef void result_type;
+
+ template <typename C, typename Arg1>
+ void operator()(C& c, Arg1 const& arg1) const
+ {
+ return c.resize(arg1);
+ }
+
+ template <typename C, typename Arg1, typename Arg2>
+ void operator()(C& c, Arg1 const& arg1, Arg2 const& arg2) const
+ {
+ return c.resize(arg1, arg2);
+ }
+ };
+
+ struct size
+ {
+ template <typename Sig>
+ struct result;
+
+ template <typename This, typename C>
+ struct result<This(C)>
+ {
+ typedef
+ typename size_type_of<
+ typename remove_reference<C>::type
+ >::type
+ type;
+ };
+
+ template <typename C>
+ typename size_type_of<C>::type
+ operator()(C const& c) const
+ {
+ return c.size();
+ }
+ };
+
+ struct splice
+ {
+ typedef void result_type;
+
+ template <typename C, typename Arg1, typename Arg2>
+ void operator()(C& c, Arg1 const& arg1, Arg2& arg2) const
+ {
+ c.splice(arg1, arg2);
+ }
+
+ template <typename C, typename Arg1, typename Arg2, typename Arg3>
+ void operator()(C& c, Arg1 const& arg1, Arg2& arg2, Arg3 const& arg3) const
+ {
+ c.splice(arg1, arg2, arg3);
+ }
+
+ template <typename C, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+ void operator()(C& c, Arg1 const& arg1, Arg2& arg2, Arg3 const& arg3, Arg4 const& arg4) const
+ {
+ c.splice(arg1, arg2, arg3, arg4);
+ }
+ };
+
+ struct value_comp
+ {
+ template <typename Sig>
+ struct result;
+
+ template <typename This, typename C>
+ struct result<This(C)>
+ {
+ typedef
+ typename value_compare_of<
+ typename remove_reference<C>::type
+ >::type
+ type;
+ };
+
+ template <typename C>
+ typename value_compare_of<C>::type
+ operator()(C const& c) const
+ {
+ return c.value_comp();
+ }
+ };
+
+} // namespace stl
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// The lazy functions themselves.
+//
+///////////////////////////////////////////////////////////////////////////////
+function<stl::assign> const assign = {};
+function<stl::at> const at = {};
+function<stl::back> const back = {};
+function<stl::begin> const begin = {};
+function<stl::capacity> const capacity = {};
+function<stl::clear> const clear = {};
+function<stl::empty> const empty = {};
+function<stl::end> const end = {};
+function<stl::erase> const erase = {};
+function<stl::front> const front = {};
+function<stl::get_allocator> const get_allocator = {};
+function<stl::insert> const insert = {};
+function<stl::key_comp> const key_comp = {};
+function<stl::max_size> const max_size = {};
+function<stl::pop_back> const pop_back = {};
+function<stl::pop_front> const pop_front = {};
+function<stl::push_back> const push_back = {};
+function<stl::push_front> const push_front = {};
+function<stl::rbegin> const rbegin = {};
+function<stl::rend> const rend = {};
+function<stl::reserve> const reserve = {};
+function<stl::resize> const resize = {};
+function<stl::size> const size = {};
+function<stl::splice> const splice = {};
+function<stl::value_comp> const value_comp = {};
+
+}} // namespace boost::phoenix
+
+#endif // PHOENIX_STL_CONTAINERS_HPP

Added: branches/proto/v4/boost/phoenix/stl/container/detail/container.hpp
==============================================================================
--- (empty file)
+++ branches/proto/v4/boost/phoenix/stl/container/detail/container.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -0,0 +1,173 @@
+/*=============================================================================
+ Copyright (c) 2004 Angus Leeming
+ Copyright (c) 2004 Joel de Guzman
+
+ 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 PHOENIX_CONTAINER_DETAIL_CONTAINER_HPP
+#define PHOENIX_CONTAINER_DETAIL_CONTAINER_HPP
+
+#include <utility>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+namespace boost { namespace phoenix { namespace stl
+{
+///////////////////////////////////////////////////////////////////////////////
+//
+// Metafunctions "value_type_of", "key_type_of" etc.
+//
+// These metafunctions define a typedef "type" that returns the nested
+// type if it exists. If not then the typedef returns void.
+//
+// For example, "value_type_of<std::vector<int> >::type" is "int" whilst
+// "value_type_of<double>::type" is "void".
+//
+// I use a macro to define structs "value_type_of" etc simply to cut
+// down on the amount of code. The macro is #undef-ed immediately after
+// its final use.
+//
+/////////////////////////////////////////////////////////////////c//////////////
+#define MEMBER_TYPE_OF(MEMBER_TYPE) \
+ template <typename C> \
+ struct BOOST_PP_CAT(MEMBER_TYPE, _of) \
+ { \
+ typedef typename C::MEMBER_TYPE type; \
+ }
+
+ MEMBER_TYPE_OF(allocator_type);
+ MEMBER_TYPE_OF(const_iterator);
+ MEMBER_TYPE_OF(const_reference);
+ MEMBER_TYPE_OF(const_reverse_iterator);
+ MEMBER_TYPE_OF(container_type);
+ MEMBER_TYPE_OF(data_type);
+ MEMBER_TYPE_OF(iterator);
+ MEMBER_TYPE_OF(key_compare);
+ MEMBER_TYPE_OF(key_type);
+ MEMBER_TYPE_OF(reference);
+ MEMBER_TYPE_OF(reverse_iterator);
+ MEMBER_TYPE_OF(size_type);
+ MEMBER_TYPE_OF(value_compare);
+ MEMBER_TYPE_OF(value_type);
+
+#undef MEMBER_TYPE_OF
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// Const-Qualified types.
+//
+// Many of the stl member functions have const and non-const
+// overloaded versions that return distinct types. For example:
+//
+// iterator begin();
+// const_iterator begin() const;
+//
+// The three class templates defined below,
+// const_qualified_reference_of, const_qualified_iterator_of
+// and const_qualified_reverse_iterator_of provide a means to extract
+// this return type automatically.
+//
+///////////////////////////////////////////////////////////////////////////////
+ template <typename C>
+ struct const_qualified_reference_of
+ {
+ typedef typename
+ boost::mpl::eval_if<
+ boost::is_const<C>
+ , const_reference_of<C>
+ , reference_of<C>
+ >::type
+ type;
+ };
+
+ template <typename C>
+ struct const_qualified_iterator_of
+ {
+ typedef typename
+ boost::mpl::eval_if<
+ boost::is_const<C>
+ , const_iterator_of<C>
+ , iterator_of<C>
+ >::type
+ type;
+ };
+
+ template <typename C>
+ struct const_qualified_reverse_iterator_of
+ {
+ typedef typename
+ boost::mpl::eval_if<
+ boost::is_const<C>
+ , const_reverse_iterator_of<C>
+ , reverse_iterator_of<C>
+ >::type
+ type;
+ };
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// has_mapped_type<C>
+//
+// Given a container C, determine if it is a map or multimap
+// by checking if it has a member type named "mapped_type".
+//
+///////////////////////////////////////////////////////////////////////////////
+ namespace stl_impl
+ {
+ struct one { char a[1]; };
+ struct two { char a[2]; };
+
+ template <typename C>
+ one has_mapped_type(typename C::mapped_type(*)());
+
+ template <typename C>
+ two has_mapped_type(...);
+ }
+
+ template <typename C>
+ struct has_mapped_type
+ : boost::mpl::bool_<
+ sizeof(stl_impl::has_mapped_type<C>(0)) == sizeof(stl_impl::one)
+ >
+ {};
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// map_insert_returns_pair<C>
+//
+// Distinguish a map from a multimap by checking the return type
+// of its "insert" member function. A map returns a pair while
+// a multimap returns an iterator.
+//
+///////////////////////////////////////////////////////////////////////////////
+ namespace stl_impl
+ {
+ // Cool implementation of map_insert_returns_pair by Daniel Wallin.
+ // Thanks Daniel!!! I owe you a Pizza!
+
+ template<class A, class B>
+ one map_insert_returns_pair_check(std::pair<A,B> const&);
+
+ template <typename T>
+ two map_insert_returns_pair_check(T const&);
+
+ template <typename C>
+ struct map_insert_returns_pair
+ {
+ static typename C::value_type const& get;
+ BOOST_STATIC_CONSTANT(int,
+ value = sizeof(
+ map_insert_returns_pair_check(((C*)0)->insert(get))));
+ typedef boost::mpl::bool_<value == sizeof(one)> type;
+ };
+ }
+
+ template <typename C>
+ struct map_insert_returns_pair
+ : stl_impl::map_insert_returns_pair<C>::type {};
+
+}}} // namespace boost::phoenix::stl
+
+#endif // PHOENIX_STL_CONTAINER_TRAITS_HPP

Modified: branches/proto/v4/libs/phoenix/test/Jamfile.v2
==============================================================================
--- branches/proto/v4/libs/phoenix/test/Jamfile.v2 (original)
+++ branches/proto/v4/libs/phoenix/test/Jamfile.v2 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -12,6 +12,7 @@
project
 : requirements
 <define>BOOST_MPL_LIMIT_METAFUNCTION_ARITY=10
+ <toolset>msvc:<define>_SCL_SECURE_NO_DEPRECATE
 ;

local multi-threading = <library>/boost/thread//boost_thread

Modified: branches/proto/v4/libs/phoenix/test/algorithm/querying2.cpp
==============================================================================
--- branches/proto/v4/libs/phoenix/test/algorithm/querying2.cpp (original)
+++ branches/proto/v4/libs/phoenix/test/algorithm/querying2.cpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -6,7 +6,7 @@
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/

-#include <boost/phoenix/stl.hpp/querying.hpp>
+#include <boost/phoenix/stl/algorithm/querying.hpp>
#include <boost/phoenix/core.hpp>
#include <boost/detail/lightweight_test.hpp>

Modified: branches/proto/v4/libs/phoenix/test/algorithm/transformation3.cpp
==============================================================================
--- branches/proto/v4/libs/phoenix/test/algorithm/transformation3.cpp (original)
+++ branches/proto/v4/libs/phoenix/test/algorithm/transformation3.cpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -6,7 +6,7 @@
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/

-#include <boost/spirit/phoenix/stl/algorithm/transformation.hpp>
+#include <boost/phoenix/stl/algorithm/transformation.hpp>
#include <boost/phoenix/core.hpp>
#include <boost/detail/lightweight_test.hpp>

Modified: branches/proto/v4/libs/phoenix/test/algorithm/transformation4.cpp
==============================================================================
--- branches/proto/v4/libs/phoenix/test/algorithm/transformation4.cpp (original)
+++ branches/proto/v4/libs/phoenix/test/algorithm/transformation4.cpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -6,7 +6,7 @@
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/

-#include <boost/spirit/phoenix/stl/algorithm/transformation.hpp>
+#include <boost/phoenix/stl/algorithm/transformation.hpp>
#include <boost/phoenix/core.hpp>
#include <boost/detail/lightweight_test.hpp>

Modified: branches/proto/v4/libs/phoenix/test/container/container_tests.hpp
==============================================================================
--- branches/proto/v4/libs/phoenix/test/container/container_tests.hpp (original)
+++ branches/proto/v4/libs/phoenix/test/container/container_tests.hpp 2008-06-01 21:10:07 EDT (Sun, 01 Jun 2008)
@@ -9,7 +9,7 @@

#include <boost/detail/lightweight_test.hpp>
#include <boost/phoenix/core.hpp>
-#include <boost/spirit/phoenix/stl/container/container.hpp>
+#include <boost/phoenix/stl/container/container.hpp>

#include <iostream>
#include <typeinfo>

Next message: chintanraoh_at_[hidden]: "[Boost-commit] svn:boost r46036 - sandbox/SOC/2008/digital_searching/dsearch/boost/dsearch"
Previous message: ockham_at_[hidden]: "[Boost-commit] svn:boost r46034 - sandbox/SOC/2006/tree/trunk/boost/tree"

Date view	Thread view	Subject view	Author view

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