[ceph.git] / ceph / src / boost / libs / proto / include / boost / proto / transform / arg.hpp

///////////////////////////////////////////////////////////////////////////////
/// \file arg.hpp
/// Contains definition of the argN transforms.
//
//  Copyright 2008 Eric Niebler. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_PROTO_TRANSFORM_ARG_HPP_EAN_11_01_2007
#define BOOST_PROTO_TRANSFORM_ARG_HPP_EAN_11_01_2007

#include <boost/mpl/if.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/traits.hpp>
#include <boost/proto/transform/impl.hpp>
#include <boost/type_traits/is_array.hpp>
#include <boost/proto/transform/env.hpp>

namespace boost { namespace proto
{

    /// \brief A PrimitiveTransform that returns the current expression
    /// unmodified
    ///
    /// Example:
    ///
    /// \code
    /// proto::terminal<int>::type i = {42};
    /// proto::terminal<int>::type & j = proto::_expr()(i);
    /// assert( boost::addressof(i) == boost::addressof(j) );
    /// \endcode
    struct _expr : transform<_expr>
    {
        template<typename Expr, typename State, typename Data>
        struct impl : transform_impl<Expr, State, Data>
        {
            typedef Expr result_type;

            /// Returns the current expression.
            /// \param e The current expression.
            /// \return \c e
            /// \throw nothrow
            BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::expr_param)
            operator()(
                typename impl::expr_param e
              , typename impl::state_param
              , typename impl::data_param
            ) const
            {
                return e;
            }
        };
    };

    /// \brief A PrimitiveTransform that returns the current state
    /// unmodified
    ///
    /// Example:
    ///
    /// \code
    /// proto::terminal<int>::type i = {42};
    /// char ch = proto::_state()(i, 'a');
    /// assert( ch == 'a' );
    /// \endcode
    struct _state : transform<_state>
    {
        template<typename Expr, typename State, typename Data>
        struct impl : transform_impl<Expr, State, Data>
        {
            typedef State result_type;

