[Boost-commit] svn:boost r66524 - in sandbox/SOC/2010/phoenix3: boost/phoenix/core boost/phoenix/operator libs/phoenix/test/operator

Subject: [Boost-commit] svn:boost r66524 - in sandbox/SOC/2010/phoenix3: boost/phoenix/core boost/phoenix/operator libs/phoenix/test/operator
From: thom.heller_at_[hidden]
Date: 2010-11-12 10:03:52

Author: theller
Date: 2010-11-12 10:03:50 EST (Fri, 12 Nov 2010)
New Revision: 66524
URL: http://svn.boost.org/trac/boost/changeset/66524

Log:
started unpack implementation
Added:
   sandbox/SOC/2010/phoenix3/boost/phoenix/core/unpack.hpp   (contents, props changed)
Text files modified: 
   sandbox/SOC/2010/phoenix3/boost/phoenix/operator/member.hpp     |   158 ++++++++++++--------------------------- 
   sandbox/SOC/2010/phoenix3/libs/phoenix/test/operator/member.cpp |     7 +                                       
   2 files changed, 57 insertions(+), 108 deletions(-)

Added: sandbox/SOC/2010/phoenix3/boost/phoenix/core/unpack.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/phoenix3/boost/phoenix/core/unpack.hpp	2010-11-12 10:03:50 EST (Fri, 12 Nov 2010)
@@ -0,0 +1,173 @@
+/*=============================================================================
+    Copyright (c) 2005-2010 Joel de Guzman
+    Copyright (c) 2010 Eric Niebler
+    Copyright (c) 2010 Thomas Heller
+
+    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_CORE_UNPACK_HPP
+#define PHOENIX_CORE_UNPACK_HPP
+
+#include <boost/fusion/include/size.hpp>
+#include <boost/proto/proto.hpp>
+
+namespace boost { namespace phoenix
+{
+	struct unpack {};
+
+	namespace detail
+	{
+		template <typename Expr, typename State, typename Data, typename Transform, long Arity = fusion::result_of::size<Expr>::value>
+		struct unpack_impl;
+		
+		template <typename Expr, typename State, typename Data, typename R>
+		struct unpack_impl<Expr, State, Data, R(unpack), 1>
+			: proto::transform_impl<Expr, State, Data>
+		{
+			typedef int result_type;
+
+			result_type
+			operator()(
+				typename unpack_impl::expr_param e
+			 , typename unpack_impl::state_param s
+			 , typename unpack_impl::data_param d
+			) const
+			{
+				std::cout << "yeha ... unpack without params 1\n";
+				return 5;
+			}
+		};
+
+		template <typename Expr, typename State, typename Data, typename R>
+		struct unpack_impl<Expr, State, Data, R(unpack), 2>
+			: proto::transform_impl<Expr, State, Data>
+		{
+			typedef int result_type;
+
+			result_type
+			operator()(
+				typename unpack_impl::expr_param e
+			 , typename unpack_impl::state_param s
+			 , typename unpack_impl::data_param d
+			) const
+			{
+				std::cout << "yeha ... unpack without params 2\n";
+				return 5;
+			}
+		};
+
+		template <typename Expr, typename State, typename Data, typename R, typename Seq>
+		struct unpack_impl<Expr, State, Data, R(unpack(Seq)), 2>
+			: proto::transform_impl<Expr, State, Data>
+		{
+			typedef int result_type;
+
+			result_type
+			operator()(
+				typename unpack_impl::expr_param e
+			 , typename unpack_impl::state_param s
+			 , typename unpack_impl::data_param d
+			) const
+			{
+				std::cout << "yeha ... unpack with Seq 2\n";
+				return 5;
+			}
+		};
+
+		template <typename Expr, typename State, typename Data, typename R>
+		struct unpack_impl<Expr, State, Data, R(unpack), 3>
+			: proto::transform_impl<Expr, State, Data>
+		{
+			typedef int result_type;
+
+			result_type
+			operator()(
+				typename unpack_impl::expr_param e
+			 , typename unpack_impl::state_param s
+			 , typename unpack_impl::data_param d
+			) const
+			{
+				std::cout << "yeha ... unpack without params 3\n";
+				return 5;
+			}
+		};
+
+		template <typename Expr, typename State, typename Data, typename R, typename Seq>
+		struct unpack_impl<Expr, State, Data, R(unpack(Seq)), 3>
+			: proto::transform_impl<Expr, State, Data>
+		{
+			typedef int result_type;
+
+			result_type
+			operator()(
+				typename unpack_impl::expr_param e
+			 , typename unpack_impl::state_param s
+			 , typename unpack_impl::data_param d
+			) const
+			{
+				typedef typename proto::when<proto::_, Seq>::template impl<Expr, State, Data>::result_type test_type;
+
+				std::cout << "yeha ... unpack with Seq 3\n";
+				std::cout << "Seq:\n";
+				std::cout << typeid(Seq).name() << "\n";
+				//std::cout << typeid(typename boost::result_of<proto::_child_c<0>(proto::when<proto::_, Seq>(Expr))>::type).name() << "\n";
+				//std::cout << typeid(typename boost::result_of<Seq(Expr)>::type).name() << "\n";
+				std::cout << typeid(test_type).name() << "\n";
+				//std::cout << typeid(typename boost::result_of<proto::_child_c<0>(test_type)>::type).name() << "\n";
+				std::cout << "Expr:\n";
+				std::cout << typeid(Expr).name() << "\n";
+				return 5;
+			}
+		};
+	}
+}}
+
+namespace boost { namespace proto
+{
+	template <typename R>
+	struct call<R(phoenix::unpack)>
+		: proto::transform<call<R(phoenix::unpack)> >
+	{
+		template <typename Expr, typename State, typename Data>
+		struct impl
+			: phoenix::detail::unpack_impl<Expr, State, Data, R(phoenix::unpack)>
+		{};
+	};
+	
+	template <typename R, typename Seq>
+	struct call<R(phoenix::unpack(Seq))>
+		: proto::transform<call<R(phoenix::unpack(Seq))> >
+	{
+		template <typename Expr, typename State, typename Data>
+		struct impl
+			: phoenix::detail::unpack_impl<Expr, State, Data, R(phoenix::unpack(Seq))>
+		{};
+	};
+	
+	template <typename R, typename Seq, typename Fun>
+	struct call<R(phoenix::unpack(Seq, Fun))>
+		: proto::transform<call<R(phoenix::unpack(Seq, Fun))> >
+	{
+		template <typename Expr, typename State, typename Data>
+		struct impl
+			: proto::transform_impl<Expr, State, Data>
+		{
+			typedef int result_type;
+
+			result_type
+			operator()(
+				typename impl::expr_param e
+			 , typename impl::state_param s
+			 , typename impl::data_param d
+			) const
+			{
+				std::cout << "yeha ... unpack with Seq and Fun param\n";
+				return 5;
+			}
+		};
+	};
+
+}}
+
+#endif

Modified: sandbox/SOC/2010/phoenix3/boost/phoenix/operator/member.hpp
==============================================================================
--- sandbox/SOC/2010/phoenix3/boost/phoenix/operator/member.hpp	(original)
+++ sandbox/SOC/2010/phoenix3/boost/phoenix/operator/member.hpp	2010-11-12 10:03:50 EST (Fri, 12 Nov 2010)
@@ -1,13 +1,3 @@
-/*==============================================================================
-    Copyright (c) 2001-2010 Joel de Guzman
-    Copyright (c) 2010 Thomas Heller
-
-    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)
-==============================================================================*/
-
-#if !PHOENIX_IS_ITERATING
-
 #ifndef PHOENIX_OPERATOR_MEMBER_HPP
 #define PHOENIX_OPERATOR_MEMBER_HPP
 
