Swiftdiff options
| author | Kevin Smith <git@kismith.co.uk> | 2013-01-12 18:41:34 (GMT) |
|---|---|---|
| committer | Swift Review <review@swift.im> | 2013-01-13 10:36:26 (GMT) |
| commit | f3bc816af1b0d61452de973963e453bf3b3f95a2 (patch) | |
| tree | e895f8afa3580e6cff6f5ad2017d45bf147a17c2 /3rdParty/Boost/src/boost/proto/functional | |
| parent | 188fc285c6555eadd3c9d50ab8a94adcade78d89 (diff) | |
| download | swift-f3bc816af1b0d61452de973963e453bf3b3f95a2.zip swift-f3bc816af1b0d61452de973963e453bf3b3f95a2.tar.bz2 | |
Adding in the spirit Boost stuff
Change-Id: I4f127ce61667243b64081b0aa309028d5077045f
Diffstat (limited to '3rdParty/Boost/src/boost/proto/functional')
17 files changed, 970 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/proto/functional/fusion.hpp b/3rdParty/Boost/src/boost/proto/functional/fusion.hpp new file mode 100644 index 0000000..8aaf4ea --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/fusion.hpp @@ -0,0 +1,19 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file fusion.hpp +/// Proto callables for things found in the Fusion library +// +// Copyright 2010 Eric Niebler. 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 BOOST_PROTO_FUNCTIONAL_FUSION_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_FUSION_HPP_EAN_11_27_2010 + +#include <boost/proto/functional/fusion/at.hpp> +#include <boost/proto/functional/fusion/pop_back.hpp> +#include <boost/proto/functional/fusion/pop_front.hpp> +#include <boost/proto/functional/fusion/push_back.hpp> +#include <boost/proto/functional/fusion/push_front.hpp> +#include <boost/proto/functional/fusion/reverse.hpp> + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/fusion/at.hpp b/3rdParty/Boost/src/boost/proto/functional/fusion/at.hpp new file mode 100644 index 0000000..328ac13 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/fusion/at.hpp @@ -0,0 +1,56 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file at.hpp +/// Proto callables Fusion at +// +// Copyright 2010 Eric Niebler. 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 BOOST_PROTO_FUNCTIONAL_FUSION_AT_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_FUSION_AT_HPP_EAN_11_27_2010 + +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/fusion/include/at.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + /// \brief A PolymorphicFunctionObject type that invokes the + /// \c fusion::at() accessor on its argument. + /// + /// A PolymorphicFunctionObject type that invokes the + /// \c fusion::at() accessor on its argument. + struct at + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Seq, typename N> + struct result<This(Seq, N)> + : fusion::result_of::at< + typename boost::remove_reference<Seq>::type + , typename boost::remove_const<typename boost::remove_reference<N>::type>::type + > + {}; + + template<typename Seq, typename N> + typename fusion::result_of::at<Seq, N>::type + operator ()(Seq &seq, N const & BOOST_PROTO_DISABLE_IF_IS_CONST(Seq)) const + { + return fusion::at<N>(seq); + } + + template<typename Seq, typename N> + typename fusion::result_of::at<Seq const, N>::type + operator ()(Seq const &seq, N const &) const + { + return fusion::at<N>(seq); + } + }; +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/fusion/pop_back.hpp b/3rdParty/Boost/src/boost/proto/functional/fusion/pop_back.hpp new file mode 100644 index 0000000..f3ebeb8 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/fusion/pop_back.hpp @@ -0,0 +1,60 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file pop_back.hpp +/// Proto callables Fusion pop_back +// +// Copyright 2010 Eric Niebler. 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 BOOST_PROTO_FUNCTIONAL_FUSION_POP_BACK_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_FUSION_POP_BACK_HPP_EAN_11_27_2010 + +#include <boost/fusion/include/begin.hpp> +#include <boost/fusion/include/end.hpp> +#include <boost/fusion/include/prior.hpp> +#include <boost/fusion/include/pop_back.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + /// \brief A PolymorphicFunctionObject type that invokes the + /// \c fusion::pop_back() algorithm on its argument. + /// + /// A PolymorphicFunctionObject type that invokes the + /// \c fusion::pop_back() algorithm on its argument. + struct pop_back + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Seq> + struct result<This(Seq)> + : result<This(Seq const &)> + {}; + + template<typename This, typename Seq> + struct result<This(Seq &)> + : fusion::result_of::pop_back<Seq> + {}; + + template<typename Seq> + typename fusion::result_of::pop_back<Seq>::type + operator ()(Seq &seq) const + { + // Work around a const-correctness issue in Fusion + typedef typename fusion::result_of::pop_back<Seq>::type result_type; + return result_type(fusion::begin(seq), fusion::prior(fusion::end(seq))); + } + + template<typename Seq> + typename fusion::result_of::pop_back<Seq const>::type + operator ()(Seq const &seq) const + { + return fusion::pop_back(seq); + } + }; +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/fusion/pop_front.hpp b/3rdParty/Boost/src/boost/proto/functional/fusion/pop_front.hpp new file mode 100644 index 0000000..9586f4d --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/fusion/pop_front.hpp @@ -0,0 +1,65 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file pop_front.hpp +/// Proto callables Fusion pop_front +// +// Copyright 2010 Eric Niebler. 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 BOOST_PROTO_FUNCTIONAL_FUSION_POP_FRONT_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_FUSION_POP_FRONT_HPP_EAN_11_27_2010 + +#include <boost/fusion/include/begin.hpp> +#include <boost/fusion/include/end.hpp> +#include <boost/fusion/include/next.hpp> +#include <boost/fusion/include/pop_front.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + /// \brief A PolymorphicFunctionObject type that invokes the + /// \c fusion::pop_front() algorithm on its argument. + /// + /// A PolymorphicFunctionObject type that invokes the + /// \c fusion::pop_front() algorithm on its argument. This is + /// useful for defining a CallableTransform like \c pop_front(_) + /// which removes the first child from a Proto expression node. + /// Such a transform might be used as the first argument to the + /// \c proto::fold\<\> transform; that is, fold all but + /// the first child. + struct pop_front + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Seq> + struct result<This(Seq)> + : result<This(Seq const &)> + {}; + + template<typename This, typename Seq> + struct result<This(Seq &)> + : fusion::result_of::pop_front<Seq> + {}; + + template<typename Seq> + typename fusion::result_of::pop_front<Seq>::type + operator ()(Seq &seq) const + { + // Work around a const-correctness issue in Fusion + typedef typename fusion::result_of::pop_front<Seq>::type result_type; + return result_type(fusion::next(fusion::begin(seq)), fusion::end(seq)); + } + + template<typename Seq> + typename fusion::result_of::pop_front<Seq const>::type + operator ()(Seq const &seq) const + { + return fusion::pop_front(seq); + } + }; +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/fusion/push_back.hpp b/3rdParty/Boost/src/boost/proto/functional/fusion/push_back.hpp new file mode 100644 index 0000000..8a427ae --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/fusion/push_back.hpp @@ -0,0 +1,49 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file push_back.hpp +/// Proto callables Fusion push_back +// +// Copyright 2010 Eric Niebler. 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 BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_BACK_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_BACK_HPP_EAN_11_27_2010 + +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/fusion/include/push_back.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + /// \brief A PolymorphicFunctionObject type that invokes the + /// \c fusion::push_back() algorithm on its argument. + /// + /// A PolymorphicFunctionObject type that invokes the + /// \c fusion::push_back() algorithm on its argument. + struct push_back + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Seq, typename T> + struct result<This(Seq, T)> + : fusion::result_of::push_back< + typename boost::add_const<typename boost::remove_reference<Seq>::type>::type + , typename boost::remove_const<typename boost::remove_reference<T>::type>::type + > + {}; + + template<typename Seq, typename T> + typename fusion::result_of::push_back<Seq const, T>::type + operator ()(Seq const &seq, T const &t) const + { + return fusion::push_back(seq, t); + } + }; +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/fusion/push_front.hpp b/3rdParty/Boost/src/boost/proto/functional/fusion/push_front.hpp new file mode 100644 index 0000000..d17f509 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/fusion/push_front.hpp @@ -0,0 +1,49 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file push_front.hpp +/// Proto callables Fusion push_front +// +// Copyright 2010 Eric Niebler. 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 BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_FRONT_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_FRONT_HPP_EAN_11_27_2010 + +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/fusion/include/push_front.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + /// \brief A PolymorphicFunctionObject type that invokes the + /// \c fusion::push_front() algorithm on its argument. + /// + /// A PolymorphicFunctionObject type that invokes the + /// \c fusion::push_front() algorithm on its argument. + struct push_front + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Seq, typename T> + struct result<This(Seq, T)> + : fusion::result_of::push_front< + typename boost::add_const<typename boost::remove_reference<Seq>::type>::type + , typename boost::remove_const<typename boost::remove_reference<T>::type>::type + > + {}; + + template<typename Seq, typename T> + typename fusion::result_of::push_front<Seq const, T>::type + operator ()(Seq const &seq, T const &t) const + { + return fusion::push_front(seq, t); + } + }; +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/fusion/reverse.hpp b/3rdParty/Boost/src/boost/proto/functional/fusion/reverse.hpp new file mode 100644 index 0000000..3ed154b --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/fusion/reverse.hpp @@ -0,0 +1,60 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file reverse.hpp +/// Proto callables Fusion reverse +// +// Copyright 2010 Eric Niebler. 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 BOOST_PROTO_FUNCTIONAL_FUSION_REVERSE_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_FUSION_REVERSE_HPP_EAN_11_27_2010 + +#include <boost/fusion/include/reverse.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + /// \brief A PolymorphicFunctionObject type that invokes the + /// \c fusion::reverse() algorithm on its argument. + /// + /// A PolymorphicFunctionObject type that invokes the + /// \c fusion::reverse() algorithm on its argument. This is + /// useful for defining a CallableTransform like \c reverse(_) + /// which reverses the order of the children of a Proto + /// expression node. + struct reverse + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Seq> + struct result<This(Seq)> + : result<This(Seq const &)> + {}; + + template<typename This, typename Seq> + struct result<This(Seq &)> + : fusion::result_of::reverse<Seq> + {}; + + template<typename Seq> + typename fusion::result_of::reverse<Seq>::type + operator ()(Seq &seq) const + { + // Work around a const-correctness issue in Fusion + typedef typename fusion::result_of::reverse<Seq>::type result_type; + return result_type(seq); + } + + template<typename Seq> + typename fusion::result_of::reverse<Seq const>::type + operator ()(Seq const &seq) const + { + return fusion::reverse(seq); + } + }; +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/range.hpp b/3rdParty/Boost/src/boost/proto/functional/range.hpp new file mode 100644 index 0000000..e83c853 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/range.hpp @@ -0,0 +1,19 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file range.hpp +/// Proto callables for things found in the boost range library +// +// Copyright 2012 Eric Niebler. 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 BOOST_PROTO_FUNCTIONAL_RANGE_HPP_EAN_27_08_2012 +#define BOOST_PROTO_FUNCTIONAL_RANGE_HPP_EAN_27_08_2012 + +#include <boost/proto/functional/range/begin.hpp> +#include <boost/proto/functional/range/empty.hpp> +#include <boost/proto/functional/range/end.hpp> +#include <boost/proto/functional/range/rbegin.hpp> +#include <boost/proto/functional/range/rend.hpp> +#include <boost/proto/functional/range/size.hpp> + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/range/begin.hpp b/3rdParty/Boost/src/boost/proto/functional/range/begin.hpp new file mode 100644 index 0000000..c425a41 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/range/begin.hpp @@ -0,0 +1,51 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file begin.hpp +/// Proto callables for boost::begin() +// +// Copyright 2012 Eric Niebler. 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 BOOST_PROTO_FUNCTIONAL_RANGE_BEGIN_HPP_EAN_27_08_2012 +#define BOOST_PROTO_FUNCTIONAL_RANGE_BEGIN_HPP_EAN_27_08_2012 + +#include <boost/range/begin.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + + // A PolymorphicFunctionObject that wraps boost::begin() + struct begin + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Rng> + struct result<This(Rng)> + : boost::range_iterator<Rng const> + {}; + + template<typename This, typename Rng> + struct result<This(Rng &)> + : boost::range_iterator<Rng> + {}; + + template<typename Rng> + typename boost::range_iterator<Rng>::type operator()(Rng &rng) const + { + return boost::begin(rng); + } + + template<typename Rng> + typename boost::range_iterator<Rng const>::type operator()(Rng const &rng) const + { + return boost::begin(rng); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/range/empty.hpp b/3rdParty/Boost/src/boost/proto/functional/range/empty.hpp new file mode 100644 index 0000000..debb82d --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/range/empty.hpp @@ -0,0 +1,34 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file empty.hpp +/// Proto callables for boost::empty() +// +// Copyright 2012 Eric Niebler. 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 BOOST_PROTO_FUNCTIONAL_RANGE_EMPTY_HPP_EAN_27_08_2012 +#define BOOST_PROTO_FUNCTIONAL_RANGE_EMPTY_HPP_EAN_27_08_2012 + +#include <boost/range/empty.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + + // A PolymorphicFunctionObject that wraps boost::empty() + struct empty + { + BOOST_PROTO_CALLABLE() + + typedef bool result_type; + + template<typename Rng> + bool operator()(Rng const &rng) const + { + return boost::empty(rng); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/range/end.hpp b/3rdParty/Boost/src/boost/proto/functional/range/end.hpp new file mode 100644 index 0000000..f7506fd --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/range/end.hpp @@ -0,0 +1,51 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file end.hpp +/// Proto callables for boost::end() +// +// Copyright 2012 Eric Niebler. 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 BOOST_PROTO_FUNCTIONAL_RANGE_END_HPP_EAN_27_08_2012 +#define BOOST_PROTO_FUNCTIONAL_RANGE_END_HPP_EAN_27_08_2012 + +#include <boost/range/end.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + + // A PolymorphicFunctionObject that wraps boost::end() + struct end + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Rng> + struct result<This(Rng)> + : boost::range_iterator<Rng const> + {}; + + template<typename This, typename Rng> + struct result<This(Rng &)> + : boost::range_iterator<Rng> + {}; + + template<typename Rng> + typename boost::range_iterator<Rng>::type operator()(Rng &rng) const + { + return boost::end(rng); + } + + template<typename Rng> + typename boost::range_iterator<Rng const>::type operator()(Rng const &rng) const + { + return boost::end(rng); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/range/rbegin.hpp b/3rdParty/Boost/src/boost/proto/functional/range/rbegin.hpp new file mode 100644 index 0000000..ecb7db9 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/range/rbegin.hpp @@ -0,0 +1,51 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file rbegin.hpp +/// Proto callables for boost::rbegin() +// +// Copyright 2012 Eric Niebler. 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 BOOST_PROTO_FUNCTIONAL_RANGE_RBEGIN_HPP_EAN_27_08_2012 +#define BOOST_PROTO_FUNCTIONAL_RANGE_RBEGIN_HPP_EAN_27_08_2012 + +#include <boost/range/rbegin.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + + // A PolymorphicFunctionObject that wraps boost::rbegin() + struct rbegin + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Rng> + struct result<This(Rng)> + : boost::range_reverse_iterator<Rng const> + {}; + + template<typename This, typename Rng> + struct result<This(Rng &)> + : boost::range_reverse_iterator<Rng> + {}; + + template<typename Rng> + typename boost::range_reverse_iterator<Rng>::type operator()(Rng &rng) const + { + return boost::rbegin(rng); + } + + template<typename Rng> + typename boost::range_reverse_iterator<Rng const>::type operator()(Rng const &rng) const + { + return boost::rbegin(rng); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/range/rend.hpp b/3rdParty/Boost/src/boost/proto/functional/range/rend.hpp new file mode 100644 index 0000000..5b37782 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/range/rend.hpp @@ -0,0 +1,51 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file rend.hpp +/// Proto callables for boost::rend() +// +// Copyright 2012 Eric Niebler. 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 BOOST_PROTO_FUNCTIONAL_RANGE_REND_HPP_EAN_27_08_2012 +#define BOOST_PROTO_FUNCTIONAL_RANGE_REND_HPP_EAN_27_08_2012 + +#include <boost/range/rend.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + + // A PolymorphicFunctionObject that wraps boost::rend() + struct rend + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Rng> + struct result<This(Rng)> + : boost::range_reverse_iterator<Rng const> + {}; + + template<typename This, typename Rng> + struct result<This(Rng &)> + : boost::range_reverse_iterator<Rng> + {}; + + template<typename Rng> + typename boost::range_reverse_iterator<Rng>::type operator()(Rng &rng) const + { + return boost::rend(rng); + } + + template<typename Rng> + typename boost::range_reverse_iterator<Rng const>::type operator()(Rng const &rng) const + { + return boost::rend(rng); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/range/size.hpp b/3rdParty/Boost/src/boost/proto/functional/range/size.hpp new file mode 100644 index 0000000..3fcdda1 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/range/size.hpp @@ -0,0 +1,45 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file size.hpp +/// Proto callables for boost::size() +// +// Copyright 2012 Eric Niebler. 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 BOOST_PROTO_FUNCTIONAL_RANGE_SIZE_HPP_EAN_27_08_2012 +#define BOOST_PROTO_FUNCTIONAL_RANGE_SIZE_HPP_EAN_27_08_2012 + +#include <boost/range/size.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + + // A PolymorphicFunctionObject that wraps boost::size() + struct size + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Rng> + struct result<This(Rng)> + : boost::range_size<Rng> + {}; + + template<typename This, typename Rng> + struct result<This(Rng &)> + : boost::range_size<Rng> + {}; + + template<typename Rng> + typename boost::range_size<Rng>::type operator()(Rng const &rng) const + { + return boost::size(rng); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/std.hpp b/3rdParty/Boost/src/boost/proto/functional/std.hpp new file mode 100644 index 0000000..3875860 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/std.hpp @@ -0,0 +1,15 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file std.hpp +/// Proto callables for things found in the std library +// +// Copyright 2010 Eric Niebler. 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 BOOST_PROTO_FUNCTIONAL_STD_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_STD_HPP_EAN_11_27_2010 + +#include <boost/proto/functional/std/utility.hpp> +#include <boost/proto/functional/std/iterator.hpp> + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/std/iterator.hpp b/3rdParty/Boost/src/boost/proto/functional/std/iterator.hpp new file mode 100644 index 0000000..3ee2c25 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/std/iterator.hpp @@ -0,0 +1,158 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file iterator.hpp +/// Proto callables for std functions found in \<iterator\> +// +// Copyright 2012 Eric Niebler. 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 BOOST_PROTO_FUNCTIONAL_STD_ITERATOR_HPP_EAN_27_08_2012 +#define BOOST_PROTO_FUNCTIONAL_STD_ITERATOR_HPP_EAN_27_08_2012 + +#include <iterator> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + + // A PolymorphicFunctionObject wrapping std::advance + struct advance + { + BOOST_PROTO_CALLABLE() + + typedef void result_type; + + template<typename InputIterator, typename Distance> + void operator()(InputIterator &x, Distance n) const + { + std::advance(x, n); + } + }; + + // A PolymorphicFunctionObject wrapping std::distance + struct distance + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename InputIter1, typename InputIter2> + struct result<This(InputIter1, InputIter2)> + { + typedef + typename std::iterator_traits< + typename boost::remove_const< + typename boost::remove_reference<InputIter1>::type + >::type + >::difference_type + type; + }; + + template<typename InputIterator> + typename std::iterator_traits<InputIterator>::difference_type + operator()(InputIterator first, InputIterator last) const + { + return std::distance(first, last); + } + }; + + // A PolymorphicFunctionObject wrapping std::next + struct next + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename ForwardIterator> + struct result<This(ForwardIterator)> + { + typedef + typename boost::remove_const< + typename boost::remove_reference<ForwardIterator>::type + >::type + type; + }; + + template<typename This, typename ForwardIterator, typename Distance> + struct result<This(ForwardIterator, Distance)> + { + typedef + typename boost::remove_const< + typename boost::remove_reference<ForwardIterator>::type + >::type + type; + }; + + template<typename ForwardIterator> + ForwardIterator operator()(ForwardIterator x) const + { + return std::advance( + x + , static_cast<typename std::iterator_traits<ForwardIterator>::difference_type>(1) + ); + } + + template<typename ForwardIterator> + ForwardIterator operator()( + ForwardIterator x + , typename std::iterator_traits<ForwardIterator>::difference_type n + ) const + { + return std::advance(x, n); + } + }; + + // A PolymorphicFunctionObject wrapping std::prior + struct prior + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename BidirectionalIterator> + struct result<This(BidirectionalIterator)> + { + typedef + typename boost::remove_const< + typename boost::remove_reference<BidirectionalIterator>::type + >::type + type; + }; + + template<typename This, typename BidirectionalIterator, typename Distance> + struct result<This(BidirectionalIterator, Distance)> + { + typedef + typename boost::remove_const< + typename boost::remove_reference<BidirectionalIterator>::type + >::type + type; + }; + + template<typename BidirectionalIterator> + BidirectionalIterator operator()(BidirectionalIterator x) const + { + return std::advance( + x + , -static_cast<typename std::iterator_traits<BidirectionalIterator>::difference_type>(1) + ); + } + + template<typename BidirectionalIterator> + BidirectionalIterator operator()( + BidirectionalIterator x + , typename std::iterator_traits<BidirectionalIterator>::difference_type n + ) const + { + return std::advance(x, -n); + } + }; + +}}} + +#endif diff --git a/3rdParty/Boost/src/boost/proto/functional/std/utility.hpp b/3rdParty/Boost/src/boost/proto/functional/std/utility.hpp new file mode 100644 index 0000000..c1270d3 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/functional/std/utility.hpp @@ -0,0 +1,137 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file utility.hpp +/// Proto callables for things found in the std \<utility\> header +// +// Copyright 2010 Eric Niebler. 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 BOOST_PROTO_FUNCTIONAL_STD_UTILITY_HPP_EAN_11_27_2010 +#define BOOST_PROTO_FUNCTIONAL_STD_UTILITY_HPP_EAN_11_27_2010 + +#include <utility> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/proto/proto_fwd.hpp> + +namespace boost { namespace proto { namespace functional +{ + /// \brief A PolymorphicFunctionObject type that invokes the + /// \c std::make_pair() algorithm on its arguments. + /// + /// A PolymorphicFunctionObject type that invokes the + /// \c std::make_pair() algorithm on its arguments. + struct make_pair + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename First, typename Second> + struct result<This(First, Second)> + { + typedef + std::pair< + typename remove_const<typename remove_reference<First>::type>::type + , typename remove_const<typename remove_reference<Second>::type>::type + > + type; + }; + + template<typename First, typename Second> + std::pair<First, Second> operator()(First const &first, Second const &second) const + { + return std::make_pair(first, second); + } + }; + + /// \brief A PolymorphicFunctionObject type that returns + /// the first element of a std::pair. + /// + /// A PolymorphicFunctionObject type that returns + /// the first element of a std::pair.. + struct first + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Pair> + struct result<This(Pair)> + { + typedef typename Pair::first_type type; + }; + + template<typename This, typename Pair> + struct result<This(Pair &)> + { + typedef typename Pair::first_type &type; + }; + + template<typename This, typename Pair> + struct result<This(Pair const &)> + { + typedef typename Pair::first_type const &type; + }; + + template<typename Pair> + typename Pair::first_type &operator()(Pair &pair) const + { + return pair.first; + } + + template<typename Pair> + typename Pair::first_type const &operator()(Pair const &pair) const + { + return pair.first; + } + }; + + /// \brief A PolymorphicFunctionObject type that returns + /// the second element of a std::pair. + /// + /// A PolymorphicFunctionObject type that returns + /// the second element of a std::pair.. + struct second + { + BOOST_PROTO_CALLABLE() + + template<typename Sig> + struct result; + + template<typename This, typename Pair> + struct result<This(Pair)> + { + typedef typename Pair::second_type type; + }; + + template<typename This, typename Pair> + struct result<This(Pair &)> + { + typedef typename Pair::second_type &type; + }; + + template<typename This, typename Pair> + struct result<This(Pair const &)> + { + typedef typename Pair::second_type const &type; + }; + + template<typename Pair> + typename Pair::second_type &operator()(Pair &pair) const + { + return pair.second; + } + + template<typename Pair> + typename Pair::second_type const &operator()(Pair const &pair) const + { + return pair.second; + } + }; + +}}} + +#endif |