            /// Returns the current state.
            /// \param s The current state.
            /// \return \c s
            /// \throw nothrow
            BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::state_param)
            operator ()(
                typename impl::expr_param
              , typename impl::state_param s
              , typename impl::data_param
            ) const
            {
                return s;
            }
        };
    };

    /// \brief A PrimitiveTransform that returns the current data
    /// unmodified
    ///
    /// Example:
    ///
    /// \code
    /// proto::terminal<int>::type i = {42};
    /// std::string str("hello");
    /// std::string & data = proto::_data()(i, 'a', str);
    /// assert( &str == &data );
    /// \endcode
    struct _data : transform<_data>
    {
        template<typename Expr, typename State, typename Data>
        struct impl
          : mpl::if_c<
                is_env<Data>::value
              , _env_var<data_type>
              , _env
            >::type::template impl<Expr, State, Data>
        {};
    };

    /// \brief A PrimitiveTransform that returns N-th child of the current
    /// expression.
    ///
    /// Example:
    ///
    /// \code
    /// proto::terminal<int>::type i = {42};
    /// proto::terminal<int>::type & j = proto::_child_c<0>()(-i);
    /// assert( boost::addressof(i) == boost::addressof(j) );
    /// \endcode
    template<int N>
    struct _child_c : transform<_child_c<N> >
    {
        template<typename Expr, typename State, typename Data>
        struct impl : transform_impl<Expr, State, Data>
        {
            typedef
                typename result_of::child_c<Expr, N>::type
            result_type;

            /// Returns the N-th child of \c e
            /// \pre <tt>arity_of\<Expr\>::value \> N</tt> 
            /// \param e The current expression.
            /// \return <tt>proto::child_c\<N\>(e)</tt>
            /// \throw nothrow
            #ifdef BOOST_PROTO_STRICT_RESULT_OF
            result_type
            #else
            typename result_of::child_c<typename impl::expr_param, N>::type
            #endif
            operator ()(
                typename impl::expr_param e
              , typename impl::state_param
              , typename impl::data_param
            ) const
            {
                return proto::child_c<N>(e);
            }
        };
    };

    /// \brief A PrimitiveTransform that returns the value of the
    /// current terminal expression.
    ///
    /// Example:
    ///
    /// \code
    /// proto::terminal<int>::type i = {42};
    /// int j = proto::_value()(i);
    /// assert( 42 == j );
    /// \endcode
    struct _value : transform<_value>
    {
        template<typename Expr, typename State, typename Data>
        struct impl : transform_impl<Expr, State, Data>
        {
            typedef
                typename result_of::value<Expr>::type
            result_type;

            /// Returns the value of the specified terminal expression.
            /// \pre <tt>arity_of\<Expr\>::value == 0</tt>.
            /// \param e The current expression.
            /// \return <tt>proto::value(e)</tt>
            /// \throw nothrow
            #ifdef BOOST_PROTO_STRICT_RESULT_OF
            typename mpl::if_c<is_array<result_type>::value, result_type &, result_type>::type
            #else
            typename result_of::value<typename impl::expr_param>::type
            #endif
            operator ()(
                typename impl::expr_param e
              , typename impl::state_param
              , typename impl::data_param
            ) const
            {
                return proto::value(e);
            }
        };
    };

    /// \brief A PrimitiveTransform that does nothing
    /// and returns void.
    struct _void : transform<_void>
    {
        template<typename Expr, typename State, typename Data>
        struct impl : transform_impl<Expr, State, Data>
        {
            typedef void result_type;

            /// Does nothing and returns void
            void operator ()(
                typename impl::expr_param
              , typename impl::state_param
              , typename impl::data_param
            ) const
            {}
        };
    };

    /// \brief A unary CallableTransform that wraps its argument
    /// in a \c boost::reference_wrapper\<\>.
    ///
    /// Example:
    ///
    /// \code
    /// proto::terminal<int>::type i = {42};
    /// boost::reference_wrapper<proto::terminal<int>::type> j
    ///     = proto::when<_, proto::_byref(_)>()(i);
    /// assert( boost::addressof(i) == boost::addressof(j.get()) );
    /// \endcode
    struct _byref : callable
    {
        template<typename Sig>
        struct result;

        template<typename This, typename T>
        struct result<This(T)>
        {
            typedef boost::reference_wrapper<T const> const type;
        };

        template<typename This, typename T>
        struct result<This(T &)>
        {
            typedef boost::reference_wrapper<T> const type;
        };

        /// Wrap the parameter \c t in a \c boost::reference_wrapper\<\>
        /// \param t The object to wrap
        /// \return <tt>boost::ref(t)</tt>
        /// \throw nothrow
        template<typename T>
        boost::reference_wrapper<T> const operator ()(T &t) const
        {
            return boost::reference_wrapper<T>(t);
        }

        /// \overload
        ///
        template<typename T>
        boost::reference_wrapper<T const> const operator ()(T const &t) const
        {
            return boost::reference_wrapper<T const>(t);
        }
    };

    /// \brief A unary CallableTransform that strips references
    /// and \c boost::reference_wrapper\<\> from its argument.
    ///
    /// Example:
    ///
    /// \code
    /// proto::terminal<int>::type i = {42};
    /// int j = 67;
    /// int k = proto::when<_, proto::_byval(proto::_state)>()(i, boost::ref(j));
    /// assert( 67 == k );
    /// \endcode
    struct _byval : callable
    {
        template<typename Sig>
        struct result;

        template<typename This, typename T>
        struct result<This(T)>
        {
            typedef T type;
        };

        template<typename This, typename T>
        struct result<This(T &)>
          : result<This(T)>
        {};

        template<typename This, typename T>
        struct result<This(boost::reference_wrapper<T>)>
          : result<This(T)>
        {};

        /// \param t The object to unref
        /// \return <tt>t</tt>
        /// \throw nothrow
        template<typename T>
        T operator ()(T const &t) const
        {
            return t;
        }

        /// \overload
        ///
        template<typename T>
        T operator ()(boost::reference_wrapper<T> const &t) const
        {
            return t;
        }
    };

    /// INTERNAL ONLY
    ///
    template<>
    struct is_callable<_expr>
      : mpl::true_
    {};

    /// INTERNAL ONLY
    ///
    template<>
    struct is_callable<_state>
      : mpl::true_
    {};

    /// INTERNAL ONLY
    ///
    template<>
    struct is_callable<_data>
      : mpl::true_
    {};

    /// INTERNAL ONLY
    ///
    template<int N>
    struct is_callable<_child_c<N> >
      : mpl::true_
    {};

    /// INTERNAL ONLY
    ///
    template<>
    struct is_callable<_value>
      : mpl::true_
    {};

    /// INTERNAL ONLY
    ///
    template<>
    struct is_callable<_byref>
      : mpl::true_
    {};

    /// INTERNAL ONLY
    ///
    template<>
    struct is_callable<_byval>
      : mpl::true_
    {};

}}