@@ -20,6 +10,8 @@
 #include <boost/proto/make_expr.hpp>
 #include <boost/proto/tags.hpp>
 #include <boost/type_traits/is_member_object_pointer.hpp>*/
+#include <boost/phoenix/core/unpack.hpp>
+#include <boost/phoenix/operator/detail/mem_fun_ptr_gen.hpp>
 #include <boost/type_traits/is_member_function_pointer.hpp>
 
 namespace boost { namespace phoenix
@@ -30,117 +22,69 @@
 
         namespace rule
         {
-		struct function
-			: proto::function<proto::vararg<meta_grammar> >
+		struct mem_fun_ptr
+			: proto::nary_expr<tag::mem_fun_ptr, proto::vararg<meta_grammar> >
                 {};
         }
 
         template <typename Dummy>
-	struct meta_grammar::case_<proto::tag::function, Dummy>
-		: proto::when<rule::function, proto::external_transform>
+	struct meta_grammar::case_<tag::mem_fun_ptr, Dummy>
+		: proto::when<rule::mem_fun_ptr, proto::external_transform>
         {};
-	
-	namespace detail {
-        namespace result_of
-        {
-            template <typename Object, typename MemPtr,
-                PHOENIX_typename_A_void(PHOENIX_MEMBER_LIMIT)
-                , typename Dummy = void>
-            struct mem_fun_ptr;
-
-            template <typename Object, typename MemPtr>
-            struct mem_fun_ptr<Object, MemPtr>
-                : proto::result_of::make_expr<
-                      proto::tag::function
-                    , phoenix_domain
-                    , MemPtr
-                    , Object>
-            {};
-
-#define PHOENIX_ITERATE_RESULT_OF 1
-#define PHOENIX_ITERATION_PARAMS                                                \
-        (4, (1, PHOENIX_MEMBER_LIMIT,                                           \
-        <boost/phoenix/operator/member.hpp>,                                    \
-        PHOENIX_ITERATE_RESULT_OF))
-#include PHOENIX_ITERATE()
-#undef PHOENIX_ITERATE_RESULT_OF
-
-        }
-
-        template <typename Object, typename MemPtr>
-        struct mem_fun_ptr
-        {
-            mem_fun_ptr(Object const& obj, MemPtr ptr)
-              : obj(obj)
-              , ptr(ptr)
-            {}
-
-            typename result_of::mem_fun_ptr<Object, MemPtr>::type const
-            operator()() const
-            {
-                return proto::make_expr<
-                    proto::tag::function, phoenix_domain>(ptr, obj);
-            }
-
-#define PHOENIX_ITERATE_OPERATOR 2
-#define PHOENIX_ITERATION_PARAMS                                                \
-        (4, (1, PHOENIX_MEMBER_LIMIT,                                           \
-        <boost/phoenix/operator/member.hpp>,                                    \
-        PHOENIX_ITERATE_OPERATOR))
-#include PHOENIX_ITERATE()
-#undef PHOENIX_ITERATE_OPERATOR
-
-            Object const& obj;
-            MemPtr ptr;
-
-        };
-
-	}
 
         template <typename Object, typename MemPtr>
     typename enable_if<
         is_member_function_pointer<MemPtr>
-      , detail::mem_fun_ptr<actor<Object>, MemPtr> const
+      , detail::mem_fun_ptr_gen<actor<Object>, MemPtr> const
       >::type
     operator->*(actor<Object> const& obj, MemPtr ptr)
     {
-        return detail::mem_fun_ptr<actor<Object>, MemPtr>(obj, ptr);
+        return detail::mem_fun_ptr_gen<actor<Object>, MemPtr>(obj, ptr);
     }
+
+	struct mem_fun_ptr_eval
+		: proto::callable
+	{
+		typedef int result_type;
+		
+		result_type
+		operator()() const
+		{
+			std::cout << "ok ... evaluate ... \n";
+			return 5;
+		}
+
+		template <typename T1>
+		result_type
+		operator()(T1 const& t1) const
+		{
+			std::cout << "ok ... evaluate ... \n";
+			return 5;
+		}
+
+		template <typename T1, typename T2>
+		result_type
+		operator()(T1 const& t1, T2 const& t2) const
+		{
+			std::cout << "ok ... evaluate ... \n";
+			return 5;
+		}
+
+		template <typename T1, typename T2, typename T3>
+		result_type
+		operator()(T1 const& t1, T2 const& t2, T3 const& t3) const
+		{
+			std::cout << "ok ... evaluate ... \n";
+			return 5;
+		}
+	};
+
+   template <typename Dummy>
+	struct default_actions::when<rule::mem_fun_ptr, Dummy>
+		//: proto::call<mem_fun_ptr_eval(unpack(proto::_))>
+		: proto::call<mem_fun_ptr_eval(unpack(fusion::vector0<>()))>
+	{};
 }}
 
 #endif
 
