Mercurial > hg > vamp-build-and-test

annotate DEPENDENCIES/generic/include/boost/proto/transform/env.hpp @ 133:4acb5d8d80b6 tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Don't fail environmental check if README.md exists (but .txt and no-suffix don't)
author Chris Cannam
date Tue, 30 Jul 2019 12:25:44 +0100
parents 2665513ce2d3
children
rev   line source
Chris@16 1 ///////////////////////////////////////////////////////////////////////////////
Chris@16 2 // env.hpp
Chris@16 3 // Helpers for producing and consuming tranform env variables.
Chris@16 4 //
Chris@16 5 // Copyright 2012 Eric Niebler. Distributed under the Boost
Chris@16 6 // Software License, Version 1.0. (See accompanying file
Chris@16 7 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16 8
Chris@16 9 #ifndef BOOST_PROTO_TRANSFORM_ENV_HPP_EAN_18_07_2012
Chris@16 10 #define BOOST_PROTO_TRANSFORM_ENV_HPP_EAN_18_07_2012
Chris@16 11
Chris@16 12 #include <boost/config.hpp>
Chris@16 13 #include <boost/detail/workaround.hpp>
Chris@16 14 #include <boost/ref.hpp>
Chris@16 15 #include <boost/utility/enable_if.hpp>
Chris@16 16 #include <boost/type_traits/is_const.hpp>
Chris@16 17 #include <boost/type_traits/is_same.hpp>
Chris@16 18 #include <boost/type_traits/add_const.hpp>
Chris@16 19 #include <boost/type_traits/add_reference.hpp>
Chris@16 20 #include <boost/type_traits/remove_const.hpp>
Chris@16 21 #include <boost/mpl/assert.hpp>
Chris@16 22 #include <boost/mpl/bool.hpp>
Chris@16 23 #include <boost/mpl/if.hpp>
Chris@16 24 #include <boost/mpl/not.hpp>
Chris@16 25 #include <boost/proto/proto_fwd.hpp>
Chris@16 26 #include <boost/proto/transform/impl.hpp>
Chris@16 27 #include <boost/proto/detail/poly_function.hpp>
Chris@16 28 #include <boost/proto/detail/is_noncopyable.hpp>
Chris@16 29
Chris@16 30 #ifdef _MSC_VER
Chris@16 31 # pragma warning(push)
Chris@16 32 # pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored
Chris@16 33 #endif
Chris@16 34
Chris@16 35 namespace boost
Chris@16 36 {
Chris@16 37 namespace proto
Chris@16 38 {
Chris@16 39 namespace detail
Chris@16 40 {
Chris@16 41 template<typename T>
Chris@16 42 struct value_type
Chris@16 43 {
Chris@16 44 typedef typename remove_const<T>::type value;
Chris@16 45 typedef typename add_reference<T>::type reference;
Chris@16 46 typedef typename mpl::if_c<is_noncopyable<T>::value, reference, value>::type type;
Chris@16 47 };
Chris@16 48
Chris@16 49 template<typename T>
Chris@16 50 struct value_type<T &>
Chris@16 51 {
Chris@16 52 typedef T &value;
Chris@16 53 typedef T &reference;
Chris@16 54 typedef T &type;
Chris@16 55 };
Chris@16 56 }
Chris@16 57
Chris@16 58 #define BOOST_PROTO_DEFINE_ENV_VAR(TAG, NAME) \
Chris@16 59 struct TAG \
Chris@16 60 { \
Chris@16 61 template<typename Value> \
Chris@16 62 boost::proto::env<TAG, Value &> const \
Chris@16 63 operator =(boost::reference_wrapper<Value> &value) const \
Chris@16 64 { \
Chris@16 65 return boost::proto::env<TAG, Value &>(value.get()); \
Chris@16 66 } \
Chris@16 67 template<typename Value> \
Chris@16 68 boost::proto::env<TAG, Value &> const \
Chris@16 69 operator =(boost::reference_wrapper<Value> const &value) const \
Chris@16 70 { \
Chris@16 71 return boost::proto::env<TAG, Value &>(value.get()); \
Chris@16 72 } \
Chris@16 73 template<typename Value> \
Chris@16 74 typename boost::disable_if_c< \
Chris@16 75 boost::is_const<Value>::value \
Chris@16 76 , boost::proto::env<TAG, typename boost::proto::detail::value_type<Value>::type> \
Chris@16 77 >::type const operator =(Value &value) const \
Chris@16 78 { \
Chris@16 79 return boost::proto::env<TAG, typename boost::proto::detail::value_type<Value>::type>(value); \
Chris@16 80 } \
Chris@16 81 template<typename Value> \
Chris@16 82 boost::proto::env<TAG, typename boost::proto::detail::value_type<Value const>::type> const \
Chris@16 83 operator =(Value const &value) const \
Chris@16 84 { \
Chris@16 85 return boost::proto::env<TAG, typename boost::proto::detail::value_type<Value const>::type>(value); \
Chris@16 86 } \
Chris@16 87 }; \
Chris@16 88 \
Chris@16 89 TAG const NAME = {} \
Chris@16 90 /**/
Chris@16 91
Chris@16 92 namespace envns_
Chris@16 93 {
Chris@16 94 ////////////////////////////////////////////////////////////////////////////////////////////
Chris@16 95 // env
Chris@16 96 // A transform env is a slot-based storage mechanism, accessible by tag.
Chris@16 97 template<typename Key, typename Value, typename Base /*= empty_env*/>
Chris@16 98 struct env
Chris@16 99 : private Base
Chris@16 100 {
Chris@16 101 private:
Chris@16 102 Value value_;
Chris@16 103
Chris@16 104 public:
Chris@16 105 typedef Value value_type;
Chris@16 106 typedef typename add_reference<Value>::type reference;
Chris@16 107 typedef typename add_reference<typename add_const<Value>::type>::type const_reference;
Chris@16 108 typedef void proto_environment_; ///< INTERNAL ONLY
Chris@16 109
Chris@16 110 explicit env(const_reference value, Base const &base = Base())
Chris@16 111 : Base(base)
Chris@16 112 , value_(value)
Chris@16 113 {}
Chris@16 114
Chris@16 115 #if BOOST_WORKAROUND(__GNUC__, == 3) || (BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ <= 2)
Chris@16 116 /// INTERNAL ONLY
Chris@16 117 struct found
Chris@16 118 {
Chris@16 119 typedef Value type;
Chris@16 120 typedef typename add_reference<typename add_const<Value>::type>::type const_reference;
Chris@16 121 };
Chris@16 122
Chris@16 123 template<typename OtherKey, typename OtherValue = key_not_found>
Chris@16 124 struct lookup
Chris@16 125 : mpl::if_c<
Chris@16 126 is_same<OtherKey, Key>::value
Chris@16 127 , found
Chris@16 128 , typename Base::template lookup<OtherKey, OtherValue>
Chris@16 129 >::type
Chris@16 130 {};
Chris@16 131 #else
Chris@16 132 /// INTERNAL ONLY
Chris@16 133 template<typename OtherKey, typename OtherValue = key_not_found>
Chris@16 134 struct lookup
Chris@16 135 : Base::template lookup<OtherKey, OtherValue>
Chris@16 136 {};
Chris@16 137
Chris@16 138 /// INTERNAL ONLY
Chris@16 139 template<typename OtherValue>
Chris@16 140 struct lookup<Key, OtherValue>
Chris@16 141 {
Chris@16 142 typedef Value type;
Chris@16 143 typedef typename add_reference<typename add_const<Value>::type>::type const_reference;
Chris@16 144 };
Chris@16 145 #endif
Chris@16 146
Chris@16 147 // For key-based lookups not intended to fail
Chris@16 148 using Base::operator[];
Chris@16 149 const_reference operator[](Key) const
Chris@16 150 {
Chris@16 151 return this->value_;
Chris@16 152 }
Chris@16 153
Chris@16 154 // For key-based lookups that can fail, use the default if key not found.
Chris@16 155 using Base::at;
Chris@16 156 template<typename T>
Chris@16 157 const_reference at(Key, T const &) const
Chris@16 158 {
Chris@16 159 return this->value_;
Chris@16 160 }
Chris@16 161 };
Chris@16 162
Chris@16 163 // define proto::data_type type and proto::data global
Chris@16 164 BOOST_PROTO_DEFINE_ENV_VAR(data_type, data);
Chris@16 165 }
Chris@16 166
Chris@16 167 using envns_::data;
Chris@16 168
Chris@16 169 namespace functional
Chris@16 170 {
Chris@16 171 ////////////////////////////////////////////////////////////////////////////////////////
Chris@16 172 // as_env
Chris@16 173 struct as_env
Chris@16 174 {
Chris@16 175 BOOST_PROTO_CALLABLE()
Chris@16 176 BOOST_PROTO_POLY_FUNCTION()
Chris@16 177
Chris@16 178 /// INTERNAL ONLY
Chris@16 179 template<typename T, bool B = is_env<T>::value>
Chris@16 180 struct impl
Chris@16 181 {
Chris@16 182 typedef env<data_type, typename detail::value_type<T>::type> result_type;
Chris@16 183
Chris@16 184 result_type const operator()(detail::arg<T> t) const
Chris@16 185 {
Chris@16 186 return result_type(t());
Chris@16 187 }
Chris@16 188 };
Chris@16 189
Chris@16 190 /// INTERNAL ONLY
Chris@16 191 template<typename T>
Chris@16 192 struct impl<T, true>
Chris@16 193 {
Chris@16 194 typedef T result_type;
Chris@16 195
Chris@16 196 typename add_const<T>::type operator()(detail::arg<T> t) const
Chris@16 197 {
Chris@16 198 return t();
Chris@16 199 }
Chris@16 200 };
Chris@16 201
Chris@16 202 template<typename Sig>
Chris@16 203 struct result;
Chris@16 204
Chris@16 205 template<typename This, typename T>
Chris@16 206 struct result<This(T)>
Chris@16 207 {
Chris@16 208 typedef typename impl<typename detail::normalize_arg<T>::type>::result_type type;
Chris@16 209 };
Chris@16 210
Chris@16 211 template<typename T>
Chris@16 212 typename impl<typename detail::normalize_arg<T &>::type>::result_type const
Chris@16 213 operator()(T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T)) const
Chris@16 214 {
Chris@16 215 return impl<typename detail::normalize_arg<T &>::type>()(
Chris@16 216 static_cast<typename detail::normalize_arg<T &>::reference>(t)
Chris@16 217 );
Chris@16 218 }
Chris@16 219
Chris@16 220 template<typename T>
Chris@16 221 typename impl<typename detail::normalize_arg<T const &>::type>::result_type const
Chris@16 222 operator()(T const &t) const
Chris@16 223 {
Chris@16 224 return impl<typename detail::normalize_arg<T const &>::type>()(
Chris@16 225 static_cast<typename detail::normalize_arg<T const &>::reference>(t)
Chris@16 226 );
Chris@16 227 }
Chris@16 228 };
Chris@16 229
Chris@16 230 ////////////////////////////////////////////////////////////////////////////////////////
Chris@16 231 // has_env_var
Chris@16 232 template<typename Key>
Chris@16 233 struct has_env_var
Chris@16 234 : detail::poly_function<has_env_var<Key> >
Chris@16 235 {
Chris@16 236 BOOST_PROTO_CALLABLE()
Chris@16 237
Chris@16 238 template<typename Env, bool IsEnv = is_env<Env>::value>
Chris@16 239 struct impl
Chris@16 240 {
Chris@16 241 typedef
Chris@16 242 mpl::not_<
Chris@16 243 is_same<
Chris@16 244 typename remove_reference<Env>::type::template lookup<Key>::type
Chris@16 245 , key_not_found
Chris@16 246 >
Chris@16 247 >
Chris@16 248 result_type;
Chris@16 249
Chris@16 250 result_type operator()(detail::arg<Env>) const
Chris@16 251 {
Chris@16 252 return result_type();
Chris@16 253 }
Chris@16 254 };
Chris@16 255
Chris@16 256 template<typename Env>
Chris@16 257 struct impl<Env, false>
Chris@16 258 {
Chris@16 259 typedef mpl::false_ result_type;
Chris@16 260
Chris@16 261 result_type operator()(detail::arg<Env>) const
Chris@16 262 {
Chris@16 263 return result_type();
Chris@16 264 }
Chris@16 265 };
Chris@16 266 };
Chris@16 267
Chris@16 268 template<>
Chris@16 269 struct has_env_var<data_type>
Chris@16 270 : detail::poly_function<has_env_var<data_type> >
Chris@16 271 {
Chris@16 272 BOOST_PROTO_CALLABLE()
Chris@16 273
Chris@16 274 template<typename Env, bool IsEnv = is_env<Env>::value>
Chris@16 275 struct impl
Chris@16 276 {
Chris@16 277 typedef
Chris@16 278 mpl::not_<
Chris@16 279 is_same<
Chris@16 280 typename remove_reference<Env>::type::template lookup<data_type>::type
Chris@16 281 , key_not_found
Chris@16 282 >
Chris@16 283 >
Chris@16 284 result_type;
Chris@16 285
Chris@16 286 result_type operator()(detail::arg<Env>) const
Chris@16 287 {
Chris@16 288 return result_type();
Chris@16 289 }
Chris@16 290 };
Chris@16 291
Chris@16 292 template<typename Env>
Chris@16 293 struct impl<Env, false>
Chris@16 294 {
Chris@16 295 typedef mpl::true_ result_type;
Chris@16 296
Chris@16 297 result_type operator()(detail::arg<Env>) const
Chris@16 298 {
Chris@16 299 return result_type();
Chris@16 300 }
Chris@16 301 };
Chris@16 302 };
Chris@16 303
Chris@16 304 ////////////////////////////////////////////////////////////////////////////////////////
Chris@16 305 // env_var
Chris@16 306 template<typename Key>
Chris@16 307 struct env_var
Chris@16 308 : detail::poly_function<env_var<Key> >
Chris@16 309 {
Chris@16 310 BOOST_PROTO_CALLABLE()
Chris@16 311
Chris@16 312 template<typename Env>
Chris@16 313 struct impl
Chris@16 314 {
Chris@16 315 typedef
Chris@16 316 typename remove_reference<Env>::type::template lookup<Key>::type
Chris@16 317 result_type;
Chris@16 318
Chris@16 319 result_type operator()(detail::arg<Env> e) const
Chris@16 320 {
Chris@16 321 return e()[Key()];
Chris@16 322 }
Chris@16 323 };
Chris@16 324 };
Chris@16 325
Chris@16 326 template<>
Chris@16 327 struct env_var<data_type>
Chris@16 328 : detail::poly_function<env_var<data_type> >
Chris@16 329 {
Chris@16 330 BOOST_PROTO_CALLABLE()
Chris@16 331
Chris@16 332 template<typename Env, bool B = is_env<Env>::value>
Chris@16 333 struct impl
Chris@16 334 {
Chris@16 335 typedef Env result_type;
Chris@16 336
Chris@16 337 result_type operator()(detail::arg<Env> e) const
Chris@16 338 {
Chris@16 339 return e();
Chris@16 340 }
Chris@16 341 };
Chris@16 342
Chris@16 343 template<typename Env>
Chris@16 344 struct impl<Env, true>
Chris@16 345 {
Chris@16 346 typedef
Chris@16 347 typename remove_reference<Env>::type::template lookup<data_type>::type
Chris@16 348 result_type;
Chris@16 349
Chris@16 350 result_type operator()(detail::arg<Env> e) const
Chris@16 351 {
Chris@16 352 return e()[proto::data];
Chris@16 353 }
Chris@16 354 };
Chris@16 355 };
Chris@16 356 }
Chris@16 357
Chris@16 358 namespace result_of
Chris@16 359 {
Chris@16 360 template<typename T>
Chris@16 361 struct as_env
Chris@16 362 : BOOST_PROTO_RESULT_OF<functional::as_env(T)>
Chris@16 363 {};
Chris@16 364
Chris@16 365 template<typename Env, typename Key>
Chris@16 366 struct has_env_var
Chris@16 367 : BOOST_PROTO_RESULT_OF<functional::has_env_var<Key>(Env)>::type
Chris@16 368 {};
Chris@16 369
Chris@16 370 template<typename Env, typename Key>
Chris@16 371 struct env_var
Chris@16 372 : BOOST_PROTO_RESULT_OF<functional::env_var<Key>(Env)>
Chris@16 373 {};
Chris@16 374 }
Chris@16 375
Chris@16 376 ////////////////////////////////////////////////////////////////////////////////////////////
Chris@16 377 // as_env
Chris@16 378 template<typename T>
Chris@16 379 typename proto::result_of::as_env<T &>::type const as_env(T &t BOOST_PROTO_DISABLE_IF_IS_CONST(T))
Chris@16 380 {
Chris@16 381 return proto::functional::as_env()(t);
Chris@16 382 }
Chris@16 383
Chris@16 384 template<typename T>
Chris@16 385 typename proto::result_of::as_env<T const &>::type const as_env(T const &t)
Chris@16 386 {
Chris@16 387 return proto::functional::as_env()(t);
Chris@16 388 }
Chris@16 389
Chris@16 390 ////////////////////////////////////////////////////////////////////////////////////////////
Chris@16 391 // has_env_var
Chris@16 392 template<typename Key, typename Env>
Chris@16 393 typename proto::result_of::has_env_var<Env &, Key>::type has_env_var(Env &e BOOST_PROTO_DISABLE_IF_IS_CONST(Env))
Chris@16 394 {
Chris@16 395 return functional::has_env_var<Key>()(e);
Chris@16 396 }
Chris@16 397
Chris@16 398 template<typename Key, typename Env>
Chris@16 399 typename proto::result_of::has_env_var<Env const &, Key>::type has_env_var(Env const &e)
Chris@16 400 {
Chris@16 401 return functional::has_env_var<Key>()(e);
Chris@16 402 }
Chris@16 403
Chris@16 404 ////////////////////////////////////////////////////////////////////////////////////////////
Chris@16 405 // env_var
Chris@16 406 template<typename Key, typename Env>
Chris@16 407 typename proto::result_of::env_var<Env &, Key>::type env_var(Env &e BOOST_PROTO_DISABLE_IF_IS_CONST(Env))
Chris@16 408 {
Chris@16 409 return functional::env_var<Key>()(e);
Chris@16 410 }
Chris@16 411
Chris@16 412 template<typename Key, typename Env>
Chris@16 413 typename proto::result_of::env_var<Env const &, Key>::type env_var(Env const &e)
Chris@16 414 {
Chris@16 415 return functional::env_var<Key>()(e);
Chris@16 416 }
Chris@16 417
Chris@16 418 namespace envns_
Chris@16 419 {
Chris@16 420 ////////////////////////////////////////////////////////////////////////////////////////
Chris@16 421 // env operator,
Chris@16 422 template<typename T, typename T1, typename V1>
Chris@16 423 inline typename disable_if_c<
Chris@16 424 is_const<T>::value
Chris@16 425 , env<T1, V1, BOOST_PROTO_UNCVREF(typename result_of::as_env<T &>::type)>
Chris@16 426 >::type const operator,(T &t, env<T1, V1> const &head)
Chris@16 427 {
Chris@16 428 return env<T1, V1, BOOST_PROTO_UNCVREF(typename result_of::as_env<T &>::type)>(
Chris@16 429 head[T1()]
Chris@16 430 , proto::as_env(t)
Chris@16 431 );
Chris@16 432 }
Chris@16 433
Chris@16 434 template<typename T, typename T1, typename V1>
Chris@16 435 inline env<T1, V1, BOOST_PROTO_UNCVREF(typename result_of::as_env<T const &>::type)> const
Chris@16 436 operator,(T const &t, env<T1, V1> const &head)
Chris@16 437 {
Chris@16 438 return env<T1, V1, BOOST_PROTO_UNCVREF(typename result_of::as_env<T const &>::type)>(
Chris@16 439 head[T1()]
Chris@16 440 , proto::as_env(t)
Chris@16 441 );
Chris@16 442 }
Chris@16 443 }
Chris@16 444
Chris@16 445 ////////////////////////////////////////////////////////////////////////////////////////////
Chris@16 446 // _env_var
Chris@16 447 template<typename Key>
Chris@16 448 struct _env_var
Chris@16 449 : proto::transform<_env_var<Key> >
Chris@16 450 {
Chris@16 451 template<typename Expr, typename State, typename Data>
Chris@16 452 struct impl
Chris@16 453 : transform_impl<Expr, State, Data>
Chris@16 454 {
Chris@16 455 typedef typename impl::data::template lookup<Key>::type result_type;
Chris@16 456 BOOST_MPL_ASSERT_NOT((is_same<result_type, key_not_found>)); // lookup failed
Chris@16 457
Chris@16 458 BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::data::template lookup<Key>::const_reference)
Chris@16 459 operator ()(
Chris@16 460 typename impl::expr_param
Chris@16 461 , typename impl::state_param
Chris@16 462 , typename impl::data_param d
Chris@16 463 ) const
Chris@16 464 {
Chris@16 465 return d[Key()];
Chris@16 466 }
Chris@16 467 };
Chris@16 468 };
Chris@16 469
Chris@16 470 struct _env
Chris@16 471 : transform<_env>
Chris@16 472 {
Chris@16 473 template<typename Expr, typename State, typename Data>
Chris@16 474 struct impl
Chris@16 475 : transform_impl<Expr, State, Data>
Chris@16 476 {
Chris@16 477 typedef Data result_type;
Chris@16 478
Chris@16 479 BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::data_param)
Chris@16 480 operator ()(
Chris@16 481 typename impl::expr_param
Chris@16 482 , typename impl::state_param
Chris@16 483 , typename impl::data_param d
Chris@16 484 ) const
Chris@16 485 {
Chris@16 486 return d;
Chris@16 487 }
Chris@16 488 };
Chris@16 489 };
Chris@16 490
Chris@16 491 /// INTERNAL ONLY
Chris@16 492 template<typename Key>
Chris@16 493 struct is_callable<_env_var<Key> >
Chris@16 494 : mpl::true_
Chris@16 495 {};
Chris@16 496
Chris@16 497 /// INTERNAL ONLY
Chris@16 498 template<typename Key>
Chris@16 499 struct is_callable<functional::has_env_var<Key> >
Chris@16 500 : mpl::true_
Chris@16 501 {};
Chris@16 502
Chris@16 503 /// INTERNAL ONLY
Chris@16 504 template<typename Key>
Chris@16 505 struct is_callable<functional::env_var<Key> >
Chris@16 506 : mpl::true_
Chris@16 507 {};
Chris@16 508 }
Chris@16 509 }
Chris@16 510
Chris@16 511 #ifdef _MSC_VER
Chris@16 512 # pragma warning(pop)
Chris@16 513 #endif
Chris@16 514
Chris@16 515 #endif