summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to '3rdParty/Boost/src/boost/proto/transform/env.hpp')
-rw-r--r--3rdParty/Boost/src/boost/proto/transform/env.hpp515
1 files changed, 515 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/proto/transform/env.hpp b/3rdParty/Boost/src/boost/proto/transform/env.hpp
new file mode 100644
index 0000000..81309fa
--- /dev/null
+++ b/3rdParty/Boost/src/boost/proto/transform/env.hpp
@@ -0,0 +1,515 @@
+///////////////////////////////////////////////////////////////////////////////
+// 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