-#else
-
-#if BOOST_PP_ITERATION_FLAGS() == PHOENIX_ITERATE_RESULT_OF
-
-            template <typename Object, typename MemPtr, PHOENIX_typename_A>
-            struct mem_fun_ptr<Object, MemPtr, PHOENIX_A>
-                : proto::result_of::make_expr<
-                      proto::tag::function
-                    , phoenix_domain
-                    , MemPtr
-                    , Object
-                    , PHOENIX_A>
-            {};
-
-#elif BOOST_PP_ITERATION_FLAGS() == PHOENIX_ITERATE_OPERATOR
-
-            template <PHOENIX_typename_A>
-            typename result_of::mem_fun_ptr<Object, MemPtr, PHOENIX_A>::type const
-            operator()(PHOENIX_A_const_ref_a) const
-            {
-                return proto::make_expr<
-                    proto::tag::function, phoenix_domain>(ptr, obj, PHOENIX_a);
-            }
-
-            template <PHOENIX_typename_A>
-            typename result_of::mem_fun_ptr<Object, MemPtr, PHOENIX_A>::type const
-            operator()(PHOENIX_A_ref_a) const
-            {
-                return proto::make_expr<
-                    proto::tag::function, phoenix_domain>(ptr, obj, PHOENIX_a);
-            }
-
-#endif
-#endif

