x
Yes
No
Do you want to visit DriveHQ English website?
Inicio
Características
Precios
Prueba gratuita
Software cliente
Acerca de nosotros
Servidor de archivos
|
Solución de copias de seguridad
|
Servidor FTP
|
Servidor de correo electrónico
|
Alojamiento web
|
Software cliente
Servidor de archivos
Solución de copia de seguridad
Servidor FTP
Servidor de correo electrónico
Alojamiento web
Software cliente
lambda_functors.hpp - Hosted on DriveHQ Cloud IT Platform
Arriba
Subir
Descargar
Compartir
Publicar
Nueva carpeta
Nuevo archivo
Copiar
Cortar
Eliminar
Pegar
Clasificación
Actualizar
Ruta de la carpeta: \\game3dprogramming\materials\GameFactory\GameFactoryDemo\references\boost_1_35_0\boost\lambda\detail\lambda_functors.hpp
Girar
Efecto
Propiedad
Historial
// Boost Lambda Library - lambda_functors.hpp ------------------------------- // 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 // ------------------------------------------------ #ifndef BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP #define BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP namespace boost { namespace lambda { // -- lambda_functor -------------------------------------------- // -------------------------------------------------------------- //inline const null_type const_null_type() { return null_type(); } namespace detail { namespace { static const null_type constant_null_type = null_type(); } // unnamed } // detail class unused {}; #define cnull_type() detail::constant_null_type // -- free variables types -------------------------------------------------- // helper to work around the case where the nullary return type deduction // is always performed, even though the functor is not nullary namespace detail { template
struct get_element_or_null_type { typedef typename detail::tuple_element_as_reference
::type type; }; template
struct get_element_or_null_type
{ typedef null_type type; }; } template
struct placeholder; template<> struct placeholder
{ template
struct sig { typedef typename detail::get_element_or_null_type<0, SigArgs>::type type; }; template
RET call(CALL_FORMAL_ARGS) const { BOOST_STATIC_ASSERT(boost::is_reference
::value); CALL_USE_ARGS; // does nothing, prevents warnings for unused args return a; } }; template<> struct placeholder
{ template
struct sig { typedef typename detail::get_element_or_null_type<1, SigArgs>::type type; }; template
RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return b; } }; template<> struct placeholder
{ template
struct sig { typedef typename detail::get_element_or_null_type<2, SigArgs>::type type; }; template
RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return c; } }; template<> struct placeholder
{ template
struct sig { typedef typename detail::get_element_or_null_type<3, SigArgs>::type type; }; template
RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return env; } }; typedef const lambda_functor
> placeholder1_type; typedef const lambda_functor
> placeholder2_type; typedef const lambda_functor
> placeholder3_type; /////////////////////////////////////////////////////////////////////////////// // free variables are lambda_functors. This is to allow uniform handling with // other lambda_functors. // ------------------------------------------------------------------- // -- lambda_functor NONE ------------------------------------------------ template
class lambda_functor : public T { BOOST_STATIC_CONSTANT(int, arity_bits = get_arity
::value); public: typedef T inherited; lambda_functor() {} lambda_functor(const lambda_functor& l) : inherited(l) {} lambda_functor(const T& t) : inherited(t) {} template
struct sig { typedef typename inherited::template sig
::type type; }; // Note that this return type deduction template is instantiated, even // if the nullary // operator() is not called at all. One must make sure that it does not fail. typedef typename inherited::template sig
::type nullary_return_type; nullary_return_type operator()() const { return inherited::template call
(cnull_type(), cnull_type(), cnull_type(), cnull_type()); } template
typename inherited::template sig
>::type operator()(A& a) const { return inherited::template call< typename inherited::template sig
>::type >(a, cnull_type(), cnull_type(), cnull_type()); } template
typename inherited::template sig
>::type operator()(A const& a) const { return inherited::template call< typename inherited::template sig
>::type >(a, cnull_type(), cnull_type(), cnull_type()); } template
typename inherited::template sig
>::type operator()(A& a, B& b) const { return inherited::template call< typename inherited::template sig
>::type >(a, b, cnull_type(), cnull_type()); } template
typename inherited::template sig
>::type operator()(A const& a, B& b) const { return inherited::template call< typename inherited::template sig
>::type >(a, b, cnull_type(), cnull_type()); } template
typename inherited::template sig
>::type operator()(A& a, B const& b) const { return inherited::template call< typename inherited::template sig
>::type >(a, b, cnull_type(), cnull_type()); } template
typename inherited::template sig
>::type operator()(A const& a, B const& b) const { return inherited::template call< typename inherited::template sig
>::type >(a, b, cnull_type(), cnull_type()); } template
typename inherited::template sig
>::type operator()(A& a, B& b, C& c) const { return inherited::template call< typename inherited::template sig
>::type >(a, b, c, cnull_type()); } template
typename inherited::template sig
>::type operator()(A const& a, B const& b, C const& c) const { return inherited::template call< typename inherited::template sig
>::type >(a, b, c, cnull_type()); } // for internal calls with env template
typename inherited::template sig
>::type internal_call(CALL_FORMAL_ARGS) const { return inherited::template call
>::type>(CALL_ACTUAL_ARGS); } template
const lambda_functor
, boost::tuple
::type> > > operator=(const A& a) const { return lambda_functor_base< other_action
, boost::tuple
::type> > ( boost::tuple
::type>(*this, a) ); } template
const lambda_functor
, boost::tuple
::type> > > operator[](const A& a) const { return lambda_functor_base< other_action
, boost::tuple
::type> > ( boost::tuple
::type>(*this, a ) ); } }; } // namespace lambda } // namespace boost // is_placeholder #include
namespace boost { template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder
> > { enum _vt { value = 1 }; }; template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder
> > { enum _vt { value = 2 }; }; template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder
> > { enum _vt { value = 3 }; }; } // namespace boost #endif
lambda_functors.hpp
Dirección de la página
Dirección del archivo
Anterior
10/20
Siguiente
Descargar
( 8 KB )
Comments
Total ratings:
0
Average rating:
No clasificado
of 10
Would you like to comment?
Join now
, or
Logon
if you are already a member.