#endif
Commit	Line	Data
7c673cae FG	1	///////////////////////////////////////////////////////////////////////////////
	2	/// \file arg.hpp
	3	/// Contains definition of the argN transforms.
	4	//
	5	// Copyright 2008 Eric Niebler. Distributed under the Boost
	6	// Software License, Version 1.0. (See accompanying file
	7	// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
	8
	9	#ifndef BOOST_PROTO_TRANSFORM_ARG_HPP_EAN_11_01_2007
	10	#define BOOST_PROTO_TRANSFORM_ARG_HPP_EAN_11_01_2007
	11
	12	#include <boost/mpl/if.hpp>
	13	#include <boost/proto/proto_fwd.hpp>
	14	#include <boost/proto/traits.hpp>
	15	#include <boost/proto/transform/impl.hpp>
	16	#include <boost/type_traits/is_array.hpp>
	17	#include <boost/proto/transform/env.hpp>
	18
	19	namespace boost { namespace proto
	20	{
	21
	22	/// \brief A PrimitiveTransform that returns the current expression
	23	/// unmodified
	24	///
	25	/// Example:
	26	///
	27	/// \code
	28	/// proto::terminal<int>::type i = {42};
	29	/// proto::terminal<int>::type & j = proto::_expr()(i);
	30	/// assert( boost::addressof(i) == boost::addressof(j) );
	31	/// \endcode
	32	struct _expr : transform<_expr>
	33	{
	34	template<typename Expr, typename State, typename Data>
	35	struct impl : transform_impl<Expr, State, Data>
	36	{
	37	typedef Expr result_type;
	38
	39	/// Returns the current expression.
	40	/// \param e The current expression.
	41	/// \return \c e
	42	/// \throw nothrow
	43	BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::expr_param)
	44	operator()(
	45	typename impl::expr_param e
	46	, typename impl::state_param
	47	, typename impl::data_param
	48	) const
	49	{
	50	return e;
	51	}
	52	};
	53	};
	54
	55	/// \brief A PrimitiveTransform that returns the current state
	56	/// unmodified
	57	///
	58	/// Example:
	59	///
	60	/// \code
	61	/// proto::terminal<int>::type i = {42};
	62	/// char ch = proto::_state()(i, 'a');
	63	/// assert( ch == 'a' );
	64	/// \endcode
65	struct _state : transform<_state>
66	{
67	template<typename Expr, typename State, typename Data>
68	struct impl : transform_impl<Expr, State, Data>
69	{
70	typedef State result_type;
71
72	/// Returns the current state.
73	/// \param s The current state.
74	/// \return \c s
75	/// \throw nothrow
76	BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::state_param)
77	operator ()(
78	typename impl::expr_param
79	, typename impl::state_param s
80	, typename impl::data_param
81	) const
82	{
83	return s;
84	}
85	};
86	};
87
88	/// \brief A PrimitiveTransform that returns the current data
89	/// unmodified
90	///
91	/// Example:
92	///
93	/// \code
94	/// proto::terminal<int>::type i = {42};
95	/// std::string str("hello");
96	/// std::string & data = proto::_data()(i, 'a', str);
97	/// assert( &str == &data );
98	/// \endcode
99	struct _data : transform<_data>
100	{
101	template<typename Expr, typename State, typename Data>
102	struct impl
103	: mpl::if_c<
104	is_env<Data>::value
105	, _env_var<data_type>
106	, _env
107	>::type::template impl<Expr, State, Data>
108	{};
109	};
110
111	/// \brief A PrimitiveTransform that returns N-th child of the current
112	/// expression.
113	///
114	/// Example:
115	///
116	/// \code
117	/// proto::terminal<int>::type i = {42};
118	/// proto::terminal<int>::type & j = proto::_child_c<0>()(-i);
119	/// assert( boost::addressof(i) == boost::addressof(j) );
120	/// \endcode
121	template<int N>
122	struct _child_c : transform<_child_c<N> >
123	{
124	template<typename Expr, typename State, typename Data>
125	struct impl : transform_impl<Expr, State, Data>
126	{
127	typedef
128	typename result_of::child_c<Expr, N>::type
129	result_type;
130
131	/// Returns the N-th child of \c e
132	/// \pre <tt>arity_of\<Expr\>::value \> N</tt>
133	/// \param e The current expression.
134	/// \return <tt>proto::child_c\<N\>(e)</tt>
135	/// \throw nothrow
136	#ifdef BOOST_PROTO_STRICT_RESULT_OF
137	result_type
138	#else
139	typename result_of::child_c<typename impl::expr_param, N>::type
140	#endif
141	operator ()(
142	typename impl::expr_param e
143	, typename impl::state_param
144	, typename impl::data_param
145	) const
146	{
147	return proto::child_c<N>(e);
148	}
149	};
150	};
151
152	/// \brief A PrimitiveTransform that returns the value of the
153	/// current terminal expression.
154	///
155	/// Example:
156	///
157	/// \code
158	/// proto::terminal<int>::type i = {42};
159	/// int j = proto::_value()(i);
160	/// assert( 42 == j );
161	/// \endcode
162	struct _value : transform<_value>
163	{
164	template<typename Expr, typename State, typename Data>
165	struct impl : transform_impl<Expr, State, Data>
166	{
167	typedef
168	typename result_of::value<Expr>::type
169	result_type;
170
171	/// Returns the value of the specified terminal expression.
172	/// \pre <tt>arity_of\<Expr\>::value == 0</tt>.
173	/// \param e The current expression.
174	/// \return <tt>proto::value(e)</tt>
175	/// \throw nothrow
176	#ifdef BOOST_PROTO_STRICT_RESULT_OF
177	typename mpl::if_c<is_array<result_type>::value, result_type &, result_type>::type
178	#else
179	typename result_of::value<typename impl::expr_param>::type
180	#endif
181	operator ()(
182	typename impl::expr_param e
183	, typename impl::state_param
184	, typename impl::data_param
185	) const
186	{
187	return proto::value(e);
188	}
189	};
190	};
191
192	/// \brief A PrimitiveTransform that does nothing
193	/// and returns void.
194	struct _void : transform<_void>
195	{
196	template<typename Expr, typename State, typename Data>
197	struct impl : transform_impl<Expr, State, Data>
198	{
199	typedef void result_type;
200
201	/// Does nothing and returns void
202	void operator ()(
203	typename impl::expr_param
204	, typename impl::state_param
205	, typename impl::data_param
206	) const
207	{}
208	};
209	};
210
211	/// \brief A unary CallableTransform that wraps its argument
212	/// in a \c boost::reference_wrapper\<\>.
213	///
214	/// Example:
215	///
216	/// \code
217	/// proto::terminal<int>::type i = {42};
218	/// boost::reference_wrapper<proto::terminal<int>::type> j
219	/// = proto::when<_, proto::_byref(_)>()(i);
220	/// assert( boost::addressof(i) == boost::addressof(j.get()) );
221	/// \endcode
222	struct _byref : callable
223	{
224	template<typename Sig>
225	struct result;
226
227	template<typename This, typename T>
228	struct result<This(T)>
229	{
230	typedef boost::reference_wrapper<T const> const type;
231	};
232
233	template<typename This, typename T>
234	struct result<This(T &)>
235	{
236	typedef boost::reference_wrapper<T> const type;
237	};
238
239	/// Wrap the parameter \c t in a \c boost::reference_wrapper\<\>
240	/// \param t The object to wrap
241	/// \return <tt>boost::ref(t)</tt>
242	/// \throw nothrow
243	template<typename T>
244	boost::reference_wrapper<T> const operator ()(T &t) const
245	{
246	return boost::reference_wrapper<T>(t);
247	}
248
249	/// \overload
250	///
251	template<typename T>
252	boost::reference_wrapper<T const> const operator ()(T const &t) const
253	{
254	return boost::reference_wrapper<T const>(t);
255	}
256	};
257
258	/// \brief A unary CallableTransform that strips references
259	/// and \c boost::reference_wrapper\<\> from its argument.
260	///
261	/// Example:
262	///
263	/// \code
264	/// proto::terminal<int>::type i = {42};
265	/// int j = 67;
266	/// int k = proto::when<_, proto::_byval(proto::_state)>()(i, boost::ref(j));
267	/// assert( 67 == k );
268	/// \endcode
269	struct _byval : callable
270	{
271	template<typename Sig>
272	struct result;
273
274	template<typename This, typename T>
275	struct result<This(T)>
276	{
277	typedef T type;
278	};
279
280	template<typename This, typename T>
281	struct result<This(T &)>
282	: result<This(T)>
283	{};
284
285	template<typename This, typename T>
286	struct result<This(boost::reference_wrapper<T>)>
287	: result<This(T)>
288	{};
289
290	/// \param t The object to unref
291	/// \return <tt>t</tt>
292	/// \throw nothrow
293	template<typename T>
294	T operator ()(T const &t) const
295	{
296	return t;
297	}
298
299	/// \overload
300	///
301	template<typename T>
302	T operator ()(boost::reference_wrapper<T> const &t) const
303	{
304	return t;
305	}
306	};
307
308	/// INTERNAL ONLY
309	///
310	template<>
311	struct is_callable<_expr>
312	: mpl::true_
313	{};
314
315	/// INTERNAL ONLY
316	///
317	template<>
318	struct is_callable<_state>
319	: mpl::true_
320	{};
321
322	/// INTERNAL ONLY
323	///
324	template<>
325	struct is_callable<_data>
326	: mpl::true_
327	{};
328
329	/// INTERNAL ONLY
330	///
331	template<int N>
332	struct is_callable<_child_c<N> >
333	: mpl::true_
334	{};
335
336	/// INTERNAL ONLY
337	///
338	template<>
339	struct is_callable<_value>
340	: mpl::true_
341	{};
342
343	/// INTERNAL ONLY
344	///
345	template<>
346	struct is_callable<_byref>
347	: mpl::true_
348	{};
349
350	/// INTERNAL ONLY
351	///
352	template<>
353	struct is_callable<_byval>
354	: mpl::true_
355	{};
356
357	}}
358
359	#endif