boost/proto/transform/env.hpp
/////////////////////////////////////////////////////////////////////////////// // env.hpp // Helpers for producing and consuming tranform env variables. // // Copyright 2012 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_ENV_HPP_EAN_18_07_2012 #define BOOST_PROTO_TRANSFORM_ENV_HPP_EAN_18_07_2012 #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #include <boost/ref.hpp> #include <boost/utility/enable_if.hpp> #include <boost/type_traits/is_const.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/type_traits/add_const.hpp> #include <boost/type_traits/add_reference.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/mpl/assert.hpp> #include <boost/mpl/bool.hpp> #include <boost/mpl/if.hpp> #include <boost/mpl/not.hpp> #include <boost/proto/proto_fwd.hpp> #include <boost/proto/transform/impl.hpp> #include <boost/proto/detail/poly_function.hpp> #include <boost/proto/detail/is_noncopyable.hpp> #ifdef _MSC_VER # pragma warning(push) # pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored #endif namespace boost { namespace proto { namespace detail { template<typename T> struct value_type { typedef typename remove_const<T>::type value; typedef typename add_reference<T>::type reference; typedef typename mpl::if_c<is_noncopyable<T>::value, reference, value>::type type; }; template<typename T> struct value_type<T &> { typedef T &value; typedef T &reference; typedef T &type; }; } #define BOOST_PROTO_DEFINE_ENV_VAR(TAG, NAME) \ struct TAG \ { \ template<typename Value> \ boost::proto::env<TAG, Value &> const \ operator =(boost::reference_wrapper<Value> &value) const \ { \ return boost::proto::env<TAG, Value &>(value.get()); \ } \ template<typename Value> \ boost::proto::env<TAG, Value &> const \ operator =(boost::reference_wrapper<Value> const &value) const \ { \ return boost::proto::env<TAG, Value &>(value.get()); \ } \ template<typename Value> \ typename boost::disable_if_c< \ boost::is_const<Value>::value \ , boost::proto::env<TAG, typename boost::proto::detail::value_type<Value>::type> \ >::type const operator =(Value &value) const \ { \ return boost::proto::env<TAG, typename boost::proto::detail::value_type<Value>::type>(value); \ } \ template<typename Value> \ boost::proto::env<TAG, typename boost::proto::detail::value_type<Value const>::type> const \ operator =(Value const &value) const \ { \ return boost::proto::env<TAG, typename boost::proto::detail::value_type<Value const>::type>(value); \ } \ }; \ \ TAG const NAME = {} \ /**/ namespace envns_ { //////////////////////////////////////////////////////////////////////////////////////////// // env // A transform env is a slot-based storage mechanism, accessible by tag. template<typename Key, typename Value, typename Base /*= empty_env*/> struct env : private Base { private: Value value_; public: typedef Value value_type; typedef typename add_reference<Value>::type reference; typedef typename add_reference<typename add_const<Value>::type>::type const_reference; typedef void proto_environment_; ///< INTERNAL ONLY explicit env(const_reference value, Base const &base = Base()) : Base(base) , value_(value) {} #if BOOST_WORKAROUND(__GNUC__, == 3) || (BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ <= 2) /// INTERNAL ONLY struct found { typedef Value type; typedef typename add_reference<typename add_const<Value>::type>::type const_reference; }; template<typename OtherKey, typename OtherValue = key_not_found> struct lookup : mpl::if_c< is_same<OtherKey, Key>::value , found , typename Base::template lookup<OtherKey, OtherValue> >::type {}; #else /// INTERNAL ONLY template<typename OtherKey, typename OtherValue = key_not_found> struct lookup : Base::template lookup<OtherKey, OtherValue> {}; /// INTERNAL ONLY template<typename OtherValue> struct lookup<Key, OtherValue> { typedef Value type; typedef typename add_reference<typename add_const<Value>::type>::type const_reference; }; #endif // For key-based lookups not intended to fail using Base::operator[]; const_reference operator[](Key) const { return this->value_; } // For key-based lookups that can fail, use the default if key not found. using Base::at; template<typename T> const_reference at(Key, T const &) const { return this->value_; } }; // define proto::data_type type and proto::data global BOOST_PROTO_DEFINE_ENV_VAR(data_type, data); } using envns_::data; namespace functional { //////////////////////////////////////////////////////////////////////////////////////// // as_env struct as_env { BOOST_PROTO_CALLABLE() BOOST_PROTO_POLY_FUNCTION() /// INTERNAL ONLY template<typename T, bool B = is_env<T>::value> struct impl { typedef env<data_type, typename detail::value_type<T>::type> result_type; result_type const operator()(detail::arg<T> t) const { return result_type(t()); } }; /// INTERNAL ONLY template<typename T> struct impl<T, true> { typedef T result_type; typename add_const<T>::type operator()(detail::arg<T> t) const { return t(); } }; template<typename Sig> struct result; template<typename This, typename T> struct result<This(T)> { typedef typename impl<typename detail::normalize_arg<T>::type>::result_type type; }; template<typename T> typename impl<typename detail::normalize_arg<T &>::type>::result_type const operator()(T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T)) const { return impl<typename detail::normalize_arg<T &>::type>()( static_cast<typename detail::normalize_arg<T &>::reference>(t) ); } template<typename T> typename impl<typename detail::normalize_arg<T const &>::type>::result_type const operator()(T const &t) const { return impl<typename detail::normalize_arg<T const &>::type>()( static_cast<typename detail::normalize_arg<T const &>::reference>(t) ); } }; //////////////////////////////////////////////////////////////////////////////////////// // has_env_var template<typename Key> struct has_env_var : detail::poly_function<has_env_var<Key> > { BOOST_PROTO_CALLABLE() template<typename Env, bool IsEnv = is_env<Env>::value> struct impl { typedef mpl::not_< is_same< typename remove_reference<Env>::type::template lookup<Key>::type , key_not_found > > result_type; result_type operator()(detail::arg<Env>) const { return result_type(); } }; template<typename Env> struct impl<Env, false> { typedef mpl::false_ result_type; result_type operator()(detail::arg<Env>) const { return result_type(); } }; }; template<> struct has_env_var<data_type> : detail::poly_function<has_env_var<data_type> > { BOOST_PROTO_CALLABLE() template<typename Env, bool IsEnv = is_env<Env>::value> struct impl { typedef mpl::not_< is_same< typename remove_reference<Env>::type::template lookup<data_type>::type , key_not_found > > result_type; result_type operator()(detail::arg<Env>) const { return result_type(); } }; template<typename Env> struct impl<Env, false> { typedef mpl::true_ result_type; result_type operator()(detail::arg<Env>) const { return result_type(); } }; }; //////////////////////////////////////////////////////////////////////////////////////// // env_var template<typename Key> struct env_var : detail::poly_function<env_var<Key> > { BOOST_PROTO_CALLABLE() template<typename Env> struct impl { typedef typename remove_reference<Env>::type::template lookup<Key>::type result_type; result_type operator()(detail::arg<Env> e) const { return e()[Key()]; } }; }; template<> struct env_var<data_type> : detail::poly_function<env_var<data_type> > { BOOST_PROTO_CALLABLE() template<typename Env, bool B = is_env<Env>::value> struct impl { typedef Env result_type; result_type operator()(detail::arg<Env> e) const { return e(); } }; template<typename Env> struct impl<Env, true> { typedef typename remove_reference<Env>::type::template lookup<data_type>::type result_type; result_type operator()(detail::arg<Env> e) const { return e()[proto::data]; } }; }; } namespace result_of { template<typename T> struct as_env : BOOST_PROTO_RESULT_OF<functional::as_env(T)> {}; template<typename Env, typename Key> struct has_env_var : BOOST_PROTO_RESULT_OF<functional::has_env_var<Key>(Env)>::type {}; template<typename Env, typename Key> struct env_var : BOOST_PROTO_RESULT_OF<functional::env_var<Key>(Env)> {}; } //////////////////////////////////////////////////////////////////////////////////////////// // as_env template<typename T> typename proto::result_of::as_env<T &>::type const as_env(T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T)) { return proto::functional::as_env()(t); } template<typename T> typename proto::result_of::as_env<T const &>::type const as_env(T const &t) { return proto::functional::as_env()(t); } //////////////////////////////////////////////////////////////////////////////////////////// // has_env_var template<typename Key, typename Env> typename proto::result_of::has_env_var<Env &, Key>::type has_env_var(Env &e BOOST_PROTO_DISABLE_IF_IS_CONST(Env)) { return functional::has_env_var<Key>()(e); } template<typename Key, typename Env> typename proto::result_of::has_env_var<Env const &, Key>::type has_env_var(Env const &e) { return functional::has_env_var<Key>()(e); } //////////////////////////////////////////////////////////////////////////////////////////// // env_var template<typename Key, typename Env> typename proto::result_of::env_var<Env &, Key>::type env_var(Env &e BOOST_PROTO_DISABLE_IF_IS_CONST(Env)) { return functional::env_var<Key>()(e); } template<typename Key, typename Env> typename proto::result_of::env_var<Env const &, Key>::type env_var(Env const &e) { return functional::env_var<Key>()(e); } namespace envns_ { //////////////////////////////////////////////////////////////////////////////////////// // env operator, template<typename T, typename T1, typename V1> inline typename disable_if_c< is_const<T>::value , env<T1, V1, BOOST_PROTO_UNCVREF(typename result_of::as_env<T &>::type)> >::type const operator,(T &t, env<T1, V1> const &head) { return env<T1, V1, BOOST_PROTO_UNCVREF(typename result_of::as_env<T &>::type)>( head[T1()] , proto::as_env(t) ); } template<typename T, typename T1, typename V1> inline env<T1, V1, BOOST_PROTO_UNCVREF(typename result_of::as_env<T const &>::type)> const operator,(T const &t, env<T1, V1> const &head) { return env<T1, V1, BOOST_PROTO_UNCVREF(typename result_of::as_env<T const &>::type)>( head[T1()] , proto::as_env(t) ); } } //////////////////////////////////////////////////////////////////////////////////////////// // _env_var template<typename Key> struct _env_var : proto::transform<_env_var<Key> > { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef typename impl::data::template lookup<Key>::type result_type; BOOST_MPL_ASSERT_NOT((is_same<result_type, key_not_found>)); // lookup failed BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::data::template lookup<Key>::const_reference) operator ()( typename impl::expr_param , typename impl::state_param , typename impl::data_param d ) const { return d[Key()]; } }; }; struct _env : transform<_env> { template<typename Expr, typename State, typename Data> struct impl : transform_impl<Expr, State, Data> { typedef Data result_type; BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::data_param) operator ()( typename impl::expr_param , typename impl::state_param , typename impl::data_param d ) const { return d; } }; }; /// INTERNAL ONLY template<typename Key> struct is_callable<_env_var<Key> > : mpl::true_ {}; /// INTERNAL ONLY template<typename Key> struct is_callable<functional::has_env_var<Key> > : mpl::true_ {}; /// INTERNAL ONLY template<typename Key> struct is_callable<functional::env_var<Key> > : mpl::true_ {}; } } #ifdef _MSC_VER # pragma warning(pop) #endif #endif