| // - casts.hpp -- BLambda Library ------------- |
| // |
| // Copyright (C) 2000 Gary Powell (powellg@amazon.com) |
| // Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) |
| // |
| // 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) |
| // |
| // For more information, see http://www.boost.org |
| |
| // ----------------------------------------------- |
| |
| #if !defined(BOOST_LAMBDA_CASTS_HPP) |
| #define BOOST_LAMBDA_CASTS_HPP |
| |
| #include "boost/lambda/detail/suppress_unused.hpp" |
| #include "boost/lambda/core.hpp" |
| |
| #include <typeinfo> |
| |
| namespace boost { |
| namespace lambda { |
| |
| template<class Act, class Args> |
| struct return_type_N; |
| |
| template<class T> class cast_action; |
| |
| template<class T> class static_cast_action; |
| template<class T> class dynamic_cast_action; |
| template<class T> class const_cast_action; |
| template<class T> class reinterpret_cast_action; |
| |
| class typeid_action; |
| class sizeof_action; |
| |
| // Cast actions |
| |
| template<class T> class cast_action<static_cast_action<T> > |
| { |
| public: |
| template<class RET, class Arg1> |
| static RET apply(Arg1 &a1) { |
| return static_cast<RET>(a1); |
| } |
| }; |
| |
| template<class T> class cast_action<dynamic_cast_action<T> > { |
| public: |
| template<class RET, class Arg1> |
| static RET apply(Arg1 &a1) { |
| return dynamic_cast<RET>(a1); |
| } |
| }; |
| |
| template<class T> class cast_action<const_cast_action<T> > { |
| public: |
| template<class RET, class Arg1> |
| static RET apply(Arg1 &a1) { |
| return const_cast<RET>(a1); |
| } |
| }; |
| |
| template<class T> class cast_action<reinterpret_cast_action<T> > { |
| public: |
| template<class RET, class Arg1> |
| static RET apply(Arg1 &a1) { |
| return reinterpret_cast<RET>(a1); |
| } |
| }; |
| |
| // typeid action |
| class typeid_action { |
| public: |
| template<class RET, class Arg1> |
| static RET apply(Arg1 &a1) { |
| detail::suppress_unused_variable_warnings(a1); |
| return typeid(a1); |
| } |
| }; |
| |
| // sizeof action |
| class sizeof_action |
| { |
| public: |
| template<class RET, class Arg1> |
| static RET apply(Arg1 &a1) { |
| return sizeof(a1); |
| } |
| }; |
| |
| |
| // return types of casting lambda_functors (all "T" type.) |
| |
| template<template <class> class cast_type, class T, class A> |
| struct return_type_N<cast_action< cast_type<T> >, A> { |
| typedef T type; |
| }; |
| |
| // return type of typeid_action |
| template<class A> |
| struct return_type_N<typeid_action, A> { |
| typedef std::type_info const & type; |
| }; |
| |
| // return type of sizeof_action |
| |
| template<class A> |
| struct return_type_N<sizeof_action, A> { |
| typedef std::size_t type; |
| }; |
| |
| |
| // the four cast & typeid overloads. |
| // casts can take ordinary variables (not just lambda functors) |
| |
| // static_cast |
| template <class T, class Arg1> |
| inline const lambda_functor< |
| lambda_functor_base< |
| action<1, cast_action<static_cast_action<T> > >, |
| tuple<typename const_copy_argument <const Arg1>::type> |
| > |
| > |
| ll_static_cast(const Arg1& a1) { |
| return |
| lambda_functor_base< |
| action<1, cast_action<static_cast_action<T> > >, |
| tuple<typename const_copy_argument <const Arg1>::type> |
| > |
| ( tuple<typename const_copy_argument <const Arg1>::type>(a1)); |
| } |
| |
| // dynamic_cast |
| template <class T, class Arg1> |
| inline const lambda_functor< |
| lambda_functor_base< |
| action<1, cast_action<dynamic_cast_action<T> > >, |
| tuple<typename const_copy_argument <const Arg1>::type> |
| > |
| > |
| ll_dynamic_cast(const Arg1& a1) { |
| return |
| lambda_functor_base< |
| action<1, cast_action<dynamic_cast_action<T> > >, |
| tuple<typename const_copy_argument <const Arg1>::type> |
| > |
| ( tuple<typename const_copy_argument <const Arg1>::type>(a1)); |
| } |
| |
| // const_cast |
| template <class T, class Arg1> |
| inline const lambda_functor< |
| lambda_functor_base< |
| action<1, cast_action<const_cast_action<T> > >, |
| tuple<typename const_copy_argument <const Arg1>::type> |
| > |
| > |
| ll_const_cast(const Arg1& a1) { |
| return |
| lambda_functor_base< |
| action<1, cast_action<const_cast_action<T> > >, |
| tuple<typename const_copy_argument <const Arg1>::type> |
| > |
| ( tuple<typename const_copy_argument <const Arg1>::type>(a1)); |
| } |
| |
| // reinterpret_cast |
| template <class T, class Arg1> |
| inline const lambda_functor< |
| lambda_functor_base< |
| action<1, cast_action<reinterpret_cast_action<T> > >, |
| tuple<typename const_copy_argument <const Arg1>::type> |
| > |
| > |
| ll_reinterpret_cast(const Arg1& a1) { |
| return |
| lambda_functor_base< |
| action<1, cast_action<reinterpret_cast_action<T> > >, |
| tuple<typename const_copy_argument <const Arg1>::type> |
| > |
| ( tuple<typename const_copy_argument <const Arg1>::type>(a1)); |
| } |
| |
| // typeid |
| // can be applied to a normal variable as well (can refer to a polymorphic |
| // class object) |
| template <class Arg1> |
| inline const lambda_functor< |
| lambda_functor_base< |
| action<1, typeid_action>, |
| tuple<typename const_copy_argument <const Arg1>::type> |
| > |
| > |
| ll_typeid(const Arg1& a1) { |
| return |
| lambda_functor_base< |
| action<1, typeid_action>, |
| tuple<typename const_copy_argument <const Arg1>::type> |
| > |
| ( tuple<typename const_copy_argument <const Arg1>::type>(a1)); |
| } |
| |
| // sizeof(expression) |
| // Always takes a lambda expression (if not, built in sizeof will do) |
| template <class Arg1> |
| inline const lambda_functor< |
| lambda_functor_base< |
| action<1, sizeof_action>, |
| tuple<lambda_functor<Arg1> > |
| > |
| > |
| ll_sizeof(const lambda_functor<Arg1>& a1) { |
| return |
| lambda_functor_base< |
| action<1, sizeof_action>, |
| tuple<lambda_functor<Arg1> > |
| > |
| ( tuple<lambda_functor<Arg1> >(a1)); |
| } |
| |
| } // namespace lambda |
| } // namespace boost |
| |
| #endif |