stabilize build system: depends, installer, boost/bdb fixes, cross targets groundwork
This commit is contained in:
@@ -0,0 +1,134 @@
|
||||
/*=============================================================================
|
||||
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_AT_05042005_0722)
|
||||
#define FUSION_AT_05042005_0722
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/mpl/int.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/mpl/or.hpp>
|
||||
#include <boost/mpl/less.hpp>
|
||||
#include <boost/mpl/empty_base.hpp>
|
||||
#include <boost/type_traits/is_const.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
|
||||
#include <boost/fusion/support/tag_of.hpp>
|
||||
#include <boost/fusion/support/category_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
|
||||
struct std_tuple_tag; // std::tuple tag
|
||||
|
||||
namespace extension
|
||||
{
|
||||
template <typename Tag>
|
||||
struct at_impl
|
||||
{
|
||||
template <typename Sequence, typename N>
|
||||
struct apply;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct at_impl<sequence_facade_tag>
|
||||
{
|
||||
template <typename Sequence, typename N>
|
||||
struct apply : Sequence::template at<Sequence, N> {};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct at_impl<boost_tuple_tag>;
|
||||
|
||||
template <>
|
||||
struct at_impl<boost_array_tag>;
|
||||
|
||||
template <>
|
||||
struct at_impl<mpl_sequence_tag>;
|
||||
|
||||
template <>
|
||||
struct at_impl<std_pair_tag>;
|
||||
|
||||
template <>
|
||||
struct at_impl<std_tuple_tag>;
|
||||
}
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template <typename Sequence, typename N, typename Tag>
|
||||
struct at_impl
|
||||
: mpl::if_<
|
||||
mpl::or_<
|
||||
mpl::less<N, typename extension::size_impl<Tag>::template apply<Sequence>::type>
|
||||
, traits::is_unbounded<Sequence>
|
||||
>
|
||||
, typename extension::at_impl<Tag>::template apply<Sequence, N>
|
||||
, mpl::empty_base
|
||||
>::type
|
||||
{};
|
||||
}
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <typename Sequence, typename N>
|
||||
struct at
|
||||
: detail::at_impl<Sequence, N, typename detail::tag_of<Sequence>::type>
|
||||
{};
|
||||
|
||||
template <typename Sequence, int N>
|
||||
struct at_c
|
||||
: at<Sequence, mpl::int_<N> >
|
||||
{};
|
||||
}
|
||||
|
||||
|
||||
template <typename N, typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename
|
||||
lazy_disable_if<
|
||||
is_const<Sequence>
|
||||
, result_of::at<Sequence, N>
|
||||
>::type
|
||||
at(Sequence& seq)
|
||||
{
|
||||
return result_of::at<Sequence, N>::call(seq);
|
||||
}
|
||||
|
||||
template <typename N, typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename result_of::at<Sequence const, N>::type
|
||||
at(Sequence const& seq)
|
||||
{
|
||||
return result_of::at<Sequence const, N>::call(seq);
|
||||
}
|
||||
|
||||
template <int N, typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename
|
||||
lazy_disable_if<
|
||||
is_const<Sequence>
|
||||
, result_of::at_c<Sequence, N>
|
||||
>::type
|
||||
at_c(Sequence& seq)
|
||||
{
|
||||
return fusion::at<mpl::int_<N> >(seq);
|
||||
}
|
||||
|
||||
template <int N, typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename result_of::at_c<Sequence const, N>::type
|
||||
at_c(Sequence const& seq)
|
||||
{
|
||||
return fusion::at<mpl::int_<N> >(seq);
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
/*=============================================================================
|
||||
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_AT_C_08252008_0308)
|
||||
#define FUSION_AT_C_08252008_0308
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/at.hpp>
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,116 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
Copyright (c) 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_AT_KEY_20060304_1755)
|
||||
#define BOOST_FUSION_AT_KEY_20060304_1755
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/type_traits/is_const.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/has_key.hpp>
|
||||
#include <boost/fusion/algorithm/query/find.hpp>
|
||||
#include <boost/fusion/iterator/deref_data.hpp>
|
||||
#include <boost/fusion/support/tag_of.hpp>
|
||||
#include <boost/fusion/support/category_of.hpp>
|
||||
#include <boost/fusion/support/detail/access.hpp>
|
||||
#include <boost/mpl/empty_base.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/mpl/or.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
// Special tags:
|
||||
struct sequence_facade_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 at_key_impl
|
||||
{
|
||||
template <typename Seq, typename Key>
|
||||
struct apply
|
||||
{
|
||||
typedef typename
|
||||
result_of::deref_data<
|
||||
typename result_of::find<Seq, Key>::type
|
||||
>::type
|
||||
type;
|
||||
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type
|
||||
call(Seq& seq)
|
||||
{
|
||||
return fusion::deref_data(fusion::find<Key>(seq));
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct at_key_impl<sequence_facade_tag>
|
||||
{
|
||||
template <typename Sequence, typename Key>
|
||||
struct apply : Sequence::template at_key_impl<Sequence, Key> {};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct at_key_impl<boost_array_tag>;
|
||||
|
||||
template <>
|
||||
struct at_key_impl<mpl_sequence_tag>;
|
||||
|
||||
template <>
|
||||
struct at_key_impl<std_pair_tag>;
|
||||
}
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template <typename Sequence, typename Key, typename Tag>
|
||||
struct at_key_impl
|
||||
: mpl::if_<
|
||||
mpl::or_<
|
||||
typename extension::has_key_impl<Tag>::template apply<Sequence, Key>
|
||||
, traits::is_unbounded<Sequence>
|
||||
>
|
||||
, typename extension::at_key_impl<Tag>::template apply<Sequence, Key>
|
||||
, mpl::empty_base
|
||||
>::type
|
||||
{};
|
||||
}
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <typename Sequence, typename Key>
|
||||
struct at_key
|
||||
: detail::at_key_impl<Sequence, Key, typename detail::tag_of<Sequence>::type>
|
||||
{};
|
||||
}
|
||||
|
||||
template <typename Key, typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename
|
||||
lazy_disable_if<
|
||||
is_const<Sequence>
|
||||
, result_of::at_key<Sequence, Key>
|
||||
>::type
|
||||
at_key(Sequence& seq)
|
||||
{
|
||||
return result_of::at_key<Sequence, Key>::call(seq);
|
||||
}
|
||||
|
||||
template <typename Key, typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename result_of::at_key<Sequence const, Key>::type
|
||||
at_key(Sequence const& seq)
|
||||
{
|
||||
return result_of::at_key<Sequence const, Key>::call(seq);
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,46 @@
|
||||
/*=============================================================================
|
||||
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_BACK_09162005_0350)
|
||||
#define FUSION_BACK_09162005_0350
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/end.hpp>
|
||||
#include <boost/fusion/iterator/prior.hpp>
|
||||
#include <boost/fusion/iterator/deref.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
struct fusion_sequence_tag;
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct back
|
||||
: result_of::deref<typename result_of::prior<typename result_of::end<Sequence>::type>::type>
|
||||
{};
|
||||
}
|
||||
|
||||
template <typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename result_of::back<Sequence>::type
|
||||
back(Sequence& seq)
|
||||
{
|
||||
return *fusion::prior(fusion::end(seq));
|
||||
}
|
||||
|
||||
template <typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename result_of::back<Sequence const>::type
|
||||
back(Sequence const& seq)
|
||||
{
|
||||
return *fusion::prior(fusion::end(seq));
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,98 @@
|
||||
/*=============================================================================
|
||||
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_BEGIN_04052005_1132)
|
||||
#define FUSION_BEGIN_04052005_1132
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/mpl/empty_base.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
|
||||
#include <boost/fusion/support/tag_of.hpp>
|
||||
#include <boost/fusion/support/is_sequence.hpp>
|
||||
#include <boost/fusion/support/is_segmented.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/detail/segmented_begin.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
// Special tags:
|
||||
struct sequence_facade_tag; // iterator 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 begin_impl
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct apply
|
||||
: mpl::if_<
|
||||
traits::is_segmented<Sequence>
|
||||
, detail::segmented_begin<Sequence>
|
||||
, mpl::empty_base
|
||||
>::type
|
||||
{};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct begin_impl<sequence_facade_tag>
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct apply : Sequence::template begin<Sequence> {};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct begin_impl<boost_tuple_tag>;
|
||||
|
||||
template <>
|
||||
struct begin_impl<boost_array_tag>;
|
||||
|
||||
template <>
|
||||
struct begin_impl<mpl_sequence_tag>;
|
||||
|
||||
template <>
|
||||
struct begin_impl<std_pair_tag>;
|
||||
}
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct begin
|
||||
: extension::begin_impl<typename detail::tag_of<Sequence>::type>::
|
||||
template apply<Sequence>
|
||||
{};
|
||||
}
|
||||
|
||||
template <typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename
|
||||
lazy_enable_if<
|
||||
traits::is_sequence<Sequence>
|
||||
, result_of::begin<Sequence>
|
||||
>::type const
|
||||
begin(Sequence& seq)
|
||||
{
|
||||
return result_of::begin<Sequence>::call(seq);
|
||||
}
|
||||
|
||||
template <typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename
|
||||
lazy_enable_if<
|
||||
traits::is_sequence<Sequence>
|
||||
, result_of::begin<Sequence const>
|
||||
>::type const
|
||||
begin(Sequence const& seq)
|
||||
{
|
||||
return result_of::begin<Sequence const>::call(seq);
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
+45
@@ -0,0 +1,45 @@
|
||||
/*=============================================================================
|
||||
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_BEGIN_HPP_INCLUDED)
|
||||
#define BOOST_FUSION_SEGMENTED_BEGIN_HPP_INCLUDED
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/detail/segmented_begin_impl.hpp>
|
||||
#include <boost/fusion/iterator/segmented_iterator.hpp>
|
||||
#include <boost/fusion/view/iterator_range.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/begin.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/end.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/empty.hpp>
|
||||
#include <boost/fusion/container/list/cons.hpp>
|
||||
|
||||
namespace boost { namespace fusion { namespace detail
|
||||
{
|
||||
//auto segmented_begin( seq )
|
||||
//{
|
||||
// return make_segmented_iterator( segmented_begin_impl( seq, nil_ ) );
|
||||
//}
|
||||
|
||||
template <typename Sequence, typename Nil_ = fusion::nil_>
|
||||
struct segmented_begin
|
||||
{
|
||||
typedef
|
||||
segmented_iterator<
|
||||
typename segmented_begin_impl<Sequence, Nil_>::type
|
||||
>
|
||||
type;
|
||||
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type call(Sequence& seq)
|
||||
{
|
||||
return type(
|
||||
segmented_begin_impl<Sequence, Nil_>::call(seq, Nil_()));
|
||||
}
|
||||
};
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
+96
@@ -0,0 +1,96 @@
|
||||
/*=============================================================================
|
||||
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_BEGIN_IMPL_HPP_INCLUDED)
|
||||
#define BOOST_FUSION_SEGMENTED_BEGIN_IMPL_HPP_INCLUDED
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/type_traits/remove_const.hpp>
|
||||
#include <boost/fusion/container/list/cons_fwd.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
|
||||
#include <boost/fusion/support/is_segmented.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/detail/segmented_end_impl.hpp>
|
||||
#include <boost/fusion/support/detail/segmented_fold_until_impl.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
template <typename First, typename Last>
|
||||
struct iterator_range;
|
||||
}}
|
||||
|
||||
namespace boost { namespace fusion { namespace detail
|
||||
{
|
||||
struct segmented_begin_fun
|
||||
{
|
||||
template <typename Sequence, typename State, typename Context>
|
||||
struct apply
|
||||
{
|
||||
typedef
|
||||
iterator_range<
|
||||
typename fusion::result_of::begin<Sequence>::type
|
||||
, typename fusion::result_of::end<Sequence>::type
|
||||
>
|
||||
range_type;
|
||||
|
||||
typedef cons<range_type, Context> type;
|
||||
typedef mpl::false_ continue_type;
|
||||
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type call(Sequence& seq, State const&, Context const& context, segmented_begin_fun)
|
||||
{
|
||||
return type(range_type(fusion::begin(seq), fusion::end(seq)), context);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template <typename Sequence, typename Stack, bool IsSegmented = traits::is_segmented<Sequence>::type::value>
|
||||
struct segmented_begin_impl_aux
|
||||
{
|
||||
typedef
|
||||
segmented_end_impl<Sequence, Stack>
|
||||
end_impl;
|
||||
|
||||
typedef
|
||||
segmented_fold_until_impl<
|
||||
Sequence
|
||||
, typename end_impl::type
|
||||
, Stack
|
||||
, segmented_begin_fun
|
||||
>
|
||||
fold_impl;
|
||||
|
||||
typedef typename fold_impl::type type;
|
||||
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type call(Sequence& seq, Stack const& stack)
|
||||
{
|
||||
return fold_impl::call(seq, end_impl::call(seq, stack), stack, segmented_begin_fun());
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Sequence, typename Stack>
|
||||
struct segmented_begin_impl_aux<Sequence, Stack, false>
|
||||
{
|
||||
typedef typename result_of::begin<Sequence>::type begin_type;
|
||||
typedef typename result_of::end<Sequence>::type end_type;
|
||||
typedef iterator_range<begin_type, end_type> pair_type;
|
||||
typedef cons<pair_type, Stack> type;
|
||||
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type call(Sequence& seq, Stack stack)
|
||||
{
|
||||
return type(pair_type(fusion::begin(seq), fusion::end(seq)), stack);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Sequence, typename Stack>
|
||||
struct segmented_begin_impl
|
||||
: segmented_begin_impl_aux<Sequence, Stack>
|
||||
{};
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
+41
@@ -0,0 +1,41 @@
|
||||
/*=============================================================================
|
||||
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_END_HPP_INCLUDED)
|
||||
#define BOOST_FUSION_SEGMENTED_END_HPP_INCLUDED
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/detail/segmented_end_impl.hpp>
|
||||
#include <boost/fusion/iterator/segmented_iterator.hpp>
|
||||
#include <boost/fusion/container/list/cons.hpp>
|
||||
|
||||
namespace boost { namespace fusion { namespace detail
|
||||
{
|
||||
//auto segmented_end( seq )
|
||||
//{
|
||||
// return make_segmented_iterator( segmented_end_impl( seq ) );
|
||||
//}
|
||||
|
||||
template <typename Sequence, typename Nil_ = fusion::nil_>
|
||||
struct segmented_end
|
||||
{
|
||||
typedef
|
||||
segmented_iterator<
|
||||
typename segmented_end_impl<Sequence, Nil_>::type
|
||||
>
|
||||
type;
|
||||
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type call(Sequence & seq)
|
||||
{
|
||||
return type(
|
||||
segmented_end_impl<Sequence, Nil_>::call(seq, Nil_()));
|
||||
}
|
||||
};
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
+68
@@ -0,0 +1,68 @@
|
||||
/*=============================================================================
|
||||
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_END_IMPL_HPP_INCLUDED)
|
||||
#define BOOST_FUSION_SEGMENTED_END_IMPL_HPP_INCLUDED
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/mpl/assert.hpp>
|
||||
#include <boost/type_traits/add_const.hpp>
|
||||
#include <boost/type_traits/remove_reference.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
|
||||
#include <boost/fusion/container/list/cons_fwd.hpp>
|
||||
#include <boost/fusion/support/is_segmented.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
template <typename First, typename Last>
|
||||
struct iterator_range;
|
||||
}}
|
||||
|
||||
namespace boost { namespace fusion { namespace detail
|
||||
{
|
||||
//auto segmented_end_impl( seq, stack )
|
||||
//{
|
||||
// assert(is_segmented(seq));
|
||||
// auto it = end(segments(seq));
|
||||
// return cons(iterator_range(it, it), stack);
|
||||
//}
|
||||
|
||||
template <typename Sequence, typename Stack>
|
||||
struct segmented_end_impl
|
||||
{
|
||||
BOOST_MPL_ASSERT((traits::is_segmented<Sequence>));
|
||||
|
||||
typedef
|
||||
typename result_of::end<
|
||||
typename remove_reference<
|
||||
typename add_const<
|
||||
typename result_of::segments<Sequence>::type
|
||||
>::type
|
||||
>::type
|
||||
>::type
|
||||
end_type;
|
||||
|
||||
typedef iterator_range<end_type, end_type> pair_type;
|
||||
typedef cons<pair_type, Stack> type;
|
||||
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static pair_type make_pair(end_type end)
|
||||
{
|
||||
return pair_type(end, end);
|
||||
}
|
||||
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
static type call(Sequence & seq, Stack stack)
|
||||
{
|
||||
return type(
|
||||
make_pair(fusion::end(fusion::segments(seq))),
|
||||
stack);
|
||||
}
|
||||
};
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
+55
@@ -0,0 +1,55 @@
|
||||
/*=============================================================================
|
||||
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_SIZE_08112006_1141)
|
||||
#define BOOST_FUSION_SEGMENTED_SIZE_08112006_1141
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/type_traits/add_const.hpp>
|
||||
#include <boost/type_traits/remove_reference.hpp>
|
||||
#include <boost/mpl/fold.hpp>
|
||||
#include <boost/mpl/plus.hpp>
|
||||
#include <boost/mpl/size_t.hpp>
|
||||
#include <boost/mpl/placeholders.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
|
||||
#include <boost/fusion/mpl/begin.hpp>
|
||||
#include <boost/fusion/mpl/end.hpp>
|
||||
#include <boost/fusion/support/is_segmented.hpp>
|
||||
|
||||
namespace boost { namespace fusion { namespace detail
|
||||
{
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// calculates the size of any segmented data structure.
|
||||
template<typename Sequence>
|
||||
struct segmented_size;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
template<typename Sequence, bool IsSegmented = traits::is_segmented<Sequence>::value>
|
||||
struct segmented_size_impl
|
||||
: mpl::fold<
|
||||
typename remove_reference<
|
||||
typename add_const<
|
||||
typename result_of::segments<Sequence>::type
|
||||
>::type
|
||||
>::type
|
||||
, mpl::size_t<0>
|
||||
, mpl::plus<mpl::_1, segmented_size<remove_reference<mpl::_2> > >
|
||||
>::type
|
||||
{};
|
||||
|
||||
template<typename Sequence>
|
||||
struct segmented_size_impl<Sequence, false>
|
||||
: result_of::size<Sequence>::type
|
||||
{};
|
||||
|
||||
template<typename Sequence>
|
||||
struct segmented_size
|
||||
: segmented_size_impl<Sequence>
|
||||
{};
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,63 @@
|
||||
/*=============================================================================
|
||||
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_EMPTY_09162005_0335)
|
||||
#define FUSION_EMPTY_09162005_0335
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/size.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/fusion/support/tag_of.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
// Special tags:
|
||||
struct sequence_facade_tag;
|
||||
struct mpl_sequence_tag; // mpl sequence tag
|
||||
|
||||
namespace extension
|
||||
{
|
||||
template <typename Tag>
|
||||
struct empty_impl
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct apply
|
||||
: mpl::bool_<(result_of::size<Sequence>::value == 0)>
|
||||
{};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct empty_impl<sequence_facade_tag>
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct apply : Sequence::template empty<Sequence> {};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct empty_impl<mpl_sequence_tag>;
|
||||
}
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct empty
|
||||
: extension::empty_impl<typename detail::tag_of<Sequence>::type>::
|
||||
template apply<Sequence>
|
||||
{};
|
||||
}
|
||||
|
||||
template <typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename result_of::empty<Sequence>::type
|
||||
empty(Sequence const&)
|
||||
{
|
||||
typedef typename result_of::empty<Sequence>::type result;
|
||||
return result();
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,98 @@
|
||||
/*=============================================================================
|
||||
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_END_04052005_1141)
|
||||
#define FUSION_END_04052005_1141
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/mpl/empty_base.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
|
||||
#include <boost/fusion/support/tag_of.hpp>
|
||||
#include <boost/fusion/support/is_sequence.hpp>
|
||||
#include <boost/fusion/support/is_segmented.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/detail/segmented_end.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 end_impl
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct apply
|
||||
: mpl::if_<
|
||||
traits::is_segmented<Sequence>
|
||||
, detail::segmented_end<Sequence>
|
||||
, mpl::empty_base
|
||||
>::type
|
||||
{};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct end_impl<sequence_facade_tag>
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct apply : Sequence::template end<Sequence> {};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct end_impl<boost_tuple_tag>;
|
||||
|
||||
template <>
|
||||
struct end_impl<boost_array_tag>;
|
||||
|
||||
template <>
|
||||
struct end_impl<mpl_sequence_tag>;
|
||||
|
||||
template <>
|
||||
struct end_impl<std_pair_tag>;
|
||||
}
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct end
|
||||
: extension::end_impl<typename detail::tag_of<Sequence>::type>::
|
||||
template apply<Sequence>
|
||||
{};
|
||||
}
|
||||
|
||||
template <typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename
|
||||
lazy_enable_if<
|
||||
traits::is_sequence<Sequence>
|
||||
, result_of::end<Sequence>
|
||||
>::type const
|
||||
end(Sequence& seq)
|
||||
{
|
||||
return result_of::end<Sequence>::call(seq);
|
||||
}
|
||||
|
||||
template <typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename
|
||||
lazy_enable_if<
|
||||
traits::is_sequence<Sequence>
|
||||
, result_of::end<Sequence const>
|
||||
>::type const
|
||||
end(Sequence const& seq)
|
||||
{
|
||||
return result_of::end<Sequence const>::call(seq);
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,45 @@
|
||||
/*=============================================================================
|
||||
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_FRONT_09162005_0343)
|
||||
#define FUSION_FRONT_09162005_0343
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/begin.hpp>
|
||||
#include <boost/fusion/iterator/deref.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
struct fusion_sequence_tag;
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct front
|
||||
: result_of::deref<typename result_of::begin<Sequence>::type>
|
||||
{};
|
||||
}
|
||||
|
||||
template <typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename result_of::front<Sequence>::type
|
||||
front(Sequence& seq)
|
||||
{
|
||||
return *fusion::begin(seq);
|
||||
}
|
||||
|
||||
template <typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename result_of::front<Sequence const>::type
|
||||
front(Sequence const& seq)
|
||||
{
|
||||
return *fusion::begin(seq);
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,81 @@
|
||||
/*=============================================================================
|
||||
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_HAS_KEY_09232005_1454)
|
||||
#define FUSION_HAS_KEY_09232005_1454
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
|
||||
#include <boost/fusion/support/tag_of.hpp>
|
||||
#include <boost/fusion/iterator/equal_to.hpp>
|
||||
#include <boost/fusion/algorithm/query/find.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/end.hpp>
|
||||
#include <boost/mpl/not.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
struct void_;
|
||||
|
||||
// Special tags:
|
||||
struct sequence_facade_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 has_key_impl
|
||||
{
|
||||
template <typename Seq, typename Key>
|
||||
struct apply
|
||||
: mpl::not_<
|
||||
typename result_of::equal_to<
|
||||
typename result_of::find<Seq, Key>::type
|
||||
, typename result_of::end<Seq>::type
|
||||
>::type
|
||||
>::type
|
||||
{};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct has_key_impl<sequence_facade_tag>
|
||||
{
|
||||
template <typename Sequence, typename Key>
|
||||
struct apply : Sequence::template has_key<Sequence, Key> {};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct has_key_impl<boost_array_tag>;
|
||||
|
||||
template <>
|
||||
struct has_key_impl<mpl_sequence_tag>;
|
||||
|
||||
template <>
|
||||
struct has_key_impl<std_pair_tag>;
|
||||
}
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <typename Sequence, typename Key>
|
||||
struct has_key
|
||||
: extension::has_key_impl<typename detail::tag_of<Sequence>::type>::
|
||||
template apply<Sequence, Key>
|
||||
{};
|
||||
}
|
||||
|
||||
template <typename Key, typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename result_of::has_key<Sequence, Key>::type
|
||||
has_key(Sequence const&)
|
||||
{
|
||||
typedef typename result_of::has_key<Sequence, Key>::type result;
|
||||
return result();
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
/*=============================================================================
|
||||
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(BOOST_FUSION_SEGMENTS_04052005_1141)
|
||||
#define BOOST_FUSION_SEGMENTS_04052005_1141
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/type_traits/is_const.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
|
||||
#include <boost/fusion/support/tag_of.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
// Special tags:
|
||||
struct sequence_facade_tag;
|
||||
struct iterator_range_tag;
|
||||
|
||||
// segments: returns a sequence of sequences
|
||||
namespace extension
|
||||
{
|
||||
template <typename Tag>
|
||||
struct segments_impl
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct apply {};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct segments_impl<sequence_facade_tag>
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct apply : Sequence::template segments<Sequence> {};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct segments_impl<iterator_range_tag>;
|
||||
}
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct segments
|
||||
{
|
||||
typedef typename traits::tag_of<Sequence>::type tag_type;
|
||||
|
||||
typedef typename
|
||||
extension::segments_impl<tag_type>::template apply<Sequence>::type
|
||||
type;
|
||||
};
|
||||
}
|
||||
|
||||
template <typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename
|
||||
lazy_disable_if<
|
||||
is_const<Sequence>
|
||||
, result_of::segments<Sequence>
|
||||
>::type
|
||||
segments(Sequence& seq)
|
||||
{
|
||||
typedef typename traits::tag_of<Sequence>::type tag_type;
|
||||
return extension::segments_impl<tag_type>::template apply<Sequence>::call(seq);
|
||||
}
|
||||
|
||||
template <typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename result_of::segments<Sequence const>::type
|
||||
segments(Sequence const& seq)
|
||||
{
|
||||
typedef typename traits::tag_of<Sequence const>::type tag_type;
|
||||
return extension::segments_impl<tag_type>::template apply<Sequence const>::call(seq);
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,86 @@
|
||||
/*=============================================================================
|
||||
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_SIZE_05052005_0214)
|
||||
#define FUSION_SIZE_05052005_0214
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/mpl/int.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
|
||||
#include <boost/fusion/support/tag_of.hpp>
|
||||
#include <boost/fusion/support/is_segmented.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/detail/segmented_size.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 size_impl
|
||||
{
|
||||
template<typename Sequence>
|
||||
struct unsegmented_size : Sequence::size {};
|
||||
|
||||
template <typename Sequence>
|
||||
struct apply
|
||||
: mpl::if_<
|
||||
traits::is_segmented<Sequence>
|
||||
, detail::segmented_size<Sequence>
|
||||
, unsegmented_size<Sequence>
|
||||
>::type
|
||||
{};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct size_impl<sequence_facade_tag>
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct apply : Sequence::template size<Sequence> {};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct size_impl<boost_tuple_tag>;
|
||||
|
||||
template <>
|
||||
struct size_impl<boost_array_tag>;
|
||||
|
||||
template <>
|
||||
struct size_impl<mpl_sequence_tag>;
|
||||
|
||||
template <>
|
||||
struct size_impl<std_pair_tag>;
|
||||
}
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <typename Sequence>
|
||||
struct size
|
||||
: mpl::int_<
|
||||
extension::size_impl<typename detail::tag_of<Sequence>::type>
|
||||
::template apply<Sequence>::type::value
|
||||
> {};
|
||||
}
|
||||
|
||||
template <typename Sequence>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename result_of::size<Sequence>::type
|
||||
size(Sequence const&)
|
||||
{
|
||||
typedef typename result_of::size<Sequence>::type result;
|
||||
return result();
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,64 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
Copyright (c) 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_SWAP_20070501_1956)
|
||||
#define BOOST_FUSION_SWAP_20070501_1956
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <algorithm>
|
||||
|
||||
#include <boost/fusion/support/is_sequence.hpp>
|
||||
#include <boost/fusion/view/zip_view.hpp>
|
||||
#include <boost/fusion/algorithm/iteration/for_each.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/front.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/back.hpp>
|
||||
#include <boost/core/enable_if.hpp>
|
||||
#include <boost/mpl/and.hpp>
|
||||
|
||||
namespace boost { namespace fusion {
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template<typename Seq1, typename Seq2>
|
||||
struct swap
|
||||
: enable_if<mpl::and_<
|
||||
traits::is_sequence<Seq1>,
|
||||
traits::is_sequence<Seq2>
|
||||
> > {};
|
||||
}
|
||||
|
||||
namespace detail
|
||||
{
|
||||
struct swap
|
||||
{
|
||||
template<typename Elem>
|
||||
struct result
|
||||
{
|
||||
typedef void type;
|
||||
};
|
||||
|
||||
template<typename Elem>
|
||||
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
void operator()(Elem const& e) const
|
||||
{
|
||||
using std::swap;
|
||||
swap(front(e), back(e));
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
template<typename Seq1, typename Seq2>
|
||||
BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename result_of::swap<Seq1, Seq2>::type
|
||||
swap(Seq1& lhs, Seq2& rhs)
|
||||
{
|
||||
typedef vector<Seq1&, Seq2&> references;
|
||||
for_each(zip_view<references>(references(lhs, rhs)), detail::swap());
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,88 @@
|
||||
/*=============================================================================
|
||||
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_VALUE_AT_05052005_0229)
|
||||
#define FUSION_VALUE_AT_05052005_0229
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/mpl/int.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/mpl/or.hpp>
|
||||
#include <boost/mpl/less.hpp>
|
||||
#include <boost/mpl/empty_base.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
|
||||
#include <boost/fusion/support/tag_of.hpp>
|
||||
#include <boost/fusion/support/category_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 value_at_impl
|
||||
{
|
||||
template <typename Sequence, typename N>
|
||||
struct apply;
|
||||
};
|
||||
|
||||
template <>
|
||||
struct value_at_impl<sequence_facade_tag>
|
||||
{
|
||||
template <typename Sequence, typename N>
|
||||
struct apply : Sequence::template value_at<Sequence, N> {};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct value_at_impl<boost_tuple_tag>;
|
||||
|
||||
template <>
|
||||
struct value_at_impl<boost_array_tag>;
|
||||
|
||||
template <>
|
||||
struct value_at_impl<mpl_sequence_tag>;
|
||||
|
||||
template <>
|
||||
struct value_at_impl<std_pair_tag>;
|
||||
}
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template <typename Sequence, typename N, typename Tag>
|
||||
struct value_at_impl
|
||||
: mpl::if_<
|
||||
mpl::or_<
|
||||
mpl::less<N, typename extension::size_impl<Tag>::template apply<Sequence>::type>
|
||||
, traits::is_unbounded<Sequence>
|
||||
>
|
||||
, typename extension::value_at_impl<Tag>::template apply<Sequence, N>
|
||||
, mpl::empty_base
|
||||
>::type
|
||||
{};
|
||||
}
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <typename Sequence, typename N>
|
||||
struct value_at
|
||||
: detail::value_at_impl<Sequence, N, typename detail::tag_of<Sequence>::type>
|
||||
{};
|
||||
|
||||
template <typename Sequence, int N>
|
||||
struct value_at_c
|
||||
: fusion::result_of::value_at<Sequence, mpl::int_<N> >
|
||||
{};
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,86 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
Copyright (c) 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_VALUE_AT_KEY_05052005_0229)
|
||||
#define FUSION_VALUE_AT_KEY_05052005_0229
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/mpl/int.hpp>
|
||||
#include <boost/mpl/empty_base.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/mpl/or.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
|
||||
#include <boost/fusion/sequence/intrinsic/has_key.hpp>
|
||||
#include <boost/fusion/iterator/value_of_data.hpp>
|
||||
#include <boost/fusion/algorithm/query/find.hpp>
|
||||
#include <boost/fusion/support/tag_of.hpp>
|
||||
#include <boost/fusion/support/category_of.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
// Special tags:
|
||||
struct sequence_facade_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 value_at_key_impl
|
||||
{
|
||||
template <typename Seq, typename Key>
|
||||
struct apply
|
||||
: result_of::value_of_data<
|
||||
typename result_of::find<Seq, Key>::type
|
||||
>
|
||||
{};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct value_at_key_impl<sequence_facade_tag>
|
||||
{
|
||||
template <typename Sequence, typename Key>
|
||||
struct apply : Sequence::template value_at_key<Sequence, Key> {};
|
||||
};
|
||||
|
||||
template <>
|
||||
struct value_at_key_impl<boost_array_tag>;
|
||||
|
||||
template <>
|
||||
struct value_at_key_impl<mpl_sequence_tag>;
|
||||
|
||||
template <>
|
||||
struct value_at_key_impl<std_pair_tag>;
|
||||
}
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template <typename Sequence, typename N, typename Tag>
|
||||
struct value_at_key_impl
|
||||
: mpl::if_<
|
||||
mpl::or_<
|
||||
typename extension::has_key_impl<Tag>::template apply<Sequence, N>
|
||||
, traits::is_unbounded<Sequence>
|
||||
>
|
||||
, typename extension::value_at_key_impl<Tag>::template apply<Sequence, N>
|
||||
, mpl::empty_base
|
||||
>::type
|
||||
{};
|
||||
}
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <typename Sequence, typename N>
|
||||
struct value_at_key
|
||||
: detail::value_at_key_impl<Sequence, N, typename detail::tag_of<Sequence>::type>
|
||||
{};
|
||||
}
|
||||
}}
|
||||
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user