nathan/agrarian
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

stabilize build system: depends, installer, boost/bdb fixes, cross targets groundwork

Browse Source
This commit is contained in:
Nathan Slaven
2026-02-24 18:38:47 +00:00
parent da8c28aaeb
commit 65cb2619a7
13106 changed files with 2484322 additions and 1804 deletions
Download Patch File Download Diff File Expand all files Collapse all files
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/as_const.hpp
+30
View File
@@ -0,0 +1,30 @@
/*=============================================================================
Copyright (c) 2012 Nathan Ridge
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_FUSION_SUPPORT_AS_CONST_HPP
#define BOOST_FUSION_SUPPORT_AS_CONST_HPP
#include <boost/config.hpp>
#include <boost/fusion/support/config.hpp>
namespace boost { namespace fusion { namespace extension
{
// A customization point that allows certain wrappers around
// Fusion sequence elements (e.g. adt_attribute_proxy) to be
// unwrapped in contexts where the element only needs to be
// read. The library wraps accesses to Fusion elements in
// such contexts with calls to this function. Users can
// specialize this function for their own wrappers.
template <typename T>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline const T& as_const(const T& obj) BOOST_NOEXCEPT
{
return obj;
}
}}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/category_of.hpp
+122
View File
@@ -0,0 +1,122 @@
/*=============================================================================
Copyright (c) 2001-2011 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)
==============================================================================*/
#if !defined(FUSION_CATEGORY_OF_07202005_0308)
#define FUSION_CATEGORY_OF_07202005_0308
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/support/detail/category_of.hpp>
#include <boost/fusion/support/tag_of.hpp>
#include <boost/type_traits/is_base_of.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct boost_tuple_tag; // boost::tuples::tuple tag
struct boost_array_tag; // boost::array tag
struct mpl_sequence_tag; // mpl sequence tag
struct std_pair_tag; // std::pair tag
struct incrementable_traversal_tag {};
struct single_pass_traversal_tag
: incrementable_traversal_tag {};
struct forward_traversal_tag
: single_pass_traversal_tag {};
struct bidirectional_traversal_tag
: forward_traversal_tag {};
struct random_access_traversal_tag
: bidirectional_traversal_tag {};
struct associative_tag {};
struct unbounded_tag {};
namespace extension
{
template<typename Tag>
struct category_of_impl
{
template<typename T>
struct apply : detail::fusion_category_of<T> {};
};
template <>
struct category_of_impl<boost_tuple_tag>;
template <>
struct category_of_impl<boost_array_tag>;
template <>
struct category_of_impl<mpl_sequence_tag>;
template <>
struct category_of_impl<std_pair_tag>;
}
namespace traits
{
template <typename T>
struct category_of
: extension::category_of_impl<typename fusion::detail::tag_of<T>::type>::
template apply<T>
{};
template <typename T>
struct is_associative
: is_base_of<
associative_tag
, typename category_of<T>::type>
{};
template <typename T>
struct is_incrementable
: is_base_of<
incrementable_traversal_tag
, typename category_of<T>::type>
{};
template <typename T>
struct is_single_pass
: is_base_of<
single_pass_traversal_tag
, typename category_of<T>::type>
{};
template <typename T>
struct is_forward
: is_base_of<
forward_traversal_tag
, typename category_of<T>::type>
{};
template <typename T>
struct is_bidirectional
: is_base_of<
bidirectional_traversal_tag
, typename category_of<T>::type>
{};
template <typename T>
struct is_random_access
: is_base_of<
random_access_traversal_tag
, typename category_of<T>::type>
{};
template <typename T>
struct is_unbounded
: is_base_of<
unbounded_tag
, typename category_of<T>::type>
{};
}
}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/config.hpp
+99
View File
@@ -0,0 +1,99 @@
/*=============================================================================
Copyright (c) 2014 Eric Niebler
Copyright (c) 2014 Kohei Takahashi
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)
==============================================================================*/
#if !defined(FUSION_SUPPORT_CONFIG_01092014_1718)
#define FUSION_SUPPORT_CONFIG_01092014_1718
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <utility>
#ifndef BOOST_FUSION_GPU_ENABLED
#define BOOST_FUSION_GPU_ENABLED BOOST_GPU_ENABLED
#endif
// Enclose with inline namespace because unqualified lookup of GCC < 4.5 is broken.
//
// namespace detail {
// struct foo;
// struct X { };
// }
//
// template <typename T> void foo(T) { }
//
// int main()
// {
// foo(detail::X());
// // prog.cc: In function 'int main()':
// // prog.cc:2: error: 'struct detail::foo' is not a function,
// // prog.cc:6: error: conflict with 'template<class T> void foo(T)'
// // prog.cc:10: error: in call to 'foo'
// }
namespace boost { namespace fusion { namespace detail
{
namespace barrier { }
using namespace barrier;
}}}
#define BOOST_FUSION_BARRIER_BEGIN namespace barrier {
#define BOOST_FUSION_BARRIER_END }
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1900))
// All of rvalue-reference ready MSVC don't perform implicit conversion from
// fundamental type to rvalue-reference of another fundamental type [1].
//
// Following example doesn't compile
//
// int i;
// long &&l = i; // sigh..., std::forward<long&&>(i) also fail.
//
// however, following one will work.
//
// int i;
// long &&l = static_cast<long &&>(i);
//
// OK, now can we replace all usage of std::forward to static_cast? -- I say NO!
// All of rvalue-reference ready Clang doesn't compile above static_cast usage [2], sigh...
//
// References:
// 1. https://connect.microsoft.com/VisualStudio/feedback/details/1037806/implicit-conversion-doesnt-perform-for-fund
// 2. http://llvm.org/bugs/show_bug.cgi?id=19917
//
// Tentatively, we use static_cast to forward if run under MSVC.
# define BOOST_FUSION_FWD_ELEM(type, value) static_cast<type&&>(value)
#else
# define BOOST_FUSION_FWD_ELEM(type, value) std::forward<type>(value)
#endif
// Workaround for LWG 2408: C++17 SFINAE-friendly std::iterator_traits.
// http://cplusplus.github.io/LWG/lwg-defects.html#2408
//
// - GCC 4.5 enables the feature under C++11.
// https://gcc.gnu.org/ml/gcc-patches/2014-11/msg01105.html
//
// - MSVC 10.0 implements iterator intrinsics; MSVC 13.0 implements LWG2408.
#if (defined(BOOST_LIBSTDCXX_VERSION) && (BOOST_LIBSTDCXX_VERSION < 40500) && \
defined(BOOST_LIBSTDCXX11)) || \
(defined(BOOST_MSVC) && (1600 <= BOOST_MSVC && BOOST_MSVC < 1900))
# define BOOST_FUSION_WORKAROUND_FOR_LWG_2408
namespace std
{
template <typename>
struct iterator_traits;
}
#endif
// Workaround for older GCC that doesn't accept `this` in constexpr.
#if BOOST_WORKAROUND(BOOST_GCC, < 40700)
#define BOOST_FUSION_CONSTEXPR_THIS
#else
#define BOOST_FUSION_CONSTEXPR_THIS BOOST_CONSTEXPR
#endif
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/deduce.hpp
+137
View File
@@ -0,0 +1,137 @@
/*=============================================================================
Copyright (c) 2007 Tobias Schwinger
Use modification and distribution are subject to 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).
==============================================================================*/
#if !defined(BOOST_FUSION_SUPPORT_DEDUCE_HPP_INCLUDED)
#define BOOST_FUSION_SUPPORT_DEDUCE_HPP_INCLUDED
#include <boost/fusion/support/config.hpp>
#include <boost/ref.hpp>
#ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL
#include <functional>
#endif
namespace boost { namespace fusion { namespace traits
{
template <typename T> struct deduce;
//----- ---- --- -- - - - -
// Non-references pass unchanged
template <typename T>
struct deduce
{
typedef T type;
};
template <typename T>
struct deduce<T const>
{
typedef T type;
};
template <typename T>
struct deduce<T volatile>
{
typedef T type;
};
template <typename T>
struct deduce<T const volatile>
{
typedef T type;
};
// Keep references on mutable LValues
template <typename T>
struct deduce<T &>
{
typedef T & type;
};
template <typename T>
struct deduce<T volatile&>
{
typedef T volatile& type;
};
// Store away potential RValues
template <typename T>
struct deduce<T const&>
{
typedef T type;
};
template <typename T>
struct deduce<T const volatile&>
{
typedef T type;
};
// Unwrap Boost.RefS (referencee cv is deduced)
template <typename T>
struct deduce<reference_wrapper<T> & >
{
typedef T& type;
};
template <typename T>
struct deduce<reference_wrapper<T> const & >
{
typedef T& type;
};
// Also unwrap C++11 std::ref if available (referencee cv is deduced)
#ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL
template <typename T>
struct deduce<std::reference_wrapper<T> &>
{
typedef T& type;
};
template <typename T>
struct deduce<std::reference_wrapper<T> const &>
{
typedef T& type;
};
#endif
// Keep references on arrays, even if const
template <typename T, int N>
struct deduce<T(&)[N]>
{
typedef T(&type)[N];
};
template <typename T, int N>
struct deduce<volatile T(&)[N]>
{
typedef volatile T(&type)[N];
};
template <typename T, int N>
struct deduce<const T(&)[N]>
{
typedef const T(&type)[N];
};
template <typename T, int N>
struct deduce<const volatile T(&)[N]>
{
typedef const volatile T(&type)[N];
};
}}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/deduce_sequence.hpp
+54
View File
@@ -0,0 +1,54 @@
/*=============================================================================
Copyright (c) 2007 Tobias Schwinger
Use modification and distribution are subject to 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).
==============================================================================*/
#if !defined(BOOST_FUSION_SUPPORT_DEDUCE_SEQUENCE_HPP_INCLUDED)
#define BOOST_FUSION_SUPPORT_DEDUCE_SEQUENCE_HPP_INCLUDED
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/support/deduce.hpp>
#include <boost/fusion/container/vector/convert.hpp>
#include <boost/fusion/view/transform_view.hpp>
#include <boost/config.hpp>
namespace boost { namespace fusion { namespace traits
{
template <class Sequence> struct deduce_sequence;
namespace detail
{
struct deducer
{
template <typename Sig>
struct result;
template <class Self, typename T>
struct result< Self(T) >
: fusion::traits::deduce<T>
{ };
// never called, but needed for decltype-based result_of (C++0x)
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
template <typename T>
BOOST_FUSION_GPU_ENABLED
typename result< deducer(T) >::type
operator()(T&&) const;
#endif
};
}
template <class Sequence>
struct deduce_sequence
: result_of::as_vector<
fusion::transform_view<Sequence, detail::deducer> >
{ };
}}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/detail/access.hpp
+65
View File
@@ -0,0 +1,65 @@
/*=============================================================================
Copyright (c) 2001-2011 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)
==============================================================================*/
#if !defined(FUSION_ACCESS_04182005_0737)
#define FUSION_ACCESS_04182005_0737
#include <boost/fusion/support/config.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_reference.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename T>
struct ref_result
{
typedef typename add_reference<T>::type type;
};
template <typename T>
struct cref_result
{
typedef typename
add_reference<
typename add_const<T>::type
>::type
type;
};
template <typename T>
struct call_param
{
typedef T const& type;
};
template <typename T>
struct call_param<T&>
{
typedef T& type;
};
template <typename T>
struct call_param<T const>
{
typedef T const& type;
};
template <typename T>
struct call_param<T volatile>
{
typedef T const& type;
};
template <typename T>
struct call_param<T const volatile>
{
typedef T const& type;
};
}}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/detail/and.hpp
+39
View File
@@ -0,0 +1,39 @@
/*=============================================================================
Copyright (c) 2016 Lee Clagett
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 FUSION_AND_07152016_1625
#define FUSION_AND_07152016_1625
#include <boost/config.hpp>
#include <boost/type_traits/integral_constant.hpp>
#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
#error fusion::detail::and_ requires variadic templates
#endif
namespace boost { namespace fusion { namespace detail {
template<typename ...Cond>
struct and_impl : false_type {};
template<typename ...T>
struct and_impl<integral_constant<T, true>...> : true_type {};
// This specialization is necessary to avoid MSVC-12 variadics bug.
template<bool ...Cond>
struct and_impl1 : and_impl<integral_constant<bool, Cond>...> {};
/* fusion::detail::and_ differs from mpl::and_ in the following ways:
- The empty set is valid and returns true
- A single element set is valid and returns the identity
- There is no upper bound on the set size
- The conditions are evaluated at once, and are not short-circuited. This
reduces instantations when returning true; the implementation is not
recursive. */
template<typename ...Cond>
struct and_ : and_impl1<Cond::value...> {};
}}}
#endif // FUSION_AND_07152016_1625
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/detail/as_fusion_element.hpp
+60
View File
@@ -0,0 +1,60 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko Jarvi
Copyright (c) 2001-2011 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)
==============================================================================*/
#if !defined(FUSION_AS_FUSION_ELEMENT_05052005_0338)
#define FUSION_AS_FUSION_ELEMENT_05052005_0338
#include <boost/fusion/support/config.hpp>
#include <boost/ref.hpp>
#ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL
#include <functional>
#endif
namespace boost { namespace fusion { namespace detail
{
template <typename T>
struct as_fusion_element
{
typedef T type;
};
template <typename T>
struct as_fusion_element<reference_wrapper<T> >
{
typedef T& type;
};
#ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL
template <typename T>
struct as_fusion_element<std::reference_wrapper<T> >
{
typedef T& type;
};
#endif
template <typename T, int N>
struct as_fusion_element<T[N]>
{
typedef const T(&type)[N];
};
template <typename T, int N>
struct as_fusion_element<volatile T[N]>
{
typedef const volatile T(&type)[N];
};
template <typename T, int N>
struct as_fusion_element<const volatile T[N]>
{
typedef const volatile T(&type)[N];
};
}}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/detail/category_of.hpp
+19
View File
@@ -0,0 +1,19 @@
/*=============================================================================
Copyright (c) 2001-2011 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)
==============================================================================*/
#if !defined(FUSION_CATEGORY_OF_07212005_1025)
#define FUSION_CATEGORY_OF_07212005_1025
namespace boost { namespace fusion { namespace detail
{
template <typename T>
struct fusion_category_of
{
typedef typename T::category type;
};
}}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/detail/enabler.hpp
+22
View File
@@ -0,0 +1,22 @@
/*=============================================================================
Copyright (c) 2015 Kohei Takahashi
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_FUSION_SUPPORT_DETAIL_ENABLER_12102015_0346
#define BOOST_FUSION_SUPPORT_DETAIL_ENABLER_12102015_0346
#include <boost/config.hpp>
namespace boost { namespace fusion { namespace detail
{
struct enabler_ {};
BOOST_STATIC_CONSTEXPR enabler_ enabler = {};
}}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/detail/index_sequence.hpp
+79
View File
@@ -0,0 +1,79 @@
/*=============================================================================
Copyright (c) 2015 Agustin K-ballo Berge
Copyright (c) 2015 Kohei Takahashi
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_FUSION_SUPPORT_DETAIL_INDEX_SEQUENCE_06232015_1038
#define BOOST_FUSION_SUPPORT_DETAIL_INDEX_SEQUENCE_06232015_1038
#include <boost/fusion/support/config.hpp>
#include <cstddef>
// GCC5 has O(logN) implementation, see https://gcc.gnu.org/PR66059 .
#if (defined(__cpp_lib_integer_sequence) && __cpp_lib_integer_sequence >= 201304) \
|| (defined(BOOST_LIBSTDCXX_VERSION) \
&& BOOST_LIBSTDCXX_VERSION >= 500000 && __cplusplus >= 201402)
#include <utility>
#define BOOST_FUSION_STDLIB_HAS_INTEGER_SEQUENCE
#endif
namespace boost { namespace fusion { namespace detail
{
#ifdef BOOST_FUSION_STDLIB_HAS_INTEGER_SEQUENCE
// Use aliasing templates without checking availability, the compiler should work.
template <std::size_t ...Ints>
using index_sequence = std::index_sequence<Ints...>;
template <std::size_t N>
struct make_index_sequence
{
using type = std::make_index_sequence<N>;
};
#else
template <std::size_t ...Ints>
struct index_sequence
{
typedef std::size_t value_type;
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
static std::size_t size() BOOST_NOEXCEPT
{ return sizeof...(Ints); }
// non standard extension
typedef index_sequence type;
};
template <typename Left, typename Right>
struct _make_index_sequence_join;
template <std::size_t... Left, std::size_t... Right>
struct _make_index_sequence_join<
index_sequence<Left...>, index_sequence<Right...>
> : index_sequence<Left..., (sizeof...(Left) + Right)...>
{};
template <std::size_t N>
struct make_index_sequence
: _make_index_sequence_join<
typename make_index_sequence<N / 2>::type
, typename make_index_sequence<N - N / 2>::type
>
{};
template <>
struct make_index_sequence<1>
: index_sequence<0>
{};
template <>
struct make_index_sequence<0>
: index_sequence<>
{};
#endif
}}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/detail/is_mpl_sequence.hpp
+28
View File
@@ -0,0 +1,28 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
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)
==============================================================================*/
#if !defined(FUSION_DETAIL_IS_MPL_SEQUENCE_29122006_1105)
#define FUSION_DETAIL_IS_MPL_SEQUENCE_29122006_1105
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/mpl/is_sequence.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/not.hpp>
#include <boost/type_traits/is_convertible.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename T>
struct is_mpl_sequence
: mpl::and_<
mpl::not_<is_convertible<T, from_sequence_convertible_type> >
, mpl::is_sequence<T> >
{};
}}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/detail/is_same_size.hpp
+29
View File
@@ -0,0 +1,29 @@
/*=============================================================================
Copyright (c) 2014-2015 Kohei Takahashi
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 FUSION_IS_SAME_SIZE_10082015_1156
#define FUSION_IS_SAME_SIZE_10082015_1156
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/core/enable_if.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/equal_to.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename Sequence1, typename Sequence2, typename = void, typename = void>
struct is_same_size : mpl::false_ {};
template <typename Sequence1, typename Sequence2>
struct is_same_size<Sequence1, Sequence2,
typename enable_if<traits::is_sequence<Sequence1> >::type,
typename enable_if<traits::is_sequence<Sequence2> >::type>
: mpl::equal_to<result_of::size<Sequence1>, result_of::size<Sequence2> >
{};
}}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/detail/is_view.hpp
+19
View File
@@ -0,0 +1,19 @@
/*=============================================================================
Copyright (c) 2001-2011 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)
==============================================================================*/
#if !defined(FUSION_IS_VIEW_03202006_0018)
#define FUSION_IS_VIEW_03202006_0018
namespace boost { namespace fusion { namespace detail
{
template <typename T>
struct fusion_is_view
{
typedef typename T::is_view type;
};
}}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/detail/mpl_iterator_category.hpp
+66
View File
@@ -0,0 +1,66 @@
/*=============================================================================
Copyright (c) 2001-2011 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)
==============================================================================*/
#if !defined(FUSION_MPL_ITERATOR_CATEGORY_07212005_0923)
#define FUSION_MPL_ITERATOR_CATEGORY_07212005_0923
namespace boost { namespace mpl
{
struct forward_iterator_tag;
struct bidirectional_iterator_tag;
struct random_access_iterator_tag;
}}
namespace boost { namespace fusion
{
struct forward_traversal_tag;
struct bidirectional_traversal_tag;
struct random_access_traversal_tag;
}}
namespace boost { namespace fusion { namespace detail
{
template <typename Category>
struct mpl_iterator_category;
template <>
struct mpl_iterator_category<mpl::forward_iterator_tag>
{
typedef forward_traversal_tag type;
};
template <>
struct mpl_iterator_category<mpl::bidirectional_iterator_tag>
{
typedef bidirectional_traversal_tag type;
};
template <>
struct mpl_iterator_category<mpl::random_access_iterator_tag>
{
typedef random_access_traversal_tag type;
};
template <>
struct mpl_iterator_category<forward_traversal_tag>
{
typedef forward_traversal_tag type;
};
template <>
struct mpl_iterator_category<bidirectional_traversal_tag>
{
typedef bidirectional_traversal_tag type;
};
template <>
struct mpl_iterator_category<random_access_traversal_tag>
{
typedef random_access_traversal_tag type;
};
}}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/detail/pp_round.hpp
+72
View File
@@ -0,0 +1,72 @@
/*=============================================================================
Copyright (c) 2011 Thomas Heller
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_BOOST_FUSION_SUPPORT_PP_ROUND_HPP
#define BOOST_BOOST_FUSION_SUPPORT_PP_ROUND_HPP
#include <boost/fusion/support/config.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/comparison/less.hpp>
#include <boost/preprocessor/control/if.hpp>
#define BOOST_FUSION_PP_ROUND_UP(N) \
BOOST_PP_CAT(BOOST_FUSION_PP_DO_ROUND_UP_, N)() \
/**/
#define BOOST_FUSION_PP_DO_ROUND_UP_0() 10
#define BOOST_FUSION_PP_DO_ROUND_UP_1() 10
#define BOOST_FUSION_PP_DO_ROUND_UP_2() 10
#define BOOST_FUSION_PP_DO_ROUND_UP_3() 10
#define BOOST_FUSION_PP_DO_ROUND_UP_4() 10
#define BOOST_FUSION_PP_DO_ROUND_UP_5() 10
#define BOOST_FUSION_PP_DO_ROUND_UP_6() 10
#define BOOST_FUSION_PP_DO_ROUND_UP_7() 10
#define BOOST_FUSION_PP_DO_ROUND_UP_8() 10
#define BOOST_FUSION_PP_DO_ROUND_UP_9() 10
#define BOOST_FUSION_PP_DO_ROUND_UP_10() 10
#define BOOST_FUSION_PP_DO_ROUND_UP_11() 20
#define BOOST_FUSION_PP_DO_ROUND_UP_12() 20
#define BOOST_FUSION_PP_DO_ROUND_UP_13() 20
#define BOOST_FUSION_PP_DO_ROUND_UP_14() 20
#define BOOST_FUSION_PP_DO_ROUND_UP_15() 20
#define BOOST_FUSION_PP_DO_ROUND_UP_16() 20
#define BOOST_FUSION_PP_DO_ROUND_UP_17() 20
#define BOOST_FUSION_PP_DO_ROUND_UP_18() 20
#define BOOST_FUSION_PP_DO_ROUND_UP_19() 20
#define BOOST_FUSION_PP_DO_ROUND_UP_20() 20
#define BOOST_FUSION_PP_DO_ROUND_UP_21() 30
#define BOOST_FUSION_PP_DO_ROUND_UP_22() 30
#define BOOST_FUSION_PP_DO_ROUND_UP_23() 30
#define BOOST_FUSION_PP_DO_ROUND_UP_24() 30
#define BOOST_FUSION_PP_DO_ROUND_UP_25() 30
#define BOOST_FUSION_PP_DO_ROUND_UP_26() 30
#define BOOST_FUSION_PP_DO_ROUND_UP_27() 30
#define BOOST_FUSION_PP_DO_ROUND_UP_28() 30
#define BOOST_FUSION_PP_DO_ROUND_UP_29() 30
#define BOOST_FUSION_PP_DO_ROUND_UP_30() 30
#define BOOST_FUSION_PP_DO_ROUND_UP_31() 40
#define BOOST_FUSION_PP_DO_ROUND_UP_32() 40
#define BOOST_FUSION_PP_DO_ROUND_UP_33() 40
#define BOOST_FUSION_PP_DO_ROUND_UP_34() 40
#define BOOST_FUSION_PP_DO_ROUND_UP_35() 40
#define BOOST_FUSION_PP_DO_ROUND_UP_36() 40
#define BOOST_FUSION_PP_DO_ROUND_UP_37() 40
#define BOOST_FUSION_PP_DO_ROUND_UP_38() 40
#define BOOST_FUSION_PP_DO_ROUND_UP_39() 40
#define BOOST_FUSION_PP_DO_ROUND_UP_40() 40
#define BOOST_FUSION_PP_DO_ROUND_UP_41() 50
#define BOOST_FUSION_PP_DO_ROUND_UP_42() 50
#define BOOST_FUSION_PP_DO_ROUND_UP_43() 50
#define BOOST_FUSION_PP_DO_ROUND_UP_44() 50
#define BOOST_FUSION_PP_DO_ROUND_UP_45() 50
#define BOOST_FUSION_PP_DO_ROUND_UP_46() 50
#define BOOST_FUSION_PP_DO_ROUND_UP_47() 50
#define BOOST_FUSION_PP_DO_ROUND_UP_48() 50
#define BOOST_FUSION_PP_DO_ROUND_UP_49() 50
#define BOOST_FUSION_PP_DO_ROUND_UP_50() 50
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/detail/segmented_fold_until_impl.hpp
+401
View File
@@ -0,0 +1,401 @@
/*=============================================================================
Copyright (c) 2011 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)
==============================================================================*/
#if !defined(BOOST_FUSION_SEGMENTED_FOLD_UNTIL_IMPL_HPP_INCLUDED)
#define BOOST_FUSION_SEGMENTED_FOLD_UNTIL_IMPL_HPP_INCLUDED
#include <boost/fusion/support/config.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/utility/result_of.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/fusion/support/void.hpp>
#include <boost/fusion/container/list/cons_fwd.hpp>
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
#include <boost/fusion/iterator/equal_to.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/support/is_segmented.hpp>
#include <boost/fusion/sequence/intrinsic/segments.hpp>
// fun(seq, state, context)
// seq: a non-segmented range
// state: the state of the fold so far
// context: the path to the current range
//
// returns: (state', fcontinue)
namespace boost { namespace fusion
{
template <typename First, typename Last>
struct iterator_range;
template <typename Context>
struct segmented_iterator;
namespace result_of
{
template <typename Cur, typename Context>
struct make_segmented_iterator
{
typedef
iterator_range<
Cur
, typename result_of::end<
typename remove_reference<
typename add_const<
typename result_of::deref<
typename Context::car_type::begin_type
>::type
>::type
>::type
>::type
>
range_type;
typedef
segmented_iterator<cons<range_type, Context> >
type;
};
}
template <typename Cur, typename Context>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::make_segmented_iterator<Cur, Context>::type
make_segmented_iterator(Cur const& cur, Context const& context)
{
typedef result_of::make_segmented_iterator<Cur, Context> impl_type;
typedef typename impl_type::type type;
typedef typename impl_type::range_type range_type;
return type(cons<range_type, Context>(range_type(cur, fusion::end(*context.car.first)), context));
}
namespace detail
{
template <
typename Begin
, typename End
, typename State
, typename Context
, typename Fun
, bool IsEmpty
>
struct segmented_fold_until_iterate_skip_empty;
template <
typename Begin
, typename End
, typename State
, typename Context
, typename Fun
, bool IsDone = result_of::equal_to<Begin, End>::type::value
>
struct segmented_fold_until_iterate;
template <
typename Sequence
, typename State
, typename Context
, typename Fun
, bool IsSegmented = traits::is_segmented<Sequence>::type::value
>
struct segmented_fold_until_impl;
template <typename Segments, typename State, typename Context, typename Fun>
struct segmented_fold_until_on_segments;
//auto push_context(cur, end, context)
//{
// return push_back(context, segment_sequence(iterator_range(cur, end)));
//}
template <typename Cur, typename End, typename Context>
struct push_context
{
typedef iterator_range<Cur, End> range_type;
typedef cons<range_type, Context> type;
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
static type call(Cur const& cur, End const& end, Context const& context)
{
return cons<range_type, Context>(range_type(cur, end), context);
}
};
//auto make_segmented_iterator(cur, end, context)
//{
// return segmented_iterator(push_context(cur, end, context));
//}
//
//auto segmented_fold_until_impl(seq, state, context, fun)
//{
// if (is_segmented(seq))
// {
// segmented_fold_until_on_segments(segments(seq), state, context, fun);
// }
// else
// {
// return fun(seq, state, context);
// }
//}
template <
typename Sequence
, typename State
, typename Context
, typename Fun
, bool IsSegmented
>
struct segmented_fold_until_impl
{
typedef
segmented_fold_until_on_segments<
typename remove_reference<
typename add_const<
typename result_of::segments<Sequence>::type
>::type
>::type
, State
, Context
, Fun
>
impl;
typedef typename impl::type type;
typedef typename impl::continue_type continue_type;
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
static type call(Sequence& seq, State const& state, Context const& context, Fun const& fun)
{
return impl::call(fusion::segments(seq), state, context, fun);
}
};
template <
typename Sequence
, typename State
, typename Context
, typename Fun
>
struct segmented_fold_until_impl<Sequence, State, Context, Fun, false>
{
typedef
typename Fun::template apply<Sequence, State, Context>
apply_type;
typedef typename apply_type::type type;
typedef typename apply_type::continue_type continue_type;
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
static type call(Sequence& seq, State const& state, Context const& context, Fun const& fun)
{
return apply_type::call(seq, state, context, fun);
}
};
//auto segmented_fold_until_on_segments(segs, state, context, fun)
//{
// auto cur = begin(segs), end = end(segs);
// for (; cur != end; ++cur)
// {
// if (empty(*cur))
// continue;
// auto context` = push_context(cur, end, context);
// state = segmented_fold_until_impl(*cur, state, context`, fun);
// if (!second(state))
// return state;
// }
//}
template <typename Apply>
struct continue_wrap
{
typedef typename Apply::continue_type type;
};
template <typename Begin, typename End, typename State, typename Context, typename Fun, bool IsEmpty>
struct segmented_fold_until_iterate_skip_empty
{
// begin != end and !empty(*begin)
typedef
push_context<Begin, End, Context>
push_context_impl;
typedef
typename push_context_impl::type
next_context_type;
typedef
segmented_fold_until_impl<
typename remove_reference<
typename add_const<
typename result_of::deref<Begin>::type
>::type
>::type
, State
, next_context_type
, Fun
>
fold_recurse_impl;
typedef
typename fold_recurse_impl::type
next_state_type;
typedef
segmented_fold_until_iterate<
typename result_of::next<Begin>::type
, End
, next_state_type
, Context
, Fun
>
next_iteration_impl;
typedef
typename mpl::eval_if<
typename fold_recurse_impl::continue_type
, next_iteration_impl
, mpl::identity<next_state_type>
>::type
type;
typedef
typename mpl::eval_if<
typename fold_recurse_impl::continue_type
, continue_wrap<next_iteration_impl>
, mpl::identity<mpl::false_>
>::type
continue_type;
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
static type call(Begin const& beg, End const& end, State const& state
, Context const& context, Fun const& fun)
{
return call(beg, end, state, context, fun, typename fold_recurse_impl::continue_type());
}
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
static type call(Begin const& beg, End const& end, State const& state
, Context const& context, Fun const& fun, mpl::true_) // continue
{
return next_iteration_impl::call(
fusion::next(beg)
, end
, fold_recurse_impl::call(
*beg
, state
, push_context_impl::call(beg, end, context)
, fun)
, context
, fun);
}
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
static type call(Begin const& beg, End const& end, State const& state
, Context const& context, Fun const& fun, mpl::false_) // break
{
return fold_recurse_impl::call(
*beg
, state
, push_context_impl::call(beg, end, context)
, fun);
}
};
template <typename Begin, typename End, typename State, typename Context, typename Fun>
struct segmented_fold_until_iterate_skip_empty<Begin, End, State, Context, Fun, true>
{
typedef
segmented_fold_until_iterate<
typename result_of::next<Begin>::type
, End
, State
, Context
, Fun
>
impl;
typedef typename impl::type type;
typedef typename impl::continue_type continue_type;
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
static type call(Begin const& beg, End const& end, State const& state
, Context const& context, Fun const& fun)
{
return impl::call(fusion::next(beg), end, state, context, fun);
}
};
template <typename Begin, typename End, typename State, typename Context, typename Fun, bool IsDone>
struct segmented_fold_until_iterate
{
typedef
typename result_of::empty<
typename remove_reference<
typename result_of::deref<Begin>::type
>::type
>::type
empty_type;
typedef
segmented_fold_until_iterate_skip_empty<Begin, End, State, Context, Fun, empty_type::value>
impl;
typedef typename impl::type type;
typedef typename impl::continue_type continue_type;
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
static type call(Begin const& beg, End const& end, State const& state
, Context const& context, Fun const& fun)
{
return impl::call(beg, end, state, context, fun);
}
};
template <typename Begin, typename End, typename State, typename Context, typename Fun>
struct segmented_fold_until_iterate<Begin, End, State, Context, Fun, true>
{
typedef State type;
typedef mpl::true_ continue_type;
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
static type call(Begin const&, End const&, State const& state
, Context const&, Fun const&)
{
return state;
}
};
template <typename Segments, typename State, typename Context, typename Fun>
struct segmented_fold_until_on_segments
{
typedef
segmented_fold_until_iterate<
typename result_of::begin<Segments>::type
, typename result_of::end<Segments>::type
, State
, Context
, Fun
>
impl;
typedef typename impl::type type;
typedef typename impl::continue_type continue_type;
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
static type call(Segments& segs, State const& state, Context const& context, Fun const& fun)
{
return impl::call(fusion::begin(segs), fusion::end(segs), state, context, fun);
}
};
}
}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/detail/unknown_key.hpp
+16
View File
@@ -0,0 +1,16 @@
/*=============================================================================
Copyright (c) 2001-2011 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)
==============================================================================*/
#if !defined(FUSION_UNKNOWN_KEY_09242005_1219)
#define FUSION_UNKNOWN_KEY_09242005_1219
namespace boost { namespace fusion { namespace detail
{
template <int index>
struct unknown_key {};
}}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/is_iterator.hpp
+21
View File
@@ -0,0 +1,21 @@
/*=============================================================================
Copyright (c) 2001-2011 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)
==============================================================================*/
#if !defined(FUSION_IS_ITERATOR_05062005_1219)
#define FUSION_IS_ITERATOR_05062005_1219
#include <boost/fusion/support/config.hpp>
#include <boost/type_traits/is_base_of.hpp>
namespace boost { namespace fusion
{
struct iterator_root;
template <typename T>
struct is_fusion_iterator : is_base_of<iterator_root, T> {};
}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/is_segmented.hpp
+55
View File
@@ -0,0 +1,55 @@
/*=============================================================================
Copyright (c) 2006 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)
==============================================================================*/
#if !defined(FUSION_IS_SEGMENTED_03202006_0015)
#define FUSION_IS_SEGMENTED_03202006_0015
#include <boost/fusion/support/config.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/fusion/support/tag_of.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct sequence_facade_tag;
struct iterator_range_tag;
namespace extension
{
template <typename Tag>
struct is_segmented_impl
{
template <typename Sequence>
struct apply
: mpl::false_
{};
};
template <>
struct is_segmented_impl<sequence_facade_tag>
{
template <typename Sequence>
struct apply : Sequence::is_segmented {};
};
template <>
struct is_segmented_impl<iterator_range_tag>;
}
namespace traits
{
template <typename Sequence>
struct is_segmented
: mpl::bool_<
(bool)extension::is_segmented_impl<typename traits::tag_of<Sequence>::type>::
template apply<Sequence>::type::value
>
{
};
}
}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/is_sequence.hpp
+77
View File
@@ -0,0 +1,77 @@
/*=============================================================================
Copyright (c) 2001-2011 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)
==============================================================================*/
#if !defined(FUSION_IS_SEQUENCE_05052005_1002)
#define FUSION_IS_SEQUENCE_05052005_1002
#include <boost/fusion/support/config.hpp>
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/fusion/support/tag_of.hpp>
#include <boost/mpl/is_sequence.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/is_same.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct non_fusion_tag;
struct boost_tuple_tag; // boost::tuples::tuple tag
struct boost_array_tag; // boost::array tag
struct mpl_sequence_tag; // mpl sequence tag
struct std_pair_tag; // std::pair tag
namespace extension
{
template <typename T>
struct is_sequence_impl
{
template <typename Sequence>
struct apply
: is_convertible<Sequence, fusion::detail::from_sequence_convertible_type>
{};
};
template <>
struct is_sequence_impl<non_fusion_tag>
{
template <typename T>
struct apply : mpl::false_ {};
};
template <>
struct is_sequence_impl<boost_tuple_tag>;
template <>
struct is_sequence_impl<boost_array_tag>;
template <>
struct is_sequence_impl<mpl_sequence_tag>;
template <>
struct is_sequence_impl<std_pair_tag>;
}
namespace traits
{
template <typename T>
struct is_sequence
: mpl::bool_<
(bool)extension::is_sequence_impl<
typename fusion::detail::tag_of<T>::type
>::template apply<T>::type::value
>
{};
template <typename Sequence, typename Enable = void>
struct is_native_fusion_sequence
: is_convertible<Sequence, fusion::detail::from_sequence_convertible_type>
{};
}
}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/is_view.hpp
+67
View File
@@ -0,0 +1,67 @@
/*=============================================================================
Copyright (c) 2001-2011 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)
==============================================================================*/
#if !defined(FUSION_IS_VIEW_03202006_0015)
#define FUSION_IS_VIEW_03202006_0015
#include <boost/fusion/support/config.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/fusion/support/detail/is_view.hpp>
#include <boost/fusion/support/tag_of.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct sequence_facade_tag;
struct boost_tuple_tag; // boost::tuples::tuple tag
struct boost_array_tag; // boost::array tag
struct mpl_sequence_tag; // mpl sequence tag
struct std_pair_tag; // std::pair tag
namespace extension
{
template<typename Tag>
struct is_view_impl
{
template <typename T>
struct apply
: detail::fusion_is_view<T>
{};
};
template <>
struct is_view_impl<sequence_facade_tag>
{
template <typename Sequence>
struct apply : Sequence::is_view {};
};
template <>
struct is_view_impl<boost_tuple_tag>;
template <>
struct is_view_impl<boost_array_tag>;
template <>
struct is_view_impl<mpl_sequence_tag>;
template <>
struct is_view_impl<std_pair_tag>;
}
namespace traits
{
template <typename T>
struct is_view :
mpl::bool_<
(bool)extension::is_view_impl<typename fusion::detail::tag_of<T>::type>::
template apply<T>::type::value
>
{};
}
}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/iterator_base.hpp
+36
View File
@@ -0,0 +1,36 @@
/*=============================================================================
Copyright (c) 2001-2011 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)
==============================================================================*/
#if !defined(FUSION_ITERATOR_BASE_05042005_1008)
#define FUSION_ITERATOR_BASE_05042005_1008
#include <boost/config.hpp>
#include <boost/fusion/support/config.hpp>
namespace boost { namespace fusion
{
struct iterator_root {};
template <typename Iterator>
struct iterator_base : iterator_root
{
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
Iterator const&
cast() const BOOST_NOEXCEPT
{
return static_cast<Iterator const&>(*this);
}
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
Iterator&
cast() BOOST_NOEXCEPT
{
return static_cast<Iterator&>(*this);
}
};
}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/pair.hpp
+168
View File
@@ -0,0 +1,168 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2006 Tobias Schwinger
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)
==============================================================================*/
#if !defined(FUSION_PAIR_07222005_1203)
#define FUSION_PAIR_07222005_1203
#include <boost/fusion/support/config.hpp>
#include <iosfwd>
#include <boost/fusion/support/detail/access.hpp>
#include <boost/fusion/support/detail/as_fusion_element.hpp>
#include <boost/config.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/is_lvalue_reference.hpp>
#if defined (BOOST_MSVC)
# pragma warning(push)
# pragma warning (disable: 4512) // assignment operator could not be generated.
#endif
namespace boost { namespace fusion
{
// A half runtime pair where the first type does not have data
template <typename First, typename Second>
struct pair
{
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
pair()
: second() {}
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
pair(pair const& rhs)
: second(rhs.second) {}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
pair(pair&& rhs)
: second(BOOST_FUSION_FWD_ELEM(Second, rhs.second)) {}
#endif
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
pair(typename detail::call_param<Second>::type val)
: second(val) {}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
template <typename Second2>
BOOST_FUSION_GPU_ENABLED
pair(Second2&& val
, typename boost::disable_if<is_lvalue_reference<Second2> >::type* /* dummy */ = 0
, typename boost::enable_if<is_convertible<Second2, Second> >::type* /*dummy*/ = 0
) : second(BOOST_FUSION_FWD_ELEM(Second, val)) {}
#endif
template <typename Second2>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
pair(pair<First, Second2> const& rhs)
: second(rhs.second) {}
template <typename Second2>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
pair& operator=(pair<First, Second2> const& rhs)
{
second = rhs.second;
return *this;
}
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
pair& operator=(pair const& rhs)
{
second = rhs.second;
return *this;
}
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
pair& operator=(pair&& rhs)
{
second = BOOST_FUSION_FWD_ELEM(Second, rhs.second);
return *this;
}
#endif
typedef First first_type;
typedef Second second_type;
Second second;
};
namespace result_of
{
template<typename First, typename Second>
struct make_pair
{
typedef fusion::pair<First,
typename detail::as_fusion_element<Second>::type> type;
};
template<class Pair>
struct first
{
typedef typename Pair::first_type type;
};
template<class Pair>
struct second
{
typedef typename Pair::second_type type;
};
}
template <typename First, typename Second>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::make_pair<First,Second>::type
make_pair(Second const& val)
{
return pair<First, typename detail::as_fusion_element<Second>::type>(val);
}
template <typename First, typename Second>
inline std::ostream&
operator<<(std::ostream& os, pair<First, Second> const& p)
{
os << p.second;
return os;
}
template <typename First, typename Second>
inline std::istream&
operator>>(std::istream& is, pair<First, Second>& p)
{
is >> p.second;
return is;
}
template <typename First, typename SecondL, typename SecondR>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline bool
operator==(pair<First, SecondL> const& l, pair<First, SecondR> const& r)
{
return l.second == r.second;
}
template <typename First, typename SecondL, typename SecondR>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline bool
operator!=(pair<First, SecondL> const& l, pair<First, SecondR> const& r)
{
return l.second != r.second;
}
template <typename First, typename SecondL, typename SecondR>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline bool
operator<(pair<First, SecondL> const& l, pair<First, SecondR> const& r)
{
return l.second < r.second;
}
}}
#if defined (BOOST_MSVC)
# pragma warning(pop)
#endif
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/segmented_fold_until.hpp
+71
View File
@@ -0,0 +1,71 @@
/*=============================================================================
Copyright (c) 2011 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)
==============================================================================*/
#if !defined(BOOST_FUSION_SEGMENTED_FOLD_UNTIL_HPP_INCLUDED)
#define BOOST_FUSION_SEGMENTED_FOLD_UNTIL_HPP_INCLUDED
#include <boost/fusion/support/config.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/fusion/support/detail/segmented_fold_until_impl.hpp>
namespace boost { namespace fusion
{
//auto segmented_fold_until(seq, state, fun)
//{
// return first(segmented_fold_until_impl(seq, state, nil_, fun));
//}
namespace result_of
{
template <typename Sequence, typename State, typename Fun>
struct segmented_fold_until
{
typedef
detail::segmented_fold_until_impl<
Sequence
, State
, fusion::nil_
, Fun
>
filter;
typedef
typename filter::type
type;
};
}
template <typename Sequence, typename State, typename Fun>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename
lazy_disable_if<
is_const<Sequence>
, result_of::segmented_fold_until<Sequence, State, Fun>
>::type
segmented_fold_until(Sequence& seq, State const& state, Fun const& fun)
{
typedef
typename result_of::segmented_fold_until<Sequence, State, Fun>::filter
filter;
return filter::call(seq, state, fusion::nil_(), fun);
}
template <typename Sequence, typename State, typename Fun>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::segmented_fold_until<Sequence const, State, Fun>::type
segmented_fold_until(Sequence const& seq, State const& state, Fun const& fun)
{
typedef
typename result_of::segmented_fold_until<Sequence const, State, Fun>::filter
filter;
return filter::call(seq, state, fusion::nil_(), fun);
}
}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/sequence_base.hpp
+59
View File
@@ -0,0 +1,59 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2007 Tobias Schwinger
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)
==============================================================================*/
#if !defined(FUSION_SEQUENCE_BASE_04182005_0737)
#define FUSION_SEQUENCE_BASE_04182005_0737
#include <boost/config.hpp>
#include <boost/fusion/support/config.hpp>
#include <boost/mpl/begin_end_fwd.hpp>
namespace boost { namespace fusion
{
namespace detail
{
struct from_sequence_convertible_type
{};
}
template <typename Sequence>
struct sequence_base
{
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
Sequence const&
derived() const BOOST_NOEXCEPT
{
return static_cast<Sequence const&>(*this);
}
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
Sequence&
derived() BOOST_NOEXCEPT
{
return static_cast<Sequence&>(*this);
}
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
operator detail::from_sequence_convertible_type() const BOOST_NOEXCEPT
{
return detail::from_sequence_convertible_type();
}
};
struct fusion_sequence_tag;
}}
namespace boost { namespace mpl
{
// Deliberately break mpl::begin, so it doesn't lie that a Fusion sequence
// is not an MPL sequence by returning mpl::void_.
// In other words: Fusion Sequences are always MPL Sequences, but they can
// be incompletely defined.
template<> struct begin_impl< boost::fusion::fusion_sequence_tag >;
}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/tag_of.hpp
+83
View File
@@ -0,0 +1,83 @@
/*=============================================================================
Copyright (c) 2001-2011 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)
==============================================================================*/
#if !defined(FUSION_TAG_OF_09232005_0845)
#define FUSION_TAG_OF_09232005_0845
#include <boost/fusion/support/config.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/fusion/support/tag_of_fwd.hpp>
#include <boost/fusion/support/detail/is_mpl_sequence.hpp>
#include <boost/mpl/has_xxx.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/if.hpp>
#include <boost/config/no_tr1/utility.hpp>
namespace boost
{
template <typename T, std::size_t N>
class array; // forward
namespace tuples
{
struct null_type;
template <
class T0, class T1, class T2, class T3, class T4,
class T5, class T6, class T7, class T8, class T9
>
class tuple;
template <class Head, class Tail>
struct cons;
}
}
namespace boost { namespace fusion
{
struct non_fusion_tag;
struct mpl_sequence_tag;
namespace detail
{
BOOST_MPL_HAS_XXX_TRAIT_DEF(fusion_tag)
template <typename Sequence, typename Active>
struct tag_of_impl
: mpl::if_<fusion::detail::is_mpl_sequence<Sequence>,
mpl::identity<mpl_sequence_tag>,
mpl::identity<non_fusion_tag> >::type
{};
template <typename Sequence>
struct tag_of_impl<
Sequence
, typename boost::enable_if<detail::has_fusion_tag<Sequence> >::type>
{
typedef typename Sequence::fusion_tag type;
};
}
namespace traits
{
template <typename Sequence, typename Active>
struct tag_of
: boost::fusion::detail::tag_of_impl<Sequence, Active>
{};
}
namespace detail
{
template<typename T>
struct tag_of
: traits::tag_of<typename remove_const<T>::type>
{};
}
}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/tag_of_fwd.hpp
+20
View File
@@ -0,0 +1,20 @@
/*=============================================================================
Copyright (c) 2001-2011 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
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)
==============================================================================*/
#if !defined(BOOST_FUSION_TAG_OF_FWD_31122005_1445)
#define BOOST_FUSION_TAG_OF_FWD_31122005_1445
namespace boost { namespace fusion
{
namespace traits
{
template<typename T, typename Active = void>
struct tag_of;
}
}}
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/unused.hpp
+95
View File
@@ -0,0 +1,95 @@
/*=============================================================================
Copyright (c) 2001-2011 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)
==============================================================================*/
#if !defined(BOOST_FUSION_SUPPORT_UNUSED_20070305_1038)
#define BOOST_FUSION_SUPPORT_UNUSED_20070305_1038
#include <boost/fusion/support/config.hpp>
#include <iosfwd>
#include <boost/config.hpp>
#if defined(BOOST_MSVC)
# pragma warning(push)
# pragma warning(disable: 4522) // multiple assignment operators specified warning
#endif
#define BOOST_FUSION_UNUSED_HAS_IO
namespace boost { namespace fusion
{
struct unused_type
{
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
unused_type() BOOST_NOEXCEPT
{
}
template <typename T>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
unused_type(T const&) BOOST_NOEXCEPT
{
}
template <typename T>
BOOST_FUSION_CONSTEXPR_THIS BOOST_FUSION_GPU_ENABLED
unused_type const&
operator=(T const&) const BOOST_NOEXCEPT
{
return *this;
}
template <typename T>
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
unused_type&
operator=(T const&) BOOST_NOEXCEPT
{
return *this;
}
BOOST_FUSION_CONSTEXPR_THIS BOOST_FUSION_GPU_ENABLED
unused_type const&
operator=(unused_type const&) const BOOST_NOEXCEPT
{
return *this;
}
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
unused_type&
operator=(unused_type const&) BOOST_NOEXCEPT
{
return *this;
}
};
BOOST_CONSTEXPR_OR_CONST unused_type unused = unused_type();
namespace detail
{
struct unused_only
{
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
unused_only(unused_type const&) BOOST_NOEXCEPT {}
};
}
BOOST_CONSTEXPR
inline std::ostream& operator<<(std::ostream& out, detail::unused_only const&) BOOST_NOEXCEPT
{
return out;
}
BOOST_CONSTEXPR
inline std::istream& operator>>(std::istream& in, unused_type&) BOOST_NOEXCEPT
{
return in;
}
}}
#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif
#endif
depends/x86_64-pc-linux-gnu/include/boost/fusion/support/void.hpp
+15
View File
@@ -0,0 +1,15 @@
/*=============================================================================
Copyright (c) 2001-2011 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)
==============================================================================*/
#if !defined(BOOST_FUSION_SUPPORT_VOID_20070706_2125)
#define BOOST_FUSION_SUPPORT_VOID_20070706_2125
namespace boost { namespace fusion
{
struct void_ {};
}}
#endif