← Back
Editing: casts.hpp
// - 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
Save File
Cancel