// - casts.hpp -- BLambda Library -------------

 //

 // Copyright (C) 2000 Gary Powell (powellg@amazon.com)

 // Copyright (C) 1999, 2000 Jaakko Järvi (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 <typeinfo>

 namespace boost { 

 namespace lambda {

 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);

   }

 };

   // typedid action

 class typeid_action {

 public:

   template<class RET, class Arg1>

   static RET apply(Arg1 &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