diff options
Diffstat (limited to '3rdParty/Boost/src/boost/spirit/home/phoenix/detail')
-rw-r--r-- | 3rdParty/Boost/src/boost/spirit/home/phoenix/detail/local_reference.hpp | 44 | ||||
-rw-r--r-- | 3rdParty/Boost/src/boost/spirit/home/phoenix/detail/type_deduction.hpp | 497 |
2 files changed, 0 insertions, 541 deletions
diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/local_reference.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/local_reference.hpp deleted file mode 100644 index ad1fdb4..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/local_reference.hpp +++ /dev/null @@ -1,44 +0,0 @@ -/*============================================================================= - Copyright (c) 2005-2007 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) -==============================================================================*/ -#ifndef PHOENIX_DETAIL_LOCAL_REFERENCE_HPP -#define PHOENIX_DETAIL_LOCAL_REFERENCE_HPP - -#include <boost/utility/addressof.hpp> - -namespace boost { namespace phoenix { namespace detail -{ - template <typename T> - struct local_reference - { - typedef T type; - - explicit local_reference(T& t): t_(boost::addressof(t)) {} - operator T& () const { return *t_; } - local_reference& operator=(T const& x) { *t_ = x; return *this; } - local_reference const& operator=(T const& x) const { *t_ = x; return *this; } - T& get() const { return *t_; } - T* get_pointer() const { return t_; } - - private: - - T* t_; - }; - - template <typename T> - struct unwrap_local_reference - { - typedef T type; // T should be a reference - }; - - template <typename T> - struct unwrap_local_reference<local_reference<T> > - { - typedef T type; // unwrap the reference; T is a value - }; -}}} - -#endif diff --git a/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/type_deduction.hpp b/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/type_deduction.hpp deleted file mode 100644 index b99ea1e..0000000 --- a/3rdParty/Boost/src/boost/spirit/home/phoenix/detail/type_deduction.hpp +++ /dev/null @@ -1,497 +0,0 @@ -/*============================================================================= - Copyright (c) 2001-2007 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) -==============================================================================*/ -#ifndef PHOENIX_DETAIL_TYPE_DEDUCTION_HPP -#define PHOENIX_DETAIL_TYPE_DEDUCTION_HPP - -/*============================================================================= - - Return Type Deduction - [JDG Sept. 15, 2003] - - Before C++ adopts the typeof, there is currently no way to deduce the - result type of an expression such as x + y. This deficiency is a major - problem with template metaprogramming; for example, when writing - forwarding functions that attempt to capture the essence of an - expression inside a function. Consider the std::plus<T>: - - template <typename T> - struct plus : public binary_function<T, T, T> - { - T operator()(T const& x, T const& y) const - { - return x + y; - } - }; - - What's wrong with this? Well, this functor does not accurately capture - the behavior of the plus operator. 1) It does not handle the case where - x and y are of different types (e.g. x is short and y is int). 2) It - assumes that the arguments and return type are the same (i.e. when - adding a short and an int, the return type ought to be an int). Due to - these shortcomings, std::plus<T>(x, y) is a poor substitute for x + y. - - The case where x is short and y is int does not really expose the - problem. We can simply use std::plus<int> and be happy that the - operands x and y will simply be converted to an int. The problem - becomes evident when an operand is a user defined type such as bigint. - Here, the conversion to bigint is simply not acceptable. Even if the - unnecessary conversion is tolerable, in generic code, it is not always - possible to choose the right T type that can accomodate both x and y - operands. - - To truly model the plus operator, what we need is a polymorphic functor - that can take arbitrary x and y operands. Here's a rough schematic: - - struct plus - { - template <typename X, typename Y> - unspecified-type - operator()(X const& x, Y const& y) const - { - return x + y; - } - }; - - Now, we can handle the case where X and Y are arbitrary types. We've - solved the first problem. To solve the second problem, we need some - form of return type deduction mechanism. If we had the typeof, it would - be something like: - - template <typename X, typename Y> - typeof(X() + Y()) - operator()(X const& x, Y const& y) const - { - return x + y; - } - - Without the typeof facility, it is only possible to wrap an expression - such as x + y in a function or functor if we are given a hint that - tells us what the actual result type of such an expression is. Such a - hint can be in the form of a metaprogram, that, given the types of the - arguments, will return the result type. Example: - - template <typename X, typename Y> - struct result_of_plus - { - typedef unspecified-type type; - }; - - Given a result_of_plus metaprogram, we can complete our polymorphic - plus functor: - - struct plus - { - template <typename X, typename Y> - typename result_of_plus<X, Y>::type - operator()(X const& x, Y const& y) const - { - return x + y; - } - }; - - The process is not automatic. We have to specialize the metaprogram for - specific argument types. Examples: - - template <> - struct result_of_plus<short, int> - { - typedef int type; - }; - - template <typename T> - struct result_of_plus<std::complex<T>, std::complex<T> > - { - typedef std::complex<T> type; - }; - - To make it easier for the user, specializations are provided for common - types such as primitive c++ types (e.g. int, char, double, etc.), and - standard types (e.g. std::complex, iostream, std containers and - iterators). - - To further improve the ease of use, for user defined classes, we can - supply a few more basic specializations through metaprogramming using - heuristics based on canonical operator rules (Such heuristics can be - found in the LL and Phoenix, for example). For example, it is rather - common that the result of x += y is X& or the result of x || y is a - bool. The client is out of luck if her classes do not follow the - canonical rules. She'll then have to supply her own specialization. - - The type deduction mechanism demostrated below approaches the problem - not through specialization and heuristics, but through a limited form - of typeof mechanism. The code does not use heuristics, hence, no - guessing games. The code takes advantage of the fact that, in general, - the result type of an expression is related to one its arguments' type. - For example, x + y, where x has type int and y has type double, has the - result type double (the second operand type). Another example, x[y] - where x is a vector<T> and y is a std::size_t, has the result type - vector<T>::reference (the vector<T>'s reference type type). - - The limited form of type deduction presented can detect common - relations if the result of a binary or unary operation, given arguments - x and y with types X and Y (respectively), is X, Y, X&, Y&, X*, Y*, X - const*, Y const*, bool, int, unsigned, double, container and iterator - elements (e.g the T, where X is: T[N], T*, vector<T>, map<T>, - vector<T>::iterator). More arguments/return type relationships can be - established if needed. - - A set of overloaded test(T) functions capture these argument related - types. Each test(T) function returns a distinct type that can be used - to determine the exact type of an expression. - - Consider: - - template <typename X, typename Y> - x_value_type - test(X const&); - - template <typename X, typename Y> - y_value_type - test(Y const&); - - Given an expression x + y, where x is int and y is double, the call to: - - test<int, double>(x + y) - - will return a y_value_type. - - Now, if we rig x_value_type and y_value_type such that both have unique - sizes, we can use sizeof(test<X, Y>(x + y)) to determine if the result - type is either X or Y. - - For example, if: - - sizeof(test<X, Y>(x + y)) == sizeof(y_value_type) - - then, we know for sure that the result of x + y has type Y. - - The same basic scheme can be used to detect more argument-dependent - return types where the sizeof the test(T) return type is used to index - through a boost::mpl vector which holds each of the corresponding - result types. - -==============================================================================*/ -#include <boost/mpl/vector/vector20.hpp> -#include <boost/mpl/at.hpp> -#include <boost/mpl/not.hpp> -#include <boost/mpl/or.hpp> -#include <boost/mpl/and.hpp> -#include <boost/mpl/identity.hpp> -#include <boost/type_traits/remove_reference.hpp> -#include <boost/type_traits/add_reference.hpp> -#include <boost/type_traits/remove_cv.hpp> -#include <boost/type_traits/is_const.hpp> -#include <boost/type_traits/is_reference.hpp> -#include <boost/type_traits/is_same.hpp> -#include <boost/type_traits/is_array.hpp> -#include <boost/type_traits/is_pointer.hpp> -#include <boost/utility/enable_if.hpp> -#include <boost/static_assert.hpp> -#include <boost/preprocessor/cat.hpp> -#include <boost/spirit/home/phoenix/detail/local_reference.hpp> - -namespace boost -{ - struct error_cant_deduce_type {}; -} - -namespace boost { namespace type_deduction_detail -{ - typedef char(&bool_value_type)[1]; - typedef char(&int_value_type)[2]; - typedef char(&uint_value_type)[3]; - typedef char(&double_value_type)[4]; - - typedef char(&bool_reference_type)[5]; - typedef char(&int_reference_type)[6]; - typedef char(&uint_reference_type)[7]; - typedef char(&double_reference_type)[8]; - - typedef char(&x_value_type)[9]; - typedef char(&x_reference_type)[10]; - typedef char(&x_const_pointer_type)[11]; - typedef char(&x_pointer_type)[12]; - - typedef char(&y_value_type)[13]; - typedef char(&y_reference_type)[14]; - typedef char(&y_const_pointer_type)[15]; - typedef char(&y_pointer_type)[16]; - - typedef char(&container_reference_type)[17]; - typedef char(&container_const_reference_type)[18]; - typedef char(&container_mapped_type)[19]; - - typedef char(&cant_deduce_type)[20]; - - template <typename T, typename Plain = typename remove_cv<T>::type> - struct is_basic - : mpl::or_< - is_same<Plain, bool> - , is_same<Plain, int> - , is_same<Plain, unsigned> - , is_same<Plain, double> - > {}; - - template <typename C> - struct reference_type - { - typedef typename C::reference type; - }; - - template <typename T> - struct reference_type<T const> - : reference_type<T> {}; - - template <typename T, std::size_t N> - struct reference_type<T[N]> - { - typedef T& type; - }; - - template <typename T> - struct reference_type<T*> - { - typedef T& type; - }; - - template <typename T> - struct reference_type<T* const> - { - typedef T const& type; - }; - - template <typename C> - struct const_reference_type - { - typedef typename C::const_reference type; - }; - - template <typename C> - struct mapped_type - { - typedef typename C::mapped_type type; - }; - - struct asymmetric; - - template <typename X, typename Y> - cant_deduce_type - test(...); // The black hole !!! - - template <typename X, typename Y> - bool_value_type - test(bool const&); - - template <typename X, typename Y> - int_value_type - test(int const&); - - template <typename X, typename Y> - uint_value_type - test(unsigned const&); - - template <typename X, typename Y> - double_value_type - test(double const&); - - template <typename X, typename Y> - bool_reference_type - test(bool&); - - template <typename X, typename Y> - int_reference_type - test(int&); - - template <typename X, typename Y> - uint_reference_type - test(unsigned&); - - template <typename X, typename Y> - double_reference_type - test(double&); - - template <typename X, typename Y> - typename disable_if< - mpl::or_<is_basic<X>, is_const<X> > - , x_value_type - >::type - test(X const&); - - template <typename X, typename Y> - typename disable_if< - is_basic<X> - , x_reference_type - >::type - test(X&); - - template <typename X, typename Y> - typename disable_if< - mpl::or_< - is_basic<X> - , is_const<X> - > - , x_const_pointer_type - >::type - test(X const*); - - template <typename X, typename Y> - x_pointer_type - test(X*); - - template <typename X, typename Y> - typename disable_if< - mpl::or_< - is_basic<Y> - , is_same<Y, asymmetric> - , is_const<Y> - , is_same<X, Y> - > - , y_value_type - >::type - test(Y const&); - - template <typename X, typename Y> - typename disable_if< - mpl::or_< - is_basic<Y> - , is_same<Y, asymmetric> - , is_same<X, Y> - > - , y_reference_type - >::type - test(Y&); - - template <typename X, typename Y> - typename disable_if< - mpl::or_< - is_same<Y, asymmetric> - , is_const<Y> - , is_same<X, Y> - > - , y_const_pointer_type - >::type - test(Y const*); - - template <typename X, typename Y> - typename disable_if< - mpl::or_< - is_same<Y, asymmetric> - , is_same<X, Y> - > - , y_pointer_type - >::type - test(Y*); - - template <typename X, typename Y> - typename disable_if< - mpl::or_< - is_basic<typename X::value_type> - , is_same<typename add_reference<X>::type, typename X::reference> - > - , container_reference_type - >::type - test(typename X::reference); - - template <typename X, typename Y, typename Z> - typename enable_if< - mpl::and_< - mpl::or_<is_array<X>, is_pointer<X> > - , mpl::not_<is_basic<Z> > - , mpl::not_<is_same<X, Z> > - > - , container_reference_type - >::type - test(Z&); - - template <typename X, typename Y> - typename disable_if< - mpl::or_< - is_basic<typename X::value_type> - , is_same<typename add_reference<X>::type, typename X::const_reference> - > - , container_const_reference_type - >::type - test(typename X::const_reference); - - template <typename X, typename Y> - typename disable_if< - is_basic<typename X::mapped_type> - , container_mapped_type - >::type - test(typename X::mapped_type); - - template <typename X, typename Y> - struct base_result_of - { - typedef typename phoenix::detail::unwrap_local_reference<X>::type x_type_; - typedef typename phoenix::detail::unwrap_local_reference<Y>::type y_type_; - typedef typename remove_reference<x_type_>::type x_type; - typedef typename remove_reference<y_type_>::type y_type; - - typedef mpl::vector20< - mpl::identity<bool> - , mpl::identity<int> - , mpl::identity<unsigned> - , mpl::identity<double> - , mpl::identity<bool&> - , mpl::identity<int&> - , mpl::identity<unsigned&> - , mpl::identity<double&> - , mpl::identity<x_type> - , mpl::identity<x_type&> - , mpl::identity<x_type const*> - , mpl::identity<x_type*> - , mpl::identity<y_type> - , mpl::identity<y_type&> - , mpl::identity<y_type const*> - , mpl::identity<y_type*> - , reference_type<x_type> - , const_reference_type<x_type> - , mapped_type<x_type> - , mpl::identity<error_cant_deduce_type> - > - types; - }; - -}} // namespace boost::type_deduction_detail - -#define BOOST_RESULT_OF_COMMON(expr, name, Y, SYMMETRY) \ - struct name \ - { \ - typedef type_deduction_detail::base_result_of<X, Y> base_type; \ - static typename base_type::x_type x; \ - static typename base_type::y_type y; \ - \ - BOOST_STATIC_CONSTANT(int, \ - size = sizeof( \ - type_deduction_detail::test< \ - typename base_type::x_type \ - , SYMMETRY \ - >(expr) \ - )); \ - \ - BOOST_STATIC_CONSTANT(int, index = (size / sizeof(char)) - 1); \ - \ - typedef typename mpl::at_c< \ - typename base_type::types, index>::type id; \ - typedef typename id::type type; \ - }; - -#define BOOST_UNARY_RESULT_OF(expr, name) \ - template <typename X> \ - BOOST_RESULT_OF_COMMON(expr, name, \ - type_deduction_detail::asymmetric, type_deduction_detail::asymmetric) - -#define BOOST_BINARY_RESULT_OF(expr, name) \ - template <typename X, typename Y> \ - BOOST_RESULT_OF_COMMON(expr, name, Y, typename base_type::y_type) - -#define BOOST_ASYMMETRIC_BINARY_RESULT_OF(expr, name) \ - template <typename X, typename Y> \ - BOOST_RESULT_OF_COMMON(expr, name, Y, type_deduction_detail::asymmetric) - -#endif |