Modified: sandbox/SOC/2010/phoenix3/libs/phoenix/test/operator/member.cpp
==============================================================================
--- sandbox/SOC/2010/phoenix3/libs/phoenix/test/operator/member.cpp	(original)
+++ sandbox/SOC/2010/phoenix3/libs/phoenix/test/operator/member.cpp	2010-11-12 10:03:50 EST (Fri, 12 Nov 2010)
@@ -42,14 +42,18 @@
     const Test* cptr = &test;
     Test* ptr = &test;
 
+	 /*
     BOOST_TEST((val(ptr)->*&Test::value)() == 1);
     BOOST_TEST((val(cptr)->*&Test::value)() == 1);
     BOOST_TEST((arg1->*&Test::value)(cptr) == 1);
 
     ((val(ptr)->*&Test::value) = 2)();
     BOOST_TEST(test.value == 2);
+	 */
 
-	 val(ptr)->*&Test::func;
+	 (val(ptr)->*&Test::func)(3)();
+
+	 /*
     BOOST_TEST((val(ptr)->*&Test::func)(3)() == 3);
     int i = 33;
     BOOST_TEST((arg1->*&Test::func)(arg2)(cptr, i) == i);
@@ -88,6 +92,7 @@
 
     BOOST_TEST((arg1->*&Test::value)(captr) == 2);
     BOOST_TEST((arg1->*&Test::func)(11)(captr) == 11);
+	 */
 
     return 0;
 }