Upgraded boost
This commit is contained in:
1 parent
10da2cde64
commit
a737c4ecf6
15332 files changed
+3057188
-2380045
No files matched your search
+1380
-1377
File diff suppressed because it is too large.
Load diff
@@ -1,19 +1,19 @@
|
||||
// -- bind.hpp -- Boost Lambda Library --------------------------------------
|
||||
|
||||
// Copyright (C) 1999-2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Gary Powell (gwpowell@hotmail.com)
|
||||
//
|
||||
// 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_BIND_HPP
|
||||
#define BOOST_LAMBDA_BIND_HPP
|
||||
|
||||
#include "boost/lambda/core.hpp"
|
||||
|
||||
#include "boost/lambda/detail/bind_functions.hpp"
|
||||
|
||||
#endif
|
||||
// -- bind.hpp -- Boost Lambda Library --------------------------------------
|
||||
|
||||
// Copyright (C) 1999-2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Gary Powell (gwpowell@hotmail.com)
|
||||
//
|
||||
// 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_BIND_HPP
|
||||
#define BOOST_LAMBDA_BIND_HPP
|
||||
|
||||
#include "boost/lambda/core.hpp"
|
||||
|
||||
#include "boost/lambda/detail/bind_functions.hpp"
|
||||
|
||||
#endif
|
||||
@@ -1,226 +1,226 @@
|
||||
// - 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
|
||||
// - 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
|
||||
@@ -1,274 +1,274 @@
|
||||
/*=============================================================================
|
||||
Adaptable closures
|
||||
|
||||
Phoenix V0.9
|
||||
Copyright (c) 2001-2002 Joel de Guzman
|
||||
|
||||
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)
|
||||
|
||||
URL: http://spirit.sourceforge.net/
|
||||
|
||||
==============================================================================*/
|
||||
#ifndef PHOENIX_CLOSURES_HPP
|
||||
#define PHOENIX_CLOSURES_HPP
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
#include "boost/lambda/core.hpp"
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Adaptable closures
|
||||
//
|
||||
// The framework will not be complete without some form of closures
|
||||
// support. Closures encapsulate a stack frame where local
|
||||
// variables are created upon entering a function and destructed
|
||||
// upon exiting. Closures provide an environment for local
|
||||
// variables to reside. Closures can hold heterogeneous types.
|
||||
//
|
||||
// Phoenix closures are true hardware stack based closures. At the
|
||||
// very least, closures enable true reentrancy in lambda functions.
|
||||
// A closure provides access to a function stack frame where local
|
||||
// variables reside. Modeled after Pascal nested stack frames,
|
||||
// closures can be nested just like nested functions where code in
|
||||
// inner closures may access local variables from in-scope outer
|
||||
// closures (accessing inner scopes from outer scopes is an error
|
||||
// and will cause a run-time assertion failure).
|
||||
//
|
||||
// There are three (3) interacting classes:
|
||||
//
|
||||
// 1) closure:
|
||||
//
|
||||
// At the point of declaration, a closure does not yet create a
|
||||
// stack frame nor instantiate any variables. A closure declaration
|
||||
// declares the types and names[note] of the local variables. The
|
||||
// closure class is meant to be subclassed. It is the
|
||||
// responsibility of a closure subclass to supply the names for
|
||||
// each of the local variable in the closure. Example:
|
||||
//
|
||||
// struct my_closure : closure<int, string, double> {
|
||||
//
|
||||
// member1 num; // names the 1st (int) local variable
|
||||
// member2 message; // names the 2nd (string) local variable
|
||||
// member3 real; // names the 3rd (double) local variable
|
||||
// };
|
||||
//
|
||||
// my_closure clos;
|
||||
//
|
||||
// Now that we have a closure 'clos', its local variables can be
|
||||
// accessed lazily using the dot notation. Each qualified local
|
||||
// variable can be used just like any primitive actor (see
|
||||
// primitives.hpp). Examples:
|
||||
//
|
||||
// clos.num = 30
|
||||
// clos.message = arg1
|
||||
// clos.real = clos.num * 1e6
|
||||
//
|
||||
// The examples above are lazily evaluated. As usual, these
|
||||
// expressions return composite actors that will be evaluated
|
||||
// through a second function call invocation (see operators.hpp).
|
||||
// Each of the members (clos.xxx) is an actor. As such, applying
|
||||
// the operator() will reveal its identity:
|
||||
//
|
||||
// clos.num() // will return the current value of clos.num
|
||||
//
|
||||
// *** [note] Acknowledgement: Juan Carlos Arevalo-Baeza (JCAB)
|
||||
// introduced and initilally implemented the closure member names
|
||||
// that uses the dot notation.
|
||||
//
|
||||
// 2) closure_member
|
||||
//
|
||||
// The named local variables of closure 'clos' above are actually
|
||||
// closure members. The closure_member class is an actor and
|
||||
// conforms to its conceptual interface. member1..memberN are
|
||||
// predefined typedefs that correspond to each of the listed types
|
||||
// in the closure template parameters.
|
||||
//
|
||||
// 3) closure_frame
|
||||
//
|
||||
// When a closure member is finally evaluated, it should refer to
|
||||
// an actual instance of the variable in the hardware stack.
|
||||
// Without doing so, the process is not complete and the evaluated
|
||||
// member will result to an assertion failure. Remember that the
|
||||
// closure is just a declaration. The local variables that a
|
||||
// closure refers to must still be instantiated.
|
||||
//
|
||||
// The closure_frame class does the actual instantiation of the
|
||||
// local variables and links these variables with the closure and
|
||||
// all its members. There can be multiple instances of
|
||||
// closure_frames typically situated in the stack inside a
|
||||
// function. Each closure_frame instance initiates a stack frame
|
||||
// with a new set of closure local variables. Example:
|
||||
//
|
||||
// void foo()
|
||||
// {
|
||||
// closure_frame<my_closure> frame(clos);
|
||||
// /* do something */
|
||||
// }
|
||||
//
|
||||
// where 'clos' is an instance of our closure 'my_closure' above.
|
||||
// Take note that the usage above precludes locally declared
|
||||
// classes. If my_closure is a locally declared type, we can still
|
||||
// use its self_type as a paramater to closure_frame:
|
||||
//
|
||||
// closure_frame<my_closure::self_type> frame(clos);
|
||||
//
|
||||
// Upon instantiation, the closure_frame links the local variables
|
||||
// to the closure. The previous link to another closure_frame
|
||||
// instance created before is saved. Upon destruction, the
|
||||
// closure_frame unlinks itself from the closure and relinks the
|
||||
// preceding closure_frame prior to this instance.
|
||||
//
|
||||
// The local variables in the closure 'clos' above is default
|
||||
// constructed in the stack inside function 'foo'. Once 'foo' is
|
||||
// exited, all of these local variables are destructed. In some
|
||||
// cases, default construction is not desirable and we need to
|
||||
// initialize the local closure variables with some values. This
|
||||
// can be done by passing in the initializers in a compatible
|
||||
// tuple. A compatible tuple is one with the same number of
|
||||
// elements as the destination and where each element from the
|
||||
// destination can be constructed from each corresponding element
|
||||
// in the source. Example:
|
||||
//
|
||||
// tuple<int, char const*, int> init(123, "Hello", 1000);
|
||||
// closure_frame<my_closure> frame(clos, init);
|
||||
//
|
||||
// Here now, our closure_frame's variables are initialized with
|
||||
// int: 123, char const*: "Hello" and int: 1000.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// closure_frame class
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
template <typename ClosureT>
|
||||
class closure_frame : public ClosureT::tuple_t {
|
||||
|
||||
public:
|
||||
|
||||
closure_frame(ClosureT& clos)
|
||||
: ClosureT::tuple_t(), save(clos.frame), frame(clos.frame)
|
||||
{ clos.frame = this; }
|
||||
|
||||
template <typename TupleT>
|
||||
closure_frame(ClosureT& clos, TupleT const& init)
|
||||
: ClosureT::tuple_t(init), save(clos.frame), frame(clos.frame)
|
||||
{ clos.frame = this; }
|
||||
|
||||
~closure_frame()
|
||||
{ frame = save; }
|
||||
|
||||
private:
|
||||
|
||||
closure_frame(closure_frame const&); // no copy
|
||||
closure_frame& operator=(closure_frame const&); // no assign
|
||||
|
||||
closure_frame* save;
|
||||
closure_frame*& frame;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// closure_member class
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
template <int N, typename ClosureT>
|
||||
class closure_member {
|
||||
|
||||
public:
|
||||
|
||||
typedef typename ClosureT::tuple_t tuple_t;
|
||||
|
||||
closure_member()
|
||||
: frame(ClosureT::closure_frame_ref()) {}
|
||||
|
||||
template <typename TupleT>
|
||||
struct sig {
|
||||
|
||||
typedef typename detail::tuple_element_as_reference<
|
||||
N, typename ClosureT::tuple_t
|
||||
>::type type;
|
||||
};
|
||||
|
||||
template <class Ret, class A, class B, class C>
|
||||
// typename detail::tuple_element_as_reference
|
||||
// <N, typename ClosureT::tuple_t>::type
|
||||
Ret
|
||||
call(A&, B&, C&) const
|
||||
{
|
||||
assert(frame);
|
||||
return boost::tuples::get<N>(*frame);
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
typename ClosureT::closure_frame_t*& frame;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// closure class
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
template <
|
||||
typename T0 = null_type,
|
||||
typename T1 = null_type,
|
||||
typename T2 = null_type,
|
||||
typename T3 = null_type,
|
||||
typename T4 = null_type
|
||||
>
|
||||
class closure {
|
||||
|
||||
public:
|
||||
|
||||
typedef tuple<T0, T1, T2, T3, T4> tuple_t;
|
||||
typedef closure<T0, T1, T2, T3, T4> self_t;
|
||||
typedef closure_frame<self_t> closure_frame_t;
|
||||
|
||||
closure()
|
||||
: frame(0) { closure_frame_ref(&frame); }
|
||||
closure_frame_t& context() { assert(frame); return frame; }
|
||||
closure_frame_t const& context() const { assert(frame); return frame; }
|
||||
|
||||
typedef lambda_functor<closure_member<0, self_t> > member1;
|
||||
typedef lambda_functor<closure_member<1, self_t> > member2;
|
||||
typedef lambda_functor<closure_member<2, self_t> > member3;
|
||||
typedef lambda_functor<closure_member<3, self_t> > member4;
|
||||
typedef lambda_functor<closure_member<4, self_t> > member5;
|
||||
|
||||
private:
|
||||
|
||||
closure(closure const&); // no copy
|
||||
closure& operator=(closure const&); // no assign
|
||||
|
||||
template <int N, typename ClosureT>
|
||||
friend class closure_member;
|
||||
|
||||
template <typename ClosureT>
|
||||
friend class closure_frame;
|
||||
|
||||
static closure_frame_t*&
|
||||
closure_frame_ref(closure_frame_t** frame_ = 0)
|
||||
{
|
||||
static closure_frame_t** frame = 0;
|
||||
if (frame_ != 0)
|
||||
frame = frame_;
|
||||
return *frame;
|
||||
}
|
||||
|
||||
closure_frame_t* frame;
|
||||
};
|
||||
|
||||
}}
|
||||
// namespace
|
||||
|
||||
#endif
|
||||
/*=============================================================================
|
||||
Adaptable closures
|
||||
|
||||
Phoenix V0.9
|
||||
Copyright (c) 2001-2002 Joel de Guzman
|
||||
|
||||
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)
|
||||
|
||||
URL: http://spirit.sourceforge.net/
|
||||
|
||||
==============================================================================*/
|
||||
#ifndef BOOST_LAMBDA_CLOSURES_HPP
|
||||
#define BOOST_LAMBDA_CLOSURES_HPP
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
#include "boost/lambda/core.hpp"
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Adaptable closures
|
||||
//
|
||||
// The framework will not be complete without some form of closures
|
||||
// support. Closures encapsulate a stack frame where local
|
||||
// variables are created upon entering a function and destructed
|
||||
// upon exiting. Closures provide an environment for local
|
||||
// variables to reside. Closures can hold heterogeneous types.
|
||||
//
|
||||
// Phoenix closures are true hardware stack based closures. At the
|
||||
// very least, closures enable true reentrancy in lambda functions.
|
||||
// A closure provides access to a function stack frame where local
|
||||
// variables reside. Modeled after Pascal nested stack frames,
|
||||
// closures can be nested just like nested functions where code in
|
||||
// inner closures may access local variables from in-scope outer
|
||||
// closures (accessing inner scopes from outer scopes is an error
|
||||
// and will cause a run-time assertion failure).
|
||||
//
|
||||
// There are three (3) interacting classes:
|
||||
//
|
||||
// 1) closure:
|
||||
//
|
||||
// At the point of declaration, a closure does not yet create a
|
||||
// stack frame nor instantiate any variables. A closure declaration
|
||||
// declares the types and names[note] of the local variables. The
|
||||
// closure class is meant to be subclassed. It is the
|
||||
// responsibility of a closure subclass to supply the names for
|
||||
// each of the local variable in the closure. Example:
|
||||
//
|
||||
// struct my_closure : closure<int, string, double> {
|
||||
//
|
||||
// member1 num; // names the 1st (int) local variable
|
||||
// member2 message; // names the 2nd (string) local variable
|
||||
// member3 real; // names the 3rd (double) local variable
|
||||
// };
|
||||
//
|
||||
// my_closure clos;
|
||||
//
|
||||
// Now that we have a closure 'clos', its local variables can be
|
||||
// accessed lazily using the dot notation. Each qualified local
|
||||
// variable can be used just like any primitive actor (see
|
||||
// primitives.hpp). Examples:
|
||||
//
|
||||
// clos.num = 30
|
||||
// clos.message = arg1
|
||||
// clos.real = clos.num * 1e6
|
||||
//
|
||||
// The examples above are lazily evaluated. As usual, these
|
||||
// expressions return composite actors that will be evaluated
|
||||
// through a second function call invocation (see operators.hpp).
|
||||
// Each of the members (clos.xxx) is an actor. As such, applying
|
||||
// the operator() will reveal its identity:
|
||||
//
|
||||
// clos.num() // will return the current value of clos.num
|
||||
//
|
||||
// *** [note] Acknowledgement: Juan Carlos Arevalo-Baeza (JCAB)
|
||||
// introduced and initilally implemented the closure member names
|
||||
// that uses the dot notation.
|
||||
//
|
||||
// 2) closure_member
|
||||
//
|
||||
// The named local variables of closure 'clos' above are actually
|
||||
// closure members. The closure_member class is an actor and
|
||||
// conforms to its conceptual interface. member1..memberN are
|
||||
// predefined typedefs that correspond to each of the listed types
|
||||
// in the closure template parameters.
|
||||
//
|
||||
// 3) closure_frame
|
||||
//
|
||||
// When a closure member is finally evaluated, it should refer to
|
||||
// an actual instance of the variable in the hardware stack.
|
||||
// Without doing so, the process is not complete and the evaluated
|
||||
// member will result to an assertion failure. Remember that the
|
||||
// closure is just a declaration. The local variables that a
|
||||
// closure refers to must still be instantiated.
|
||||
//
|
||||
// The closure_frame class does the actual instantiation of the
|
||||
// local variables and links these variables with the closure and
|
||||
// all its members. There can be multiple instances of
|
||||
// closure_frames typically situated in the stack inside a
|
||||
// function. Each closure_frame instance initiates a stack frame
|
||||
// with a new set of closure local variables. Example:
|
||||
//
|
||||
// void foo()
|
||||
// {
|
||||
// closure_frame<my_closure> frame(clos);
|
||||
// /* do something */
|
||||
// }
|
||||
//
|
||||
// where 'clos' is an instance of our closure 'my_closure' above.
|
||||
// Take note that the usage above precludes locally declared
|
||||
// classes. If my_closure is a locally declared type, we can still
|
||||
// use its self_type as a paramater to closure_frame:
|
||||
//
|
||||
// closure_frame<my_closure::self_type> frame(clos);
|
||||
//
|
||||
// Upon instantiation, the closure_frame links the local variables
|
||||
// to the closure. The previous link to another closure_frame
|
||||
// instance created before is saved. Upon destruction, the
|
||||
// closure_frame unlinks itself from the closure and relinks the
|
||||
// preceding closure_frame prior to this instance.
|
||||
//
|
||||
// The local variables in the closure 'clos' above is default
|
||||
// constructed in the stack inside function 'foo'. Once 'foo' is
|
||||
// exited, all of these local variables are destructed. In some
|
||||
// cases, default construction is not desirable and we need to
|
||||
// initialize the local closure variables with some values. This
|
||||
// can be done by passing in the initializers in a compatible
|
||||
// tuple. A compatible tuple is one with the same number of
|
||||
// elements as the destination and where each element from the
|
||||
// destination can be constructed from each corresponding element
|
||||
// in the source. Example:
|
||||
//
|
||||
// tuple<int, char const*, int> init(123, "Hello", 1000);
|
||||
// closure_frame<my_closure> frame(clos, init);
|
||||
//
|
||||
// Here now, our closure_frame's variables are initialized with
|
||||
// int: 123, char const*: "Hello" and int: 1000.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// closure_frame class
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
template <typename ClosureT>
|
||||
class closure_frame : public ClosureT::tuple_t {
|
||||
|
||||
public:
|
||||
|
||||
closure_frame(ClosureT& clos)
|
||||
: ClosureT::tuple_t(), save(clos.frame), frame(clos.frame)
|
||||
{ clos.frame = this; }
|
||||
|
||||
template <typename TupleT>
|
||||
closure_frame(ClosureT& clos, TupleT const& init)
|
||||
: ClosureT::tuple_t(init), save(clos.frame), frame(clos.frame)
|
||||
{ clos.frame = this; }
|
||||
|
||||
~closure_frame()
|
||||
{ frame = save; }
|
||||
|
||||
private:
|
||||
|
||||
closure_frame(closure_frame const&); // no copy
|
||||
closure_frame& operator=(closure_frame const&); // no assign
|
||||
|
||||
closure_frame* save;
|
||||
closure_frame*& frame;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// closure_member class
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
template <int N, typename ClosureT>
|
||||
class closure_member {
|
||||
|
||||
public:
|
||||
|
||||
typedef typename ClosureT::tuple_t tuple_t;
|
||||
|
||||
closure_member()
|
||||
: frame(ClosureT::closure_frame_ref()) {}
|
||||
|
||||
template <typename TupleT>
|
||||
struct sig {
|
||||
|
||||
typedef typename detail::tuple_element_as_reference<
|
||||
N, typename ClosureT::tuple_t
|
||||
>::type type;
|
||||
};
|
||||
|
||||
template <class Ret, class A, class B, class C>
|
||||
// typename detail::tuple_element_as_reference
|
||||
// <N, typename ClosureT::tuple_t>::type
|
||||
Ret
|
||||
call(A&, B&, C&) const
|
||||
{
|
||||
assert(frame);
|
||||
return boost::tuples::get<N>(*frame);
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
typename ClosureT::closure_frame_t*& frame;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// closure class
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
template <
|
||||
typename T0 = null_type,
|
||||
typename T1 = null_type,
|
||||
typename T2 = null_type,
|
||||
typename T3 = null_type,
|
||||
typename T4 = null_type
|
||||
>
|
||||
class closure {
|
||||
|
||||
public:
|
||||
|
||||
typedef tuple<T0, T1, T2, T3, T4> tuple_t;
|
||||
typedef closure<T0, T1, T2, T3, T4> self_t;
|
||||
typedef closure_frame<self_t> closure_frame_t;
|
||||
|
||||
closure()
|
||||
: frame(0) { closure_frame_ref(&frame); }
|
||||
closure_frame_t& context() { assert(frame); return frame; }
|
||||
closure_frame_t const& context() const { assert(frame); return frame; }
|
||||
|
||||
typedef lambda_functor<closure_member<0, self_t> > member1;
|
||||
typedef lambda_functor<closure_member<1, self_t> > member2;
|
||||
typedef lambda_functor<closure_member<2, self_t> > member3;
|
||||
typedef lambda_functor<closure_member<3, self_t> > member4;
|
||||
typedef lambda_functor<closure_member<4, self_t> > member5;
|
||||
|
||||
private:
|
||||
|
||||
closure(closure const&); // no copy
|
||||
closure& operator=(closure const&); // no assign
|
||||
|
||||
template <int N, typename ClosureT>
|
||||
friend class closure_member;
|
||||
|
||||
template <typename ClosureT>
|
||||
friend class closure_frame;
|
||||
|
||||
static closure_frame_t*&
|
||||
closure_frame_ref(closure_frame_t** frame_ = 0)
|
||||
{
|
||||
static closure_frame_t** frame = 0;
|
||||
if (frame_ != 0)
|
||||
frame = frame_;
|
||||
return *frame;
|
||||
}
|
||||
|
||||
closure_frame_t* frame;
|
||||
};
|
||||
|
||||
}}
|
||||
// namespace
|
||||
|
||||
#endif
|
||||
@@ -1,240 +1,240 @@
|
||||
// - construct.hpp -- Lambda 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_CONSTRUCT_HPP)
|
||||
#define BOOST_LAMBDA_CONSTRUCT_HPP
|
||||
|
||||
#include "boost/type_traits/remove_cv.hpp"
|
||||
#include "boost/type_traits/is_pointer.hpp"
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
// constructor is used together with bind. constructor<A> creates a bindable
|
||||
// function object that passes its arguments forward to a constructor call
|
||||
// of type A
|
||||
|
||||
template<class T> struct constructor {
|
||||
|
||||
template <class U> struct sig { typedef T type; };
|
||||
|
||||
T operator()() const {
|
||||
return T();
|
||||
}
|
||||
|
||||
template<class A1>
|
||||
T operator()(A1& a1) const {
|
||||
return T(a1);
|
||||
}
|
||||
|
||||
template<class A1, class A2>
|
||||
T operator()(A1& a1, A2& a2) const {
|
||||
return T(a1, a2);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3>
|
||||
T operator()(A1& a1, A2& a2, A3& a3) const {
|
||||
return T(a1, a2, a3);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4>
|
||||
T operator()(A1& a1, A2& a2, A3& a3, A4& a4) const {
|
||||
return T(a1, a2, a3, a4);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5>
|
||||
T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) const {
|
||||
return T(a1, a2, a3, a4, a5);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6>
|
||||
T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) const {
|
||||
return T(a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7>
|
||||
T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) const {
|
||||
return T(a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
|
||||
T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) const {
|
||||
return T(a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
|
||||
T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) const {
|
||||
return T(a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
|
||||
T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) const {
|
||||
return T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
namespace detail {
|
||||
|
||||
// A standard conforming compiler could disambiguate between
|
||||
// A1* and A1&, but not all compilers do that, so we need the
|
||||
// helpers
|
||||
|
||||
|
||||
template <bool IsPointer>
|
||||
struct destructor_helper {
|
||||
|
||||
template<class A1>
|
||||
static void exec(A1& a1) {
|
||||
// remove all the qualifiers, not sure whether it is necessary
|
||||
typedef typename boost::remove_cv<A1>::type plainA1;
|
||||
a1.~plainA1();
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct destructor_helper<true> {
|
||||
|
||||
template<class A1>
|
||||
static void exec(A1* a1) {
|
||||
typedef typename boost::remove_cv<A1>::type plainA1;
|
||||
(*a1).~plainA1();
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
// destructor funtion object
|
||||
struct destructor {
|
||||
|
||||
template <class T> struct sig { typedef void type; };
|
||||
|
||||
template<class A1>
|
||||
void operator()(A1& a1) const {
|
||||
typedef typename boost::remove_cv<A1>::type plainA1;
|
||||
detail::destructor_helper<boost::is_pointer<plainA1>::value>::exec(a1);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
// new_ptr is used together with bind.
|
||||
|
||||
// note: placement new is not supported
|
||||
|
||||
template<class T> struct new_ptr {
|
||||
|
||||
template <class U> struct sig { typedef T* type; };
|
||||
|
||||
T* operator()() const {
|
||||
return new T();
|
||||
}
|
||||
|
||||
template<class A1>
|
||||
T* operator()(A1& a1) const {
|
||||
return new T(a1);
|
||||
}
|
||||
|
||||
template<class A1, class A2>
|
||||
T* operator()(A1& a1, A2& a2) const {
|
||||
return new T(a1, a2);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3>
|
||||
T* operator()(A1& a1, A2& a2, A3& a3) const {
|
||||
return new T(a1, a2, a3);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4>
|
||||
T* operator()(A1& a1, A2& a2, A3& a3, A4& a4) const {
|
||||
return new T(a1, a2, a3, a4);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5>
|
||||
T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) const {
|
||||
return new T(a1, a2, a3, a4, a5);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6>
|
||||
T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) const {
|
||||
return new T(a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7>
|
||||
T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) const {
|
||||
return new T(a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
|
||||
T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) const {
|
||||
return new T(a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
|
||||
T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) const {
|
||||
return new T(a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
|
||||
T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) const {
|
||||
return new T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
// delete_ptr return void
|
||||
|
||||
struct delete_ptr {
|
||||
|
||||
template <class U> struct sig { typedef void type; };
|
||||
|
||||
template <class A1>
|
||||
void operator()(A1& a1) const {
|
||||
delete a1;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
// new_array is used together with bind.
|
||||
|
||||
template<class T> struct new_array {
|
||||
|
||||
template <class U> struct sig { typedef T* type; };
|
||||
|
||||
T* operator()(int size) const {
|
||||
return new T[size];
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// delete_ptr return void
|
||||
|
||||
struct delete_array {
|
||||
|
||||
template <class U> struct sig { typedef void type; };
|
||||
|
||||
template <class A1>
|
||||
void operator()(A1& a1) const {
|
||||
delete[] a1;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
// - construct.hpp -- Lambda 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_CONSTRUCT_HPP)
|
||||
#define BOOST_LAMBDA_CONSTRUCT_HPP
|
||||
|
||||
#include "boost/type_traits/remove_cv.hpp"
|
||||
#include "boost/type_traits/is_pointer.hpp"
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
// constructor is used together with bind. constructor<A> creates a bindable
|
||||
// function object that passes its arguments forward to a constructor call
|
||||
// of type A
|
||||
|
||||
template<class T> struct constructor {
|
||||
|
||||
template <class U> struct sig { typedef T type; };
|
||||
|
||||
T operator()() const {
|
||||
return T();
|
||||
}
|
||||
|
||||
template<class A1>
|
||||
T operator()(A1& a1) const {
|
||||
return T(a1);
|
||||
}
|
||||
|
||||
template<class A1, class A2>
|
||||
T operator()(A1& a1, A2& a2) const {
|
||||
return T(a1, a2);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3>
|
||||
T operator()(A1& a1, A2& a2, A3& a3) const {
|
||||
return T(a1, a2, a3);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4>
|
||||
T operator()(A1& a1, A2& a2, A3& a3, A4& a4) const {
|
||||
return T(a1, a2, a3, a4);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5>
|
||||
T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) const {
|
||||
return T(a1, a2, a3, a4, a5);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6>
|
||||
T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) const {
|
||||
return T(a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7>
|
||||
T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) const {
|
||||
return T(a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
|
||||
T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) const {
|
||||
return T(a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
|
||||
T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) const {
|
||||
return T(a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
|
||||
T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) const {
|
||||
return T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
namespace detail {
|
||||
|
||||
// A standard conforming compiler could disambiguate between
|
||||
// A1* and A1&, but not all compilers do that, so we need the
|
||||
// helpers
|
||||
|
||||
|
||||
template <bool IsPointer>
|
||||
struct destructor_helper {
|
||||
|
||||
template<class A1>
|
||||
static void exec(A1& a1) {
|
||||
// remove all the qualifiers, not sure whether it is necessary
|
||||
typedef typename boost::remove_cv<A1>::type plainA1;
|
||||
a1.~plainA1();
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct destructor_helper<true> {
|
||||
|
||||
template<class A1>
|
||||
static void exec(A1* a1) {
|
||||
typedef typename boost::remove_cv<A1>::type plainA1;
|
||||
(*a1).~plainA1();
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
// destructor funtion object
|
||||
struct destructor {
|
||||
|
||||
template <class T> struct sig { typedef void type; };
|
||||
|
||||
template<class A1>
|
||||
void operator()(A1& a1) const {
|
||||
typedef typename boost::remove_cv<A1>::type plainA1;
|
||||
detail::destructor_helper<boost::is_pointer<plainA1>::value>::exec(a1);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
// new_ptr is used together with bind.
|
||||
|
||||
// note: placement new is not supported
|
||||
|
||||
template<class T> struct new_ptr {
|
||||
|
||||
template <class U> struct sig { typedef T* type; };
|
||||
|
||||
T* operator()() const {
|
||||
return new T();
|
||||
}
|
||||
|
||||
template<class A1>
|
||||
T* operator()(A1& a1) const {
|
||||
return new T(a1);
|
||||
}
|
||||
|
||||
template<class A1, class A2>
|
||||
T* operator()(A1& a1, A2& a2) const {
|
||||
return new T(a1, a2);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3>
|
||||
T* operator()(A1& a1, A2& a2, A3& a3) const {
|
||||
return new T(a1, a2, a3);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4>
|
||||
T* operator()(A1& a1, A2& a2, A3& a3, A4& a4) const {
|
||||
return new T(a1, a2, a3, a4);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5>
|
||||
T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) const {
|
||||
return new T(a1, a2, a3, a4, a5);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6>
|
||||
T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) const {
|
||||
return new T(a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7>
|
||||
T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) const {
|
||||
return new T(a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
|
||||
T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) const {
|
||||
return new T(a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
|
||||
T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) const {
|
||||
return new T(a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
}
|
||||
|
||||
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
|
||||
T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) const {
|
||||
return new T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
// delete_ptr return void
|
||||
|
||||
struct delete_ptr {
|
||||
|
||||
template <class U> struct sig { typedef void type; };
|
||||
|
||||
template <class A1>
|
||||
void operator()(A1& a1) const {
|
||||
delete a1;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
// new_array is used together with bind.
|
||||
|
||||
template<class T> struct new_array {
|
||||
|
||||
template <class U> struct sig { typedef T* type; };
|
||||
|
||||
T* operator()(int size) const {
|
||||
return new T[size];
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// delete_ptr return void
|
||||
|
||||
struct delete_array {
|
||||
|
||||
template <class U> struct sig { typedef void type; };
|
||||
|
||||
template <class A1>
|
||||
void operator()(A1& a1) const {
|
||||
delete[] a1;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
@@ -1,23 +1,23 @@
|
||||
// -- control_structures.hpp -- Boost Lambda Library --------------------------
|
||||
// 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 www.boost.org
|
||||
|
||||
#ifndef BOOST_LAMBDA_CONTROL_STRUCTURES_HPP
|
||||
#define BOOST_LAMBDA_CONTROL_STRUCTURES_HPP
|
||||
|
||||
|
||||
#include "boost/lambda/core.hpp"
|
||||
|
||||
// Arithmetic type promotion needed for if_then_else_return
|
||||
#include "boost/lambda/detail/operator_actions.hpp"
|
||||
#include "boost/lambda/detail/operator_return_type_traits.hpp"
|
||||
|
||||
#include "boost/lambda/if.hpp"
|
||||
#include "boost/lambda/loops.hpp"
|
||||
|
||||
#endif
|
||||
// -- control_structures.hpp -- Boost Lambda Library --------------------------
|
||||
// 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 www.boost.org
|
||||
|
||||
#ifndef BOOST_LAMBDA_CONTROL_STRUCTURES_HPP
|
||||
#define BOOST_LAMBDA_CONTROL_STRUCTURES_HPP
|
||||
|
||||
|
||||
#include "boost/lambda/core.hpp"
|
||||
|
||||
// Arithmetic type promotion needed for if_then_else_return
|
||||
#include "boost/lambda/detail/operator_actions.hpp"
|
||||
#include "boost/lambda/detail/operator_return_type_traits.hpp"
|
||||
|
||||
#include "boost/lambda/if.hpp"
|
||||
#include "boost/lambda/loops.hpp"
|
||||
|
||||
#endif
|
||||
@@ -1,79 +1,81 @@
|
||||
// -- core.hpp -- Boost Lambda 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 www.boost.org
|
||||
//
|
||||
// Includes the core of LL, without any real features for client:
|
||||
//
|
||||
// tuples, lambda functors, return type deduction templates,
|
||||
// argument substitution mechanism (select functions)
|
||||
//
|
||||
// Some functionality comes as well:
|
||||
// Assignment and subscript operators, as well as function
|
||||
// call operator for placeholder variables.
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_CORE_HPP
|
||||
#define BOOST_LAMBDA_CORE_HPP
|
||||
|
||||
#include "boost/type_traits/transform_traits.hpp"
|
||||
#include "boost/type_traits/cv_traits.hpp"
|
||||
|
||||
#include "boost/tuple/tuple.hpp"
|
||||
|
||||
// inject some of the tuple names into lambda
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
using ::boost::tuples::tuple;
|
||||
using ::boost::tuples::null_type;
|
||||
|
||||
} // lambda
|
||||
} // boost
|
||||
|
||||
#include "boost/lambda/detail/lambda_config.hpp"
|
||||
#include "boost/lambda/detail/lambda_fwd.hpp"
|
||||
|
||||
#include "boost/lambda/detail/arity_code.hpp"
|
||||
#include "boost/lambda/detail/actions.hpp"
|
||||
|
||||
#include "boost/lambda/detail/lambda_traits.hpp"
|
||||
|
||||
#include "boost/lambda/detail/function_adaptors.hpp"
|
||||
#include "boost/lambda/detail/return_type_traits.hpp"
|
||||
|
||||
#include "boost/lambda/detail/select_functions.hpp"
|
||||
|
||||
#include "boost/lambda/detail/lambda_functor_base.hpp"
|
||||
|
||||
#include "boost/lambda/detail/lambda_functors.hpp"
|
||||
|
||||
#include "boost/lambda/detail/ret.hpp"
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
namespace {
|
||||
|
||||
// These are constants types and need to be initialised
|
||||
boost::lambda::placeholder1_type free1 = boost::lambda::placeholder1_type();
|
||||
boost::lambda::placeholder2_type free2 = boost::lambda::placeholder2_type();
|
||||
boost::lambda::placeholder3_type free3 = boost::lambda::placeholder3_type();
|
||||
|
||||
boost::lambda::placeholder1_type& _1 = free1;
|
||||
boost::lambda::placeholder2_type& _2 = free2;
|
||||
boost::lambda::placeholder3_type& _3 = free3;
|
||||
// _1, _2, ... naming scheme by Peter Dimov
|
||||
} // unnamed
|
||||
|
||||
} // lambda
|
||||
} // boost
|
||||
|
||||
|
||||
#endif //BOOST_LAMBDA_CORE_HPP
|
||||
// -- core.hpp -- Boost Lambda 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 www.boost.org
|
||||
//
|
||||
// Includes the core of LL, without any real features for client:
|
||||
//
|
||||
// tuples, lambda functors, return type deduction templates,
|
||||
// argument substitution mechanism (select functions)
|
||||
//
|
||||
// Some functionality comes as well:
|
||||
// Assignment and subscript operators, as well as function
|
||||
// call operator for placeholder variables.
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_CORE_HPP
|
||||
#define BOOST_LAMBDA_CORE_HPP
|
||||
|
||||
#include "boost/config.hpp"
|
||||
|
||||
#include "boost/type_traits/transform_traits.hpp"
|
||||
#include "boost/type_traits/cv_traits.hpp"
|
||||
|
||||
#include "boost/tuple/tuple.hpp"
|
||||
|
||||
// inject some of the tuple names into lambda
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
using ::boost::tuples::tuple;
|
||||
using ::boost::tuples::null_type;
|
||||
|
||||
} // lambda
|
||||
} // boost
|
||||
|
||||
#include "boost/lambda/detail/lambda_config.hpp"
|
||||
#include "boost/lambda/detail/lambda_fwd.hpp"
|
||||
|
||||
#include "boost/lambda/detail/arity_code.hpp"
|
||||
#include "boost/lambda/detail/actions.hpp"
|
||||
|
||||
#include "boost/lambda/detail/lambda_traits.hpp"
|
||||
|
||||
#include "boost/lambda/detail/function_adaptors.hpp"
|
||||
#include "boost/lambda/detail/return_type_traits.hpp"
|
||||
|
||||
#include "boost/lambda/detail/select_functions.hpp"
|
||||
|
||||
#include "boost/lambda/detail/lambda_functor_base.hpp"
|
||||
|
||||
#include "boost/lambda/detail/lambda_functors.hpp"
|
||||
|
||||
#include "boost/lambda/detail/ret.hpp"
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
namespace {
|
||||
|
||||
// These are constants types and need to be initialised
|
||||
boost::lambda::placeholder1_type free1 = boost::lambda::placeholder1_type();
|
||||
boost::lambda::placeholder2_type free2 = boost::lambda::placeholder2_type();
|
||||
boost::lambda::placeholder3_type free3 = boost::lambda::placeholder3_type();
|
||||
|
||||
boost::lambda::placeholder1_type& BOOST_ATTRIBUTE_UNUSED _1 = free1;
|
||||
boost::lambda::placeholder2_type& BOOST_ATTRIBUTE_UNUSED _2 = free2;
|
||||
boost::lambda::placeholder3_type& BOOST_ATTRIBUTE_UNUSED _3 = free3;
|
||||
// _1, _2, ... naming scheme by Peter Dimov
|
||||
} // unnamed
|
||||
|
||||
} // lambda
|
||||
} // boost
|
||||
|
||||
|
||||
#endif //BOOST_LAMBDA_CORE_HPP
|
||||
@@ -1,174 +1,174 @@
|
||||
// -- Boost Lambda Library - actions.hpp ----------------------------------
|
||||
|
||||
// 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 www.boost.org
|
||||
|
||||
// ----------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_ACTIONS_HPP
|
||||
#define BOOST_LAMBDA_ACTIONS_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
|
||||
|
||||
template<int Arity, class Act> class action;
|
||||
|
||||
// these need to be defined here, since the corresponding lambda
|
||||
// functions are members of lambda_functor classes
|
||||
|
||||
class assignment_action {};
|
||||
class subscript_action {};
|
||||
|
||||
template <class Action> class other_action;
|
||||
|
||||
// action for specifying the explicit return type
|
||||
template <class RET> class explicit_return_type_action {};
|
||||
|
||||
// action for preventing the expansion of a lambda expression
|
||||
struct protect_action {};
|
||||
|
||||
// must be defined here, comma is a special case
|
||||
struct comma_action {};
|
||||
|
||||
|
||||
// actions, for which the existence of protect is checked in return type
|
||||
// deduction.
|
||||
|
||||
template <class Action> struct is_protectable {
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
|
||||
// NOTE: comma action is protectable. Other protectable actions
|
||||
// are listed in operator_actions.hpp
|
||||
|
||||
template<> struct is_protectable<other_action<comma_action> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
|
||||
|
||||
namespace detail {
|
||||
|
||||
// this type is used in return type deductions to signal that deduction
|
||||
// did not find a result. It does not necessarily mean an error, it commonly
|
||||
// means that something else should be tried.
|
||||
class unspecified {};
|
||||
}
|
||||
|
||||
// function action is a special case: bind functions can be called with
|
||||
// the return type specialized explicitly e.g. bind<int>(foo);
|
||||
// If this call syntax is used, the return type is stored in the latter
|
||||
// argument of function_action template. Otherwise the argument gets the type
|
||||
// 'unspecified'.
|
||||
// This argument is only relevant in the return type deduction code
|
||||
template <int I, class Result_type = detail::unspecified>
|
||||
class function_action {};
|
||||
|
||||
template<class T> class function_action<1, T> {
|
||||
public:
|
||||
template<class RET, class A1>
|
||||
static RET apply(A1& a1) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<2, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2>
|
||||
static RET apply(A1& a1, A2& a2) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<3, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2, class A3>
|
||||
static RET apply(A1& a1, A2& a2, A3& a3) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2, a3);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<4, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2, class A3, class A4>
|
||||
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2, a3, a4);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<5, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2, class A3, class A4, class A5>
|
||||
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2, a3, a4, a5);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<6, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2, class A3, class A4, class A5,
|
||||
class A6>
|
||||
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<7, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2, class A3, class A4, class A5,
|
||||
class A6, class A7>
|
||||
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<8, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2, class A3, class A4, class A5,
|
||||
class A6, class A7, class A8>
|
||||
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7,
|
||||
A8& a8) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<9, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2, class A3, class A4, class A5,
|
||||
class A6, class A7, class A8, class A9>
|
||||
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7,
|
||||
A8& a8, A9& a9) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<10, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2, class A3, class A4, class A5,
|
||||
class A6, class A7, class A8, class A9, class A10>
|
||||
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7,
|
||||
A8& a8, A9& a9, A10& a10) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
// -- Boost Lambda Library - actions.hpp ----------------------------------
|
||||
|
||||
// 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 www.boost.org
|
||||
|
||||
// ----------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_ACTIONS_HPP
|
||||
#define BOOST_LAMBDA_ACTIONS_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
|
||||
|
||||
template<int Arity, class Act> class action;
|
||||
|
||||
// these need to be defined here, since the corresponding lambda
|
||||
// functions are members of lambda_functor classes
|
||||
|
||||
class assignment_action {};
|
||||
class subscript_action {};
|
||||
|
||||
template <class Action> class other_action;
|
||||
|
||||
// action for specifying the explicit return type
|
||||
template <class RET> class explicit_return_type_action {};
|
||||
|
||||
// action for preventing the expansion of a lambda expression
|
||||
struct protect_action {};
|
||||
|
||||
// must be defined here, comma is a special case
|
||||
struct comma_action {};
|
||||
|
||||
|
||||
// actions, for which the existence of protect is checked in return type
|
||||
// deduction.
|
||||
|
||||
template <class Action> struct is_protectable {
|
||||
BOOST_STATIC_CONSTANT(bool, value = false);
|
||||
};
|
||||
|
||||
// NOTE: comma action is protectable. Other protectable actions
|
||||
// are listed in operator_actions.hpp
|
||||
|
||||
template<> struct is_protectable<other_action<comma_action> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
|
||||
|
||||
namespace detail {
|
||||
|
||||
// this type is used in return type deductions to signal that deduction
|
||||
// did not find a result. It does not necessarily mean an error, it commonly
|
||||
// means that something else should be tried.
|
||||
class unspecified {};
|
||||
}
|
||||
|
||||
// function action is a special case: bind functions can be called with
|
||||
// the return type specialized explicitly e.g. bind<int>(foo);
|
||||
// If this call syntax is used, the return type is stored in the latter
|
||||
// argument of function_action template. Otherwise the argument gets the type
|
||||
// 'unspecified'.
|
||||
// This argument is only relevant in the return type deduction code
|
||||
template <int I, class Result_type = detail::unspecified>
|
||||
class function_action {};
|
||||
|
||||
template<class T> class function_action<1, T> {
|
||||
public:
|
||||
template<class RET, class A1>
|
||||
static RET apply(A1& a1) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<2, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2>
|
||||
static RET apply(A1& a1, A2& a2) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<3, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2, class A3>
|
||||
static RET apply(A1& a1, A2& a2, A3& a3) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2, a3);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<4, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2, class A3, class A4>
|
||||
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2, a3, a4);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<5, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2, class A3, class A4, class A5>
|
||||
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2, a3, a4, a5);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<6, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2, class A3, class A4, class A5,
|
||||
class A6>
|
||||
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2, a3, a4, a5, a6);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<7, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2, class A3, class A4, class A5,
|
||||
class A6, class A7>
|
||||
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2, a3, a4, a5, a6, a7);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<8, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2, class A3, class A4, class A5,
|
||||
class A6, class A7, class A8>
|
||||
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7,
|
||||
A8& a8) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<9, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2, class A3, class A4, class A5,
|
||||
class A6, class A7, class A8, class A9>
|
||||
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7,
|
||||
A8& a8, A9& a9) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8, a9);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T> class function_action<10, T> {
|
||||
public:
|
||||
template<class RET, class A1, class A2, class A3, class A4, class A5,
|
||||
class A6, class A7, class A8, class A9, class A10>
|
||||
static RET apply(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7,
|
||||
A8& a8, A9& a9, A10& a10) {
|
||||
return function_adaptor<typename boost::remove_cv<A1>::type>::
|
||||
template apply<RET>(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
@@ -1,110 +1,110 @@
|
||||
// -- Boost Lambda Library -------------------------------------------------
|
||||
|
||||
// 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 www.boost.org
|
||||
|
||||
// --------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_ARITY_CODE_HPP
|
||||
#define BOOST_LAMBDA_ARITY_CODE_HPP
|
||||
|
||||
#include "boost/type_traits/cv_traits.hpp"
|
||||
#include "boost/type_traits/transform_traits.hpp"
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
// These constants state, whether a lambda_functor instantiation results from
|
||||
// an expression which contains no placeholders (NONE),
|
||||
// only free1 placeholders (FIRST),
|
||||
// free2 placeholders and maybe free1 placeholders (SECOND),
|
||||
// free3 and maybe free1 and free2 placeholders (THIRD),
|
||||
// freeE placeholders and maybe free1 and free2 (EXCEPTION).
|
||||
// RETHROW means, that a rethrow expression is used somewhere in the lambda_functor.
|
||||
|
||||
enum { NONE = 0x00, // Notice we are using bits as flags here.
|
||||
FIRST = 0x01,
|
||||
SECOND = 0x02,
|
||||
THIRD = 0x04,
|
||||
EXCEPTION = 0x08,
|
||||
RETHROW = 0x10};
|
||||
|
||||
|
||||
template<class T>
|
||||
struct get_tuple_arity;
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <class T> struct get_arity_;
|
||||
|
||||
} // end detail;
|
||||
|
||||
template <class T> struct get_arity {
|
||||
|
||||
BOOST_STATIC_CONSTANT(int, value = detail::get_arity_<typename boost::remove_cv<typename boost::remove_reference<T>::type>::type>::value);
|
||||
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class T>
|
||||
struct get_arity_ {
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct get_arity_<lambda_functor<T> > {
|
||||
BOOST_STATIC_CONSTANT(int, value = get_arity<T>::value);
|
||||
};
|
||||
|
||||
template<class Action, class Args>
|
||||
struct get_arity_<lambda_functor_base<Action, Args> > {
|
||||
BOOST_STATIC_CONSTANT(int, value = get_tuple_arity<Args>::value);
|
||||
};
|
||||
|
||||
template<int I>
|
||||
struct get_arity_<placeholder<I> > {
|
||||
BOOST_STATIC_CONSTANT(int, value = I);
|
||||
};
|
||||
|
||||
} // detail
|
||||
|
||||
template<class T>
|
||||
struct get_tuple_arity {
|
||||
BOOST_STATIC_CONSTANT(int, value = get_arity<typename T::head_type>::value | get_tuple_arity<typename T::tail_type>::value);
|
||||
};
|
||||
|
||||
|
||||
template<>
|
||||
struct get_tuple_arity<null_type> {
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
|
||||
|
||||
// Does T have placeholder<I> as it's subexpression?
|
||||
|
||||
template<class T, int I>
|
||||
struct has_placeholder {
|
||||
BOOST_STATIC_CONSTANT(bool, value = (get_arity<T>::value & I) != 0);
|
||||
};
|
||||
|
||||
template<int I, int J>
|
||||
struct includes_placeholder {
|
||||
BOOST_STATIC_CONSTANT(bool, value = (J & I) != 0);
|
||||
};
|
||||
|
||||
template<int I, int J>
|
||||
struct lacks_placeholder {
|
||||
BOOST_STATIC_CONSTANT(bool, value = ((J & I) == 0));
|
||||
};
|
||||
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
// -- Boost Lambda Library -------------------------------------------------
|
||||
|
||||
// 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 www.boost.org
|
||||
|
||||
// --------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_ARITY_CODE_HPP
|
||||
#define BOOST_LAMBDA_ARITY_CODE_HPP
|
||||
|
||||
#include "boost/type_traits/cv_traits.hpp"
|
||||
#include "boost/type_traits/transform_traits.hpp"
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
// These constants state, whether a lambda_functor instantiation results from
|
||||
// an expression which contains no placeholders (NONE),
|
||||
// only free1 placeholders (FIRST),
|
||||
// free2 placeholders and maybe free1 placeholders (SECOND),
|
||||
// free3 and maybe free1 and free2 placeholders (THIRD),
|
||||
// freeE placeholders and maybe free1 and free2 (EXCEPTION).
|
||||
// RETHROW means, that a rethrow expression is used somewhere in the lambda_functor.
|
||||
|
||||
enum { NONE = 0x00, // Notice we are using bits as flags here.
|
||||
FIRST = 0x01,
|
||||
SECOND = 0x02,
|
||||
THIRD = 0x04,
|
||||
EXCEPTION = 0x08,
|
||||
RETHROW = 0x10};
|
||||
|
||||
|
||||
template<class T>
|
||||
struct get_tuple_arity;
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <class T> struct get_arity_;
|
||||
|
||||
} // end detail;
|
||||
|
||||
template <class T> struct get_arity {
|
||||
|
||||
BOOST_STATIC_CONSTANT(int, value = detail::get_arity_<typename boost::remove_cv<typename boost::remove_reference<T>::type>::type>::value);
|
||||
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class T>
|
||||
struct get_arity_ {
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct get_arity_<lambda_functor<T> > {
|
||||
BOOST_STATIC_CONSTANT(int, value = get_arity<T>::value);
|
||||
};
|
||||
|
||||
template<class Action, class Args>
|
||||
struct get_arity_<lambda_functor_base<Action, Args> > {
|
||||
BOOST_STATIC_CONSTANT(int, value = get_tuple_arity<Args>::value);
|
||||
};
|
||||
|
||||
template<int I>
|
||||
struct get_arity_<placeholder<I> > {
|
||||
BOOST_STATIC_CONSTANT(int, value = I);
|
||||
};
|
||||
|
||||
} // detail
|
||||
|
||||
template<class T>
|
||||
struct get_tuple_arity {
|
||||
BOOST_STATIC_CONSTANT(int, value = get_arity<typename T::head_type>::value | get_tuple_arity<typename T::tail_type>::value);
|
||||
};
|
||||
|
||||
|
||||
template<>
|
||||
struct get_tuple_arity<null_type> {
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
|
||||
|
||||
// Does T have placeholder<I> as it's subexpression?
|
||||
|
||||
template<class T, int I>
|
||||
struct has_placeholder {
|
||||
BOOST_STATIC_CONSTANT(bool, value = (get_arity<T>::value & I) != 0);
|
||||
};
|
||||
|
||||
template<int I, int J>
|
||||
struct includes_placeholder {
|
||||
BOOST_STATIC_CONSTANT(bool, value = (J & I) != 0);
|
||||
};
|
||||
|
||||
template<int I, int J>
|
||||
struct lacks_placeholder {
|
||||
BOOST_STATIC_CONSTANT(bool, value = ((J & I) == 0));
|
||||
};
|
||||
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large.
Load diff
@@ -1,50 +1,50 @@
|
||||
// Boost Lambda Library -- control_constructs_common.hpp -------------------
|
||||
|
||||
// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
|
||||
//
|
||||
// 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 www.boost.org
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
#if !defined(BOOST_CONTROL_CONSTRUCTS_COMMON_HPP)
|
||||
#define BOOST_CONTROL_CONSTRUCTS_COMMON_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
// special types of lambda functors, used with control structures
|
||||
// to guarantee that they are composed correctly.
|
||||
|
||||
template<class Tag, class LambdaFunctor>
|
||||
class tagged_lambda_functor;
|
||||
|
||||
template<class Tag, class Args>
|
||||
class tagged_lambda_functor<Tag, lambda_functor<Args> >
|
||||
: public lambda_functor<Args>
|
||||
{
|
||||
public:
|
||||
tagged_lambda_functor(const Args& a) : lambda_functor<Args>(a) {}
|
||||
|
||||
tagged_lambda_functor(const lambda_functor<Args>& a)
|
||||
: lambda_functor<Args>(a) {}
|
||||
|
||||
// for the no body cases in control structures.
|
||||
tagged_lambda_functor() : lambda_functor<Args>() {}
|
||||
};
|
||||
|
||||
} // lambda
|
||||
} // boost
|
||||
|
||||
#endif // BOOST_CONTROL_CONSTRUCTS_COMMON_HPP
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// Boost Lambda Library -- control_constructs_common.hpp -------------------
|
||||
|
||||
// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
|
||||
//
|
||||
// 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 www.boost.org
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
#if !defined(BOOST_CONTROL_CONSTRUCTS_COMMON_HPP)
|
||||
#define BOOST_CONTROL_CONSTRUCTS_COMMON_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
// special types of lambda functors, used with control structures
|
||||
// to guarantee that they are composed correctly.
|
||||
|
||||
template<class Tag, class LambdaFunctor>
|
||||
class tagged_lambda_functor;
|
||||
|
||||
template<class Tag, class Args>
|
||||
class tagged_lambda_functor<Tag, lambda_functor<Args> >
|
||||
: public lambda_functor<Args>
|
||||
{
|
||||
public:
|
||||
tagged_lambda_functor(const Args& a) : lambda_functor<Args>(a) {}
|
||||
|
||||
tagged_lambda_functor(const lambda_functor<Args>& a)
|
||||
: lambda_functor<Args>(a) {}
|
||||
|
||||
// for the no body cases in control structures.
|
||||
tagged_lambda_functor() : lambda_functor<Args>() {}
|
||||
};
|
||||
|
||||
} // lambda
|
||||
} // boost
|
||||
|
||||
#endif // BOOST_CONTROL_CONSTRUCTS_COMMON_HPP
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -1,104 +1,104 @@
|
||||
// Boost Lambda Library - is_instance_of.hpp ---------------------
|
||||
|
||||
// Copyright (C) 2001 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 www.boost.org
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_IS_INSTANCE_OF
|
||||
#define BOOST_LAMBDA_IS_INSTANCE_OF
|
||||
|
||||
#include "boost/config.hpp" // for BOOST_STATIC_CONSTANT
|
||||
#include "boost/type_traits/conversion_traits.hpp" // for is_convertible
|
||||
#include "boost/preprocessor/enum_shifted_params.hpp"
|
||||
#include "boost/preprocessor/repeat_2nd.hpp"
|
||||
|
||||
// is_instance_of --------------------------------
|
||||
//
|
||||
// is_instance_of_n<A, B>::value is true, if type A is
|
||||
// an instantiation of a template B, or A derives from an instantiation
|
||||
// of template B
|
||||
//
|
||||
// n is the number of template arguments for B
|
||||
//
|
||||
// Example:
|
||||
// is_instance_of_2<std::istream, basic_stream>::value == true
|
||||
|
||||
// The original implementation was somewhat different, with different versions
|
||||
// for different compilers. However, there was still a problem
|
||||
// with gcc.3.0.2 and 3.0.3 compilers, which didn't think regard
|
||||
// is_instance_of_N<...>::value was a constant.
|
||||
// John Maddock suggested the way around this problem by building
|
||||
// is_instance_of templates using boost::is_convertible.
|
||||
// Now we only have one version of is_instance_of templates, which delagate
|
||||
// all the nasty compiler tricks to is_convertible.
|
||||
|
||||
#define BOOST_LAMBDA_CLASS(z, N,A) BOOST_PP_COMMA_IF(N) class
|
||||
#define BOOST_LAMBDA_CLASS_ARG(z, N,A) BOOST_PP_COMMA_IF(N) class A##N
|
||||
#define BOOST_LAMBDA_ARG(z, N,A) BOOST_PP_COMMA_IF(N) A##N
|
||||
|
||||
#define BOOST_LAMBDA_CLASS_LIST(n, NAME) BOOST_PP_REPEAT(n, BOOST_LAMBDA_CLASS, NAME)
|
||||
|
||||
#define BOOST_LAMBDA_CLASS_ARG_LIST(n, NAME) BOOST_PP_REPEAT(n, BOOST_LAMBDA_CLASS_ARG, NAME)
|
||||
|
||||
#define BOOST_LAMBDA_ARG_LIST(n, NAME) BOOST_PP_REPEAT(n, BOOST_LAMBDA_ARG, NAME)
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
#define BOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE(INDEX) \
|
||||
\
|
||||
namespace detail { \
|
||||
\
|
||||
template <template<BOOST_LAMBDA_CLASS_LIST(INDEX,T)> class F> \
|
||||
struct BOOST_PP_CAT(conversion_tester_,INDEX) { \
|
||||
template<BOOST_LAMBDA_CLASS_ARG_LIST(INDEX,A)> \
|
||||
BOOST_PP_CAT(conversion_tester_,INDEX) \
|
||||
(const F<BOOST_LAMBDA_ARG_LIST(INDEX,A)>&); \
|
||||
}; \
|
||||
\
|
||||
} /* end detail */ \
|
||||
\
|
||||
template <class From, template <BOOST_LAMBDA_CLASS_LIST(INDEX,T)> class To> \
|
||||
struct BOOST_PP_CAT(is_instance_of_,INDEX) \
|
||||
{ \
|
||||
private: \
|
||||
typedef ::boost::is_convertible< \
|
||||
From, \
|
||||
BOOST_PP_CAT(detail::conversion_tester_,INDEX)<To> \
|
||||
> helper_type; \
|
||||
\
|
||||
public: \
|
||||
BOOST_STATIC_CONSTANT(bool, value = helper_type::value); \
|
||||
};
|
||||
|
||||
|
||||
#define BOOST_LAMBDA_HELPER(z, N, A) BOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE( BOOST_PP_INC(N) )
|
||||
|
||||
// Generate the traits for 1-4 argument templates
|
||||
|
||||
BOOST_PP_REPEAT_2ND(4,BOOST_LAMBDA_HELPER,FOO)
|
||||
|
||||
#undef BOOST_LAMBDA_HELPER
|
||||
#undef BOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE
|
||||
#undef BOOST_LAMBDA_CLASS
|
||||
#undef BOOST_LAMBDA_ARG
|
||||
#undef BOOST_LAMBDA_CLASS_ARG
|
||||
#undef BOOST_LAMBDA_CLASS_LIST
|
||||
#undef BOOST_LAMBDA_ARG_LIST
|
||||
#undef BOOST_LAMBDA_CLASS_ARG_LIST
|
||||
|
||||
} // lambda
|
||||
} // boost
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// Boost Lambda Library - is_instance_of.hpp ---------------------
|
||||
|
||||
// Copyright (C) 2001 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 www.boost.org
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_IS_INSTANCE_OF
|
||||
#define BOOST_LAMBDA_IS_INSTANCE_OF
|
||||
|
||||
#include "boost/config.hpp" // for BOOST_STATIC_CONSTANT
|
||||
#include "boost/type_traits/conversion_traits.hpp" // for is_convertible
|
||||
#include "boost/preprocessor/enum_shifted_params.hpp"
|
||||
#include "boost/preprocessor/repeat_2nd.hpp"
|
||||
|
||||
// is_instance_of --------------------------------
|
||||
//
|
||||
// is_instance_of_n<A, B>::value is true, if type A is
|
||||
// an instantiation of a template B, or A derives from an instantiation
|
||||
// of template B
|
||||
//
|
||||
// n is the number of template arguments for B
|
||||
//
|
||||
// Example:
|
||||
// is_instance_of_2<std::istream, basic_stream>::value == true
|
||||
|
||||
// The original implementation was somewhat different, with different versions
|
||||
// for different compilers. However, there was still a problem
|
||||
// with gcc.3.0.2 and 3.0.3 compilers, which didn't think regard
|
||||
// is_instance_of_N<...>::value was a constant.
|
||||
// John Maddock suggested the way around this problem by building
|
||||
// is_instance_of templates using boost::is_convertible.
|
||||
// Now we only have one version of is_instance_of templates, which delagate
|
||||
// all the nasty compiler tricks to is_convertible.
|
||||
|
||||
#define BOOST_LAMBDA_CLASS(z, N,A) BOOST_PP_COMMA_IF(N) class
|
||||
#define BOOST_LAMBDA_CLASS_ARG(z, N,A) BOOST_PP_COMMA_IF(N) class A##N
|
||||
#define BOOST_LAMBDA_ARG(z, N,A) BOOST_PP_COMMA_IF(N) A##N
|
||||
|
||||
#define BOOST_LAMBDA_CLASS_LIST(n, NAME) BOOST_PP_REPEAT(n, BOOST_LAMBDA_CLASS, NAME)
|
||||
|
||||
#define BOOST_LAMBDA_CLASS_ARG_LIST(n, NAME) BOOST_PP_REPEAT(n, BOOST_LAMBDA_CLASS_ARG, NAME)
|
||||
|
||||
#define BOOST_LAMBDA_ARG_LIST(n, NAME) BOOST_PP_REPEAT(n, BOOST_LAMBDA_ARG, NAME)
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
#define BOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE(INDEX) \
|
||||
\
|
||||
namespace detail { \
|
||||
\
|
||||
template <template<BOOST_LAMBDA_CLASS_LIST(INDEX,T)> class F> \
|
||||
struct BOOST_PP_CAT(conversion_tester_,INDEX) { \
|
||||
template<BOOST_LAMBDA_CLASS_ARG_LIST(INDEX,A)> \
|
||||
BOOST_PP_CAT(conversion_tester_,INDEX) \
|
||||
(const F<BOOST_LAMBDA_ARG_LIST(INDEX,A)>&); \
|
||||
}; \
|
||||
\
|
||||
} /* end detail */ \
|
||||
\
|
||||
template <class From, template <BOOST_LAMBDA_CLASS_LIST(INDEX,T)> class To> \
|
||||
struct BOOST_PP_CAT(is_instance_of_,INDEX) \
|
||||
{ \
|
||||
private: \
|
||||
typedef ::boost::is_convertible< \
|
||||
From, \
|
||||
BOOST_PP_CAT(detail::conversion_tester_,INDEX)<To> \
|
||||
> helper_type; \
|
||||
\
|
||||
public: \
|
||||
BOOST_STATIC_CONSTANT(bool, value = helper_type::value); \
|
||||
};
|
||||
|
||||
|
||||
#define BOOST_LAMBDA_HELPER(z, N, A) BOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE( BOOST_PP_INC(N) )
|
||||
|
||||
// Generate the traits for 1-4 argument templates
|
||||
|
||||
BOOST_PP_REPEAT_2ND(4,BOOST_LAMBDA_HELPER,FOO)
|
||||
|
||||
#undef BOOST_LAMBDA_HELPER
|
||||
#undef BOOST_LAMBDA_IS_INSTANCE_OF_TEMPLATE
|
||||
#undef BOOST_LAMBDA_CLASS
|
||||
#undef BOOST_LAMBDA_ARG
|
||||
#undef BOOST_LAMBDA_CLASS_ARG
|
||||
#undef BOOST_LAMBDA_CLASS_LIST
|
||||
#undef BOOST_LAMBDA_ARG_LIST
|
||||
#undef BOOST_LAMBDA_CLASS_ARG_LIST
|
||||
|
||||
} // lambda
|
||||
} // boost
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,41 +1,41 @@
|
||||
// Boost Lambda Library - lambda_config.hpp ------------------------------
|
||||
|
||||
// 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 www.boost.org
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_LAMBDA_CONFIG_HPP
|
||||
#define BOOST_LAMBDA_LAMBDA_CONFIG_HPP
|
||||
|
||||
// add to boost/config.hpp
|
||||
// for now
|
||||
|
||||
|
||||
# if defined __GNUC__
|
||||
# if (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
|
||||
# define BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
|
||||
# define BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING
|
||||
# endif
|
||||
# endif // __GNUC__
|
||||
|
||||
|
||||
#if defined __KCC
|
||||
|
||||
#define BOOST_NO_FDECL_TEMPLATES_AS_TEMPLATE_TEMPLATE_PARAMS
|
||||
|
||||
#endif // __KCC
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// Boost Lambda Library - lambda_config.hpp ------------------------------
|
||||
|
||||
// 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 www.boost.org
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_LAMBDA_CONFIG_HPP
|
||||
#define BOOST_LAMBDA_LAMBDA_CONFIG_HPP
|
||||
|
||||
// add to boost/config.hpp
|
||||
// for now
|
||||
|
||||
|
||||
# if defined __GNUC__
|
||||
# if (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
|
||||
# define BOOST_REF_TO_FUNC_CONFLICTS_WITH_REF_TO_T
|
||||
# define BOOST_LAMBDA_INCORRECT_BIND_OVERLOADING
|
||||
# endif
|
||||
# endif // __GNUC__
|
||||
|
||||
|
||||
#if defined __KCC
|
||||
|
||||
#define BOOST_NO_FDECL_TEMPLATES_AS_TEMPLATE_TEMPLATE_PARAMS
|
||||
|
||||
#endif // __KCC
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -1,357 +1,357 @@
|
||||
// Boost Lambda Library - lambda_functors.hpp -------------------------------
|
||||
|
||||
// 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
|
||||
|
||||
// ------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP
|
||||
#define BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/utility/result_of.hpp>
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
|
||||
|
||||
#include <boost/mpl/or.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/type_traits/is_array.hpp>
|
||||
|
||||
#define BOOST_LAMBDA_DISABLE_IF_ARRAY1(A1, R1)\
|
||||
typename lazy_disable_if<is_array<A1>, typename R1 >::type
|
||||
#define BOOST_LAMBDA_DISABLE_IF_ARRAY2(A1, A2, R1, R2) \
|
||||
typename lazy_disable_if<mpl::or_<is_array<A1>, is_array<A2> >, typename R1, R2 >::type
|
||||
#define BOOST_LAMBDA_DISABLE_IF_ARRAY3(A1, A2, A3, R1, R2, R3) \
|
||||
typename lazy_disable_if<mpl::or_<is_array<A1>, is_array<A2>, is_array<A3> >, typename R1, R2, R3 >::type
|
||||
|
||||
#else
|
||||
|
||||
#define BOOST_LAMBDA_DISABLE_IF_ARRAY1(A1, R1) typename R1::type
|
||||
#define BOOST_LAMBDA_DISABLE_IF_ARRAY2(A1, A2, R1, R2) typename R1, R2::type
|
||||
#define BOOST_LAMBDA_DISABLE_IF_ARRAY3(A1, A2, A3, R1, R2, R3) typename R1, R2, R3::type
|
||||
|
||||
#endif
|
||||
|
||||
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<int N, class Tuple> struct get_element_or_null_type {
|
||||
typedef typename
|
||||
detail::tuple_element_as_reference<N, Tuple>::type type;
|
||||
};
|
||||
template<int N> struct get_element_or_null_type<N, null_type> {
|
||||
typedef null_type type;
|
||||
};
|
||||
}
|
||||
|
||||
template <int I> struct placeholder;
|
||||
|
||||
template<> struct placeholder<FIRST> {
|
||||
|
||||
template<class SigArgs> struct sig {
|
||||
typedef typename detail::get_element_or_null_type<0, SigArgs>::type type;
|
||||
};
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const {
|
||||
BOOST_STATIC_ASSERT(boost::is_reference<RET>::value);
|
||||
CALL_USE_ARGS; // does nothing, prevents warnings for unused args
|
||||
return a;
|
||||
}
|
||||
};
|
||||
|
||||
template<> struct placeholder<SECOND> {
|
||||
|
||||
template<class SigArgs> struct sig {
|
||||
typedef typename detail::get_element_or_null_type<1, SigArgs>::type type;
|
||||
};
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return b; }
|
||||
};
|
||||
|
||||
template<> struct placeholder<THIRD> {
|
||||
|
||||
template<class SigArgs> struct sig {
|
||||
typedef typename detail::get_element_or_null_type<2, SigArgs>::type type;
|
||||
};
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return c; }
|
||||
};
|
||||
|
||||
template<> struct placeholder<EXCEPTION> {
|
||||
|
||||
template<class SigArgs> struct sig {
|
||||
typedef typename detail::get_element_or_null_type<3, SigArgs>::type type;
|
||||
};
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return env; }
|
||||
};
|
||||
|
||||
typedef const lambda_functor<placeholder<FIRST> > placeholder1_type;
|
||||
typedef const lambda_functor<placeholder<SECOND> > placeholder2_type;
|
||||
typedef const lambda_functor<placeholder<THIRD> > placeholder3_type;
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
// free variables are lambda_functors. This is to allow uniform handling with
|
||||
// other lambda_functors.
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable:4512) //assignment operator could not be generated
|
||||
#endif
|
||||
|
||||
// -- lambda_functor NONE ------------------------------------------------
|
||||
template <class T>
|
||||
class lambda_functor : public T
|
||||
{
|
||||
|
||||
BOOST_STATIC_CONSTANT(int, arity_bits = get_arity<T>::value);
|
||||
|
||||
public:
|
||||
typedef T inherited;
|
||||
|
||||
lambda_functor() {}
|
||||
lambda_functor(const lambda_functor& l) : inherited(l) {}
|
||||
|
||||
lambda_functor(const T& t) : inherited(t) {}
|
||||
|
||||
template <class SigArgs> struct sig {
|
||||
typedef typename inherited::template
|
||||
sig<typename SigArgs::tail_type>::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<null_type>::type
|
||||
nullary_return_type;
|
||||
|
||||
// Support for boost::result_of.
|
||||
template <class Sig> struct result;
|
||||
template <class F>
|
||||
struct result<F()> {
|
||||
typedef nullary_return_type type;
|
||||
};
|
||||
template <class F, class A>
|
||||
struct result<F(A)> {
|
||||
typedef typename sig<tuple<F, A> >::type type;
|
||||
};
|
||||
template <class F, class A, class B>
|
||||
struct result<F(A, B)> {
|
||||
typedef typename sig<tuple<F, A, B> >::type type;
|
||||
};
|
||||
template <class F, class A, class B, class C>
|
||||
struct result<F(A, B, C)> {
|
||||
typedef typename sig<tuple<F, A, B, C> >::type type;
|
||||
};
|
||||
|
||||
nullary_return_type operator()() const {
|
||||
return inherited::template
|
||||
call<nullary_return_type>
|
||||
(cnull_type(), cnull_type(), cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A>
|
||||
typename inherited::template sig<tuple<A&> >::type
|
||||
operator()(A& a) const {
|
||||
return inherited::template call<
|
||||
typename inherited::template sig<tuple<A&> >::type
|
||||
>(a, cnull_type(), cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A>
|
||||
BOOST_LAMBDA_DISABLE_IF_ARRAY1(A, inherited::template sig<tuple<A const&> >)
|
||||
operator()(A const& a) const {
|
||||
return inherited::template call<
|
||||
typename inherited::template sig<tuple<A const&> >::type
|
||||
>(a, cnull_type(), cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B>
|
||||
typename inherited::template sig<tuple<A&, B&> >::type
|
||||
operator()(A& a, B& b) const {
|
||||
return inherited::template call<
|
||||
typename inherited::template sig<tuple<A&, B&> >::type
|
||||
>(a, b, cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B>
|
||||
BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B&> >)
|
||||
operator()(A const& a, B& b) const {
|
||||
return inherited::template call<
|
||||
typename inherited::template sig<tuple<A const&, B&> >::type
|
||||
>(a, b, cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B>
|
||||
BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A&, B const&> >)
|
||||
operator()(A& a, B const& b) const {
|
||||
return inherited::template call<
|
||||
typename inherited::template sig<tuple<A&, B const&> >::type
|
||||
>(a, b, cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B>
|
||||
BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B const&> >)
|
||||
operator()(A const& a, B const& b) const {
|
||||
return inherited::template call<
|
||||
typename inherited::template sig<tuple<A const&, B const&> >::type
|
||||
>(a, b, cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B, class C>
|
||||
typename inherited::template sig<tuple<A&, B&, C&> >::type
|
||||
operator()(A& a, B& b, C& c) const
|
||||
{
|
||||
return inherited::template call<
|
||||
typename inherited::template sig<tuple<A&, B&, C&> >::type
|
||||
>(a, b, c, cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B, class C>
|
||||
BOOST_LAMBDA_DISABLE_IF_ARRAY3(A, B, C, inherited::template sig<tuple<A const&, B const&, C const&> >)
|
||||
operator()(A const& a, B const& b, C const& c) const
|
||||
{
|
||||
return inherited::template call<
|
||||
typename inherited::template sig<tuple<A const&, B const&, C const&> >::type
|
||||
>(a, b, c, cnull_type());
|
||||
}
|
||||
|
||||
// for internal calls with env
|
||||
template<CALL_TEMPLATE_ARGS>
|
||||
typename inherited::template sig<tuple<CALL_REFERENCE_TYPES> >::type
|
||||
internal_call(CALL_FORMAL_ARGS) const {
|
||||
return inherited::template
|
||||
call<typename inherited::template
|
||||
sig<tuple<CALL_REFERENCE_TYPES> >::type>(CALL_ACTUAL_ARGS);
|
||||
}
|
||||
|
||||
template<class A>
|
||||
const lambda_functor<lambda_functor_base<
|
||||
other_action<assignment_action>,
|
||||
boost::tuple<lambda_functor,
|
||||
typename const_copy_argument <const A>::type> > >
|
||||
operator=(const A& a) const {
|
||||
return lambda_functor_base<
|
||||
other_action<assignment_action>,
|
||||
boost::tuple<lambda_functor,
|
||||
typename const_copy_argument <const A>::type> >
|
||||
( boost::tuple<lambda_functor,
|
||||
typename const_copy_argument <const A>::type>(*this, a) );
|
||||
}
|
||||
|
||||
template<class A>
|
||||
const lambda_functor<lambda_functor_base<
|
||||
other_action<subscript_action>,
|
||||
boost::tuple<lambda_functor,
|
||||
typename const_copy_argument <const A>::type> > >
|
||||
operator[](const A& a) const {
|
||||
return lambda_functor_base<
|
||||
other_action<subscript_action>,
|
||||
boost::tuple<lambda_functor,
|
||||
typename const_copy_argument <const A>::type> >
|
||||
( boost::tuple<lambda_functor,
|
||||
typename const_copy_argument <const A>::type>(*this, a ) );
|
||||
}
|
||||
};
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
namespace boost {
|
||||
|
||||
#if !defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_NO_CXX11_DECLTYPE)
|
||||
|
||||
template<class T>
|
||||
struct result_of<boost::lambda::lambda_functor<T>()>
|
||||
{
|
||||
typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct result_of<const boost::lambda::lambda_functor<T>()>
|
||||
{
|
||||
typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
template<class T>
|
||||
struct tr1_result_of<boost::lambda::lambda_functor<T>()>
|
||||
{
|
||||
typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct tr1_result_of<const boost::lambda::lambda_functor<T>()>
|
||||
{
|
||||
typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
// is_placeholder
|
||||
|
||||
#include <boost/is_placeholder.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
|
||||
template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::FIRST> > >
|
||||
{
|
||||
enum _vt { value = 1 };
|
||||
};
|
||||
|
||||
template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::SECOND> > >
|
||||
{
|
||||
enum _vt { value = 2 };
|
||||
};
|
||||
|
||||
template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::THIRD> > >
|
||||
{
|
||||
enum _vt { value = 3 };
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
// Boost Lambda Library - lambda_functors.hpp -------------------------------
|
||||
|
||||
// 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
|
||||
|
||||
// ------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP
|
||||
#define BOOST_LAMBDA_LAMBDA_FUNCTORS_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/utility/result_of.hpp>
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
|
||||
|
||||
#include <boost/mpl/or.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/type_traits/is_array.hpp>
|
||||
|
||||
#define BOOST_LAMBDA_DISABLE_IF_ARRAY1(A1, R1)\
|
||||
typename lazy_disable_if<is_array<A1>, typename R1 >::type
|
||||
#define BOOST_LAMBDA_DISABLE_IF_ARRAY2(A1, A2, R1, R2) \
|
||||
typename lazy_disable_if<mpl::or_<is_array<A1>, is_array<A2> >, typename R1, R2 >::type
|
||||
#define BOOST_LAMBDA_DISABLE_IF_ARRAY3(A1, A2, A3, R1, R2, R3) \
|
||||
typename lazy_disable_if<mpl::or_<is_array<A1>, is_array<A2>, is_array<A3> >, typename R1, R2, R3 >::type
|
||||
|
||||
#else
|
||||
|
||||
#define BOOST_LAMBDA_DISABLE_IF_ARRAY1(A1, R1) typename R1::type
|
||||
#define BOOST_LAMBDA_DISABLE_IF_ARRAY2(A1, A2, R1, R2) typename R1, R2::type
|
||||
#define BOOST_LAMBDA_DISABLE_IF_ARRAY3(A1, A2, A3, R1, R2, R3) typename R1, R2, R3::type
|
||||
|
||||
#endif
|
||||
|
||||
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<int N, class Tuple> struct get_element_or_null_type {
|
||||
typedef typename
|
||||
detail::tuple_element_as_reference<N, Tuple>::type type;
|
||||
};
|
||||
template<int N> struct get_element_or_null_type<N, null_type> {
|
||||
typedef null_type type;
|
||||
};
|
||||
}
|
||||
|
||||
template <int I> struct placeholder;
|
||||
|
||||
template<> struct placeholder<FIRST> {
|
||||
|
||||
template<class SigArgs> struct sig {
|
||||
typedef typename detail::get_element_or_null_type<0, SigArgs>::type type;
|
||||
};
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const {
|
||||
BOOST_STATIC_ASSERT(boost::is_reference<RET>::value);
|
||||
CALL_USE_ARGS; // does nothing, prevents warnings for unused args
|
||||
return a;
|
||||
}
|
||||
};
|
||||
|
||||
template<> struct placeholder<SECOND> {
|
||||
|
||||
template<class SigArgs> struct sig {
|
||||
typedef typename detail::get_element_or_null_type<1, SigArgs>::type type;
|
||||
};
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return b; }
|
||||
};
|
||||
|
||||
template<> struct placeholder<THIRD> {
|
||||
|
||||
template<class SigArgs> struct sig {
|
||||
typedef typename detail::get_element_or_null_type<2, SigArgs>::type type;
|
||||
};
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return c; }
|
||||
};
|
||||
|
||||
template<> struct placeholder<EXCEPTION> {
|
||||
|
||||
template<class SigArgs> struct sig {
|
||||
typedef typename detail::get_element_or_null_type<3, SigArgs>::type type;
|
||||
};
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const { CALL_USE_ARGS; return env; }
|
||||
};
|
||||
|
||||
typedef const lambda_functor<placeholder<FIRST> > placeholder1_type;
|
||||
typedef const lambda_functor<placeholder<SECOND> > placeholder2_type;
|
||||
typedef const lambda_functor<placeholder<THIRD> > placeholder3_type;
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
// free variables are lambda_functors. This is to allow uniform handling with
|
||||
// other lambda_functors.
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable:4512) //assignment operator could not be generated
|
||||
#endif
|
||||
|
||||
// -- lambda_functor NONE ------------------------------------------------
|
||||
template <class T>
|
||||
class lambda_functor : public T
|
||||
{
|
||||
|
||||
BOOST_STATIC_CONSTANT(int, arity_bits = get_arity<T>::value);
|
||||
|
||||
public:
|
||||
typedef T inherited;
|
||||
|
||||
lambda_functor() {}
|
||||
lambda_functor(const lambda_functor& l) : inherited(l) {}
|
||||
|
||||
lambda_functor(const T& t) : inherited(t) {}
|
||||
|
||||
template <class SigArgs> struct sig {
|
||||
typedef typename inherited::template
|
||||
sig<typename SigArgs::tail_type>::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<null_type>::type
|
||||
nullary_return_type;
|
||||
|
||||
// Support for boost::result_of.
|
||||
template <class Sig> struct result;
|
||||
template <class F>
|
||||
struct result<F()> {
|
||||
typedef nullary_return_type type;
|
||||
};
|
||||
template <class F, class A>
|
||||
struct result<F(A)> {
|
||||
typedef typename sig<tuple<F, A> >::type type;
|
||||
};
|
||||
template <class F, class A, class B>
|
||||
struct result<F(A, B)> {
|
||||
typedef typename sig<tuple<F, A, B> >::type type;
|
||||
};
|
||||
template <class F, class A, class B, class C>
|
||||
struct result<F(A, B, C)> {
|
||||
typedef typename sig<tuple<F, A, B, C> >::type type;
|
||||
};
|
||||
|
||||
nullary_return_type operator()() const {
|
||||
return inherited::template
|
||||
call<nullary_return_type>
|
||||
(cnull_type(), cnull_type(), cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A>
|
||||
typename inherited::template sig<tuple<A&> >::type
|
||||
operator()(A& a) const {
|
||||
return inherited::template call<
|
||||
typename inherited::template sig<tuple<A&> >::type
|
||||
>(a, cnull_type(), cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A>
|
||||
BOOST_LAMBDA_DISABLE_IF_ARRAY1(A, inherited::template sig<tuple<A const&> >)
|
||||
operator()(A const& a) const {
|
||||
return inherited::template call<
|
||||
typename inherited::template sig<tuple<A const&> >::type
|
||||
>(a, cnull_type(), cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B>
|
||||
typename inherited::template sig<tuple<A&, B&> >::type
|
||||
operator()(A& a, B& b) const {
|
||||
return inherited::template call<
|
||||
typename inherited::template sig<tuple<A&, B&> >::type
|
||||
>(a, b, cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B>
|
||||
BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B&> >)
|
||||
operator()(A const& a, B& b) const {
|
||||
return inherited::template call<
|
||||
typename inherited::template sig<tuple<A const&, B&> >::type
|
||||
>(a, b, cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B>
|
||||
BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A&, B const&> >)
|
||||
operator()(A& a, B const& b) const {
|
||||
return inherited::template call<
|
||||
typename inherited::template sig<tuple<A&, B const&> >::type
|
||||
>(a, b, cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B>
|
||||
BOOST_LAMBDA_DISABLE_IF_ARRAY2(A, B, inherited::template sig<tuple<A const&, B const&> >)
|
||||
operator()(A const& a, B const& b) const {
|
||||
return inherited::template call<
|
||||
typename inherited::template sig<tuple<A const&, B const&> >::type
|
||||
>(a, b, cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B, class C>
|
||||
typename inherited::template sig<tuple<A&, B&, C&> >::type
|
||||
operator()(A& a, B& b, C& c) const
|
||||
{
|
||||
return inherited::template call<
|
||||
typename inherited::template sig<tuple<A&, B&, C&> >::type
|
||||
>(a, b, c, cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B, class C>
|
||||
BOOST_LAMBDA_DISABLE_IF_ARRAY3(A, B, C, inherited::template sig<tuple<A const&, B const&, C const&> >)
|
||||
operator()(A const& a, B const& b, C const& c) const
|
||||
{
|
||||
return inherited::template call<
|
||||
typename inherited::template sig<tuple<A const&, B const&, C const&> >::type
|
||||
>(a, b, c, cnull_type());
|
||||
}
|
||||
|
||||
// for internal calls with env
|
||||
template<CALL_TEMPLATE_ARGS>
|
||||
typename inherited::template sig<tuple<CALL_REFERENCE_TYPES> >::type
|
||||
internal_call(CALL_FORMAL_ARGS) const {
|
||||
return inherited::template
|
||||
call<typename inherited::template
|
||||
sig<tuple<CALL_REFERENCE_TYPES> >::type>(CALL_ACTUAL_ARGS);
|
||||
}
|
||||
|
||||
template<class A>
|
||||
const lambda_functor<lambda_functor_base<
|
||||
other_action<assignment_action>,
|
||||
boost::tuple<lambda_functor,
|
||||
typename const_copy_argument <const A>::type> > >
|
||||
operator=(const A& a) const {
|
||||
return lambda_functor_base<
|
||||
other_action<assignment_action>,
|
||||
boost::tuple<lambda_functor,
|
||||
typename const_copy_argument <const A>::type> >
|
||||
( boost::tuple<lambda_functor,
|
||||
typename const_copy_argument <const A>::type>(*this, a) );
|
||||
}
|
||||
|
||||
template<class A>
|
||||
const lambda_functor<lambda_functor_base<
|
||||
other_action<subscript_action>,
|
||||
boost::tuple<lambda_functor,
|
||||
typename const_copy_argument <const A>::type> > >
|
||||
operator[](const A& a) const {
|
||||
return lambda_functor_base<
|
||||
other_action<subscript_action>,
|
||||
boost::tuple<lambda_functor,
|
||||
typename const_copy_argument <const A>::type> >
|
||||
( boost::tuple<lambda_functor,
|
||||
typename const_copy_argument <const A>::type>(*this, a ) );
|
||||
}
|
||||
};
|
||||
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
namespace boost {
|
||||
|
||||
#if !defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_NO_CXX11_DECLTYPE)
|
||||
|
||||
template<class T>
|
||||
struct result_of<boost::lambda::lambda_functor<T>()>
|
||||
{
|
||||
typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct result_of<const boost::lambda::lambda_functor<T>()>
|
||||
{
|
||||
typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
template<class T>
|
||||
struct tr1_result_of<boost::lambda::lambda_functor<T>()>
|
||||
{
|
||||
typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct tr1_result_of<const boost::lambda::lambda_functor<T>()>
|
||||
{
|
||||
typedef typename boost::lambda::lambda_functor<T>::nullary_return_type type;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
// is_placeholder
|
||||
|
||||
#include <boost/is_placeholder.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
|
||||
template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::FIRST> > >
|
||||
{
|
||||
enum _vt { value = 1 };
|
||||
};
|
||||
|
||||
template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::SECOND> > >
|
||||
{
|
||||
enum _vt { value = 2 };
|
||||
};
|
||||
|
||||
template<> struct is_placeholder< lambda::lambda_functor< lambda::placeholder<lambda::THIRD> > >
|
||||
{
|
||||
enum _vt { value = 3 };
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
@@ -1,74 +1,74 @@
|
||||
// lambda_fwd.hpp - Boost Lambda Library -------------------------------
|
||||
|
||||
// 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 www.boost.org
|
||||
|
||||
// -------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_FWD_HPP
|
||||
#define BOOST_LAMBDA_FWD_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class T> struct generate_error;
|
||||
|
||||
}
|
||||
// -- placeholders --------------------------------------------
|
||||
|
||||
template <int I> struct placeholder;
|
||||
|
||||
// function_adaptors
|
||||
template <class Func>
|
||||
struct function_adaptor;
|
||||
|
||||
template <int I, class Act> class action;
|
||||
|
||||
template <class Base>
|
||||
class lambda_functor;
|
||||
|
||||
template <class Act, class Args>
|
||||
class lambda_functor_base;
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
|
||||
// #define CALL_TEMPLATE_ARGS class A, class Env
|
||||
// #define CALL_FORMAL_ARGS A& a, Env& env
|
||||
// #define CALL_ACTUAL_ARGS a, env
|
||||
// #define CALL_ACTUAL_ARGS_NO_ENV a
|
||||
// #define CALL_REFERENCE_TYPES A&, Env&
|
||||
// #define CALL_PLAIN_TYPES A, Env
|
||||
#define CALL_TEMPLATE_ARGS class A, class B, class C, class Env
|
||||
#define CALL_FORMAL_ARGS A& a, B& b, C& c, Env& env
|
||||
#define CALL_ACTUAL_ARGS a, b, c, env
|
||||
#define CALL_ACTUAL_ARGS_NO_ENV a, b, c
|
||||
#define CALL_REFERENCE_TYPES A&, B&, C&, Env&
|
||||
#define CALL_PLAIN_TYPES A, B, C, Env
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
namespace detail {
|
||||
|
||||
template<class A1, class A2, class A3, class A4>
|
||||
void do_nothing(A1&, A2&, A3&, A4&) {}
|
||||
|
||||
} // detail
|
||||
} // lambda
|
||||
} // boost
|
||||
|
||||
// prevent the warnings from unused arguments
|
||||
#define CALL_USE_ARGS \
|
||||
::boost::lambda::detail::do_nothing(a, b, c, env)
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
// lambda_fwd.hpp - Boost Lambda Library -------------------------------
|
||||
|
||||
// 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 www.boost.org
|
||||
|
||||
// -------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_FWD_HPP
|
||||
#define BOOST_LAMBDA_FWD_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class T> struct generate_error;
|
||||
|
||||
}
|
||||
// -- placeholders --------------------------------------------
|
||||
|
||||
template <int I> struct placeholder;
|
||||
|
||||
// function_adaptors
|
||||
template <class Func>
|
||||
struct function_adaptor;
|
||||
|
||||
template <int I, class Act> class action;
|
||||
|
||||
template <class Base>
|
||||
class lambda_functor;
|
||||
|
||||
template <class Act, class Args>
|
||||
class lambda_functor_base;
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
|
||||
// #define CALL_TEMPLATE_ARGS class A, class Env
|
||||
// #define CALL_FORMAL_ARGS A& a, Env& env
|
||||
// #define CALL_ACTUAL_ARGS a, env
|
||||
// #define CALL_ACTUAL_ARGS_NO_ENV a
|
||||
// #define CALL_REFERENCE_TYPES A&, Env&
|
||||
// #define CALL_PLAIN_TYPES A, Env
|
||||
#define CALL_TEMPLATE_ARGS class A, class B, class C, class Env
|
||||
#define CALL_FORMAL_ARGS A& a, B& b, C& c, Env& env
|
||||
#define CALL_ACTUAL_ARGS a, b, c, env
|
||||
#define CALL_ACTUAL_ARGS_NO_ENV a, b, c
|
||||
#define CALL_REFERENCE_TYPES A&, B&, C&, Env&
|
||||
#define CALL_PLAIN_TYPES A, B, C, Env
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
namespace detail {
|
||||
|
||||
template<class A1, class A2, class A3, class A4>
|
||||
void do_nothing(A1&, A2&, A3&, A4&) {}
|
||||
|
||||
} // detail
|
||||
} // lambda
|
||||
} // boost
|
||||
|
||||
// prevent the warnings from unused arguments
|
||||
#define CALL_USE_ARGS \
|
||||
::boost::lambda::detail::do_nothing(a, b, c, env)
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -1,139 +1,139 @@
|
||||
// -- operator_actions.hpp - Boost Lambda Library ----------------------
|
||||
|
||||
// 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://lambda.cs.utu.fi
|
||||
|
||||
#ifndef BOOST_LAMBDA_OPERATOR_ACTIONS_HPP
|
||||
#define BOOST_LAMBDA_OPERATOR_ACTIONS_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
|
||||
// -- artihmetic ----------------------
|
||||
|
||||
class plus_action {};
|
||||
class minus_action {};
|
||||
class multiply_action {};
|
||||
class divide_action {};
|
||||
class remainder_action {};
|
||||
|
||||
// -- bitwise -------------------
|
||||
|
||||
class leftshift_action {};
|
||||
class rightshift_action {};
|
||||
class xor_action {};
|
||||
|
||||
|
||||
// -- bitwise/logical -------------------
|
||||
|
||||
class and_action {};
|
||||
class or_action {};
|
||||
class not_action {};
|
||||
|
||||
// -- relational -------------------------
|
||||
|
||||
class less_action {};
|
||||
class greater_action {};
|
||||
class lessorequal_action {};
|
||||
class greaterorequal_action {};
|
||||
class equal_action {};
|
||||
class notequal_action {};
|
||||
|
||||
// -- increment/decrement ------------------------------
|
||||
|
||||
class increment_action {};
|
||||
class decrement_action {};
|
||||
|
||||
// -- void return ------------------------------
|
||||
|
||||
// -- other ------------------------------
|
||||
|
||||
class addressof_action {};
|
||||
// class comma_action {}; // defined in actions.hpp
|
||||
class contentsof_action {};
|
||||
// class member_pointer_action {}; (defined in member_ptr.hpp)
|
||||
|
||||
|
||||
// -- actioun group templates --------------------
|
||||
|
||||
template <class Action> class arithmetic_action;
|
||||
template <class Action> class bitwise_action;
|
||||
template <class Action> class logical_action;
|
||||
template <class Action> class relational_action;
|
||||
template <class Action> class arithmetic_assignment_action;
|
||||
template <class Action> class bitwise_assignment_action;
|
||||
template <class Action> class unary_arithmetic_action;
|
||||
template <class Action> class pre_increment_decrement_action;
|
||||
template <class Action> class post_increment_decrement_action;
|
||||
|
||||
// ---------------------------------------------------------
|
||||
|
||||
// actions, for which the existence of protect is checked in return type
|
||||
// deduction.
|
||||
|
||||
template <class Act> struct is_protectable<arithmetic_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <class Act> struct is_protectable<bitwise_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <class Act> struct is_protectable<logical_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <class Act> struct is_protectable<relational_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <class Act>
|
||||
struct is_protectable<arithmetic_assignment_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <class Act> struct is_protectable<bitwise_assignment_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <class Act> struct is_protectable<unary_arithmetic_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <class Act>
|
||||
struct is_protectable<pre_increment_decrement_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <class Act> struct
|
||||
is_protectable<post_increment_decrement_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
|
||||
template <> struct is_protectable<other_action<addressof_action> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <> struct is_protectable<other_action<contentsof_action> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
|
||||
template<> struct is_protectable<other_action<subscript_action> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template<> struct is_protectable<other_action<assignment_action> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
|
||||
// NOTE: comma action is also protectable, but the specialization is
|
||||
// in actions.hpp
|
||||
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// -- operator_actions.hpp - Boost Lambda Library ----------------------
|
||||
|
||||
// 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://lambda.cs.utu.fi
|
||||
|
||||
#ifndef BOOST_LAMBDA_OPERATOR_ACTIONS_HPP
|
||||
#define BOOST_LAMBDA_OPERATOR_ACTIONS_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
|
||||
// -- artihmetic ----------------------
|
||||
|
||||
class plus_action {};
|
||||
class minus_action {};
|
||||
class multiply_action {};
|
||||
class divide_action {};
|
||||
class remainder_action {};
|
||||
|
||||
// -- bitwise -------------------
|
||||
|
||||
class leftshift_action {};
|
||||
class rightshift_action {};
|
||||
class xor_action {};
|
||||
|
||||
|
||||
// -- bitwise/logical -------------------
|
||||
|
||||
class and_action {};
|
||||
class or_action {};
|
||||
class not_action {};
|
||||
|
||||
// -- relational -------------------------
|
||||
|
||||
class less_action {};
|
||||
class greater_action {};
|
||||
class lessorequal_action {};
|
||||
class greaterorequal_action {};
|
||||
class equal_action {};
|
||||
class notequal_action {};
|
||||
|
||||
// -- increment/decrement ------------------------------
|
||||
|
||||
class increment_action {};
|
||||
class decrement_action {};
|
||||
|
||||
// -- void return ------------------------------
|
||||
|
||||
// -- other ------------------------------
|
||||
|
||||
class addressof_action {};
|
||||
// class comma_action {}; // defined in actions.hpp
|
||||
class contentsof_action {};
|
||||
// class member_pointer_action {}; (defined in member_ptr.hpp)
|
||||
|
||||
|
||||
// -- actioun group templates --------------------
|
||||
|
||||
template <class Action> class arithmetic_action;
|
||||
template <class Action> class bitwise_action;
|
||||
template <class Action> class logical_action;
|
||||
template <class Action> class relational_action;
|
||||
template <class Action> class arithmetic_assignment_action;
|
||||
template <class Action> class bitwise_assignment_action;
|
||||
template <class Action> class unary_arithmetic_action;
|
||||
template <class Action> class pre_increment_decrement_action;
|
||||
template <class Action> class post_increment_decrement_action;
|
||||
|
||||
// ---------------------------------------------------------
|
||||
|
||||
// actions, for which the existence of protect is checked in return type
|
||||
// deduction.
|
||||
|
||||
template <class Act> struct is_protectable<arithmetic_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <class Act> struct is_protectable<bitwise_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <class Act> struct is_protectable<logical_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <class Act> struct is_protectable<relational_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <class Act>
|
||||
struct is_protectable<arithmetic_assignment_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <class Act> struct is_protectable<bitwise_assignment_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <class Act> struct is_protectable<unary_arithmetic_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <class Act>
|
||||
struct is_protectable<pre_increment_decrement_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <class Act> struct
|
||||
is_protectable<post_increment_decrement_action<Act> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
|
||||
template <> struct is_protectable<other_action<addressof_action> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template <> struct is_protectable<other_action<contentsof_action> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
|
||||
template<> struct is_protectable<other_action<subscript_action> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
template<> struct is_protectable<other_action<assignment_action> > {
|
||||
BOOST_STATIC_CONSTANT(bool, value = true);
|
||||
};
|
||||
|
||||
// NOTE: comma action is also protectable, but the specialization is
|
||||
// in actions.hpp
|
||||
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,271 +1,271 @@
|
||||
// Boost Lambda Library - operator_lambda_func_base.hpp -----------------
|
||||
//
|
||||
// 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 www.boost.org
|
||||
|
||||
// ------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_OPERATOR_LAMBDA_FUNC_BASE_HPP
|
||||
#define BOOST_LAMBDA_OPERATOR_LAMBDA_FUNC_BASE_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
|
||||
// These operators cannot be implemented as apply functions of action
|
||||
// templates
|
||||
|
||||
|
||||
// Specialization for comma.
|
||||
template<class Args>
|
||||
class lambda_functor_base<other_action<comma_action>, Args> {
|
||||
public:
|
||||
Args args;
|
||||
public:
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {}
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const {
|
||||
return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS),
|
||||
detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
|
||||
}
|
||||
|
||||
|
||||
template<class SigArgs> struct sig {
|
||||
private:
|
||||
typedef typename
|
||||
detail::deduce_argument_types<Args, SigArgs>::type rets_t;
|
||||
public:
|
||||
typedef typename return_type_2_comma< // comma needs special handling
|
||||
typename detail::element_or_null<0, rets_t>::type,
|
||||
typename detail::element_or_null<1, rets_t>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
// helper traits to make the expression shorter, takes binary action
|
||||
// bound argument tuple, open argument tuple and gives the return type
|
||||
|
||||
template<class Action, class Bound, class Open> class binary_rt {
|
||||
private:
|
||||
typedef typename
|
||||
detail::deduce_argument_types<Bound, Open>::type rets_t;
|
||||
public:
|
||||
typedef typename return_type_2_prot<
|
||||
Action,
|
||||
typename detail::element_or_null<0, rets_t>::type,
|
||||
typename detail::element_or_null<1, rets_t>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
|
||||
// same for unary actions
|
||||
template<class Action, class Bound, class Open> class unary_rt {
|
||||
private:
|
||||
typedef typename
|
||||
detail::deduce_argument_types<Bound, Open>::type rets_t;
|
||||
public:
|
||||
typedef typename return_type_1_prot<
|
||||
Action,
|
||||
typename detail::element_or_null<0, rets_t>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
|
||||
} // end detail
|
||||
|
||||
// Specialization for logical and (to preserve shortcircuiting)
|
||||
// this could be done with a macro as the others, code used to be different
|
||||
template<class Args>
|
||||
class lambda_functor_base<logical_action<and_action>, Args> {
|
||||
public:
|
||||
Args args;
|
||||
public:
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {}
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const {
|
||||
return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) &&
|
||||
detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
|
||||
}
|
||||
template<class SigArgs> struct sig {
|
||||
typedef typename
|
||||
detail::binary_rt<logical_action<and_action>, Args, SigArgs>::type type;
|
||||
};
|
||||
};
|
||||
|
||||
// Specialization for logical or (to preserve shortcircuiting)
|
||||
// this could be done with a macro as the others, code used to be different
|
||||
template<class Args>
|
||||
class lambda_functor_base<logical_action< or_action>, Args> {
|
||||
public:
|
||||
Args args;
|
||||
public:
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {}
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const {
|
||||
return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) ||
|
||||
detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
|
||||
}
|
||||
|
||||
template<class SigArgs> struct sig {
|
||||
typedef typename
|
||||
detail::binary_rt<logical_action<or_action>, Args, SigArgs>::type type;
|
||||
};
|
||||
};
|
||||
|
||||
// Specialization for subscript
|
||||
template<class Args>
|
||||
class lambda_functor_base<other_action<subscript_action>, Args> {
|
||||
public:
|
||||
Args args;
|
||||
public:
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {}
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const {
|
||||
return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)
|
||||
[detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS)];
|
||||
}
|
||||
|
||||
template<class SigArgs> struct sig {
|
||||
typedef typename
|
||||
detail::binary_rt<other_action<subscript_action>, Args, SigArgs>::type
|
||||
type;
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
#define BOOST_LAMBDA_BINARY_ACTION(SYMBOL, ACTION_CLASS) \
|
||||
template<class Args> \
|
||||
class lambda_functor_base<ACTION_CLASS, Args> { \
|
||||
public: \
|
||||
Args args; \
|
||||
public: \
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {} \
|
||||
\
|
||||
template<class RET, CALL_TEMPLATE_ARGS> \
|
||||
RET call(CALL_FORMAL_ARGS) const { \
|
||||
return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) \
|
||||
SYMBOL \
|
||||
detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); \
|
||||
} \
|
||||
template<class SigArgs> struct sig { \
|
||||
typedef typename \
|
||||
detail::binary_rt<ACTION_CLASS, Args, SigArgs>::type type; \
|
||||
}; \
|
||||
};
|
||||
|
||||
#define BOOST_LAMBDA_PREFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS) \
|
||||
template<class Args> \
|
||||
class lambda_functor_base<ACTION_CLASS, Args> { \
|
||||
public: \
|
||||
Args args; \
|
||||
public: \
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {} \
|
||||
\
|
||||
template<class RET, CALL_TEMPLATE_ARGS> \
|
||||
RET call(CALL_FORMAL_ARGS) const { \
|
||||
return SYMBOL \
|
||||
detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); \
|
||||
} \
|
||||
template<class SigArgs> struct sig { \
|
||||
typedef typename \
|
||||
detail::unary_rt<ACTION_CLASS, Args, SigArgs>::type type; \
|
||||
}; \
|
||||
};
|
||||
|
||||
#define BOOST_LAMBDA_POSTFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS) \
|
||||
template<class Args> \
|
||||
class lambda_functor_base<ACTION_CLASS, Args> { \
|
||||
public: \
|
||||
Args args; \
|
||||
public: \
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {} \
|
||||
\
|
||||
template<class RET, CALL_TEMPLATE_ARGS> \
|
||||
RET call(CALL_FORMAL_ARGS) const { \
|
||||
return \
|
||||
detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) SYMBOL; \
|
||||
} \
|
||||
template<class SigArgs> struct sig { \
|
||||
typedef typename \
|
||||
detail::unary_rt<ACTION_CLASS, Args, SigArgs>::type type; \
|
||||
}; \
|
||||
};
|
||||
|
||||
BOOST_LAMBDA_BINARY_ACTION(+,arithmetic_action<plus_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(-,arithmetic_action<minus_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(*,arithmetic_action<multiply_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(/,arithmetic_action<divide_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(%,arithmetic_action<remainder_action>)
|
||||
|
||||
BOOST_LAMBDA_BINARY_ACTION(<<,bitwise_action<leftshift_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(>>,bitwise_action<rightshift_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(&,bitwise_action<and_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(|,bitwise_action<or_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(^,bitwise_action<xor_action>)
|
||||
|
||||
BOOST_LAMBDA_BINARY_ACTION(<,relational_action<less_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(>,relational_action<greater_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(<=,relational_action<lessorequal_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(>=,relational_action<greaterorequal_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(==,relational_action<equal_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(!=,relational_action<notequal_action>)
|
||||
|
||||
BOOST_LAMBDA_BINARY_ACTION(+=,arithmetic_assignment_action<plus_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(-=,arithmetic_assignment_action<minus_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(*=,arithmetic_assignment_action<multiply_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(/=,arithmetic_assignment_action<divide_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(%=,arithmetic_assignment_action<remainder_action>)
|
||||
|
||||
BOOST_LAMBDA_BINARY_ACTION(<<=,bitwise_assignment_action<leftshift_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(>>=,bitwise_assignment_action<rightshift_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(&=,bitwise_assignment_action<and_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(|=,bitwise_assignment_action<or_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(^=,bitwise_assignment_action<xor_action>)
|
||||
|
||||
BOOST_LAMBDA_BINARY_ACTION(=,other_action< assignment_action>)
|
||||
|
||||
|
||||
BOOST_LAMBDA_PREFIX_UNARY_ACTION(+, unary_arithmetic_action<plus_action>)
|
||||
BOOST_LAMBDA_PREFIX_UNARY_ACTION(-, unary_arithmetic_action<minus_action>)
|
||||
BOOST_LAMBDA_PREFIX_UNARY_ACTION(~, bitwise_action<not_action>)
|
||||
BOOST_LAMBDA_PREFIX_UNARY_ACTION(!, logical_action<not_action>)
|
||||
BOOST_LAMBDA_PREFIX_UNARY_ACTION(++, pre_increment_decrement_action<increment_action>)
|
||||
BOOST_LAMBDA_PREFIX_UNARY_ACTION(--, pre_increment_decrement_action<decrement_action>)
|
||||
|
||||
BOOST_LAMBDA_PREFIX_UNARY_ACTION(&,other_action<addressof_action>)
|
||||
BOOST_LAMBDA_PREFIX_UNARY_ACTION(*,other_action<contentsof_action>)
|
||||
|
||||
BOOST_LAMBDA_POSTFIX_UNARY_ACTION(++, post_increment_decrement_action<increment_action>)
|
||||
BOOST_LAMBDA_POSTFIX_UNARY_ACTION(--, post_increment_decrement_action<decrement_action>)
|
||||
|
||||
|
||||
#undef BOOST_LAMBDA_POSTFIX_UNARY_ACTION
|
||||
#undef BOOST_LAMBDA_PREFIX_UNARY_ACTION
|
||||
#undef BOOST_LAMBDA_BINARY_ACTION
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// Boost Lambda Library - operator_lambda_func_base.hpp -----------------
|
||||
//
|
||||
// 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 www.boost.org
|
||||
|
||||
// ------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_OPERATOR_LAMBDA_FUNC_BASE_HPP
|
||||
#define BOOST_LAMBDA_OPERATOR_LAMBDA_FUNC_BASE_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
|
||||
// These operators cannot be implemented as apply functions of action
|
||||
// templates
|
||||
|
||||
|
||||
// Specialization for comma.
|
||||
template<class Args>
|
||||
class lambda_functor_base<other_action<comma_action>, Args> {
|
||||
public:
|
||||
Args args;
|
||||
public:
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {}
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const {
|
||||
return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS),
|
||||
detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
|
||||
}
|
||||
|
||||
|
||||
template<class SigArgs> struct sig {
|
||||
private:
|
||||
typedef typename
|
||||
detail::deduce_argument_types<Args, SigArgs>::type rets_t;
|
||||
public:
|
||||
typedef typename return_type_2_comma< // comma needs special handling
|
||||
typename detail::element_or_null<0, rets_t>::type,
|
||||
typename detail::element_or_null<1, rets_t>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
// helper traits to make the expression shorter, takes binary action
|
||||
// bound argument tuple, open argument tuple and gives the return type
|
||||
|
||||
template<class Action, class Bound, class Open> class binary_rt {
|
||||
private:
|
||||
typedef typename
|
||||
detail::deduce_argument_types<Bound, Open>::type rets_t;
|
||||
public:
|
||||
typedef typename return_type_2_prot<
|
||||
Action,
|
||||
typename detail::element_or_null<0, rets_t>::type,
|
||||
typename detail::element_or_null<1, rets_t>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
|
||||
// same for unary actions
|
||||
template<class Action, class Bound, class Open> class unary_rt {
|
||||
private:
|
||||
typedef typename
|
||||
detail::deduce_argument_types<Bound, Open>::type rets_t;
|
||||
public:
|
||||
typedef typename return_type_1_prot<
|
||||
Action,
|
||||
typename detail::element_or_null<0, rets_t>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
|
||||
} // end detail
|
||||
|
||||
// Specialization for logical and (to preserve shortcircuiting)
|
||||
// this could be done with a macro as the others, code used to be different
|
||||
template<class Args>
|
||||
class lambda_functor_base<logical_action<and_action>, Args> {
|
||||
public:
|
||||
Args args;
|
||||
public:
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {}
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const {
|
||||
return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) &&
|
||||
detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
|
||||
}
|
||||
template<class SigArgs> struct sig {
|
||||
typedef typename
|
||||
detail::binary_rt<logical_action<and_action>, Args, SigArgs>::type type;
|
||||
};
|
||||
};
|
||||
|
||||
// Specialization for logical or (to preserve shortcircuiting)
|
||||
// this could be done with a macro as the others, code used to be different
|
||||
template<class Args>
|
||||
class lambda_functor_base<logical_action< or_action>, Args> {
|
||||
public:
|
||||
Args args;
|
||||
public:
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {}
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const {
|
||||
return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) ||
|
||||
detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
|
||||
}
|
||||
|
||||
template<class SigArgs> struct sig {
|
||||
typedef typename
|
||||
detail::binary_rt<logical_action<or_action>, Args, SigArgs>::type type;
|
||||
};
|
||||
};
|
||||
|
||||
// Specialization for subscript
|
||||
template<class Args>
|
||||
class lambda_functor_base<other_action<subscript_action>, Args> {
|
||||
public:
|
||||
Args args;
|
||||
public:
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {}
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const {
|
||||
return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)
|
||||
[detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS)];
|
||||
}
|
||||
|
||||
template<class SigArgs> struct sig {
|
||||
typedef typename
|
||||
detail::binary_rt<other_action<subscript_action>, Args, SigArgs>::type
|
||||
type;
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
#define BOOST_LAMBDA_BINARY_ACTION(SYMBOL, ACTION_CLASS) \
|
||||
template<class Args> \
|
||||
class lambda_functor_base<ACTION_CLASS, Args> { \
|
||||
public: \
|
||||
Args args; \
|
||||
public: \
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {} \
|
||||
\
|
||||
template<class RET, CALL_TEMPLATE_ARGS> \
|
||||
RET call(CALL_FORMAL_ARGS) const { \
|
||||
return detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) \
|
||||
SYMBOL \
|
||||
detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS); \
|
||||
} \
|
||||
template<class SigArgs> struct sig { \
|
||||
typedef typename \
|
||||
detail::binary_rt<ACTION_CLASS, Args, SigArgs>::type type; \
|
||||
}; \
|
||||
};
|
||||
|
||||
#define BOOST_LAMBDA_PREFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS) \
|
||||
template<class Args> \
|
||||
class lambda_functor_base<ACTION_CLASS, Args> { \
|
||||
public: \
|
||||
Args args; \
|
||||
public: \
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {} \
|
||||
\
|
||||
template<class RET, CALL_TEMPLATE_ARGS> \
|
||||
RET call(CALL_FORMAL_ARGS) const { \
|
||||
return SYMBOL \
|
||||
detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS); \
|
||||
} \
|
||||
template<class SigArgs> struct sig { \
|
||||
typedef typename \
|
||||
detail::unary_rt<ACTION_CLASS, Args, SigArgs>::type type; \
|
||||
}; \
|
||||
};
|
||||
|
||||
#define BOOST_LAMBDA_POSTFIX_UNARY_ACTION(SYMBOL, ACTION_CLASS) \
|
||||
template<class Args> \
|
||||
class lambda_functor_base<ACTION_CLASS, Args> { \
|
||||
public: \
|
||||
Args args; \
|
||||
public: \
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {} \
|
||||
\
|
||||
template<class RET, CALL_TEMPLATE_ARGS> \
|
||||
RET call(CALL_FORMAL_ARGS) const { \
|
||||
return \
|
||||
detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS) SYMBOL; \
|
||||
} \
|
||||
template<class SigArgs> struct sig { \
|
||||
typedef typename \
|
||||
detail::unary_rt<ACTION_CLASS, Args, SigArgs>::type type; \
|
||||
}; \
|
||||
};
|
||||
|
||||
BOOST_LAMBDA_BINARY_ACTION(+,arithmetic_action<plus_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(-,arithmetic_action<minus_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(*,arithmetic_action<multiply_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(/,arithmetic_action<divide_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(%,arithmetic_action<remainder_action>)
|
||||
|
||||
BOOST_LAMBDA_BINARY_ACTION(<<,bitwise_action<leftshift_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(>>,bitwise_action<rightshift_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(&,bitwise_action<and_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(|,bitwise_action<or_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(^,bitwise_action<xor_action>)
|
||||
|
||||
BOOST_LAMBDA_BINARY_ACTION(<,relational_action<less_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(>,relational_action<greater_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(<=,relational_action<lessorequal_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(>=,relational_action<greaterorequal_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(==,relational_action<equal_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(!=,relational_action<notequal_action>)
|
||||
|
||||
BOOST_LAMBDA_BINARY_ACTION(+=,arithmetic_assignment_action<plus_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(-=,arithmetic_assignment_action<minus_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(*=,arithmetic_assignment_action<multiply_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(/=,arithmetic_assignment_action<divide_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(%=,arithmetic_assignment_action<remainder_action>)
|
||||
|
||||
BOOST_LAMBDA_BINARY_ACTION(<<=,bitwise_assignment_action<leftshift_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(>>=,bitwise_assignment_action<rightshift_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(&=,bitwise_assignment_action<and_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(|=,bitwise_assignment_action<or_action>)
|
||||
BOOST_LAMBDA_BINARY_ACTION(^=,bitwise_assignment_action<xor_action>)
|
||||
|
||||
BOOST_LAMBDA_BINARY_ACTION(=,other_action< assignment_action>)
|
||||
|
||||
|
||||
BOOST_LAMBDA_PREFIX_UNARY_ACTION(+, unary_arithmetic_action<plus_action>)
|
||||
BOOST_LAMBDA_PREFIX_UNARY_ACTION(-, unary_arithmetic_action<minus_action>)
|
||||
BOOST_LAMBDA_PREFIX_UNARY_ACTION(~, bitwise_action<not_action>)
|
||||
BOOST_LAMBDA_PREFIX_UNARY_ACTION(!, logical_action<not_action>)
|
||||
BOOST_LAMBDA_PREFIX_UNARY_ACTION(++, pre_increment_decrement_action<increment_action>)
|
||||
BOOST_LAMBDA_PREFIX_UNARY_ACTION(--, pre_increment_decrement_action<decrement_action>)
|
||||
|
||||
BOOST_LAMBDA_PREFIX_UNARY_ACTION(&,other_action<addressof_action>)
|
||||
BOOST_LAMBDA_PREFIX_UNARY_ACTION(*,other_action<contentsof_action>)
|
||||
|
||||
BOOST_LAMBDA_POSTFIX_UNARY_ACTION(++, post_increment_decrement_action<increment_action>)
|
||||
BOOST_LAMBDA_POSTFIX_UNARY_ACTION(--, post_increment_decrement_action<decrement_action>)
|
||||
|
||||
|
||||
#undef BOOST_LAMBDA_POSTFIX_UNARY_ACTION
|
||||
#undef BOOST_LAMBDA_PREFIX_UNARY_ACTION
|
||||
#undef BOOST_LAMBDA_BINARY_ACTION
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -1,352 +1,352 @@
|
||||
// Boost Lambda Library - operators.hpp --------------------------------------
|
||||
|
||||
// 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 www.boost.org
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_OPERATORS_HPP
|
||||
#define BOOST_LAMBDA_OPERATORS_HPP
|
||||
|
||||
#include "boost/lambda/detail/is_instance_of.hpp"
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
#if defined BOOST_LAMBDA_BE1
|
||||
#error "Multiple defines of BOOST_LAMBDA_BE1"
|
||||
#endif
|
||||
|
||||
// For all BOOSTA_LAMBDA_BE* macros:
|
||||
|
||||
// CONSTA must be either 'A' or 'const A'
|
||||
// CONSTB must be either 'B' or 'const B'
|
||||
|
||||
// It is stupid to have the names A and B as macro arguments, but it avoids
|
||||
// the need to pass in emtpy macro arguments, which gives warnings on some
|
||||
// compilers
|
||||
|
||||
#define BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION) \
|
||||
template<class Arg, class B> \
|
||||
inline const \
|
||||
lambda_functor< \
|
||||
lambda_functor_base< \
|
||||
ACTION, \
|
||||
tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type> \
|
||||
> \
|
||||
> \
|
||||
OPER_NAME (const lambda_functor<Arg>& a, CONSTB& b) { \
|
||||
return \
|
||||
lambda_functor_base< \
|
||||
ACTION, \
|
||||
tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>\
|
||||
> \
|
||||
(tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>(a, b)); \
|
||||
}
|
||||
|
||||
|
||||
#if defined BOOST_LAMBDA_BE2
|
||||
#error "Multiple defines of BOOST_LAMBDA_BE2"
|
||||
#endif
|
||||
|
||||
#define BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION) \
|
||||
template<class A, class Arg> \
|
||||
inline const \
|
||||
lambda_functor< \
|
||||
lambda_functor_base< \
|
||||
ACTION, \
|
||||
tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> > \
|
||||
> \
|
||||
> \
|
||||
OPER_NAME (CONSTA& a, const lambda_functor<Arg>& b) { \
|
||||
return \
|
||||
lambda_functor_base< \
|
||||
ACTION, \
|
||||
tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> > \
|
||||
> \
|
||||
(tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >(a, b)); \
|
||||
}
|
||||
|
||||
|
||||
#if defined BOOST_LAMBDA_BE3
|
||||
#error "Multiple defines of BOOST_LAMBDA_BE3"
|
||||
#endif
|
||||
|
||||
#define BOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION) \
|
||||
template<class ArgA, class ArgB> \
|
||||
inline const \
|
||||
lambda_functor< \
|
||||
lambda_functor_base< \
|
||||
ACTION, \
|
||||
tuple<lambda_functor<ArgA>, lambda_functor<ArgB> > \
|
||||
> \
|
||||
> \
|
||||
OPER_NAME (const lambda_functor<ArgA>& a, const lambda_functor<ArgB>& b) { \
|
||||
return \
|
||||
lambda_functor_base< \
|
||||
ACTION, \
|
||||
tuple<lambda_functor<ArgA>, lambda_functor<ArgB> > \
|
||||
> \
|
||||
(tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >(a, b)); \
|
||||
}
|
||||
|
||||
#if defined BOOST_LAMBDA_BE
|
||||
#error "Multiple defines of BOOST_LAMBDA_BE"
|
||||
#endif
|
||||
|
||||
#define BOOST_LAMBDA_BE(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) \
|
||||
BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) \
|
||||
BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) \
|
||||
BOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)
|
||||
|
||||
#define BOOST_LAMBDA_EMPTY()
|
||||
|
||||
BOOST_LAMBDA_BE(operator+, arithmetic_action<plus_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator-, arithmetic_action<minus_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator*, arithmetic_action<multiply_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator/, arithmetic_action<divide_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator%, arithmetic_action<remainder_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator<<, bitwise_action<leftshift_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator>>, bitwise_action<rightshift_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator&, bitwise_action<and_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator|, bitwise_action<or_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator^, bitwise_action<xor_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator&&, logical_action<and_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator||, logical_action<or_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator<, relational_action<less_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator>, relational_action<greater_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator<=, relational_action<lessorequal_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator>=, relational_action<greaterorequal_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator==, relational_action<equal_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator!=, relational_action<notequal_action>, const A, const B, const_copy_argument)
|
||||
|
||||
BOOST_LAMBDA_BE(operator+=, arithmetic_assignment_action<plus_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator-=, arithmetic_assignment_action<minus_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator*=, arithmetic_assignment_action<multiply_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator/=, arithmetic_assignment_action<divide_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator%=, arithmetic_assignment_action<remainder_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator<<=, bitwise_assignment_action<leftshift_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator>>=, bitwise_assignment_action<rightshift_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator&=, bitwise_assignment_action<and_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator|=, bitwise_assignment_action<or_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator^=, bitwise_assignment_action<xor_action>, A, const B, reference_argument)
|
||||
|
||||
|
||||
// A special trick for comma operator for correct preprocessing
|
||||
#if defined BOOST_LAMBDA_COMMA_OPERATOR_NAME
|
||||
#error "Multiple defines of BOOST_LAMBDA_COMMA_OPERATOR_NAME"
|
||||
#endif
|
||||
|
||||
#define BOOST_LAMBDA_COMMA_OPERATOR_NAME operator,
|
||||
|
||||
BOOST_LAMBDA_BE1(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE2(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE3(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
|
||||
|
||||
|
||||
|
||||
namespace detail {
|
||||
|
||||
// special cases for ostream& << Any and istream& >> Any ---------------
|
||||
// the actual stream classes may vary and thus a specialisation for,
|
||||
// say ostream& does not match (the general case above is chosen).
|
||||
// Therefore we specialise for non-const reference:
|
||||
// if the left argument is a stream, we store the stream as reference
|
||||
// if it is something else, we store a const plain by default
|
||||
|
||||
// Note that the overloading is const vs. non-const first argument
|
||||
|
||||
|
||||
template<class T> struct convert_ostream_to_ref_others_to_c_plain_by_default {
|
||||
typedef typename detail::IF<
|
||||
is_instance_of_2<
|
||||
T, std::basic_ostream
|
||||
>::value,
|
||||
T&,
|
||||
typename const_copy_argument <T>::type
|
||||
>::RET type;
|
||||
};
|
||||
|
||||
template<class T> struct convert_istream_to_ref_others_to_c_plain_by_default {
|
||||
typedef typename detail::IF<
|
||||
is_instance_of_2<
|
||||
T, std::basic_istream
|
||||
>::value,
|
||||
T&,
|
||||
typename const_copy_argument <T>::type
|
||||
>::RET type;
|
||||
};
|
||||
|
||||
} // detail
|
||||
|
||||
BOOST_LAMBDA_BE2(operator<<, bitwise_action< leftshift_action>, A, const B, detail::convert_ostream_to_ref_others_to_c_plain_by_default)
|
||||
BOOST_LAMBDA_BE2(operator>>, bitwise_action< rightshift_action>, A, const B, detail::convert_istream_to_ref_others_to_c_plain_by_default)
|
||||
|
||||
|
||||
// special case for io_manipulators.
|
||||
// function references cannot be given as arguments to lambda operator
|
||||
// expressions in general. With << and >> the use of manipulators is
|
||||
// so common, that specializations are provided to make them work.
|
||||
|
||||
template<class Arg, class Ret, class ManipArg>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
bitwise_action<leftshift_action>,
|
||||
tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
|
||||
>
|
||||
>
|
||||
operator<<(const lambda_functor<Arg>& a, Ret(&b)(ManipArg))
|
||||
{
|
||||
return
|
||||
lambda_functor_base<
|
||||
bitwise_action<leftshift_action>,
|
||||
tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
|
||||
>
|
||||
( tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>(a, b) );
|
||||
}
|
||||
|
||||
template<class Arg, class Ret, class ManipArg>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
bitwise_action<rightshift_action>,
|
||||
tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
|
||||
>
|
||||
>
|
||||
operator>>(const lambda_functor<Arg>& a, Ret(&b)(ManipArg))
|
||||
{
|
||||
return
|
||||
lambda_functor_base<
|
||||
bitwise_action<rightshift_action>,
|
||||
tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
|
||||
>
|
||||
( tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>(a, b) );
|
||||
}
|
||||
|
||||
|
||||
// (+ and -) take their arguments as const references.
|
||||
// This has consquences with pointer artihmetic
|
||||
// E.g int a[]; ... *a = 1 works but not *(a+1) = 1.
|
||||
// the result of a+1 would be const
|
||||
// To make the latter work too,
|
||||
// non-const arrays are taken as non-const and stored as non-const as well.
|
||||
#if defined BOOST_LAMBDA_PTR_ARITHMETIC_E1
|
||||
#error "Multiple defines of BOOST_LAMBDA_PTR_ARITHMETIC_E1"
|
||||
#endif
|
||||
|
||||
#define BOOST_LAMBDA_PTR_ARITHMETIC_E1(OPER_NAME, ACTION, CONSTB) \
|
||||
template<class Arg, int N, class B> \
|
||||
inline const \
|
||||
lambda_functor< \
|
||||
lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> > \
|
||||
> \
|
||||
OPER_NAME (const lambda_functor<Arg>& a, CONSTB(&b)[N]) \
|
||||
{ \
|
||||
return \
|
||||
lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> > \
|
||||
(tuple<lambda_functor<Arg>, CONSTB(&)[N]>(a, b)); \
|
||||
}
|
||||
|
||||
|
||||
#if defined BOOST_LAMBDA_PTR_ARITHMETIC_E2
|
||||
#error "Multiple defines of BOOST_LAMBDA_PTR_ARITHMETIC_E2"
|
||||
#endif
|
||||
|
||||
#define BOOST_LAMBDA_PTR_ARITHMETIC_E2(OPER_NAME, ACTION, CONSTA) \
|
||||
template<int N, class A, class Arg> \
|
||||
inline const \
|
||||
lambda_functor< \
|
||||
lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > > \
|
||||
> \
|
||||
OPER_NAME (CONSTA(&a)[N], const lambda_functor<Arg>& b) \
|
||||
{ \
|
||||
return \
|
||||
lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > > \
|
||||
(tuple<CONSTA(&)[N], lambda_functor<Arg> >(a, b)); \
|
||||
}
|
||||
|
||||
|
||||
BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>, B)
|
||||
BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>, A)
|
||||
BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>,const B)
|
||||
BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>,const A)
|
||||
|
||||
|
||||
//BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator-, arithmetic_action<minus_action>)
|
||||
// This is not needed, since the result of ptr-ptr is an rvalue anyway
|
||||
|
||||
BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, A)
|
||||
BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, const A)
|
||||
|
||||
|
||||
#undef BOOST_LAMBDA_BE1
|
||||
#undef BOOST_LAMBDA_BE2
|
||||
#undef BOOST_LAMBDA_BE3
|
||||
#undef BOOST_LAMBDA_BE
|
||||
#undef BOOST_LAMBDA_COMMA_OPERATOR_NAME
|
||||
|
||||
#undef BOOST_LAMBDA_PTR_ARITHMETIC_E1
|
||||
#undef BOOST_LAMBDA_PTR_ARITHMETIC_E2
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// unary operators -----------------------------------------------------
|
||||
// ---------------------------------------------------------------------
|
||||
|
||||
#if defined BOOST_LAMBDA_UE
|
||||
#error "Multiple defines of BOOST_LAMBDA_UE"
|
||||
#endif
|
||||
|
||||
#define BOOST_LAMBDA_UE(OPER_NAME, ACTION) \
|
||||
template<class Arg> \
|
||||
inline const \
|
||||
lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \
|
||||
OPER_NAME (const lambda_functor<Arg>& a) \
|
||||
{ \
|
||||
return \
|
||||
lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > \
|
||||
( tuple<lambda_functor<Arg> >(a) ); \
|
||||
}
|
||||
|
||||
|
||||
BOOST_LAMBDA_UE(operator+, unary_arithmetic_action<plus_action>)
|
||||
BOOST_LAMBDA_UE(operator-, unary_arithmetic_action<minus_action>)
|
||||
BOOST_LAMBDA_UE(operator~, bitwise_action<not_action>)
|
||||
BOOST_LAMBDA_UE(operator!, logical_action<not_action>)
|
||||
BOOST_LAMBDA_UE(operator++, pre_increment_decrement_action<increment_action>)
|
||||
BOOST_LAMBDA_UE(operator--, pre_increment_decrement_action<decrement_action>)
|
||||
BOOST_LAMBDA_UE(operator*, other_action<contentsof_action>)
|
||||
BOOST_LAMBDA_UE(operator&, other_action<addressof_action>)
|
||||
|
||||
#if defined BOOST_LAMBDA_POSTFIX_UE
|
||||
#error "Multiple defines of BOOST_LAMBDA_POSTFIX_UE"
|
||||
#endif
|
||||
|
||||
#define BOOST_LAMBDA_POSTFIX_UE(OPER_NAME, ACTION) \
|
||||
template<class Arg> \
|
||||
inline const \
|
||||
lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \
|
||||
OPER_NAME (const lambda_functor<Arg>& a, int) \
|
||||
{ \
|
||||
return \
|
||||
lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > \
|
||||
( tuple<lambda_functor<Arg> >(a) ); \
|
||||
}
|
||||
|
||||
|
||||
BOOST_LAMBDA_POSTFIX_UE(operator++, post_increment_decrement_action<increment_action>)
|
||||
BOOST_LAMBDA_POSTFIX_UE(operator--, post_increment_decrement_action<decrement_action>)
|
||||
|
||||
#undef BOOST_LAMBDA_UE
|
||||
#undef BOOST_LAMBDA_POSTFIX_UE
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
// Boost Lambda Library - operators.hpp --------------------------------------
|
||||
|
||||
// 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 www.boost.org
|
||||
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_OPERATORS_HPP
|
||||
#define BOOST_LAMBDA_OPERATORS_HPP
|
||||
|
||||
#include "boost/lambda/detail/is_instance_of.hpp"
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
#if defined BOOST_LAMBDA_BE1
|
||||
#error "Multiple defines of BOOST_LAMBDA_BE1"
|
||||
#endif
|
||||
|
||||
// For all BOOSTA_LAMBDA_BE* macros:
|
||||
|
||||
// CONSTA must be either 'A' or 'const A'
|
||||
// CONSTB must be either 'B' or 'const B'
|
||||
|
||||
// It is stupid to have the names A and B as macro arguments, but it avoids
|
||||
// the need to pass in emtpy macro arguments, which gives warnings on some
|
||||
// compilers
|
||||
|
||||
#define BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION) \
|
||||
template<class Arg, class B> \
|
||||
inline const \
|
||||
lambda_functor< \
|
||||
lambda_functor_base< \
|
||||
ACTION, \
|
||||
tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type> \
|
||||
> \
|
||||
> \
|
||||
OPER_NAME (const lambda_functor<Arg>& a, CONSTB& b) { \
|
||||
return \
|
||||
lambda_functor_base< \
|
||||
ACTION, \
|
||||
tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>\
|
||||
> \
|
||||
(tuple<lambda_functor<Arg>, typename const_copy_argument <CONSTB>::type>(a, b)); \
|
||||
}
|
||||
|
||||
|
||||
#if defined BOOST_LAMBDA_BE2
|
||||
#error "Multiple defines of BOOST_LAMBDA_BE2"
|
||||
#endif
|
||||
|
||||
#define BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION) \
|
||||
template<class A, class Arg> \
|
||||
inline const \
|
||||
lambda_functor< \
|
||||
lambda_functor_base< \
|
||||
ACTION, \
|
||||
tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> > \
|
||||
> \
|
||||
> \
|
||||
OPER_NAME (CONSTA& a, const lambda_functor<Arg>& b) { \
|
||||
return \
|
||||
lambda_functor_base< \
|
||||
ACTION, \
|
||||
tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> > \
|
||||
> \
|
||||
(tuple<typename CONVERSION <CONSTA>::type, lambda_functor<Arg> >(a, b)); \
|
||||
}
|
||||
|
||||
|
||||
#if defined BOOST_LAMBDA_BE3
|
||||
#error "Multiple defines of BOOST_LAMBDA_BE3"
|
||||
#endif
|
||||
|
||||
#define BOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONVERSION) \
|
||||
template<class ArgA, class ArgB> \
|
||||
inline const \
|
||||
lambda_functor< \
|
||||
lambda_functor_base< \
|
||||
ACTION, \
|
||||
tuple<lambda_functor<ArgA>, lambda_functor<ArgB> > \
|
||||
> \
|
||||
> \
|
||||
OPER_NAME (const lambda_functor<ArgA>& a, const lambda_functor<ArgB>& b) { \
|
||||
return \
|
||||
lambda_functor_base< \
|
||||
ACTION, \
|
||||
tuple<lambda_functor<ArgA>, lambda_functor<ArgB> > \
|
||||
> \
|
||||
(tuple<lambda_functor<ArgA>, lambda_functor<ArgB> >(a, b)); \
|
||||
}
|
||||
|
||||
#if defined BOOST_LAMBDA_BE
|
||||
#error "Multiple defines of BOOST_LAMBDA_BE"
|
||||
#endif
|
||||
|
||||
#define BOOST_LAMBDA_BE(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) \
|
||||
BOOST_LAMBDA_BE1(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) \
|
||||
BOOST_LAMBDA_BE2(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION) \
|
||||
BOOST_LAMBDA_BE3(OPER_NAME, ACTION, CONSTA, CONSTB, CONST_CONVERSION)
|
||||
|
||||
#define BOOST_LAMBDA_EMPTY()
|
||||
|
||||
BOOST_LAMBDA_BE(operator+, arithmetic_action<plus_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator-, arithmetic_action<minus_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator*, arithmetic_action<multiply_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator/, arithmetic_action<divide_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator%, arithmetic_action<remainder_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator<<, bitwise_action<leftshift_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator>>, bitwise_action<rightshift_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator&, bitwise_action<and_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator|, bitwise_action<or_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator^, bitwise_action<xor_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator&&, logical_action<and_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator||, logical_action<or_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator<, relational_action<less_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator>, relational_action<greater_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator<=, relational_action<lessorequal_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator>=, relational_action<greaterorequal_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator==, relational_action<equal_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE(operator!=, relational_action<notequal_action>, const A, const B, const_copy_argument)
|
||||
|
||||
BOOST_LAMBDA_BE(operator+=, arithmetic_assignment_action<plus_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator-=, arithmetic_assignment_action<minus_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator*=, arithmetic_assignment_action<multiply_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator/=, arithmetic_assignment_action<divide_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator%=, arithmetic_assignment_action<remainder_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator<<=, bitwise_assignment_action<leftshift_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator>>=, bitwise_assignment_action<rightshift_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator&=, bitwise_assignment_action<and_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator|=, bitwise_assignment_action<or_action>, A, const B, reference_argument)
|
||||
BOOST_LAMBDA_BE(operator^=, bitwise_assignment_action<xor_action>, A, const B, reference_argument)
|
||||
|
||||
|
||||
// A special trick for comma operator for correct preprocessing
|
||||
#if defined BOOST_LAMBDA_COMMA_OPERATOR_NAME
|
||||
#error "Multiple defines of BOOST_LAMBDA_COMMA_OPERATOR_NAME"
|
||||
#endif
|
||||
|
||||
#define BOOST_LAMBDA_COMMA_OPERATOR_NAME operator,
|
||||
|
||||
BOOST_LAMBDA_BE1(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE2(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
|
||||
BOOST_LAMBDA_BE3(BOOST_LAMBDA_COMMA_OPERATOR_NAME, other_action<comma_action>, const A, const B, const_copy_argument)
|
||||
|
||||
|
||||
|
||||
namespace detail {
|
||||
|
||||
// special cases for ostream& << Any and istream& >> Any ---------------
|
||||
// the actual stream classes may vary and thus a specialisation for,
|
||||
// say ostream& does not match (the general case above is chosen).
|
||||
// Therefore we specialise for non-const reference:
|
||||
// if the left argument is a stream, we store the stream as reference
|
||||
// if it is something else, we store a const plain by default
|
||||
|
||||
// Note that the overloading is const vs. non-const first argument
|
||||
|
||||
|
||||
template<class T> struct convert_ostream_to_ref_others_to_c_plain_by_default {
|
||||
typedef typename detail::IF<
|
||||
is_instance_of_2<
|
||||
T, std::basic_ostream
|
||||
>::value,
|
||||
T&,
|
||||
typename const_copy_argument <T>::type
|
||||
>::RET type;
|
||||
};
|
||||
|
||||
template<class T> struct convert_istream_to_ref_others_to_c_plain_by_default {
|
||||
typedef typename detail::IF<
|
||||
is_instance_of_2<
|
||||
T, std::basic_istream
|
||||
>::value,
|
||||
T&,
|
||||
typename const_copy_argument <T>::type
|
||||
>::RET type;
|
||||
};
|
||||
|
||||
} // detail
|
||||
|
||||
BOOST_LAMBDA_BE2(operator<<, bitwise_action< leftshift_action>, A, const B, detail::convert_ostream_to_ref_others_to_c_plain_by_default)
|
||||
BOOST_LAMBDA_BE2(operator>>, bitwise_action< rightshift_action>, A, const B, detail::convert_istream_to_ref_others_to_c_plain_by_default)
|
||||
|
||||
|
||||
// special case for io_manipulators.
|
||||
// function references cannot be given as arguments to lambda operator
|
||||
// expressions in general. With << and >> the use of manipulators is
|
||||
// so common, that specializations are provided to make them work.
|
||||
|
||||
template<class Arg, class Ret, class ManipArg>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
bitwise_action<leftshift_action>,
|
||||
tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
|
||||
>
|
||||
>
|
||||
operator<<(const lambda_functor<Arg>& a, Ret(&b)(ManipArg))
|
||||
{
|
||||
return
|
||||
lambda_functor_base<
|
||||
bitwise_action<leftshift_action>,
|
||||
tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
|
||||
>
|
||||
( tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>(a, b) );
|
||||
}
|
||||
|
||||
template<class Arg, class Ret, class ManipArg>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
bitwise_action<rightshift_action>,
|
||||
tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
|
||||
>
|
||||
>
|
||||
operator>>(const lambda_functor<Arg>& a, Ret(&b)(ManipArg))
|
||||
{
|
||||
return
|
||||
lambda_functor_base<
|
||||
bitwise_action<rightshift_action>,
|
||||
tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>
|
||||
>
|
||||
( tuple<lambda_functor<Arg>, Ret(&)(ManipArg)>(a, b) );
|
||||
}
|
||||
|
||||
|
||||
// (+ and -) take their arguments as const references.
|
||||
// This has consquences with pointer artihmetic
|
||||
// E.g int a[]; ... *a = 1 works but not *(a+1) = 1.
|
||||
// the result of a+1 would be const
|
||||
// To make the latter work too,
|
||||
// non-const arrays are taken as non-const and stored as non-const as well.
|
||||
#if defined BOOST_LAMBDA_PTR_ARITHMETIC_E1
|
||||
#error "Multiple defines of BOOST_LAMBDA_PTR_ARITHMETIC_E1"
|
||||
#endif
|
||||
|
||||
#define BOOST_LAMBDA_PTR_ARITHMETIC_E1(OPER_NAME, ACTION, CONSTB) \
|
||||
template<class Arg, int N, class B> \
|
||||
inline const \
|
||||
lambda_functor< \
|
||||
lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> > \
|
||||
> \
|
||||
OPER_NAME (const lambda_functor<Arg>& a, CONSTB(&b)[N]) \
|
||||
{ \
|
||||
return \
|
||||
lambda_functor_base<ACTION, tuple<lambda_functor<Arg>, CONSTB(&)[N]> > \
|
||||
(tuple<lambda_functor<Arg>, CONSTB(&)[N]>(a, b)); \
|
||||
}
|
||||
|
||||
|
||||
#if defined BOOST_LAMBDA_PTR_ARITHMETIC_E2
|
||||
#error "Multiple defines of BOOST_LAMBDA_PTR_ARITHMETIC_E2"
|
||||
#endif
|
||||
|
||||
#define BOOST_LAMBDA_PTR_ARITHMETIC_E2(OPER_NAME, ACTION, CONSTA) \
|
||||
template<int N, class A, class Arg> \
|
||||
inline const \
|
||||
lambda_functor< \
|
||||
lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > > \
|
||||
> \
|
||||
OPER_NAME (CONSTA(&a)[N], const lambda_functor<Arg>& b) \
|
||||
{ \
|
||||
return \
|
||||
lambda_functor_base<ACTION, tuple<CONSTA(&)[N], lambda_functor<Arg> > > \
|
||||
(tuple<CONSTA(&)[N], lambda_functor<Arg> >(a, b)); \
|
||||
}
|
||||
|
||||
|
||||
BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>, B)
|
||||
BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>, A)
|
||||
BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator+, arithmetic_action<plus_action>,const B)
|
||||
BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator+, arithmetic_action<plus_action>,const A)
|
||||
|
||||
|
||||
//BOOST_LAMBDA_PTR_ARITHMETIC_E1(operator-, arithmetic_action<minus_action>)
|
||||
// This is not needed, since the result of ptr-ptr is an rvalue anyway
|
||||
|
||||
BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, A)
|
||||
BOOST_LAMBDA_PTR_ARITHMETIC_E2(operator-, arithmetic_action<minus_action>, const A)
|
||||
|
||||
|
||||
#undef BOOST_LAMBDA_BE1
|
||||
#undef BOOST_LAMBDA_BE2
|
||||
#undef BOOST_LAMBDA_BE3
|
||||
#undef BOOST_LAMBDA_BE
|
||||
#undef BOOST_LAMBDA_COMMA_OPERATOR_NAME
|
||||
|
||||
#undef BOOST_LAMBDA_PTR_ARITHMETIC_E1
|
||||
#undef BOOST_LAMBDA_PTR_ARITHMETIC_E2
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// unary operators -----------------------------------------------------
|
||||
// ---------------------------------------------------------------------
|
||||
|
||||
#if defined BOOST_LAMBDA_UE
|
||||
#error "Multiple defines of BOOST_LAMBDA_UE"
|
||||
#endif
|
||||
|
||||
#define BOOST_LAMBDA_UE(OPER_NAME, ACTION) \
|
||||
template<class Arg> \
|
||||
inline const \
|
||||
lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \
|
||||
OPER_NAME (const lambda_functor<Arg>& a) \
|
||||
{ \
|
||||
return \
|
||||
lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > \
|
||||
( tuple<lambda_functor<Arg> >(a) ); \
|
||||
}
|
||||
|
||||
|
||||
BOOST_LAMBDA_UE(operator+, unary_arithmetic_action<plus_action>)
|
||||
BOOST_LAMBDA_UE(operator-, unary_arithmetic_action<minus_action>)
|
||||
BOOST_LAMBDA_UE(operator~, bitwise_action<not_action>)
|
||||
BOOST_LAMBDA_UE(operator!, logical_action<not_action>)
|
||||
BOOST_LAMBDA_UE(operator++, pre_increment_decrement_action<increment_action>)
|
||||
BOOST_LAMBDA_UE(operator--, pre_increment_decrement_action<decrement_action>)
|
||||
BOOST_LAMBDA_UE(operator*, other_action<contentsof_action>)
|
||||
BOOST_LAMBDA_UE(operator&, other_action<addressof_action>)
|
||||
|
||||
#if defined BOOST_LAMBDA_POSTFIX_UE
|
||||
#error "Multiple defines of BOOST_LAMBDA_POSTFIX_UE"
|
||||
#endif
|
||||
|
||||
#define BOOST_LAMBDA_POSTFIX_UE(OPER_NAME, ACTION) \
|
||||
template<class Arg> \
|
||||
inline const \
|
||||
lambda_functor<lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > > \
|
||||
OPER_NAME (const lambda_functor<Arg>& a, int) \
|
||||
{ \
|
||||
return \
|
||||
lambda_functor_base<ACTION, tuple<lambda_functor<Arg> > > \
|
||||
( tuple<lambda_functor<Arg> >(a) ); \
|
||||
}
|
||||
|
||||
|
||||
BOOST_LAMBDA_POSTFIX_UE(operator++, post_increment_decrement_action<increment_action>)
|
||||
BOOST_LAMBDA_POSTFIX_UE(operator--, post_increment_decrement_action<decrement_action>)
|
||||
|
||||
#undef BOOST_LAMBDA_UE
|
||||
#undef BOOST_LAMBDA_POSTFIX_UE
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
@@ -1,325 +1,325 @@
|
||||
// Boost Lambda Library ret.hpp -----------------------------------------
|
||||
|
||||
// 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 www.boost.org
|
||||
|
||||
|
||||
#ifndef BOOST_LAMBDA_RET_HPP
|
||||
#define BOOST_LAMBDA_RET_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
// TODO:
|
||||
|
||||
// Add specializations for function references for ret, protect and unlambda
|
||||
// e.g void foo(); unlambda(foo); fails, as it would add a const qualifier
|
||||
// for a function type.
|
||||
// on the other hand unlambda(*foo) does work
|
||||
|
||||
|
||||
// -- ret -------------------------
|
||||
// the explicit return type template
|
||||
|
||||
// TODO: It'd be nice to make ret a nop for other than lambda functors
|
||||
// but causes an ambiguiyty with gcc (not with KCC), check what is the
|
||||
// right interpretation.
|
||||
|
||||
// // ret for others than lambda functors has no effect
|
||||
// template <class U, class T>
|
||||
// inline const T& ret(const T& t) { return t; }
|
||||
|
||||
|
||||
template<class RET, class Arg>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
explicit_return_type_action<RET>,
|
||||
tuple<lambda_functor<Arg> >
|
||||
>
|
||||
>
|
||||
ret(const lambda_functor<Arg>& a1)
|
||||
{
|
||||
return
|
||||
lambda_functor_base<
|
||||
explicit_return_type_action<RET>,
|
||||
tuple<lambda_functor<Arg> >
|
||||
>
|
||||
(tuple<lambda_functor<Arg> >(a1));
|
||||
}
|
||||
|
||||
// protect ------------------
|
||||
|
||||
// protecting others than lambda functors has no effect
|
||||
template <class T>
|
||||
inline const T& protect(const T& t) { return t; }
|
||||
|
||||
template<class Arg>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
protect_action,
|
||||
tuple<lambda_functor<Arg> >
|
||||
>
|
||||
>
|
||||
protect(const lambda_functor<Arg>& a1)
|
||||
{
|
||||
return
|
||||
lambda_functor_base<
|
||||
protect_action,
|
||||
tuple<lambda_functor<Arg> >
|
||||
>
|
||||
(tuple<lambda_functor<Arg> >(a1));
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
// Hides the lambda functorness of a lambda functor.
|
||||
// After this, the functor is immune to argument substitution, etc.
|
||||
// This can be used, e.g. to make it safe to pass lambda functors as
|
||||
// arguments to functions, which might use them as target functions
|
||||
|
||||
// note, unlambda and protect are different things. Protect hides the lambda
|
||||
// functor for one application, unlambda for good.
|
||||
|
||||
template <class LambdaFunctor>
|
||||
class non_lambda_functor
|
||||
{
|
||||
LambdaFunctor lf;
|
||||
public:
|
||||
|
||||
// This functor defines the result_type typedef.
|
||||
// The result type must be deducible without knowing the arguments
|
||||
|
||||
template <class SigArgs> struct sig {
|
||||
typedef typename
|
||||
LambdaFunctor::inherited::
|
||||
template sig<typename SigArgs::tail_type>::type type;
|
||||
};
|
||||
|
||||
explicit non_lambda_functor(const LambdaFunctor& a) : lf(a) {}
|
||||
|
||||
typename LambdaFunctor::nullary_return_type
|
||||
operator()() const {
|
||||
return lf.template
|
||||
call<typename LambdaFunctor::nullary_return_type>
|
||||
(cnull_type(), cnull_type(), cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A>
|
||||
typename sig<tuple<const non_lambda_functor, A&> >::type
|
||||
operator()(A& a) const {
|
||||
return lf.template call<typename sig<tuple<const non_lambda_functor, A&> >::type >(a, cnull_type(), cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B>
|
||||
typename sig<tuple<const non_lambda_functor, A&, B&> >::type
|
||||
operator()(A& a, B& b) const {
|
||||
return lf.template call<typename sig<tuple<const non_lambda_functor, A&, B&> >::type >(a, b, cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B, class C>
|
||||
typename sig<tuple<const non_lambda_functor, A&, B&, C&> >::type
|
||||
operator()(A& a, B& b, C& c) const {
|
||||
return lf.template call<typename sig<tuple<const non_lambda_functor, A&, B&, C&> >::type>(a, b, c, cnull_type());
|
||||
}
|
||||
};
|
||||
|
||||
template <class Arg>
|
||||
inline const Arg& unlambda(const Arg& a) { return a; }
|
||||
|
||||
template <class Arg>
|
||||
inline const non_lambda_functor<lambda_functor<Arg> >
|
||||
unlambda(const lambda_functor<Arg>& a)
|
||||
{
|
||||
return non_lambda_functor<lambda_functor<Arg> >(a);
|
||||
}
|
||||
|
||||
// Due to a language restriction, lambda functors cannot be made to
|
||||
// accept non-const rvalue arguments. Usually iterators do not return
|
||||
// temporaries, but sometimes they do. That's why a workaround is provided.
|
||||
// Note, that this potentially breaks const correctness, so be careful!
|
||||
|
||||
// any lambda functor can be turned into a const_incorrect_lambda_functor
|
||||
// The operator() takes arguments as consts and then casts constness
|
||||
// away. So this breaks const correctness!!! but is a necessary workaround
|
||||
// in some cases due to language limitations.
|
||||
// Note, that this is not a lambda_functor anymore, so it can not be used
|
||||
// as a sub lambda expression.
|
||||
|
||||
template <class LambdaFunctor>
|
||||
struct const_incorrect_lambda_functor {
|
||||
LambdaFunctor lf;
|
||||
public:
|
||||
|
||||
explicit const_incorrect_lambda_functor(const LambdaFunctor& a) : lf(a) {}
|
||||
|
||||
template <class SigArgs> struct sig {
|
||||
typedef typename
|
||||
LambdaFunctor::inherited::template
|
||||
sig<typename SigArgs::tail_type>::type type;
|
||||
};
|
||||
|
||||
// The nullary case is not needed (no arguments, no parameter type problems)
|
||||
|
||||
template<class A>
|
||||
typename sig<tuple<const const_incorrect_lambda_functor, A&> >::type
|
||||
operator()(const A& a) const {
|
||||
return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&> >::type >(const_cast<A&>(a), cnull_type(), cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B>
|
||||
typename sig<tuple<const const_incorrect_lambda_functor, A&, B&> >::type
|
||||
operator()(const A& a, const B& b) const {
|
||||
return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&, B&> >::type >(const_cast<A&>(a), const_cast<B&>(b), cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B, class C>
|
||||
typename sig<tuple<const const_incorrect_lambda_functor, A&, B&, C&> >::type
|
||||
operator()(const A& a, const B& b, const C& c) const {
|
||||
return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&, B&, C&> >::type>(const_cast<A&>(a), const_cast<B&>(b), const_cast<C&>(c), cnull_type());
|
||||
}
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// any lambda functor can be turned into a const_parameter_lambda_functor
|
||||
// The operator() takes arguments as const.
|
||||
// This is useful if lambda functors are called with non-const rvalues.
|
||||
// Note, that this is not a lambda_functor anymore, so it can not be used
|
||||
// as a sub lambda expression.
|
||||
|
||||
template <class LambdaFunctor>
|
||||
struct const_parameter_lambda_functor {
|
||||
LambdaFunctor lf;
|
||||
public:
|
||||
|
||||
explicit const_parameter_lambda_functor(const LambdaFunctor& a) : lf(a) {}
|
||||
|
||||
template <class SigArgs> struct sig {
|
||||
typedef typename
|
||||
LambdaFunctor::inherited::template
|
||||
sig<typename SigArgs::tail_type>::type type;
|
||||
};
|
||||
|
||||
// The nullary case is not needed: no arguments, no constness problems.
|
||||
|
||||
template<class A>
|
||||
typename sig<tuple<const const_parameter_lambda_functor, const A&> >::type
|
||||
operator()(const A& a) const {
|
||||
return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&> >::type >(a, cnull_type(), cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B>
|
||||
typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&> >::type
|
||||
operator()(const A& a, const B& b) const {
|
||||
return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&> >::type >(a, b, cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B, class C>
|
||||
typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&, const C&>
|
||||
>::type
|
||||
operator()(const A& a, const B& b, const C& c) const {
|
||||
return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&, const C&> >::type>(a, b, c, cnull_type());
|
||||
}
|
||||
};
|
||||
|
||||
template <class Arg>
|
||||
inline const const_incorrect_lambda_functor<lambda_functor<Arg> >
|
||||
break_const(const lambda_functor<Arg>& lf)
|
||||
{
|
||||
return const_incorrect_lambda_functor<lambda_functor<Arg> >(lf);
|
||||
}
|
||||
|
||||
|
||||
template <class Arg>
|
||||
inline const const_parameter_lambda_functor<lambda_functor<Arg> >
|
||||
const_parameters(const lambda_functor<Arg>& lf)
|
||||
{
|
||||
return const_parameter_lambda_functor<lambda_functor<Arg> >(lf);
|
||||
}
|
||||
|
||||
// make void ------------------------------------------------
|
||||
// make_void( x ) turns a lambda functor x with some return type y into
|
||||
// another lambda functor, which has a void return type
|
||||
// when called, the original return type is discarded
|
||||
|
||||
// we use this action. The action class will be called, which means that
|
||||
// the wrapped lambda functor is evaluated, but we just don't do anything
|
||||
// with the result.
|
||||
struct voidifier_action {
|
||||
template<class Ret, class A> static void apply(A&) {}
|
||||
};
|
||||
|
||||
template<class Args> struct return_type_N<voidifier_action, Args> {
|
||||
typedef void type;
|
||||
};
|
||||
|
||||
template<class Arg1>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
action<1, voidifier_action>,
|
||||
tuple<lambda_functor<Arg1> >
|
||||
>
|
||||
>
|
||||
make_void(const lambda_functor<Arg1>& a1) {
|
||||
return
|
||||
lambda_functor_base<
|
||||
action<1, voidifier_action>,
|
||||
tuple<lambda_functor<Arg1> >
|
||||
>
|
||||
(tuple<lambda_functor<Arg1> > (a1));
|
||||
}
|
||||
|
||||
// for non-lambda functors, make_void does nothing
|
||||
// (the argument gets evaluated immediately)
|
||||
|
||||
template<class Arg1>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<do_nothing_action, null_type>
|
||||
>
|
||||
make_void(const Arg1&) {
|
||||
return
|
||||
lambda_functor_base<do_nothing_action, null_type>();
|
||||
}
|
||||
|
||||
// std_functor -----------------------------------------------------
|
||||
|
||||
// The STL uses the result_type typedef as the convention to let binders know
|
||||
// the return type of a function object.
|
||||
// LL uses the sig template.
|
||||
// To let LL know that the function object has the result_type typedef
|
||||
// defined, it can be wrapped with the std_functor function.
|
||||
|
||||
|
||||
// Just inherit form the template parameter (the standard functor),
|
||||
// and provide a sig template. So we have a class which is still the
|
||||
// same functor + the sig template.
|
||||
|
||||
template<class T>
|
||||
struct result_type_to_sig : public T {
|
||||
template<class Args> struct sig { typedef typename T::result_type type; };
|
||||
result_type_to_sig(const T& t) : T(t) {}
|
||||
};
|
||||
|
||||
template<class F>
|
||||
inline result_type_to_sig<F> std_functor(const F& f) { return f; }
|
||||
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// Boost Lambda Library ret.hpp -----------------------------------------
|
||||
|
||||
// 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 www.boost.org
|
||||
|
||||
|
||||
#ifndef BOOST_LAMBDA_RET_HPP
|
||||
#define BOOST_LAMBDA_RET_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
// TODO:
|
||||
|
||||
// Add specializations for function references for ret, protect and unlambda
|
||||
// e.g void foo(); unlambda(foo); fails, as it would add a const qualifier
|
||||
// for a function type.
|
||||
// on the other hand unlambda(*foo) does work
|
||||
|
||||
|
||||
// -- ret -------------------------
|
||||
// the explicit return type template
|
||||
|
||||
// TODO: It'd be nice to make ret a nop for other than lambda functors
|
||||
// but causes an ambiguiyty with gcc (not with KCC), check what is the
|
||||
// right interpretation.
|
||||
|
||||
// // ret for others than lambda functors has no effect
|
||||
// template <class U, class T>
|
||||
// inline const T& ret(const T& t) { return t; }
|
||||
|
||||
|
||||
template<class RET, class Arg>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
explicit_return_type_action<RET>,
|
||||
tuple<lambda_functor<Arg> >
|
||||
>
|
||||
>
|
||||
ret(const lambda_functor<Arg>& a1)
|
||||
{
|
||||
return
|
||||
lambda_functor_base<
|
||||
explicit_return_type_action<RET>,
|
||||
tuple<lambda_functor<Arg> >
|
||||
>
|
||||
(tuple<lambda_functor<Arg> >(a1));
|
||||
}
|
||||
|
||||
// protect ------------------
|
||||
|
||||
// protecting others than lambda functors has no effect
|
||||
template <class T>
|
||||
inline const T& protect(const T& t) { return t; }
|
||||
|
||||
template<class Arg>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
protect_action,
|
||||
tuple<lambda_functor<Arg> >
|
||||
>
|
||||
>
|
||||
protect(const lambda_functor<Arg>& a1)
|
||||
{
|
||||
return
|
||||
lambda_functor_base<
|
||||
protect_action,
|
||||
tuple<lambda_functor<Arg> >
|
||||
>
|
||||
(tuple<lambda_functor<Arg> >(a1));
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
|
||||
// Hides the lambda functorness of a lambda functor.
|
||||
// After this, the functor is immune to argument substitution, etc.
|
||||
// This can be used, e.g. to make it safe to pass lambda functors as
|
||||
// arguments to functions, which might use them as target functions
|
||||
|
||||
// note, unlambda and protect are different things. Protect hides the lambda
|
||||
// functor for one application, unlambda for good.
|
||||
|
||||
template <class LambdaFunctor>
|
||||
class non_lambda_functor
|
||||
{
|
||||
LambdaFunctor lf;
|
||||
public:
|
||||
|
||||
// This functor defines the result_type typedef.
|
||||
// The result type must be deducible without knowing the arguments
|
||||
|
||||
template <class SigArgs> struct sig {
|
||||
typedef typename
|
||||
LambdaFunctor::inherited::
|
||||
template sig<typename SigArgs::tail_type>::type type;
|
||||
};
|
||||
|
||||
explicit non_lambda_functor(const LambdaFunctor& a) : lf(a) {}
|
||||
|
||||
typename LambdaFunctor::nullary_return_type
|
||||
operator()() const {
|
||||
return lf.template
|
||||
call<typename LambdaFunctor::nullary_return_type>
|
||||
(cnull_type(), cnull_type(), cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A>
|
||||
typename sig<tuple<const non_lambda_functor, A&> >::type
|
||||
operator()(A& a) const {
|
||||
return lf.template call<typename sig<tuple<const non_lambda_functor, A&> >::type >(a, cnull_type(), cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B>
|
||||
typename sig<tuple<const non_lambda_functor, A&, B&> >::type
|
||||
operator()(A& a, B& b) const {
|
||||
return lf.template call<typename sig<tuple<const non_lambda_functor, A&, B&> >::type >(a, b, cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B, class C>
|
||||
typename sig<tuple<const non_lambda_functor, A&, B&, C&> >::type
|
||||
operator()(A& a, B& b, C& c) const {
|
||||
return lf.template call<typename sig<tuple<const non_lambda_functor, A&, B&, C&> >::type>(a, b, c, cnull_type());
|
||||
}
|
||||
};
|
||||
|
||||
template <class Arg>
|
||||
inline const Arg& unlambda(const Arg& a) { return a; }
|
||||
|
||||
template <class Arg>
|
||||
inline const non_lambda_functor<lambda_functor<Arg> >
|
||||
unlambda(const lambda_functor<Arg>& a)
|
||||
{
|
||||
return non_lambda_functor<lambda_functor<Arg> >(a);
|
||||
}
|
||||
|
||||
// Due to a language restriction, lambda functors cannot be made to
|
||||
// accept non-const rvalue arguments. Usually iterators do not return
|
||||
// temporaries, but sometimes they do. That's why a workaround is provided.
|
||||
// Note, that this potentially breaks const correctness, so be careful!
|
||||
|
||||
// any lambda functor can be turned into a const_incorrect_lambda_functor
|
||||
// The operator() takes arguments as consts and then casts constness
|
||||
// away. So this breaks const correctness!!! but is a necessary workaround
|
||||
// in some cases due to language limitations.
|
||||
// Note, that this is not a lambda_functor anymore, so it can not be used
|
||||
// as a sub lambda expression.
|
||||
|
||||
template <class LambdaFunctor>
|
||||
struct const_incorrect_lambda_functor {
|
||||
LambdaFunctor lf;
|
||||
public:
|
||||
|
||||
explicit const_incorrect_lambda_functor(const LambdaFunctor& a) : lf(a) {}
|
||||
|
||||
template <class SigArgs> struct sig {
|
||||
typedef typename
|
||||
LambdaFunctor::inherited::template
|
||||
sig<typename SigArgs::tail_type>::type type;
|
||||
};
|
||||
|
||||
// The nullary case is not needed (no arguments, no parameter type problems)
|
||||
|
||||
template<class A>
|
||||
typename sig<tuple<const const_incorrect_lambda_functor, A&> >::type
|
||||
operator()(const A& a) const {
|
||||
return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&> >::type >(const_cast<A&>(a), cnull_type(), cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B>
|
||||
typename sig<tuple<const const_incorrect_lambda_functor, A&, B&> >::type
|
||||
operator()(const A& a, const B& b) const {
|
||||
return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&, B&> >::type >(const_cast<A&>(a), const_cast<B&>(b), cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B, class C>
|
||||
typename sig<tuple<const const_incorrect_lambda_functor, A&, B&, C&> >::type
|
||||
operator()(const A& a, const B& b, const C& c) const {
|
||||
return lf.template call<typename sig<tuple<const const_incorrect_lambda_functor, A&, B&, C&> >::type>(const_cast<A&>(a), const_cast<B&>(b), const_cast<C&>(c), cnull_type());
|
||||
}
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// any lambda functor can be turned into a const_parameter_lambda_functor
|
||||
// The operator() takes arguments as const.
|
||||
// This is useful if lambda functors are called with non-const rvalues.
|
||||
// Note, that this is not a lambda_functor anymore, so it can not be used
|
||||
// as a sub lambda expression.
|
||||
|
||||
template <class LambdaFunctor>
|
||||
struct const_parameter_lambda_functor {
|
||||
LambdaFunctor lf;
|
||||
public:
|
||||
|
||||
explicit const_parameter_lambda_functor(const LambdaFunctor& a) : lf(a) {}
|
||||
|
||||
template <class SigArgs> struct sig {
|
||||
typedef typename
|
||||
LambdaFunctor::inherited::template
|
||||
sig<typename SigArgs::tail_type>::type type;
|
||||
};
|
||||
|
||||
// The nullary case is not needed: no arguments, no constness problems.
|
||||
|
||||
template<class A>
|
||||
typename sig<tuple<const const_parameter_lambda_functor, const A&> >::type
|
||||
operator()(const A& a) const {
|
||||
return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&> >::type >(a, cnull_type(), cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B>
|
||||
typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&> >::type
|
||||
operator()(const A& a, const B& b) const {
|
||||
return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&> >::type >(a, b, cnull_type(), cnull_type());
|
||||
}
|
||||
|
||||
template<class A, class B, class C>
|
||||
typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&, const C&>
|
||||
>::type
|
||||
operator()(const A& a, const B& b, const C& c) const {
|
||||
return lf.template call<typename sig<tuple<const const_parameter_lambda_functor, const A&, const B&, const C&> >::type>(a, b, c, cnull_type());
|
||||
}
|
||||
};
|
||||
|
||||
template <class Arg>
|
||||
inline const const_incorrect_lambda_functor<lambda_functor<Arg> >
|
||||
break_const(const lambda_functor<Arg>& lf)
|
||||
{
|
||||
return const_incorrect_lambda_functor<lambda_functor<Arg> >(lf);
|
||||
}
|
||||
|
||||
|
||||
template <class Arg>
|
||||
inline const const_parameter_lambda_functor<lambda_functor<Arg> >
|
||||
const_parameters(const lambda_functor<Arg>& lf)
|
||||
{
|
||||
return const_parameter_lambda_functor<lambda_functor<Arg> >(lf);
|
||||
}
|
||||
|
||||
// make void ------------------------------------------------
|
||||
// make_void( x ) turns a lambda functor x with some return type y into
|
||||
// another lambda functor, which has a void return type
|
||||
// when called, the original return type is discarded
|
||||
|
||||
// we use this action. The action class will be called, which means that
|
||||
// the wrapped lambda functor is evaluated, but we just don't do anything
|
||||
// with the result.
|
||||
struct voidifier_action {
|
||||
template<class Ret, class A> static void apply(A&) {}
|
||||
};
|
||||
|
||||
template<class Args> struct return_type_N<voidifier_action, Args> {
|
||||
typedef void type;
|
||||
};
|
||||
|
||||
template<class Arg1>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
action<1, voidifier_action>,
|
||||
tuple<lambda_functor<Arg1> >
|
||||
>
|
||||
>
|
||||
make_void(const lambda_functor<Arg1>& a1) {
|
||||
return
|
||||
lambda_functor_base<
|
||||
action<1, voidifier_action>,
|
||||
tuple<lambda_functor<Arg1> >
|
||||
>
|
||||
(tuple<lambda_functor<Arg1> > (a1));
|
||||
}
|
||||
|
||||
// for non-lambda functors, make_void does nothing
|
||||
// (the argument gets evaluated immediately)
|
||||
|
||||
template<class Arg1>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<do_nothing_action, null_type>
|
||||
>
|
||||
make_void(const Arg1&) {
|
||||
return
|
||||
lambda_functor_base<do_nothing_action, null_type>();
|
||||
}
|
||||
|
||||
// std_functor -----------------------------------------------------
|
||||
|
||||
// The STL uses the result_type typedef as the convention to let binders know
|
||||
// the return type of a function object.
|
||||
// LL uses the sig template.
|
||||
// To let LL know that the function object has the result_type typedef
|
||||
// defined, it can be wrapped with the std_functor function.
|
||||
|
||||
|
||||
// Just inherit form the template parameter (the standard functor),
|
||||
// and provide a sig template. So we have a class which is still the
|
||||
// same functor + the sig template.
|
||||
|
||||
template<class T>
|
||||
struct result_type_to_sig : public T {
|
||||
template<class Args> struct sig { typedef typename T::result_type type; };
|
||||
result_type_to_sig(const T& t) : T(t) {}
|
||||
};
|
||||
|
||||
template<class F>
|
||||
inline result_type_to_sig<F> std_functor(const F& f) { return f; }
|
||||
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,269 +1,269 @@
|
||||
// return_type_traits.hpp -- Boost Lambda Library ---------------------------
|
||||
|
||||
// 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 www.boost.org
|
||||
|
||||
|
||||
#ifndef BOOST_LAMBDA_RETURN_TYPE_TRAITS_HPP
|
||||
#define BOOST_LAMBDA_RETURN_TYPE_TRAITS_HPP
|
||||
|
||||
#include "boost/mpl/has_xxx.hpp"
|
||||
|
||||
#include <cstddef> // needed for the ptrdiff_t
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
// Much of the type deduction code for standard arithmetic types
|
||||
// from Gary Powell
|
||||
|
||||
// different arities:
|
||||
template <class Act, class A1> struct return_type_1; // 1-ary actions
|
||||
template <class Act, class A1, class A2> struct return_type_2; // 2-ary
|
||||
template <class Act, class Args> struct return_type_N; // >3- ary
|
||||
|
||||
template <class Act, class A1> struct return_type_1_prot;
|
||||
template <class Act, class A1, class A2> struct return_type_2_prot; // 2-ary
|
||||
template <class Act, class A1> struct return_type_N_prot; // >3-ary
|
||||
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class> class return_type_deduction_failure {};
|
||||
|
||||
// In some cases return type deduction should fail (an invalid lambda
|
||||
// expression). Sometimes the lambda expression can be ok, the return type
|
||||
// just is not deducible (user defined operators). Then return type deduction
|
||||
// should never be entered at all, and the use of ret<> does this.
|
||||
// However, for nullary lambda functors, return type deduction is always
|
||||
// entered, and there seems to be no way around this.
|
||||
|
||||
// (the return type is part of the prototype of the non-template
|
||||
// operator()(). The prototype is instantiated, even though the body
|
||||
// is not.)
|
||||
|
||||
// So, in the case the return type deduction should fail, it should not
|
||||
// fail directly, but rather result in a valid but wrong return type,
|
||||
// causing a compile time error only if the function is really called.
|
||||
|
||||
|
||||
|
||||
} // end detail
|
||||
|
||||
|
||||
|
||||
// return_type_X_prot classes --------------------------------------------
|
||||
// These classes are the first layer that gets instantiated from the
|
||||
// lambda_functor_base sig templates. It will check whether
|
||||
// the action is protectable and one of arguments is "protected" or its
|
||||
// evaluation will otherwise result in another lambda functor.
|
||||
// If this is a case, the result type will be another lambda functor.
|
||||
|
||||
// The arguments are always non-reference types, except for comma action
|
||||
// where the right argument can be a reference too. This is because it
|
||||
// matters (in the builtin case) whether the argument is an lvalue or
|
||||
// rvalue: int i; i, 1 -> rvalue; 1, i -> lvalue
|
||||
|
||||
template <class Act, class A> struct return_type_1_prot {
|
||||
public:
|
||||
typedef typename
|
||||
detail::IF<
|
||||
is_protectable<Act>::value && is_lambda_functor<A>::value,
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
Act,
|
||||
tuple<typename detail::remove_reference_and_cv<A>::type>
|
||||
>
|
||||
>,
|
||||
typename return_type_1<Act, A>::type
|
||||
>::RET type;
|
||||
};
|
||||
|
||||
// take care of the unavoidable instantiation for nullary case
|
||||
template<class Act> struct return_type_1_prot<Act, null_type> {
|
||||
typedef null_type type;
|
||||
};
|
||||
|
||||
// Unary actions (result from unary operators)
|
||||
// do not have a default return type.
|
||||
template<class Act, class A> struct return_type_1 {
|
||||
typedef typename
|
||||
detail::return_type_deduction_failure<return_type_1> type;
|
||||
};
|
||||
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <class T>
|
||||
class protect_conversion {
|
||||
typedef typename boost::remove_reference<T>::type non_ref_T;
|
||||
public:
|
||||
|
||||
// add const to rvalues, so that all rvalues are stored as const in
|
||||
// the args tuple
|
||||
typedef typename detail::IF_type<
|
||||
boost::is_reference<T>::value && !boost::is_const<non_ref_T>::value,
|
||||
detail::identity_mapping<T>,
|
||||
const_copy_argument<non_ref_T> // handles funtion and array
|
||||
>::type type; // types correctly
|
||||
};
|
||||
|
||||
} // end detail
|
||||
|
||||
template <class Act, class A, class B> struct return_type_2_prot {
|
||||
|
||||
// experimental feature
|
||||
// We may have a lambda functor as a result type of a subexpression
|
||||
// (if protect) has been used.
|
||||
// Thus, if one of the parameter types is a lambda functor, the result
|
||||
// is a lambda functor as well.
|
||||
// We need to make a conservative choise here.
|
||||
// The resulting lambda functor stores all const reference arguments as
|
||||
// const copies. References to non-const are stored as such.
|
||||
// So if the source of the argument is a const open argument, a bound
|
||||
// argument stored as a const reference, or a function returning a
|
||||
// const reference, that information is lost. There is no way of
|
||||
// telling apart 'real const references' from just 'LL internal
|
||||
// const references' (or it would be really hard)
|
||||
|
||||
// The return type is a subclass of lambda_functor, which has a converting
|
||||
// copy constructor. It can copy any lambda functor, that has the same
|
||||
// action type and code, and a copy compatible argument tuple.
|
||||
|
||||
|
||||
typedef typename boost::remove_reference<A>::type non_ref_A;
|
||||
typedef typename boost::remove_reference<B>::type non_ref_B;
|
||||
|
||||
typedef typename
|
||||
detail::IF<
|
||||
is_protectable<Act>::value &&
|
||||
(is_lambda_functor<A>::value || is_lambda_functor<B>::value),
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
Act,
|
||||
tuple<typename detail::protect_conversion<A>::type,
|
||||
typename detail::protect_conversion<B>::type>
|
||||
>
|
||||
>,
|
||||
typename return_type_2<Act, non_ref_A, non_ref_B>::type
|
||||
>::RET type;
|
||||
};
|
||||
|
||||
// take care of the unavoidable instantiation for nullary case
|
||||
template<class Act> struct return_type_2_prot<Act, null_type, null_type> {
|
||||
typedef null_type type;
|
||||
};
|
||||
// take care of the unavoidable instantiation for nullary case
|
||||
template<class Act, class Other> struct return_type_2_prot<Act, Other, null_type> {
|
||||
typedef null_type type;
|
||||
};
|
||||
// take care of the unavoidable instantiation for nullary case
|
||||
template<class Act, class Other> struct return_type_2_prot<Act, null_type, Other> {
|
||||
typedef null_type type;
|
||||
};
|
||||
|
||||
// comma is a special case, as the user defined operator can return
|
||||
// an lvalue (reference) too, hence it must be handled at this level.
|
||||
template<class A, class B>
|
||||
struct return_type_2_comma
|
||||
{
|
||||
typedef typename boost::remove_reference<A>::type non_ref_A;
|
||||
typedef typename boost::remove_reference<B>::type non_ref_B;
|
||||
|
||||
typedef typename
|
||||
detail::IF<
|
||||
is_protectable<other_action<comma_action> >::value && // it is protectable
|
||||
(is_lambda_functor<A>::value || is_lambda_functor<B>::value),
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
other_action<comma_action>,
|
||||
tuple<typename detail::protect_conversion<A>::type,
|
||||
typename detail::protect_conversion<B>::type>
|
||||
>
|
||||
>,
|
||||
typename
|
||||
return_type_2<other_action<comma_action>, non_ref_A, non_ref_B>::type
|
||||
>::RET type1;
|
||||
|
||||
// if no user defined return_type_2 (or plain_return_type_2) specialization
|
||||
// matches, then return the righthand argument
|
||||
typedef typename
|
||||
detail::IF<
|
||||
boost::is_same<type1, detail::unspecified>::value,
|
||||
B,
|
||||
type1
|
||||
>::RET type;
|
||||
|
||||
};
|
||||
|
||||
|
||||
// currently there are no protectable actions with > 2 args
|
||||
|
||||
template<class Act, class Args> struct return_type_N_prot {
|
||||
typedef typename return_type_N<Act, Args>::type type;
|
||||
};
|
||||
|
||||
// take care of the unavoidable instantiation for nullary case
|
||||
template<class Act> struct return_type_N_prot<Act, null_type> {
|
||||
typedef null_type type;
|
||||
};
|
||||
|
||||
// handle different kind of actions ------------------------
|
||||
|
||||
// use the return type given in the bind invocation as bind<Ret>(...)
|
||||
template<int I, class Args, class Ret>
|
||||
struct return_type_N<function_action<I, Ret>, Args> {
|
||||
typedef Ret type;
|
||||
};
|
||||
|
||||
// ::result_type support
|
||||
|
||||
namespace detail
|
||||
{
|
||||
|
||||
BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
|
||||
|
||||
template<class F> struct get_result_type
|
||||
{
|
||||
typedef typename F::result_type type;
|
||||
};
|
||||
|
||||
template<class F, class A> struct get_sig
|
||||
{
|
||||
typedef typename function_adaptor<F>::template sig<A>::type type;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// Ret is detail::unspecified, so try to deduce return type
|
||||
template<int I, class Args>
|
||||
struct return_type_N<function_action<I, detail::unspecified>, Args > {
|
||||
|
||||
// in the case of function action, the first element in Args is
|
||||
// some type of function
|
||||
typedef typename Args::head_type Func;
|
||||
typedef typename detail::remove_reference_and_cv<Func>::type plain_Func;
|
||||
|
||||
public:
|
||||
// pass the function to function_adaptor, and get the return type from
|
||||
// that
|
||||
typedef typename detail::IF<
|
||||
detail::has_result_type<plain_Func>::value,
|
||||
detail::get_result_type<plain_Func>,
|
||||
detail::get_sig<plain_Func, Args>
|
||||
>::RET::type type;
|
||||
};
|
||||
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
// return_type_traits.hpp -- Boost Lambda Library ---------------------------
|
||||
|
||||
// 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 www.boost.org
|
||||
|
||||
|
||||
#ifndef BOOST_LAMBDA_RETURN_TYPE_TRAITS_HPP
|
||||
#define BOOST_LAMBDA_RETURN_TYPE_TRAITS_HPP
|
||||
|
||||
#include "boost/mpl/has_xxx.hpp"
|
||||
|
||||
#include <cstddef> // needed for the ptrdiff_t
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
// Much of the type deduction code for standard arithmetic types
|
||||
// from Gary Powell
|
||||
|
||||
// different arities:
|
||||
template <class Act, class A1> struct return_type_1; // 1-ary actions
|
||||
template <class Act, class A1, class A2> struct return_type_2; // 2-ary
|
||||
template <class Act, class Args> struct return_type_N; // >3- ary
|
||||
|
||||
template <class Act, class A1> struct return_type_1_prot;
|
||||
template <class Act, class A1, class A2> struct return_type_2_prot; // 2-ary
|
||||
template <class Act, class A1> struct return_type_N_prot; // >3-ary
|
||||
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class> class return_type_deduction_failure {};
|
||||
|
||||
// In some cases return type deduction should fail (an invalid lambda
|
||||
// expression). Sometimes the lambda expression can be ok, the return type
|
||||
// just is not deducible (user defined operators). Then return type deduction
|
||||
// should never be entered at all, and the use of ret<> does this.
|
||||
// However, for nullary lambda functors, return type deduction is always
|
||||
// entered, and there seems to be no way around this.
|
||||
|
||||
// (the return type is part of the prototype of the non-template
|
||||
// operator()(). The prototype is instantiated, even though the body
|
||||
// is not.)
|
||||
|
||||
// So, in the case the return type deduction should fail, it should not
|
||||
// fail directly, but rather result in a valid but wrong return type,
|
||||
// causing a compile time error only if the function is really called.
|
||||
|
||||
|
||||
|
||||
} // end detail
|
||||
|
||||
|
||||
|
||||
// return_type_X_prot classes --------------------------------------------
|
||||
// These classes are the first layer that gets instantiated from the
|
||||
// lambda_functor_base sig templates. It will check whether
|
||||
// the action is protectable and one of arguments is "protected" or its
|
||||
// evaluation will otherwise result in another lambda functor.
|
||||
// If this is a case, the result type will be another lambda functor.
|
||||
|
||||
// The arguments are always non-reference types, except for comma action
|
||||
// where the right argument can be a reference too. This is because it
|
||||
// matters (in the builtin case) whether the argument is an lvalue or
|
||||
// rvalue: int i; i, 1 -> rvalue; 1, i -> lvalue
|
||||
|
||||
template <class Act, class A> struct return_type_1_prot {
|
||||
public:
|
||||
typedef typename
|
||||
detail::IF<
|
||||
is_protectable<Act>::value && is_lambda_functor<A>::value,
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
Act,
|
||||
tuple<typename detail::remove_reference_and_cv<A>::type>
|
||||
>
|
||||
>,
|
||||
typename return_type_1<Act, A>::type
|
||||
>::RET type;
|
||||
};
|
||||
|
||||
// take care of the unavoidable instantiation for nullary case
|
||||
template<class Act> struct return_type_1_prot<Act, null_type> {
|
||||
typedef null_type type;
|
||||
};
|
||||
|
||||
// Unary actions (result from unary operators)
|
||||
// do not have a default return type.
|
||||
template<class Act, class A> struct return_type_1 {
|
||||
typedef typename
|
||||
detail::return_type_deduction_failure<return_type_1> type;
|
||||
};
|
||||
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <class T>
|
||||
class protect_conversion {
|
||||
typedef typename boost::remove_reference<T>::type non_ref_T;
|
||||
public:
|
||||
|
||||
// add const to rvalues, so that all rvalues are stored as const in
|
||||
// the args tuple
|
||||
typedef typename detail::IF_type<
|
||||
boost::is_reference<T>::value && !boost::is_const<non_ref_T>::value,
|
||||
detail::identity_mapping<T>,
|
||||
const_copy_argument<non_ref_T> // handles funtion and array
|
||||
>::type type; // types correctly
|
||||
};
|
||||
|
||||
} // end detail
|
||||
|
||||
template <class Act, class A, class B> struct return_type_2_prot {
|
||||
|
||||
// experimental feature
|
||||
// We may have a lambda functor as a result type of a subexpression
|
||||
// (if protect) has been used.
|
||||
// Thus, if one of the parameter types is a lambda functor, the result
|
||||
// is a lambda functor as well.
|
||||
// We need to make a conservative choise here.
|
||||
// The resulting lambda functor stores all const reference arguments as
|
||||
// const copies. References to non-const are stored as such.
|
||||
// So if the source of the argument is a const open argument, a bound
|
||||
// argument stored as a const reference, or a function returning a
|
||||
// const reference, that information is lost. There is no way of
|
||||
// telling apart 'real const references' from just 'LL internal
|
||||
// const references' (or it would be really hard)
|
||||
|
||||
// The return type is a subclass of lambda_functor, which has a converting
|
||||
// copy constructor. It can copy any lambda functor, that has the same
|
||||
// action type and code, and a copy compatible argument tuple.
|
||||
|
||||
|
||||
typedef typename boost::remove_reference<A>::type non_ref_A;
|
||||
typedef typename boost::remove_reference<B>::type non_ref_B;
|
||||
|
||||
typedef typename
|
||||
detail::IF<
|
||||
is_protectable<Act>::value &&
|
||||
(is_lambda_functor<A>::value || is_lambda_functor<B>::value),
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
Act,
|
||||
tuple<typename detail::protect_conversion<A>::type,
|
||||
typename detail::protect_conversion<B>::type>
|
||||
>
|
||||
>,
|
||||
typename return_type_2<Act, non_ref_A, non_ref_B>::type
|
||||
>::RET type;
|
||||
};
|
||||
|
||||
// take care of the unavoidable instantiation for nullary case
|
||||
template<class Act> struct return_type_2_prot<Act, null_type, null_type> {
|
||||
typedef null_type type;
|
||||
};
|
||||
// take care of the unavoidable instantiation for nullary case
|
||||
template<class Act, class Other> struct return_type_2_prot<Act, Other, null_type> {
|
||||
typedef null_type type;
|
||||
};
|
||||
// take care of the unavoidable instantiation for nullary case
|
||||
template<class Act, class Other> struct return_type_2_prot<Act, null_type, Other> {
|
||||
typedef null_type type;
|
||||
};
|
||||
|
||||
// comma is a special case, as the user defined operator can return
|
||||
// an lvalue (reference) too, hence it must be handled at this level.
|
||||
template<class A, class B>
|
||||
struct return_type_2_comma
|
||||
{
|
||||
typedef typename boost::remove_reference<A>::type non_ref_A;
|
||||
typedef typename boost::remove_reference<B>::type non_ref_B;
|
||||
|
||||
typedef typename
|
||||
detail::IF<
|
||||
is_protectable<other_action<comma_action> >::value && // it is protectable
|
||||
(is_lambda_functor<A>::value || is_lambda_functor<B>::value),
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
other_action<comma_action>,
|
||||
tuple<typename detail::protect_conversion<A>::type,
|
||||
typename detail::protect_conversion<B>::type>
|
||||
>
|
||||
>,
|
||||
typename
|
||||
return_type_2<other_action<comma_action>, non_ref_A, non_ref_B>::type
|
||||
>::RET type1;
|
||||
|
||||
// if no user defined return_type_2 (or plain_return_type_2) specialization
|
||||
// matches, then return the righthand argument
|
||||
typedef typename
|
||||
detail::IF<
|
||||
boost::is_same<type1, detail::unspecified>::value,
|
||||
B,
|
||||
type1
|
||||
>::RET type;
|
||||
|
||||
};
|
||||
|
||||
|
||||
// currently there are no protectable actions with > 2 args
|
||||
|
||||
template<class Act, class Args> struct return_type_N_prot {
|
||||
typedef typename return_type_N<Act, Args>::type type;
|
||||
};
|
||||
|
||||
// take care of the unavoidable instantiation for nullary case
|
||||
template<class Act> struct return_type_N_prot<Act, null_type> {
|
||||
typedef null_type type;
|
||||
};
|
||||
|
||||
// handle different kind of actions ------------------------
|
||||
|
||||
// use the return type given in the bind invocation as bind<Ret>(...)
|
||||
template<int I, class Args, class Ret>
|
||||
struct return_type_N<function_action<I, Ret>, Args> {
|
||||
typedef Ret type;
|
||||
};
|
||||
|
||||
// ::result_type support
|
||||
|
||||
namespace detail
|
||||
{
|
||||
|
||||
BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
|
||||
|
||||
template<class F> struct get_result_type
|
||||
{
|
||||
typedef typename F::result_type type;
|
||||
};
|
||||
|
||||
template<class F, class A> struct get_sig
|
||||
{
|
||||
typedef typename function_adaptor<F>::template sig<A>::type type;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
// Ret is detail::unspecified, so try to deduce return type
|
||||
template<int I, class Args>
|
||||
struct return_type_N<function_action<I, detail::unspecified>, Args > {
|
||||
|
||||
// in the case of function action, the first element in Args is
|
||||
// some type of function
|
||||
typedef typename Args::head_type Func;
|
||||
typedef typename detail::remove_reference_and_cv<Func>::type plain_Func;
|
||||
|
||||
public:
|
||||
// pass the function to function_adaptor, and get the return type from
|
||||
// that
|
||||
typedef typename detail::IF<
|
||||
detail::has_result_type<plain_Func>::value,
|
||||
detail::get_result_type<plain_Func>,
|
||||
detail::get_sig<plain_Func, Args>
|
||||
>::RET::type type;
|
||||
};
|
||||
|
||||
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
@@ -1,74 +1,74 @@
|
||||
// -- select_functions.hpp -- Boost Lambda Library --------------------------
|
||||
|
||||
// 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
|
||||
|
||||
|
||||
#ifndef BOOST_LAMBDA_SELECT_FUNCTIONS_HPP
|
||||
#define BOOST_LAMBDA_SELECT_FUNCTIONS_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
namespace detail {
|
||||
|
||||
|
||||
// select functions -------------------------------
|
||||
template<class Any, CALL_TEMPLATE_ARGS>
|
||||
inline Any& select(Any& any, CALL_FORMAL_ARGS) { CALL_USE_ARGS; return any; }
|
||||
|
||||
|
||||
template<class Arg, CALL_TEMPLATE_ARGS>
|
||||
inline typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
|
||||
select ( const lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) {
|
||||
return op.template call<
|
||||
typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
|
||||
>(CALL_ACTUAL_ARGS);
|
||||
}
|
||||
template<class Arg, CALL_TEMPLATE_ARGS>
|
||||
inline typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
|
||||
select ( lambda_functor<Arg>& op, CALL_FORMAL_ARGS) {
|
||||
return op.template call<
|
||||
typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
|
||||
>(CALL_ACTUAL_ARGS);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// select functions where the return type is explicitly given
|
||||
// Note: on many functions, this return type is just discarded.
|
||||
// The select functions are inside a class template, and the return type
|
||||
// is a class template argument.
|
||||
// The first implementation used function templates with an explicitly
|
||||
// specified template parameter.
|
||||
// However, this resulted in ambiguous calls (at least with gcc 2.95.2
|
||||
// and edg 2.44). Not sure whether the compilers were right or wrong.
|
||||
|
||||
template<class RET> struct r_select {
|
||||
|
||||
// Any == RET
|
||||
template<class Any, CALL_TEMPLATE_ARGS>
|
||||
static
|
||||
inline RET go (Any& any, CALL_FORMAL_ARGS) { CALL_USE_ARGS; return any; }
|
||||
|
||||
|
||||
template<class Arg, CALL_TEMPLATE_ARGS>
|
||||
static
|
||||
inline RET go (const lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) {
|
||||
return op.template call<RET>(CALL_ACTUAL_ARGS);
|
||||
}
|
||||
template<class Arg, CALL_TEMPLATE_ARGS>
|
||||
static
|
||||
inline RET go (lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) {
|
||||
return op.template call<RET>(CALL_ACTUAL_ARGS);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
// -- select_functions.hpp -- Boost Lambda Library --------------------------
|
||||
|
||||
// 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
|
||||
|
||||
|
||||
#ifndef BOOST_LAMBDA_SELECT_FUNCTIONS_HPP
|
||||
#define BOOST_LAMBDA_SELECT_FUNCTIONS_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
namespace detail {
|
||||
|
||||
|
||||
// select functions -------------------------------
|
||||
template<class Any, CALL_TEMPLATE_ARGS>
|
||||
inline Any& select(Any& any, CALL_FORMAL_ARGS) { CALL_USE_ARGS; return any; }
|
||||
|
||||
|
||||
template<class Arg, CALL_TEMPLATE_ARGS>
|
||||
inline typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
|
||||
select ( const lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) {
|
||||
return op.template call<
|
||||
typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
|
||||
>(CALL_ACTUAL_ARGS);
|
||||
}
|
||||
template<class Arg, CALL_TEMPLATE_ARGS>
|
||||
inline typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
|
||||
select ( lambda_functor<Arg>& op, CALL_FORMAL_ARGS) {
|
||||
return op.template call<
|
||||
typename Arg::template sig<tuple<CALL_REFERENCE_TYPES> >::type
|
||||
>(CALL_ACTUAL_ARGS);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// select functions where the return type is explicitly given
|
||||
// Note: on many functions, this return type is just discarded.
|
||||
// The select functions are inside a class template, and the return type
|
||||
// is a class template argument.
|
||||
// The first implementation used function templates with an explicitly
|
||||
// specified template parameter.
|
||||
// However, this resulted in ambiguous calls (at least with gcc 2.95.2
|
||||
// and edg 2.44). Not sure whether the compilers were right or wrong.
|
||||
|
||||
template<class RET> struct r_select {
|
||||
|
||||
// Any == RET
|
||||
template<class Any, CALL_TEMPLATE_ARGS>
|
||||
static
|
||||
inline RET go (Any& any, CALL_FORMAL_ARGS) { CALL_USE_ARGS; return any; }
|
||||
|
||||
|
||||
template<class Arg, CALL_TEMPLATE_ARGS>
|
||||
static
|
||||
inline RET go (const lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) {
|
||||
return op.template call<RET>(CALL_ACTUAL_ARGS);
|
||||
}
|
||||
template<class Arg, CALL_TEMPLATE_ARGS>
|
||||
static
|
||||
inline RET go (lambda_functor<Arg>& op, CALL_FORMAL_ARGS ) {
|
||||
return op.template call<RET>(CALL_ACTUAL_ARGS);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace lambda
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
@@ -1,27 +1,27 @@
|
||||
// Boost Lambda Library suppress_unused.hpp -----------------------------
|
||||
//
|
||||
// Copyright (C) 2009 Steven Watanabe
|
||||
//
|
||||
// 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 www.boost.org
|
||||
|
||||
// ------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_SUPPRESS_UNUSED_HPP
|
||||
#define BOOST_LAMBDA_SUPPRESS_UNUSED_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
namespace detail {
|
||||
|
||||
template<class T>
|
||||
inline void suppress_unused_variable_warnings(const T&) {}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
// Boost Lambda Library suppress_unused.hpp -----------------------------
|
||||
//
|
||||
// Copyright (C) 2009 Steven Watanabe
|
||||
//
|
||||
// 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 www.boost.org
|
||||
|
||||
// ------------------------------------------------------------
|
||||
|
||||
#ifndef BOOST_LAMBDA_SUPPRESS_UNUSED_HPP
|
||||
#define BOOST_LAMBDA_SUPPRESS_UNUSED_HPP
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
namespace detail {
|
||||
|
||||
template<class T>
|
||||
inline void suppress_unused_variable_warnings(const T&) {}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
+1741
-1741
File diff suppressed because it is too large.
Load diff
+462
-462
@@ -1,462 +1,462 @@
|
||||
// Boost Lambda Library -- if.hpp ------------------------------------------
|
||||
|
||||
// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
|
||||
// Copyright (C) 2001-2002 Joel de Guzman
|
||||
//
|
||||
// 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 www.boost.org
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
#if !defined(BOOST_LAMBDA_IF_HPP)
|
||||
#define BOOST_LAMBDA_IF_HPP
|
||||
|
||||
#include "boost/lambda/core.hpp"
|
||||
|
||||
// Arithmetic type promotion needed for if_then_else_return
|
||||
#include "boost/lambda/detail/operator_actions.hpp"
|
||||
#include "boost/lambda/detail/operator_return_type_traits.hpp"
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
// -- if control construct actions ----------------------
|
||||
|
||||
class ifthen_action {};
|
||||
class ifthenelse_action {};
|
||||
class ifthenelsereturn_action {};
|
||||
|
||||
// Specialization for if_then.
|
||||
template<class Args>
|
||||
class
|
||||
lambda_functor_base<ifthen_action, Args> {
|
||||
public:
|
||||
Args args;
|
||||
template <class T> struct sig { typedef void type; };
|
||||
public:
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {}
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const {
|
||||
if (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS))
|
||||
detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
|
||||
}
|
||||
};
|
||||
|
||||
// If Then
|
||||
template <class Arg1, class Arg2>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
ifthen_action,
|
||||
tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
|
||||
>
|
||||
>
|
||||
if_then(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2) {
|
||||
return
|
||||
lambda_functor_base<
|
||||
ifthen_action,
|
||||
tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
|
||||
>
|
||||
( tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2) );
|
||||
}
|
||||
|
||||
|
||||
// Specialization for if_then_else.
|
||||
template<class Args>
|
||||
class
|
||||
lambda_functor_base<ifthenelse_action, Args> {
|
||||
public:
|
||||
Args args;
|
||||
template <class T> struct sig { typedef void type; };
|
||||
public:
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {}
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const {
|
||||
if (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS))
|
||||
detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
|
||||
else
|
||||
detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
// If then else
|
||||
|
||||
template <class Arg1, class Arg2, class Arg3>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
ifthenelse_action,
|
||||
tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> >
|
||||
>
|
||||
>
|
||||
if_then_else(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2,
|
||||
const lambda_functor<Arg3>& a3) {
|
||||
return
|
||||
lambda_functor_base<
|
||||
ifthenelse_action,
|
||||
tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> >
|
||||
>
|
||||
(tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> >
|
||||
(a1, a2, a3) );
|
||||
}
|
||||
|
||||
// Our version of operator?:()
|
||||
|
||||
template <class Arg1, class Arg2, class Arg3>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
other_action<ifthenelsereturn_action>,
|
||||
tuple<lambda_functor<Arg1>,
|
||||
typename const_copy_argument<Arg2>::type,
|
||||
typename const_copy_argument<Arg3>::type>
|
||||
>
|
||||
>
|
||||
if_then_else_return(const lambda_functor<Arg1>& a1,
|
||||
const Arg2 & a2,
|
||||
const Arg3 & a3) {
|
||||
return
|
||||
lambda_functor_base<
|
||||
other_action<ifthenelsereturn_action>,
|
||||
tuple<lambda_functor<Arg1>,
|
||||
typename const_copy_argument<Arg2>::type,
|
||||
typename const_copy_argument<Arg3>::type>
|
||||
> ( tuple<lambda_functor<Arg1>,
|
||||
typename const_copy_argument<Arg2>::type,
|
||||
typename const_copy_argument<Arg3>::type> (a1, a2, a3) );
|
||||
}
|
||||
|
||||
namespace detail {
|
||||
|
||||
// return type specialization for conditional expression begins -----------
|
||||
// start reading below and move upwards
|
||||
|
||||
// PHASE 6:1
|
||||
// check if A is conbertible to B and B to A
|
||||
template<int Phase, bool AtoB, bool BtoA, bool SameType, class A, class B>
|
||||
struct return_type_2_ifthenelsereturn;
|
||||
|
||||
// if A can be converted to B and vice versa -> ambiguous
|
||||
template<int Phase, class A, class B>
|
||||
struct return_type_2_ifthenelsereturn<Phase, true, true, false, A, B> {
|
||||
typedef
|
||||
detail::return_type_deduction_failure<return_type_2_ifthenelsereturn> type;
|
||||
// ambiguous type in conditional expression
|
||||
};
|
||||
// if A can be converted to B and vice versa and are of same type
|
||||
template<int Phase, class A, class B>
|
||||
struct return_type_2_ifthenelsereturn<Phase, true, true, true, A, B> {
|
||||
typedef A type;
|
||||
};
|
||||
|
||||
|
||||
// A can be converted to B
|
||||
template<int Phase, class A, class B>
|
||||
struct return_type_2_ifthenelsereturn<Phase, true, false, false, A, B> {
|
||||
typedef B type;
|
||||
};
|
||||
|
||||
// B can be converted to A
|
||||
template<int Phase, class A, class B>
|
||||
struct return_type_2_ifthenelsereturn<Phase, false, true, false, A, B> {
|
||||
typedef A type;
|
||||
};
|
||||
|
||||
// neither can be converted. Then we drop the potential references, and
|
||||
// try again
|
||||
template<class A, class B>
|
||||
struct return_type_2_ifthenelsereturn<1, false, false, false, A, B> {
|
||||
// it is safe to add const, since the result will be an rvalue and thus
|
||||
// const anyway. The const are needed eg. if the types
|
||||
// are 'const int*' and 'void *'. The remaining type should be 'const void*'
|
||||
typedef const typename boost::remove_reference<A>::type plainA;
|
||||
typedef const typename boost::remove_reference<B>::type plainB;
|
||||
// TODO: Add support for volatile ?
|
||||
|
||||
typedef typename
|
||||
return_type_2_ifthenelsereturn<
|
||||
2,
|
||||
boost::is_convertible<plainA,plainB>::value,
|
||||
boost::is_convertible<plainB,plainA>::value,
|
||||
boost::is_same<plainA,plainB>::value,
|
||||
plainA,
|
||||
plainB>::type type;
|
||||
};
|
||||
|
||||
// PHASE 6:2
|
||||
template<class A, class B>
|
||||
struct return_type_2_ifthenelsereturn<2, false, false, false, A, B> {
|
||||
typedef
|
||||
detail::return_type_deduction_failure<return_type_2_ifthenelsereturn> type;
|
||||
// types_do_not_match_in_conditional_expression
|
||||
};
|
||||
|
||||
|
||||
|
||||
// PHASE 5: now we know that types are not arithmetic.
|
||||
template<class A, class B>
|
||||
struct non_numeric_types {
|
||||
typedef typename
|
||||
return_type_2_ifthenelsereturn<
|
||||
1, // phase 1
|
||||
is_convertible<A,B>::value,
|
||||
is_convertible<B,A>::value,
|
||||
is_same<A,B>::value,
|
||||
A,
|
||||
B>::type type;
|
||||
};
|
||||
|
||||
// PHASE 4 :
|
||||
// the base case covers arithmetic types with differing promote codes
|
||||
// use the type deduction of arithmetic_actions
|
||||
template<int CodeA, int CodeB, class A, class B>
|
||||
struct arithmetic_or_not {
|
||||
typedef typename
|
||||
return_type_2<arithmetic_action<plus_action>, A, B>::type type;
|
||||
// plus_action is just a random pick, has to be a concrete instance
|
||||
};
|
||||
|
||||
// this case covers the case of artihmetic types with the same promote codes.
|
||||
// non numeric deduction is used since e.g. integral promotion is not
|
||||
// performed with operator ?:
|
||||
template<int CodeA, class A, class B>
|
||||
struct arithmetic_or_not<CodeA, CodeA, A, B> {
|
||||
typedef typename non_numeric_types<A, B>::type type;
|
||||
};
|
||||
|
||||
// if either A or B has promote code -1 it is not an arithmetic type
|
||||
template<class A, class B>
|
||||
struct arithmetic_or_not <-1, -1, A, B> {
|
||||
typedef typename non_numeric_types<A, B>::type type;
|
||||
};
|
||||
template<int CodeB, class A, class B>
|
||||
struct arithmetic_or_not <-1, CodeB, A, B> {
|
||||
typedef typename non_numeric_types<A, B>::type type;
|
||||
};
|
||||
template<int CodeA, class A, class B>
|
||||
struct arithmetic_or_not <CodeA, -1, A, B> {
|
||||
typedef typename non_numeric_types<A, B>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
// PHASE 3 : Are the types same?
|
||||
// No, check if they are arithmetic or not
|
||||
template <class A, class B>
|
||||
struct same_or_not {
|
||||
typedef typename detail::remove_reference_and_cv<A>::type plainA;
|
||||
typedef typename detail::remove_reference_and_cv<B>::type plainB;
|
||||
|
||||
typedef typename
|
||||
arithmetic_or_not<
|
||||
detail::promote_code<plainA>::value,
|
||||
detail::promote_code<plainB>::value,
|
||||
A,
|
||||
B>::type type;
|
||||
};
|
||||
// Yes, clear.
|
||||
template <class A> struct same_or_not<A, A> {
|
||||
typedef A type;
|
||||
};
|
||||
|
||||
} // detail
|
||||
|
||||
// PHASE 2 : Perform first the potential array_to_pointer conversion
|
||||
template<class A, class B>
|
||||
struct return_type_2<other_action<ifthenelsereturn_action>, A, B> {
|
||||
|
||||
typedef typename detail::array_to_pointer<A>::type A1;
|
||||
typedef typename detail::array_to_pointer<B>::type B1;
|
||||
|
||||
typedef typename
|
||||
boost::add_const<typename detail::same_or_not<A1, B1>::type>::type type;
|
||||
};
|
||||
|
||||
// PHASE 1 : Deduction is based on the second and third operand
|
||||
|
||||
|
||||
// return type specialization for conditional expression ends -----------
|
||||
|
||||
|
||||
// Specialization of lambda_functor_base for if_then_else_return.
|
||||
template<class Args>
|
||||
class
|
||||
lambda_functor_base<other_action<ifthenelsereturn_action>, Args> {
|
||||
public:
|
||||
Args args;
|
||||
|
||||
template <class SigArgs> struct sig {
|
||||
private:
|
||||
typedef typename detail::nth_return_type_sig<1, Args, SigArgs>::type ret1;
|
||||
typedef typename detail::nth_return_type_sig<2, Args, SigArgs>::type ret2;
|
||||
public:
|
||||
typedef typename return_type_2<
|
||||
other_action<ifthenelsereturn_action>, ret1, ret2
|
||||
>::type type;
|
||||
};
|
||||
|
||||
public:
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {}
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const {
|
||||
return (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)) ?
|
||||
detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS)
|
||||
:
|
||||
detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS);
|
||||
}
|
||||
};
|
||||
|
||||
// The code below is from Joel de Guzman, some name changes etc.
|
||||
// has been made.
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// if_then_else_composite
|
||||
//
|
||||
// This composite has two (2) forms:
|
||||
//
|
||||
// if_(condition)
|
||||
// [
|
||||
// statement
|
||||
// ]
|
||||
//
|
||||
// and
|
||||
//
|
||||
// if_(condition)
|
||||
// [
|
||||
// true_statement
|
||||
// ]
|
||||
// .else_
|
||||
// [
|
||||
// false_statement
|
||||
// ]
|
||||
//
|
||||
// where condition is an lambda_functor that evaluates to bool. If condition
|
||||
// is true, the true_statement (again an lambda_functor) is executed
|
||||
// otherwise, the false_statement (another lambda_functor) is executed. The
|
||||
// result type of this is void. Note the trailing underscore after
|
||||
// if_ and the leading dot and the trailing underscore before
|
||||
// and after .else_.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
template <typename CondT, typename ThenT, typename ElseT>
|
||||
struct if_then_else_composite {
|
||||
|
||||
typedef if_then_else_composite<CondT, ThenT, ElseT> self_t;
|
||||
|
||||
template <class SigArgs>
|
||||
struct sig { typedef void type; };
|
||||
|
||||
if_then_else_composite(
|
||||
CondT const& cond_,
|
||||
ThenT const& then_,
|
||||
ElseT const& else__)
|
||||
: cond(cond_), then(then_), else_(else__) {}
|
||||
|
||||
template <class Ret, CALL_TEMPLATE_ARGS>
|
||||
Ret call(CALL_FORMAL_ARGS) const
|
||||
{
|
||||
if (cond.internal_call(CALL_ACTUAL_ARGS))
|
||||
then.internal_call(CALL_ACTUAL_ARGS);
|
||||
else
|
||||
else_.internal_call(CALL_ACTUAL_ARGS);
|
||||
}
|
||||
|
||||
CondT cond; ThenT then; ElseT else_; // lambda_functors
|
||||
};
|
||||
|
||||
//////////////////////////////////
|
||||
template <typename CondT, typename ThenT>
|
||||
struct else_gen {
|
||||
|
||||
else_gen(CondT const& cond_, ThenT const& then_)
|
||||
: cond(cond_), then(then_) {}
|
||||
|
||||
template <typename ElseT>
|
||||
lambda_functor<if_then_else_composite<CondT, ThenT,
|
||||
typename as_lambda_functor<ElseT>::type> >
|
||||
operator[](ElseT const& else_)
|
||||
{
|
||||
typedef if_then_else_composite<CondT, ThenT,
|
||||
typename as_lambda_functor<ElseT>::type>
|
||||
result;
|
||||
|
||||
return result(cond, then, to_lambda_functor(else_));
|
||||
}
|
||||
|
||||
CondT cond; ThenT then;
|
||||
};
|
||||
|
||||
//////////////////////////////////
|
||||
template <typename CondT, typename ThenT>
|
||||
struct if_then_composite {
|
||||
|
||||
template <class SigArgs>
|
||||
struct sig { typedef void type; };
|
||||
|
||||
if_then_composite(CondT const& cond_, ThenT const& then_)
|
||||
: cond(cond_), then(then_), else_(cond, then) {}
|
||||
|
||||
template <class Ret, CALL_TEMPLATE_ARGS>
|
||||
Ret call(CALL_FORMAL_ARGS) const
|
||||
{
|
||||
if (cond.internal_call(CALL_ACTUAL_ARGS))
|
||||
then.internal_call(CALL_ACTUAL_ARGS);
|
||||
}
|
||||
|
||||
CondT cond; ThenT then; // lambda_functors
|
||||
else_gen<CondT, ThenT> else_;
|
||||
};
|
||||
|
||||
//////////////////////////////////
|
||||
template <typename CondT>
|
||||
struct if_gen {
|
||||
|
||||
if_gen(CondT const& cond_)
|
||||
: cond(cond_) {}
|
||||
|
||||
template <typename ThenT>
|
||||
lambda_functor<if_then_composite<
|
||||
typename as_lambda_functor<CondT>::type,
|
||||
typename as_lambda_functor<ThenT>::type> >
|
||||
operator[](ThenT const& then) const
|
||||
{
|
||||
typedef if_then_composite<
|
||||
typename as_lambda_functor<CondT>::type,
|
||||
typename as_lambda_functor<ThenT>::type>
|
||||
result;
|
||||
|
||||
return result(
|
||||
to_lambda_functor(cond),
|
||||
to_lambda_functor(then));
|
||||
}
|
||||
|
||||
CondT cond;
|
||||
};
|
||||
|
||||
//////////////////////////////////
|
||||
template <typename CondT>
|
||||
inline if_gen<CondT>
|
||||
if_(CondT const& cond)
|
||||
{
|
||||
return if_gen<CondT>(cond);
|
||||
}
|
||||
|
||||
|
||||
|
||||
} // lambda
|
||||
} // boost
|
||||
|
||||
#endif // BOOST_LAMBDA_IF_HPP
|
||||
|
||||
|
||||
// Boost Lambda Library -- if.hpp ------------------------------------------
|
||||
|
||||
// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
|
||||
// Copyright (C) 2001-2002 Joel de Guzman
|
||||
//
|
||||
// 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 www.boost.org
|
||||
|
||||
// --------------------------------------------------------------------------
|
||||
|
||||
#if !defined(BOOST_LAMBDA_IF_HPP)
|
||||
#define BOOST_LAMBDA_IF_HPP
|
||||
|
||||
#include "boost/lambda/core.hpp"
|
||||
|
||||
// Arithmetic type promotion needed for if_then_else_return
|
||||
#include "boost/lambda/detail/operator_actions.hpp"
|
||||
#include "boost/lambda/detail/operator_return_type_traits.hpp"
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
// -- if control construct actions ----------------------
|
||||
|
||||
class ifthen_action {};
|
||||
class ifthenelse_action {};
|
||||
class ifthenelsereturn_action {};
|
||||
|
||||
// Specialization for if_then.
|
||||
template<class Args>
|
||||
class
|
||||
lambda_functor_base<ifthen_action, Args> {
|
||||
public:
|
||||
Args args;
|
||||
template <class T> struct sig { typedef void type; };
|
||||
public:
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {}
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const {
|
||||
if (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS))
|
||||
detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
|
||||
}
|
||||
};
|
||||
|
||||
// If Then
|
||||
template <class Arg1, class Arg2>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
ifthen_action,
|
||||
tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
|
||||
>
|
||||
>
|
||||
if_then(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2) {
|
||||
return
|
||||
lambda_functor_base<
|
||||
ifthen_action,
|
||||
tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >
|
||||
>
|
||||
( tuple<lambda_functor<Arg1>, lambda_functor<Arg2> >(a1, a2) );
|
||||
}
|
||||
|
||||
|
||||
// Specialization for if_then_else.
|
||||
template<class Args>
|
||||
class
|
||||
lambda_functor_base<ifthenelse_action, Args> {
|
||||
public:
|
||||
Args args;
|
||||
template <class T> struct sig { typedef void type; };
|
||||
public:
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {}
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const {
|
||||
if (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS))
|
||||
detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS);
|
||||
else
|
||||
detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
// If then else
|
||||
|
||||
template <class Arg1, class Arg2, class Arg3>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
ifthenelse_action,
|
||||
tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> >
|
||||
>
|
||||
>
|
||||
if_then_else(const lambda_functor<Arg1>& a1, const lambda_functor<Arg2>& a2,
|
||||
const lambda_functor<Arg3>& a3) {
|
||||
return
|
||||
lambda_functor_base<
|
||||
ifthenelse_action,
|
||||
tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> >
|
||||
>
|
||||
(tuple<lambda_functor<Arg1>, lambda_functor<Arg2>, lambda_functor<Arg3> >
|
||||
(a1, a2, a3) );
|
||||
}
|
||||
|
||||
// Our version of operator?:()
|
||||
|
||||
template <class Arg1, class Arg2, class Arg3>
|
||||
inline const
|
||||
lambda_functor<
|
||||
lambda_functor_base<
|
||||
other_action<ifthenelsereturn_action>,
|
||||
tuple<lambda_functor<Arg1>,
|
||||
typename const_copy_argument<Arg2>::type,
|
||||
typename const_copy_argument<Arg3>::type>
|
||||
>
|
||||
>
|
||||
if_then_else_return(const lambda_functor<Arg1>& a1,
|
||||
const Arg2 & a2,
|
||||
const Arg3 & a3) {
|
||||
return
|
||||
lambda_functor_base<
|
||||
other_action<ifthenelsereturn_action>,
|
||||
tuple<lambda_functor<Arg1>,
|
||||
typename const_copy_argument<Arg2>::type,
|
||||
typename const_copy_argument<Arg3>::type>
|
||||
> ( tuple<lambda_functor<Arg1>,
|
||||
typename const_copy_argument<Arg2>::type,
|
||||
typename const_copy_argument<Arg3>::type> (a1, a2, a3) );
|
||||
}
|
||||
|
||||
namespace detail {
|
||||
|
||||
// return type specialization for conditional expression begins -----------
|
||||
// start reading below and move upwards
|
||||
|
||||
// PHASE 6:1
|
||||
// check if A is conbertible to B and B to A
|
||||
template<int Phase, bool AtoB, bool BtoA, bool SameType, class A, class B>
|
||||
struct return_type_2_ifthenelsereturn;
|
||||
|
||||
// if A can be converted to B and vice versa -> ambiguous
|
||||
template<int Phase, class A, class B>
|
||||
struct return_type_2_ifthenelsereturn<Phase, true, true, false, A, B> {
|
||||
typedef
|
||||
detail::return_type_deduction_failure<return_type_2_ifthenelsereturn> type;
|
||||
// ambiguous type in conditional expression
|
||||
};
|
||||
// if A can be converted to B and vice versa and are of same type
|
||||
template<int Phase, class A, class B>
|
||||
struct return_type_2_ifthenelsereturn<Phase, true, true, true, A, B> {
|
||||
typedef A type;
|
||||
};
|
||||
|
||||
|
||||
// A can be converted to B
|
||||
template<int Phase, class A, class B>
|
||||
struct return_type_2_ifthenelsereturn<Phase, true, false, false, A, B> {
|
||||
typedef B type;
|
||||
};
|
||||
|
||||
// B can be converted to A
|
||||
template<int Phase, class A, class B>
|
||||
struct return_type_2_ifthenelsereturn<Phase, false, true, false, A, B> {
|
||||
typedef A type;
|
||||
};
|
||||
|
||||
// neither can be converted. Then we drop the potential references, and
|
||||
// try again
|
||||
template<class A, class B>
|
||||
struct return_type_2_ifthenelsereturn<1, false, false, false, A, B> {
|
||||
// it is safe to add const, since the result will be an rvalue and thus
|
||||
// const anyway. The const are needed eg. if the types
|
||||
// are 'const int*' and 'void *'. The remaining type should be 'const void*'
|
||||
typedef const typename boost::remove_reference<A>::type plainA;
|
||||
typedef const typename boost::remove_reference<B>::type plainB;
|
||||
// TODO: Add support for volatile ?
|
||||
|
||||
typedef typename
|
||||
return_type_2_ifthenelsereturn<
|
||||
2,
|
||||
boost::is_convertible<plainA,plainB>::value,
|
||||
boost::is_convertible<plainB,plainA>::value,
|
||||
boost::is_same<plainA,plainB>::value,
|
||||
plainA,
|
||||
plainB>::type type;
|
||||
};
|
||||
|
||||
// PHASE 6:2
|
||||
template<class A, class B>
|
||||
struct return_type_2_ifthenelsereturn<2, false, false, false, A, B> {
|
||||
typedef
|
||||
detail::return_type_deduction_failure<return_type_2_ifthenelsereturn> type;
|
||||
// types_do_not_match_in_conditional_expression
|
||||
};
|
||||
|
||||
|
||||
|
||||
// PHASE 5: now we know that types are not arithmetic.
|
||||
template<class A, class B>
|
||||
struct non_numeric_types {
|
||||
typedef typename
|
||||
return_type_2_ifthenelsereturn<
|
||||
1, // phase 1
|
||||
is_convertible<A,B>::value,
|
||||
is_convertible<B,A>::value,
|
||||
is_same<A,B>::value,
|
||||
A,
|
||||
B>::type type;
|
||||
};
|
||||
|
||||
// PHASE 4 :
|
||||
// the base case covers arithmetic types with differing promote codes
|
||||
// use the type deduction of arithmetic_actions
|
||||
template<int CodeA, int CodeB, class A, class B>
|
||||
struct arithmetic_or_not {
|
||||
typedef typename
|
||||
return_type_2<arithmetic_action<plus_action>, A, B>::type type;
|
||||
// plus_action is just a random pick, has to be a concrete instance
|
||||
};
|
||||
|
||||
// this case covers the case of artihmetic types with the same promote codes.
|
||||
// non numeric deduction is used since e.g. integral promotion is not
|
||||
// performed with operator ?:
|
||||
template<int CodeA, class A, class B>
|
||||
struct arithmetic_or_not<CodeA, CodeA, A, B> {
|
||||
typedef typename non_numeric_types<A, B>::type type;
|
||||
};
|
||||
|
||||
// if either A or B has promote code -1 it is not an arithmetic type
|
||||
template<class A, class B>
|
||||
struct arithmetic_or_not <-1, -1, A, B> {
|
||||
typedef typename non_numeric_types<A, B>::type type;
|
||||
};
|
||||
template<int CodeB, class A, class B>
|
||||
struct arithmetic_or_not <-1, CodeB, A, B> {
|
||||
typedef typename non_numeric_types<A, B>::type type;
|
||||
};
|
||||
template<int CodeA, class A, class B>
|
||||
struct arithmetic_or_not <CodeA, -1, A, B> {
|
||||
typedef typename non_numeric_types<A, B>::type type;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
// PHASE 3 : Are the types same?
|
||||
// No, check if they are arithmetic or not
|
||||
template <class A, class B>
|
||||
struct same_or_not {
|
||||
typedef typename detail::remove_reference_and_cv<A>::type plainA;
|
||||
typedef typename detail::remove_reference_and_cv<B>::type plainB;
|
||||
|
||||
typedef typename
|
||||
arithmetic_or_not<
|
||||
detail::promote_code<plainA>::value,
|
||||
detail::promote_code<plainB>::value,
|
||||
A,
|
||||
B>::type type;
|
||||
};
|
||||
// Yes, clear.
|
||||
template <class A> struct same_or_not<A, A> {
|
||||
typedef A type;
|
||||
};
|
||||
|
||||
} // detail
|
||||
|
||||
// PHASE 2 : Perform first the potential array_to_pointer conversion
|
||||
template<class A, class B>
|
||||
struct return_type_2<other_action<ifthenelsereturn_action>, A, B> {
|
||||
|
||||
typedef typename detail::array_to_pointer<A>::type A1;
|
||||
typedef typename detail::array_to_pointer<B>::type B1;
|
||||
|
||||
typedef typename
|
||||
boost::add_const<typename detail::same_or_not<A1, B1>::type>::type type;
|
||||
};
|
||||
|
||||
// PHASE 1 : Deduction is based on the second and third operand
|
||||
|
||||
|
||||
// return type specialization for conditional expression ends -----------
|
||||
|
||||
|
||||
// Specialization of lambda_functor_base for if_then_else_return.
|
||||
template<class Args>
|
||||
class
|
||||
lambda_functor_base<other_action<ifthenelsereturn_action>, Args> {
|
||||
public:
|
||||
Args args;
|
||||
|
||||
template <class SigArgs> struct sig {
|
||||
private:
|
||||
typedef typename detail::nth_return_type_sig<1, Args, SigArgs>::type ret1;
|
||||
typedef typename detail::nth_return_type_sig<2, Args, SigArgs>::type ret2;
|
||||
public:
|
||||
typedef typename return_type_2<
|
||||
other_action<ifthenelsereturn_action>, ret1, ret2
|
||||
>::type type;
|
||||
};
|
||||
|
||||
public:
|
||||
explicit lambda_functor_base(const Args& a) : args(a) {}
|
||||
|
||||
template<class RET, CALL_TEMPLATE_ARGS>
|
||||
RET call(CALL_FORMAL_ARGS) const {
|
||||
return (detail::select(boost::tuples::get<0>(args), CALL_ACTUAL_ARGS)) ?
|
||||
detail::select(boost::tuples::get<1>(args), CALL_ACTUAL_ARGS)
|
||||
:
|
||||
detail::select(boost::tuples::get<2>(args), CALL_ACTUAL_ARGS);
|
||||
}
|
||||
};
|
||||
|
||||
// The code below is from Joel de Guzman, some name changes etc.
|
||||
// has been made.
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// if_then_else_composite
|
||||
//
|
||||
// This composite has two (2) forms:
|
||||
//
|
||||
// if_(condition)
|
||||
// [
|
||||
// statement
|
||||
// ]
|
||||
//
|
||||
// and
|
||||
//
|
||||
// if_(condition)
|
||||
// [
|
||||
// true_statement
|
||||
// ]
|
||||
// .else_
|
||||
// [
|
||||
// false_statement
|
||||
// ]
|
||||
//
|
||||
// where condition is an lambda_functor that evaluates to bool. If condition
|
||||
// is true, the true_statement (again an lambda_functor) is executed
|
||||
// otherwise, the false_statement (another lambda_functor) is executed. The
|
||||
// result type of this is void. Note the trailing underscore after
|
||||
// if_ and the leading dot and the trailing underscore before
|
||||
// and after .else_.
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
template <typename CondT, typename ThenT, typename ElseT>
|
||||
struct if_then_else_composite {
|
||||
|
||||
typedef if_then_else_composite<CondT, ThenT, ElseT> self_t;
|
||||
|
||||
template <class SigArgs>
|
||||
struct sig { typedef void type; };
|
||||
|
||||
if_then_else_composite(
|
||||
CondT const& cond_,
|
||||
ThenT const& then_,
|
||||
ElseT const& else__)
|
||||
: cond(cond_), then(then_), else_(else__) {}
|
||||
|
||||
template <class Ret, CALL_TEMPLATE_ARGS>
|
||||
Ret call(CALL_FORMAL_ARGS) const
|
||||
{
|
||||
if (cond.internal_call(CALL_ACTUAL_ARGS))
|
||||
then.internal_call(CALL_ACTUAL_ARGS);
|
||||
else
|
||||
else_.internal_call(CALL_ACTUAL_ARGS);
|
||||
}
|
||||
|
||||
CondT cond; ThenT then; ElseT else_; // lambda_functors
|
||||
};
|
||||
|
||||
//////////////////////////////////
|
||||
template <typename CondT, typename ThenT>
|
||||
struct else_gen {
|
||||
|
||||
else_gen(CondT const& cond_, ThenT const& then_)
|
||||
: cond(cond_), then(then_) {}
|
||||
|
||||
template <typename ElseT>
|
||||
lambda_functor<if_then_else_composite<CondT, ThenT,
|
||||
typename as_lambda_functor<ElseT>::type> >
|
||||
operator[](ElseT const& else_)
|
||||
{
|
||||
typedef if_then_else_composite<CondT, ThenT,
|
||||
typename as_lambda_functor<ElseT>::type>
|
||||
result;
|
||||
|
||||
return result(cond, then, to_lambda_functor(else_));
|
||||
}
|
||||
|
||||
CondT cond; ThenT then;
|
||||
};
|
||||
|
||||
//////////////////////////////////
|
||||
template <typename CondT, typename ThenT>
|
||||
struct if_then_composite {
|
||||
|
||||
template <class SigArgs>
|
||||
struct sig { typedef void type; };
|
||||
|
||||
if_then_composite(CondT const& cond_, ThenT const& then_)
|
||||
: cond(cond_), then(then_), else_(cond, then) {}
|
||||
|
||||
template <class Ret, CALL_TEMPLATE_ARGS>
|
||||
Ret call(CALL_FORMAL_ARGS) const
|
||||
{
|
||||
if (cond.internal_call(CALL_ACTUAL_ARGS))
|
||||
then.internal_call(CALL_ACTUAL_ARGS);
|
||||
}
|
||||
|
||||
CondT cond; ThenT then; // lambda_functors
|
||||
else_gen<CondT, ThenT> else_;
|
||||
};
|
||||
|
||||
//////////////////////////////////
|
||||
template <typename CondT>
|
||||
struct if_gen {
|
||||
|
||||
if_gen(CondT const& cond_)
|
||||
: cond(cond_) {}
|
||||
|
||||
template <typename ThenT>
|
||||
lambda_functor<if_then_composite<
|
||||
typename as_lambda_functor<CondT>::type,
|
||||
typename as_lambda_functor<ThenT>::type> >
|
||||
operator[](ThenT const& then) const
|
||||
{
|
||||
typedef if_then_composite<
|
||||
typename as_lambda_functor<CondT>::type,
|
||||
typename as_lambda_functor<ThenT>::type>
|
||||
result;
|
||||
|
||||
return result(
|
||||
to_lambda_functor(cond),
|
||||
to_lambda_functor(then));
|
||||
}
|
||||
|
||||
CondT cond;
|
||||
};
|
||||
|
||||
//////////////////////////////////
|
||||
template <typename CondT>
|
||||
inline if_gen<CondT>
|
||||
if_(CondT const& cond)
|
||||
{
|
||||
return if_gen<CondT>(cond);
|
||||
}
|
||||
|
||||
|
||||
|
||||
} // lambda
|
||||
} // boost
|
||||
|
||||
#endif // BOOST_LAMBDA_IF_HPP
|
||||
|
||||
|
||||
@@ -1,29 +1,29 @@
|
||||
// -- lambda.hpp -- Boost Lambda Library -----------------------------------
|
||||
// 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://lambda.cs.utu.fi
|
||||
|
||||
#ifndef BOOST_LAMBDA_LAMBDA_HPP
|
||||
#define BOOST_LAMBDA_LAMBDA_HPP
|
||||
|
||||
|
||||
#include "boost/lambda/core.hpp"
|
||||
|
||||
#ifdef BOOST_NO_FDECL_TEMPLATES_AS_TEMPLATE_TEMPLATE_PARAMS
|
||||
#include <istream>
|
||||
#include <ostream>
|
||||
#endif
|
||||
|
||||
#include "boost/lambda/detail/operator_actions.hpp"
|
||||
#include "boost/lambda/detail/operator_lambda_func_base.hpp"
|
||||
#include "boost/lambda/detail/operator_return_type_traits.hpp"
|
||||
|
||||
|
||||
#include "boost/lambda/detail/operators.hpp"
|
||||
#include "boost/lambda/detail/member_ptr.hpp"
|
||||
|
||||
#endif
|
||||
// -- lambda.hpp -- Boost Lambda Library -----------------------------------
|
||||
// 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://lambda.cs.utu.fi
|
||||
|
||||
#ifndef BOOST_LAMBDA_LAMBDA_HPP
|
||||
#define BOOST_LAMBDA_LAMBDA_HPP
|
||||
|
||||
|
||||
#include "boost/lambda/core.hpp"
|
||||
|
||||
#ifdef BOOST_NO_FDECL_TEMPLATES_AS_TEMPLATE_TEMPLATE_PARAMS
|
||||
#include <istream>
|
||||
#include <ostream>
|
||||
#endif
|
||||
|
||||
#include "boost/lambda/detail/operator_actions.hpp"
|
||||
#include "boost/lambda/detail/operator_lambda_func_base.hpp"
|
||||
#include "boost/lambda/detail/operator_return_type_traits.hpp"
|
||||
|
||||
|
||||
#include "boost/lambda/detail/operators.hpp"
|
||||
#include "boost/lambda/detail/member_ptr.hpp"
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large.
Load diff
@@ -1,119 +1,119 @@
|
||||
// -- numeric.hpp -- Boost Lambda Library -----------------------------------
|
||||
// Copyright (C) 2002 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 2002 Gary Powell (gwpowell@hotmail.com)
|
||||
//
|
||||
// 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_NUMERIC_HPP
|
||||
#define BOOST_LAMBDA_NUMERIC_HPP
|
||||
|
||||
#include "boost/lambda/core.hpp"
|
||||
|
||||
#include <numeric>
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
namespace ll {
|
||||
|
||||
// accumulate ---------------------------------
|
||||
|
||||
struct accumulate {
|
||||
|
||||
template <class Args>
|
||||
struct sig {
|
||||
typedef typename boost::remove_const<
|
||||
typename boost::tuples::element<3, Args>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
template <class A, class B, class C>
|
||||
C
|
||||
operator()(A a, B b, C c) const
|
||||
{ return ::std::accumulate(a, b, c); }
|
||||
|
||||
template <class A, class B, class C, class D>
|
||||
C
|
||||
operator()(A a, B b, C c, D d) const
|
||||
{ return ::std::accumulate(a, b, c, d); }
|
||||
};
|
||||
|
||||
// inner_product ---------------------------------
|
||||
|
||||
struct inner_product {
|
||||
|
||||
template <class Args>
|
||||
struct sig {
|
||||
typedef typename boost::remove_const<
|
||||
typename boost::tuples::element<4, Args>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
template <class A, class B, class C, class D>
|
||||
D
|
||||
operator()(A a, B b, C c, D d) const
|
||||
{ return ::std::inner_product(a, b, c, d); }
|
||||
|
||||
template <class A, class B, class C, class D, class E, class F>
|
||||
D
|
||||
operator()(A a, B b, C c, D d, E e, F f) const
|
||||
{ return ::std::inner_product(a, b, c, d, e, f); }
|
||||
};
|
||||
|
||||
|
||||
// partial_sum ---------------------------------
|
||||
|
||||
struct partial_sum {
|
||||
|
||||
template <class Args>
|
||||
struct sig {
|
||||
typedef typename boost::remove_const<
|
||||
typename boost::tuples::element<3, Args>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
template <class A, class B, class C>
|
||||
C
|
||||
operator()(A a, B b, C c) const
|
||||
{ return ::std::partial_sum(a, b, c); }
|
||||
|
||||
template <class A, class B, class C, class D>
|
||||
C
|
||||
operator()(A a, B b, C c, D d) const
|
||||
{ return ::std::partial_sum(a, b, c, d); }
|
||||
};
|
||||
|
||||
// adjacent_difference ---------------------------------
|
||||
|
||||
struct adjacent_difference {
|
||||
|
||||
template <class Args>
|
||||
struct sig {
|
||||
typedef typename boost::remove_const<
|
||||
typename boost::tuples::element<3, Args>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
template <class A, class B, class C>
|
||||
C
|
||||
operator()(A a, B b, C c) const
|
||||
{ return ::std::adjacent_difference(a, b, c); }
|
||||
|
||||
template <class A, class B, class C, class D>
|
||||
C
|
||||
operator()(A a, B b, C c, D d) const
|
||||
{ return ::std::adjacent_difference(a, b, c, d); }
|
||||
};
|
||||
|
||||
} // end of ll namespace
|
||||
|
||||
} // end of lambda namespace
|
||||
} // end of boost namespace
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
// -- numeric.hpp -- Boost Lambda Library -----------------------------------
|
||||
// Copyright (C) 2002 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 2002 Gary Powell (gwpowell@hotmail.com)
|
||||
//
|
||||
// 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_NUMERIC_HPP
|
||||
#define BOOST_LAMBDA_NUMERIC_HPP
|
||||
|
||||
#include "boost/lambda/core.hpp"
|
||||
|
||||
#include <numeric>
|
||||
|
||||
namespace boost {
|
||||
namespace lambda {
|
||||
|
||||
namespace ll {
|
||||
|
||||
// accumulate ---------------------------------
|
||||
|
||||
struct accumulate {
|
||||
|
||||
template <class Args>
|
||||
struct sig {
|
||||
typedef typename boost::remove_const<
|
||||
typename boost::tuples::element<3, Args>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
template <class A, class B, class C>
|
||||
C
|
||||
operator()(A a, B b, C c) const
|
||||
{ return ::std::accumulate(a, b, c); }
|
||||
|
||||
template <class A, class B, class C, class D>
|
||||
C
|
||||
operator()(A a, B b, C c, D d) const
|
||||
{ return ::std::accumulate(a, b, c, d); }
|
||||
};
|
||||
|
||||
// inner_product ---------------------------------
|
||||
|
||||
struct inner_product {
|
||||
|
||||
template <class Args>
|
||||
struct sig {
|
||||
typedef typename boost::remove_const<
|
||||
typename boost::tuples::element<4, Args>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
template <class A, class B, class C, class D>
|
||||
D
|
||||
operator()(A a, B b, C c, D d) const
|
||||
{ return ::std::inner_product(a, b, c, d); }
|
||||
|
||||
template <class A, class B, class C, class D, class E, class F>
|
||||
D
|
||||
operator()(A a, B b, C c, D d, E e, F f) const
|
||||
{ return ::std::inner_product(a, b, c, d, e, f); }
|
||||
};
|
||||
|
||||
|
||||
// partial_sum ---------------------------------
|
||||
|
||||
struct partial_sum {
|
||||
|
||||
template <class Args>
|
||||
struct sig {
|
||||
typedef typename boost::remove_const<
|
||||
typename boost::tuples::element<3, Args>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
template <class A, class B, class C>
|
||||
C
|
||||
operator()(A a, B b, C c) const
|
||||
{ return ::std::partial_sum(a, b, c); }
|
||||
|
||||
template <class A, class B, class C, class D>
|
||||
C
|
||||
operator()(A a, B b, C c, D d) const
|
||||
{ return ::std::partial_sum(a, b, c, d); }
|
||||
};
|
||||
|
||||
// adjacent_difference ---------------------------------
|
||||
|
||||
struct adjacent_difference {
|
||||
|
||||
template <class Args>
|
||||
struct sig {
|
||||
typedef typename boost::remove_const<
|
||||
typename boost::tuples::element<3, Args>::type
|
||||
>::type type;
|
||||
};
|
||||
|
||||
template <class A, class B, class C>
|
||||
C
|
||||
operator()(A a, B b, C c) const
|
||||
{ return ::std::adjacent_difference(a, b, c); }
|
||||
|
||||
template <class A, class B, class C, class D>
|
||||
C
|
||||
operator()(A a, B b, C c, D d) const
|
||||
{ return ::std::adjacent_difference(a, b, c, d); }
|
||||
};
|
||||
|
||||
} // end of ll namespace
|
||||
|
||||
} // end of lambda namespace
|
||||
} // end of boost namespace
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large.
Load diff
Reference in new issue
Block a user