feedc0de/boost_fusion
1
0
Fork 0
forked from boostorg/fusion
Code Pull Requests Activity

branch for creating branch for fusion 2.1

Browse Source 
[SVN r40237]
This commit is contained in:
Joel de Guzman
2007-10-21 00:52:09 +00:00
parent 7a6e82b7cf
commit 32f1c58ce7
476 changed files with 25709 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
include/boost/fusion/sequence/comparison.hpp Normal file
View File

@ -0,0 +1,17 @@
/*=============================================================================
Copyright (c) 2001-2006 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_SEQUENCE_COMPARISON_10022005_0615)
#define FUSION_SEQUENCE_COMPARISON_10022005_0615
#include <boost/fusion/sequence/comparison/equal_to.hpp>
#include <boost/fusion/sequence/comparison/greater.hpp>
#include <boost/fusion/sequence/comparison/greater_equal.hpp>
#include <boost/fusion/sequence/comparison/less.hpp>
#include <boost/fusion/sequence/comparison/less_equal.hpp>
#include <boost/fusion/sequence/comparison/not_equal_to.hpp>
#endif

38
include/boost/fusion/sequence/comparison/detail/enable_comparison.hpp Normal file
View File

@ -0,0 +1,38 @@
/*=============================================================================
Copyright (c) 2001-2006 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_ENABLE_COMPARISON_09232005_1958)
#define FUSION_ENABLE_COMPARISON_09232005_1958
#include <boost/mpl/or.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/not.hpp>
#include <boost/mpl/equal_to.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/support/detail/is_mpl_sequence.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename Sequence>
struct is_native_fusion_sequence : is_base_of<sequence_root, Sequence> {};
template <typename Seq1, typename Seq2>
struct enable_equality
: mpl::or_<is_native_fusion_sequence<Seq1>, is_native_fusion_sequence<Seq2> >
{};
template <typename Seq1, typename Seq2>
struct enable_comparison
: mpl::and_<
mpl::or_<is_native_fusion_sequence<Seq1>, is_native_fusion_sequence<Seq2> >
, mpl::equal_to<result_of::size<Seq1>, result_of::size<Seq2> >
>
{};
}}}
#endif

60
include/boost/fusion/sequence/comparison/detail/equal_to.hpp Normal file
View File

@ -0,0 +1,60 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 2001-2006 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_EQUAL_TO_05052005_1142)
#define FUSION_EQUAL_TO_05052005_1142
#include <boost/mpl/bool.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/equal_to.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename Seq1, typename Seq2, bool same_size>
struct sequence_equal_to
{
typedef typename result_of::end<Seq1>::type end1_type;
typedef typename result_of::end<Seq2>::type end2_type;
template <typename I1, typename I2>
static bool
call(I1 const&, I2 const&, mpl::true_)
{
return true;
}
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b, mpl::false_)
{
return *a == *b
&& call(fusion::next(a), fusion::next(b));
}
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b)
{
typename result_of::equal_to<I1, end1_type>::type eq;
return call(a, b, eq);
}
};
template <typename Seq1, typename Seq2>
struct sequence_equal_to<Seq1, Seq2, false>
{
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b)
{
return false;
}
};
}}}
#endif

50
include/boost/fusion/sequence/comparison/detail/greater.hpp Normal file
View File

@ -0,0 +1,50 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 2001-2006 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_GREATER_05052005_1142)
#define FUSION_GREATER_05052005_1142
#include <boost/mpl/bool.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/equal_to.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename Seq1, typename Seq2>
struct sequence_greater
{
typedef typename result_of::end<Seq1>::type end1_type;
typedef typename result_of::end<Seq2>::type end2_type;
template <typename I1, typename I2>
static bool
call(I1 const&, I2 const&, mpl::true_)
{
return false;
}
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b, mpl::false_)
{
return *a > *b
|| !(*b > *a)
&& call(fusion::next(a), fusion::next(b));
}
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b)
{
typename result_of::equal_to<I1, end1_type>::type eq;
return call(a, b, eq);
}
};
}}}
#endif

49
include/boost/fusion/sequence/comparison/detail/greater_equal.hpp Normal file
View File

@ -0,0 +1,49 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 2001-2006 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_GREATER_EQUAL_05052005_1142)
#define FUSION_GREATER_EQUAL_05052005_1142
#include <boost/mpl/bool.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/equal_to.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename Seq1, typename Seq2>
struct sequence_greater_equal
{
typedef typename result_of::end<Seq1>::type end1_type;
typedef typename result_of::end<Seq2>::type end2_type;
template <typename I1, typename I2>
static bool
call(I1 const&, I2 const&, mpl::true_)
{
return true;
}
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b, mpl::false_)
{
return *a >= *b
&& (!(*b >= *a) || call(fusion::next(a), fusion::next(b)));
}
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b)
{
typename result_of::equal_to<I1, end1_type>::type eq;
return call(a, b, eq);
}
};
}}}
#endif

50
include/boost/fusion/sequence/comparison/detail/less.hpp Normal file
View File

@ -0,0 +1,50 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 2001-2006 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_LESS_05052005_1141)
#define FUSION_LESS_05052005_1141
#include <boost/mpl/bool.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/equal_to.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename Seq1, typename Seq2>
struct sequence_less
{
typedef typename result_of::end<Seq1>::type end1_type;
typedef typename result_of::end<Seq2>::type end2_type;
template <typename I1, typename I2>
static bool
call(I1 const&, I2 const&, mpl::true_)
{
return false;
}
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b, mpl::false_)
{
return *a < *b
|| !(*b < *a)
&& call(fusion::next(a), fusion::next(b));
}
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b)
{
typename result_of::equal_to<I1, end1_type>::type eq;
return call(a, b, eq);
}
};
}}}
#endif

49
include/boost/fusion/sequence/comparison/detail/less_equal.hpp Normal file
View File

@ -0,0 +1,49 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 2001-2006 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_LESS_EQUAL_05052005_1141)
#define FUSION_LESS_EQUAL_05052005_1141
#include <boost/mpl/bool.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/equal_to.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename Seq1, typename Seq2>
struct sequence_less_equal
{
typedef typename result_of::end<Seq1>::type end1_type;
typedef typename result_of::end<Seq2>::type end2_type;
template <typename I1, typename I2>
static bool
call(I1 const&, I2 const&, mpl::true_)
{
return true;
}
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b, mpl::false_)
{
return *a <= *b
&& (!(*b <= *a) || call(fusion::next(a), fusion::next(b)));
}
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b)
{
typename result_of::equal_to<I1, end1_type>::type eq;
return call(a, b, eq);
}
};
}}}
#endif

60
include/boost/fusion/sequence/comparison/detail/not_equal_to.hpp Normal file
View File

@ -0,0 +1,60 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 2001-2006 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_NOT_EQUAL_TO_05052005_1141)
#define FUSION_NOT_EQUAL_TO_05052005_1141
#include <boost/mpl/bool.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/equal_to.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename Seq1, typename Seq2, bool same_size>
struct sequence_not_equal_to
{
typedef typename result_of::end<Seq1>::type end1_type;
typedef typename result_of::end<Seq2>::type end2_type;
template <typename I1, typename I2>
static bool
call(I1 const&, I2 const&, mpl::true_)
{
return false;
}
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b, mpl::false_)
{
return *a != *b
|| call(fusion::next(a), fusion::next(b));
}
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b)
{
typename result_of::equal_to<I1, end1_type>::type eq;
return call(a, b, eq);
}
};
template <typename Seq1, typename Seq2>
struct sequence_not_equal_to<Seq1, Seq2, false>
{
template <typename I1, typename I2>
static bool
call(I1 const& a, I2 const& b)
{
return true;
}
};
}}}
#endif

46
include/boost/fusion/sequence/comparison/equal_to.hpp Normal file
View File

@ -0,0 +1,46 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 2001-2006 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_EQUAL_TO_05052005_0431)
#define FUSION_EQUAL_TO_05052005_0431
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/comparison/detail/equal_to.hpp>
#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
namespace boost { namespace fusion
{
template <typename Seq1, typename Seq2>
inline bool
equal_to(Seq1 const& a, Seq2 const& b)
{
return result_of::size<Seq1>::value == result_of::size<Seq2>::value
&& detail::sequence_equal_to<
Seq1 const, Seq2 const
, result_of::size<Seq1>::value == result_of::size<Seq2>::value>::
call(fusion::begin(a), fusion::begin(b));
}
namespace operators
{
template <typename Seq1, typename Seq2>
inline typename
enable_if<
detail::enable_equality<Seq1, Seq2>
, bool
>::type
operator==(Seq1 const& a, Seq2 const& b)
{
return fusion::equal_to(a, b);
}
}
using operators::operator==;
}}
#endif

52
include/boost/fusion/sequence/comparison/greater.hpp Normal file
View File

@ -0,0 +1,52 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 2001-2006 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_GREATER_05052005_0432)
#define FUSION_GREATER_05052005_0432
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
#if defined(FUSION_DIRECT_OPERATOR_USAGE)
#include <boost/fusion/sequence/comparison/detail/greater.hpp>
#else
#include <boost/fusion/sequence/comparison/less.hpp>
#endif
namespace boost { namespace fusion
{
template <typename Seq1, typename Seq2>
inline bool
greater(Seq1 const& a, Seq2 const& b)
{
#if defined(FUSION_DIRECT_OPERATOR_USAGE)
return detail::sequence_greater<Seq1 const, Seq2 const>::
call(fusion::begin(a), fusion::begin(b));
#else
return (b < a);
#endif
}
namespace operators
{
template <typename Seq1, typename Seq2>
inline typename
enable_if<
detail::enable_comparison<Seq1, Seq2>
, bool
>::type
operator>(Seq1 const& a, Seq2 const& b)
{
return fusion::greater(a, b);
}
}
using operators::operator>;
}}
#endif

52
include/boost/fusion/sequence/comparison/greater_equal.hpp Normal file
View File

@ -0,0 +1,52 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 2001-2006 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_GREATER_EQUAL_05052005_0432)
#define FUSION_GREATER_EQUAL_05052005_0432
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
#if defined(FUSION_DIRECT_OPERATOR_USAGE)
#include <boost/fusion/sequence/comparison/detail/greater_equal.hpp>
#else
#include <boost/fusion/sequence/comparison/less.hpp>
#endif
namespace boost { namespace fusion
{
template <typename Seq1, typename Seq2>
inline bool
greater_equal(Seq1 const& a, Seq2 const& b)
{
#if defined(FUSION_DIRECT_OPERATOR_USAGE)
return detail::sequence_greater_equal<Seq1 const, Seq2 const>::
call(fusion::begin(a), fusion::begin(b));
#else
return !(a < b);
#endif
}
namespace operators
{
template <typename Seq1, typename Seq2>
inline typename
enable_if<
detail::enable_comparison<Seq1, Seq2>
, bool
>::type
operator>=(Seq1 const& a, Seq2 const& b)
{
return fusion::greater_equal(a, b);
}
}
using operators::operator>=;
}}
#endif

43
include/boost/fusion/sequence/comparison/less.hpp Normal file
View File

@ -0,0 +1,43 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 2001-2006 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_LESS_05052005_0432)
#define FUSION_LESS_05052005_0432
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/comparison/detail/less.hpp>
#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
namespace boost { namespace fusion
{
template <typename Seq1, typename Seq2>
inline bool
less(Seq1 const& a, Seq2 const& b)
{
return detail::sequence_less<Seq1 const, Seq2 const>::
call(fusion::begin(a), fusion::begin(b));
}
namespace operators
{
template <typename Seq1, typename Seq2>
inline typename
enable_if<
detail::enable_comparison<Seq1, Seq2>
, bool
>::type
operator<(Seq1 const& a, Seq2 const& b)
{
return fusion::less(a, b);
}
}
using operators::operator<;
}}
#endif

80
include/boost/fusion/sequence/comparison/less_equal.hpp Normal file
View File

@ -0,0 +1,80 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 2001-2006 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_LESS_EQUAL_05052005_0432)
#define FUSION_LESS_EQUAL_05052005_0432
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
#if defined(FUSION_DIRECT_OPERATOR_USAGE)
#include <boost/fusion/sequence/comparison/detail/less_equal.hpp>
#else
#include <boost/fusion/sequence/comparison/less.hpp>
#endif
namespace boost { namespace fusion
{
template <typename Seq1, typename Seq2>
inline bool
less_equal(Seq1 const& a, Seq2 const& b)
{
#if defined(FUSION_DIRECT_OPERATOR_USAGE)
return detail::sequence_less_equal<Seq1 const, Seq2 const>::
call(fusion::begin(a), fusion::begin(b));
#else
return !(b < a);
#endif
}
namespace operators
{
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1400)
// Workaround for VC8.0 and VC7.1
template <typename Seq1, typename Seq2>
inline bool
operator<=(sequence_base<Seq1> const& a, sequence_base<Seq2> const& b)
{
return less_equal(a.derived(), b.derived());
}
template <typename Seq1, typename Seq2>
inline typename disable_if<detail::is_native_fusion_sequence<Seq2>, bool>::type
operator<=(sequence_base<Seq1> const& a, Seq2 const& b)
{
return less_equal(a.derived(), b);
}
template <typename Seq1, typename Seq2>
inline typename disable_if<detail::is_native_fusion_sequence<Seq1>, bool>::type
operator<=(Seq1 const& a, sequence_base<Seq2> const& b)
{
return less_equal(a, b.derived());
}
#else
// Somehow VC8.0 and VC7.1 does not like this code
// but barfs somewhere else.
template <typename Seq1, typename Seq2>
inline typename
enable_if<
detail::enable_comparison<Seq1, Seq2>
, bool
>::type
operator<=(Seq1 const& a, Seq2 const& b)
{
return fusion::less_equal(a, b);
}
#endif
}
using operators::operator<=;
}}
#endif

55
include/boost/fusion/sequence/comparison/not_equal_to.hpp Normal file
View File

@ -0,0 +1,55 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 2001-2006 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_NOT_EQUAL_TO_05052005_0431)
#define FUSION_NOT_EQUAL_TO_05052005_0431
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/comparison/detail/enable_comparison.hpp>
#if defined(FUSION_DIRECT_OPERATOR_USAGE)
#include <boost/fusion/sequence/comparison/detail/not_equal_to.hpp>
#else
#include <boost/fusion/sequence/comparison/equal_to.hpp>
#endif
namespace boost { namespace fusion
{
template <typename Seq1, typename Seq2>
inline bool
not_equal_to(Seq1 const& a, Seq2 const& b)
{
#if defined(FUSION_DIRECT_OPERATOR_USAGE)
return result_of::size<Seq1>::value != result_of::size<Seq2>::value
|| detail::sequence_not_equal_to<
Seq1 const, Seq2 const
, result_of::size<Seq1>::value == result_of::size<Seq2>::value>::
call(fusion::begin(a), fusion::begin(b));
#else
return !(a == b);
#endif
}
namespace operators
{
template <typename Seq1, typename Seq2>
inline typename
enable_if<
detail::enable_equality<Seq1, Seq2>
, bool
>::type
operator!=(Seq1 const& a, Seq2 const& b)
{
return fusion::not_equal_to(a, b);
}
}
using operators::operator!=;
}}
#endif

48
include/boost/fusion/sequence/convert.hpp Normal file
View File

@ -0,0 +1,48 @@
/*=============================================================================
Copyright (c) 2001-2006 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_CONVERT_10022005_1442)
#define FUSION_CONVERT_10022005_1442
namespace boost { namespace fusion
{
namespace extension
{
template <typename Tag>
struct convert_impl;
}
namespace result_of
{
template <typename Tag, typename Sequence>
struct convert
{
typedef typename extension::convert_impl<Tag> gen;
typedef typename
gen::template apply<Sequence>::type
type;
};
}
template <typename Tag, typename Sequence>
inline typename result_of::convert<Tag, Sequence>::type
convert(Sequence& seq)
{
typedef typename result_of::convert<Tag, Sequence>::gen gen;
return gen::call(seq);
}
template <typename Tag, typename Sequence>
inline typename result_of::convert<Tag, Sequence const>::type
convert(Sequence const& seq)
{
typedef typename result_of::convert<Tag, Sequence const>::gen gen;
return gen::call(seq);
}
}}
#endif

20
include/boost/fusion/sequence/generation.hpp Normal file
View File

@ -0,0 +1,20 @@
/*=============================================================================
Copyright (c) 2001-2006 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_SEQUENCE_GENERATION_10022005_0615)
#define FUSION_SEQUENCE_GENERATION_10022005_0615
#include <boost/fusion/sequence/generation/cons_tie.hpp>
#include <boost/fusion/sequence/generation/ignore.hpp>
#include <boost/fusion/sequence/generation/list_tie.hpp>
#include <boost/fusion/sequence/generation/make_cons.hpp>
#include <boost/fusion/sequence/generation/make_list.hpp>
#include <boost/fusion/sequence/generation/make_map.hpp>
#include <boost/fusion/sequence/generation/make_vector.hpp>
#include <boost/fusion/sequence/generation/vector_tie.hpp>
#include <boost/fusion/sequence/generation/make_set.hpp>
#endif

43
include/boost/fusion/sequence/generation/cons_tie.hpp Normal file
View File

@ -0,0 +1,43 @@
/*=============================================================================
Copyright (c) 2005 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_CONS_TIE_07182005_0854)
#define FUSION_CONS_TIE_07182005_0854
#include <boost/fusion/container/list/cons.hpp>
namespace boost { namespace fusion
{
struct nil;
namespace result_of
{
template <typename Car, typename Cdr = nil>
struct cons_tie
{
typedef cons<Car&, Cdr> type;
};
}
// $$$ do we really want a cons_tie? $$$
template <typename Car>
inline cons<Car&>
cons_tie(Car& car)
{
return cons<Car&>(car);
}
// $$$ do we really want a cons_tie? $$$
template <typename Car, typename Cdr>
inline cons<Car&, Cdr>
cons_tie(Car& car, Cdr const& cdr)
{
return cons<Car&, Cdr>(car, cdr);
}
}}
#endif

72
include/boost/fusion/sequence/generation/deque_tie.hpp Normal file
View File

@ -0,0 +1,72 @@
/*=============================================================================
Copyright (c) 2001-2006 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)
==============================================================================*/
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_DEQUE_TIE_07192005_1242)
#define FUSION_DEQUE_TIE_07192005_1242
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/fusion/container/deque/deque.hpp>
namespace boost { namespace fusion
{
struct void_;
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_DEQUE_SIZE, typename T, void_)
, typename Extra = void_
>
struct deque_tie;
}
#define BOOST_FUSION_REF(z, n, data) BOOST_PP_CAT(T, n)&
#define BOOST_PP_FILENAME_1 <boost/fusion/sequence/generation/deque_tie.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_REF
}}
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
namespace result_of
{
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
struct deque_tie<BOOST_PP_ENUM_PARAMS(N, T)>
{
typedef deque<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)> type;
};
}
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
inline deque<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>
deque_tie(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & _))
{
return deque<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>(
BOOST_PP_ENUM_PARAMS(N, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)

32
include/boost/fusion/sequence/generation/ignore.hpp Normal file
View File

@ -0,0 +1,32 @@
/*=============================================================================
Copyright (c) 2001 Doug Gregor
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 2001-2006 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_IGNORE_07192005_0329)
#define FUSION_IGNORE_07192005_0329
namespace boost { namespace fusion
{
// Swallows any assignment (by Doug Gregor)
namespace detail
{
struct swallow_assign
{
template<typename T>
swallow_assign const&
operator=(const T&) const
{
return *this;
}
};
}
// "ignore" allows tuple positions to be ignored when using "tie".
detail::swallow_assign const ignore = detail::swallow_assign();
}}
#endif

72
include/boost/fusion/sequence/generation/list_tie.hpp Normal file
View File

@ -0,0 +1,72 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_LIST_TIE_07192005_0109)
#define FUSION_LIST_TIE_07192005_0109
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/fusion/container/list/list.hpp>
namespace boost { namespace fusion
{
struct void_;
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_LIST_SIZE, typename T, void_)
, typename Extra = void_
>
struct list_tie;
}
// $$$ shouldn't we remove_reference first to allow references? $$$
#define BOOST_FUSION_REF(z, n, data) BOOST_PP_CAT(T, n)&
#define BOOST_PP_FILENAME_1 <boost/fusion/sequence/generation/list_tie.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_LIST_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_REF
}}
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
namespace result_of
{
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
struct list_tie<BOOST_PP_ENUM_PARAMS(N, T)>
{
typedef list<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)> type;
};
}
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
inline list<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>
list_tie(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & _))
{
return list<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>(
BOOST_PP_ENUM_PARAMS(N, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)

43
include/boost/fusion/sequence/generation/make_cons.hpp Normal file
View File

@ -0,0 +1,43 @@
/*=============================================================================
Copyright (c) 2005 Joel de Guzman
Copyright (c) 2005 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_MAKE_CONS_07172005_0918)
#define FUSION_MAKE_CONS_07172005_0918
#include <boost/fusion/support/detail/as_fusion_element.hpp>
#include <boost/fusion/container/list/cons.hpp>
namespace boost { namespace fusion
{
struct nil;
namespace result_of
{
template <typename Car, typename Cdr = nil>
struct make_cons
{
typedef cons<typename detail::as_fusion_element<Car>::type, Cdr> type;
};
}
template <typename Car>
inline cons<typename detail::as_fusion_element<Car>::type>
make_cons(Car const& car)
{
return cons<typename detail::as_fusion_element<Car>::type>(car);
}
template <typename Car, typename Cdr>
inline cons<typename detail::as_fusion_element<Car>::type, Cdr>
make_cons(Car const& car, Cdr const& cdr)
{
return cons<typename detail::as_fusion_element<Car>::type, Cdr>(car, cdr);
}
}}
#endif

91
include/boost/fusion/sequence/generation/make_deque.hpp Normal file
View File

@ -0,0 +1,91 @@
/*=============================================================================
Copyright (c) 2001-2006 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)
==============================================================================*/
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_MAKE_DEQUE_07162005_0243)
#define FUSION_MAKE_DEQUE_07162005_0243
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/fusion/container/deque/deque.hpp>
#include <boost/fusion/support/detail/as_fusion_element.hpp>
namespace boost { namespace fusion
{
struct void_;
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_DEQUE_SIZE, typename T, void_)
, typename Extra = void_
>
struct make_deque;
template <>
struct make_deque<>
{
typedef deque<> type;
};
}
inline deque<>
make_deque()
{
return deque<>();
}
#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data) \
typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
#define BOOST_PP_FILENAME_1 <boost/fusion/sequence/generation/make_deque.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_DEQUE_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_AS_FUSION_ELEMENT
}}
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
namespace result_of
{
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
struct make_deque<BOOST_PP_ENUM_PARAMS(N, T)>
{
typedef deque<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)> type;
};
}
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
inline deque<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>
make_deque(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& _))
{
return deque<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>(
BOOST_PP_ENUM_PARAMS(N, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)

84
include/boost/fusion/sequence/generation/make_list.hpp Normal file
View File

@ -0,0 +1,84 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_MAKE_LIST_07192005_1239)
#define FUSION_MAKE_LIST_07192005_1239
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/fusion/container/list/list.hpp>
#include <boost/fusion/support/detail/as_fusion_element.hpp>
namespace boost { namespace fusion
{
struct void_;
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_LIST_SIZE, typename T, void_)
, typename Extra = void_
>
struct make_list;
template <>
struct make_list<>
{
typedef list<> type;
};
}
inline list<>
make_list()
{
return list<>();
}
#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data) \
typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
#define BOOST_PP_FILENAME_1 <boost/fusion/sequence/generation/make_list.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_LIST_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_AS_FUSION_ELEMENT
}}
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
namespace result_of
{
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
struct make_list<BOOST_PP_ENUM_PARAMS(N, T)>
{
typedef list<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)> type;
};
}
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
inline list<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>
make_list(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& _))
{
return list<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>(
BOOST_PP_ENUM_PARAMS(N, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)

99
include/boost/fusion/sequence/generation/make_map.hpp Normal file
View File

@ -0,0 +1,99 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_MAKE_MAP_07222005_1247)
#define FUSION_MAKE_MAP_07222005_1247
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/fusion/container/map/map.hpp>
#include <boost/fusion/support/detail/as_fusion_element.hpp>
#include <boost/fusion/support/pair.hpp>
namespace boost { namespace fusion
{
struct void_;
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_VECTOR_SIZE, typename K, void_)
, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_VECTOR_SIZE, typename D, void_)
, typename Extra = void_
>
struct make_map;
template <>
struct make_map<>
{
typedef map<> type;
};
}
inline map<>
make_map()
{
return map<>();
}
#define BOOST_FUSION_PAIR(z, n, data) \
fusion::pair< \
BOOST_PP_CAT(K, n) \
, typename detail::as_fusion_element<BOOST_PP_CAT(D, n)>::type>
#define BOOST_FUSION_MAKE_PAIR(z, n, data) \
fusion::make_pair<BOOST_PP_CAT(K, n)>(BOOST_PP_CAT(_, n)) \
#define BOOST_PP_FILENAME_1 <boost/fusion/sequence/generation/make_map.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_PAIR
#undef BOOST_FUSION_MAKE_PAIR
}}
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS(N, typename K)
, BOOST_PP_ENUM_PARAMS(N, typename D)
>
struct make_map<BOOST_PP_ENUM_PARAMS(N, K), BOOST_PP_ENUM_PARAMS(N, D)>
{
typedef map<BOOST_PP_ENUM(N, BOOST_FUSION_PAIR, _)> type;
};
}
template <
BOOST_PP_ENUM_PARAMS(N, typename K)
, BOOST_PP_ENUM_PARAMS(N, typename D)
>
inline map<BOOST_PP_ENUM(N, BOOST_FUSION_PAIR, _)>
make_map(BOOST_PP_ENUM_BINARY_PARAMS(N, D, const& _))
{
return map<BOOST_PP_ENUM(N, BOOST_FUSION_PAIR, _)>(
BOOST_PP_ENUM(N, BOOST_FUSION_MAKE_PAIR, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)

86
include/boost/fusion/sequence/generation/make_set.hpp Normal file
View File

@ -0,0 +1,86 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_MAKE_SET_09162005_1125)
#define FUSION_MAKE_SET_09162005_1125
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/fusion/container/set/set.hpp>
#include <boost/fusion/support/detail/as_fusion_element.hpp>
#include <boost/fusion/support/pair.hpp>
namespace boost { namespace fusion
{
struct void_;
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_VECTOR_SIZE, typename T, void_)
, typename Extra = void_
>
struct make_set;
template <>
struct make_set<>
{
typedef set<> type;
};
}
inline set<>
make_set()
{
return set<>();
}
#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data) \
typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
#define BOOST_PP_FILENAME_1 <boost/fusion/sequence/generation/make_set.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_ELEMENT
#undef BOOST_FUSION_AS_ELEMENT
}}
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
namespace result_of
{
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
struct make_set<BOOST_PP_ENUM_PARAMS(N, T)>
{
typedef set<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)> type;
};
}
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
inline set<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>
make_set(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& _))
{
return set<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>(
BOOST_PP_ENUM_PARAMS(N, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)

84
include/boost/fusion/sequence/generation/make_vector.hpp Normal file
View File

@ -0,0 +1,84 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_MAKE_VECTOR_07162005_0243)
#define FUSION_MAKE_VECTOR_07162005_0243
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/fusion/container/vector/vector.hpp>
#include <boost/fusion/support/detail/as_fusion_element.hpp>
namespace boost { namespace fusion
{
struct void_;
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_VECTOR_SIZE, typename T, void_)
, typename Extra = void_
>
struct make_vector;
template <>
struct make_vector<>
{
typedef vector<> type;
};
}
inline vector<>
make_vector()
{
return vector<>();
}
#define BOOST_FUSION_AS_FUSION_ELEMENT(z, n, data) \
typename detail::as_fusion_element<BOOST_PP_CAT(T, n)>::type
#define BOOST_PP_FILENAME_1 <boost/fusion/sequence/generation/make_vector.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_AS_FUSION_ELEMENT
}}
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
namespace result_of
{
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
struct make_vector<BOOST_PP_ENUM_PARAMS(N, T)>
{
typedef vector<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)> type;
};
}
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
inline vector<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>
make_vector(BOOST_PP_ENUM_BINARY_PARAMS(N, T, const& _))
{
return vector<BOOST_PP_ENUM(N, BOOST_FUSION_AS_FUSION_ELEMENT, _)>(
BOOST_PP_ENUM_PARAMS(N, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)

102
include/boost/fusion/sequence/generation/map_tie.hpp Normal file
View File

@ -0,0 +1,102 @@
/*=============================================================================
Copyright (c) 2001-2006 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)
==============================================================================*/
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_MAP_TIE_20060814_1116)
#define FUSION_MAP_TIE_20060814_1116
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/fusion/container/map/map.hpp>
#include <boost/fusion/container/map/limits.hpp>
#include <boost/fusion/support/pair.hpp>
#include <boost/fusion/sequence/generation/pair_tie.hpp>
#include <boost/type_traits/add_reference.hpp>
namespace boost { namespace fusion
{
struct void_;
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_MAP_SIZE, typename K, void_)
, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_MAP_SIZE, typename D, void_)
, typename Extra = void_
>
struct map_tie;
template <>
struct map_tie<>
{
typedef map<> type;
};
}
inline map<>
map_tie()
{
return map<>();
}
#define BOOST_FUSION_TIED_PAIR(z, n, data) \
fusion::pair< \
BOOST_PP_CAT(K, n) \
, typename add_reference<BOOST_PP_CAT(D, n)>::type>
#define BOOST_FUSION_PAIR_TIE(z, n, data) \
fusion::pair_tie<BOOST_PP_CAT(K, n)>(BOOST_PP_CAT(_, n)) \
#define BOOST_PP_FILENAME_1 <boost/fusion/sequence/generation/map_tie.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_MAP_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_PAIR
#undef BOOST_FUSION_MAKE_PAIR
}}
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS(N, typename K)
, BOOST_PP_ENUM_PARAMS(N, typename D)
>
struct map_tie<BOOST_PP_ENUM_PARAMS(N, K), BOOST_PP_ENUM_PARAMS(N, D)>
{
typedef map<BOOST_PP_ENUM(N, BOOST_FUSION_TIED_PAIR, _)> type;
};
}
template <
BOOST_PP_ENUM_PARAMS(N, typename K)
, BOOST_PP_ENUM_PARAMS(N, typename D)
>
inline map<BOOST_PP_ENUM(N, BOOST_FUSION_TIED_PAIR, _)>
map_tie(BOOST_PP_ENUM_BINARY_PARAMS(N, D, & _))
{
return map<BOOST_PP_ENUM(N, BOOST_FUSION_TIED_PAIR, _)>(
BOOST_PP_ENUM(N, BOOST_FUSION_PAIR_TIE, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)

43
include/boost/fusion/sequence/generation/pair_tie.hpp Normal file
View File

@ -0,0 +1,43 @@
/*=============================================================================
Copyright (c) 2001-2006 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_PAIR_TIE_20060812_2058)
#define BOOST_FUSION_PAIR_TIE_20060812_2058
#include <boost/type_traits/is_const.hpp>
#include <boost/utility/enable_if.hpp>
namespace boost { namespace fusion {
template<typename Key, typename T>
struct pair;
namespace result_of
{
template<typename Key, typename T>
struct pair_tie
{
typedef fusion::pair<Key, T&> type;
};
}
template<typename Key, typename T>
typename disable_if<is_const<T>, typename result_of::pair_tie<Key, T>::type>::type
pair_tie(T& t)
{
return typename result_of::pair_tie<Key, T>::type(t);
}
template<typename Key, typename T>
typename result_of::pair_tie<Key, T const>::type
pair_tie(T const& t)
{
return typename result_of::pair_tie<Key, T const>::type(t);
}
}}
#endif

71
include/boost/fusion/sequence/generation/vector_tie.hpp Normal file
View File

@ -0,0 +1,71 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#ifndef BOOST_PP_IS_ITERATING
#if !defined(FUSION_VECTOR_TIE_07192005_1242)
#define FUSION_VECTOR_TIE_07192005_1242
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#include <boost/fusion/container/vector/vector.hpp>
namespace boost { namespace fusion
{
struct void_;
namespace result_of
{
template <
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_VECTOR_SIZE, typename T, void_)
, typename Extra = void_
>
struct vector_tie;
}
#define BOOST_FUSION_REF(z, n, data) BOOST_PP_CAT(T, n)&
#define BOOST_PP_FILENAME_1 <boost/fusion/sequence/generation/vector_tie.hpp>
#define BOOST_PP_ITERATION_LIMITS (1, FUSION_MAX_VECTOR_SIZE)
#include BOOST_PP_ITERATE()
#undef BOOST_FUSION_REF
}}
#endif
#else // defined(BOOST_PP_IS_ITERATING)
///////////////////////////////////////////////////////////////////////////////
//
// Preprocessor vertical repetition code
//
///////////////////////////////////////////////////////////////////////////////
#define N BOOST_PP_ITERATION()
namespace result_of
{
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
struct vector_tie<BOOST_PP_ENUM_PARAMS(N, T)>
{
typedef vector<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)> type;
};
}
template <BOOST_PP_ENUM_PARAMS(N, typename T)>
inline vector<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>
vector_tie(BOOST_PP_ENUM_BINARY_PARAMS(N, T, & _))
{
return vector<BOOST_PP_ENUM(N, BOOST_FUSION_REF, _)>(
BOOST_PP_ENUM_PARAMS(N, _));
}
#undef N
#endif // defined(BOOST_PP_IS_ITERATING)

22
include/boost/fusion/sequence/intrinsic.hpp Normal file
View File

@ -0,0 +1,22 @@
/*=============================================================================
Copyright (c) 2001-2006 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_SEQUENCE_INTRINSIC_10022005_0618)
#define FUSION_SEQUENCE_INTRINSIC_10022005_0618
#include <boost/fusion/sequence/intrinsic/at.hpp>
#include <boost/fusion/sequence/intrinsic/back.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/empty.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/sequence/intrinsic/front.hpp>
#include <boost/fusion/sequence/intrinsic/has_key.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/intrinsic/value_at.hpp>
#include <boost/fusion/sequence/intrinsic/at_key.hpp>
#include <boost/fusion/sequence/intrinsic/value_at_key.hpp>
#endif

106
include/boost/fusion/sequence/intrinsic/at.hpp Normal file
View File

@ -0,0 +1,106 @@
/*=============================================================================
Copyright (c) 2001-2006 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/mpl/int.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/fusion/support/tag_of.hpp>
#include <boost/fusion/support/detail/access.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct sequence_facade_tag;
struct boost_tuple_tag; // boost::tuples::tuple tag
struct 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_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<array_tag>;
template <>
struct at_impl<mpl_sequence_tag>;
template <>
struct at_impl<std_pair_tag>;
}
namespace result_of
{
template <typename Sequence, typename N>
struct at
: extension::at_impl<typename detail::tag_of<Sequence>::type>::
template apply<Sequence, N>
{};
template <typename Sequence, int N>
struct at_c
: at<Sequence, mpl::int_<N> >
{};
}
template <typename N, typename Sequence>
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>
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>
inline typename
lazy_disable_if<
is_const<Sequence>
, result_of::at_c<Sequence, N>
>::type
at_c(Sequence& seq)
{
return at<mpl::int_<N> >(seq);
}
template <int N, typename Sequence>
inline typename result_of::at_c<Sequence const, N>::type
at_c(Sequence const& seq)
{
return at<mpl::int_<N> >(seq);
}
}}
#endif

77
include/boost/fusion/sequence/intrinsic/at_key.hpp Normal file
View File

@ -0,0 +1,77 @@
/*=============================================================================
Copyright (c) 2001-2006 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/type_traits/is_const.hpp>
#include <boost/fusion/support/tag_of.hpp>
#include <boost/fusion/support/detail/access.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct sequence_facade_tag;
struct 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 Sequence, typename Key>
struct apply;
};
template <>
struct at_key_impl<sequence_facade_tag>
{
template <typename Sequence, typename Key>
struct apply : Sequence::template at_key<Sequence, Key> {};
};
template <>
struct at_key_impl<array_tag>;
template <>
struct at_key_impl<mpl_sequence_tag>;
template <>
struct at_key_impl<std_pair_tag>;
}
namespace result_of
{
template <typename Sequence, typename Key>
struct at_key
: extension::at_key_impl<typename detail::tag_of<Sequence>::type>::
template apply<Sequence, Key>
{};
}
template <typename Key, typename Sequence>
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>
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

42
include/boost/fusion/sequence/intrinsic/back.hpp Normal file
View File

@ -0,0 +1,42 @@
/*=============================================================================
Copyright (c) 2001-2006 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/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>
inline typename result_of::back<Sequence>::type
back(Sequence& seq)
{
return *fusion::prior(fusion::end(seq));
}
template <typename Sequence>
inline typename result_of::back<Sequence const>::type
back(Sequence const& seq)
{
return *fusion::prior(fusion::end(seq));
}
}}
#endif

74
include/boost/fusion/sequence/intrinsic/begin.hpp Normal file
View File

@ -0,0 +1,74 @@
/*=============================================================================
Copyright (c) 2001-2006 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/tag_of.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct sequence_facade_tag; // iterator facade tag
struct boost_tuple_tag; // boost::tuples::tuple tag
struct 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;
};
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<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>
inline typename result_of::begin<Sequence>::type const
begin(Sequence& seq)
{
return result_of::begin<Sequence>::call(seq);
}
template <typename Sequence>
inline typename result_of::begin<Sequence const>::type const
begin(Sequence const& seq)
{
return result_of::begin<Sequence const>::call(seq);
}
}}
#endif

60
include/boost/fusion/sequence/intrinsic/empty.hpp Normal file
View File

@ -0,0 +1,60 @@
/*=============================================================================
Copyright (c) 2001-2006 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/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>
inline typename result_of::empty<Sequence>::type
empty(Sequence const&)
{
typedef typename result_of::empty<Sequence>::type result;
return result();
}
}}
#endif

74
include/boost/fusion/sequence/intrinsic/end.hpp Normal file
View File

@ -0,0 +1,74 @@
/*=============================================================================
Copyright (c) 2001-2006 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/tag_of.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct sequence_facade_tag;
struct boost_tuple_tag; // boost::tuples::tuple tag
struct 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;
};
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<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>
inline typename result_of::end<Sequence>::type const
end(Sequence& seq)
{
return result_of::end<Sequence>::call(seq);
}
template <typename Sequence>
inline typename result_of::end<Sequence const>::type const
end(Sequence const& seq)
{
return result_of::end<Sequence const>::call(seq);
}
}}
#endif

56
include/boost/fusion/sequence/intrinsic/ext_/segments.hpp Executable file
View File

@ -0,0 +1,56 @@
/*=============================================================================
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_SEGMENTS_04052005_1141)
#define FUSION_SEGMENTS_04052005_1141
#include <boost/fusion/support/tag_of.hpp>
namespace boost { namespace fusion
{
// segments: returns a sequence of sequences
namespace extension
{
template <typename Tag>
struct segments_impl
{
template <typename Sequence>
struct apply {};
};
}
namespace result_of
{
template <typename Sequence>
struct segments
{
typedef typename
extension::segments_impl<typename traits::tag_of<Sequence>::type>::
template apply<Sequence>::type
type;
};
}
template <typename Sequence>
typename result_of::segments<Sequence>::type
segments(Sequence & seq)
{
return
extension::segments_impl<typename traits::tag_of<Sequence>::type>::
template apply<Sequence>::call(seq);
}
template <typename Sequence>
typename result_of::segments<Sequence const>::type
segments(Sequence const& seq)
{
return
extension::segments_impl<typename traits::tag_of<Sequence>::type>::
template apply<Sequence const>::call(seq);
}
}}
#endif

57
include/boost/fusion/sequence/intrinsic/ext_/size_s.hpp Executable file
View File

@ -0,0 +1,57 @@
/*=============================================================================
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_SIZE_S_08112006_1141)
#define FUSION_SIZE_S_08112006_1141
#include <boost/mpl/plus.hpp>
#include <boost/mpl/size_t.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/fusion/algorithm/iteration/fold.hpp>
#include <boost/fusion/support/ext_/is_segmented.hpp>
#include <boost/fusion/sequence/intrinsic/ext_/segments.hpp>
namespace boost { namespace fusion
{
///////////////////////////////////////////////////////////////////////////
// calculates the size of any segmented data structure.
template<typename Sequence, bool IsSegmented = traits::is_segmented<Sequence>::value>
struct segmented_size;
namespace detail
{
struct size_plus
{
template<typename Sig>
struct result;
template<typename This, typename Seq, typename State>
struct result<This(Seq, State)>
: mpl::plus<
segmented_size<typename remove_reference<Seq>::type>
, typename remove_reference<State>::type
>
{};
};
}
///////////////////////////////////////////////////////////////////////////
template<typename Sequence, bool IsSegmented>
struct segmented_size
: result_of::fold<
typename result_of::segments<Sequence>::type
, mpl::size_t<0>
, detail::size_plus
>::type
{};
template<typename Sequence>
struct segmented_size<Sequence, false>
: result_of::size<Sequence>
{};
}}
#endif

41
include/boost/fusion/sequence/intrinsic/front.hpp Normal file
View File

@ -0,0 +1,41 @@
/*=============================================================================
Copyright (c) 2001-2006 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/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>
inline typename result_of::front<Sequence>::type
front(Sequence& seq)
{
return *fusion::begin(seq);
}
template <typename Sequence>
inline typename result_of::front<Sequence const>::type
front(Sequence const& seq)
{
return *fusion::begin(seq);
}
}}
#endif

72
include/boost/fusion/sequence/intrinsic/has_key.hpp Normal file
View File

@ -0,0 +1,72 @@
/*=============================================================================
Copyright (c) 2001-2006 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/mpl/not.hpp>
#include <boost/fusion/support/tag_of.hpp>
#include <boost/type_traits/is_same.hpp>
namespace boost { namespace fusion
{
struct void_;
// Special tags:
struct sequence_facade_tag;
struct 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 Sequence, typename Key>
struct apply
: mpl::not_<is_same<typename Sequence::
template meta_at_impl<Key>::type, void_> >
{};
};
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<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>
inline typename result_of::has_key<Sequence, Key>::type
has_key(Sequence const& seq)
{
typedef typename result_of::has_key<Sequence, Key>::type result;
return result();
}
}}
#endif

74
include/boost/fusion/sequence/intrinsic/size.hpp Normal file
View File

@ -0,0 +1,74 @@
/*=============================================================================
Copyright (c) 2001-2006 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/mpl/int.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 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 apply : Sequence::size {};
};
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<array_tag>;
template <>
struct size_impl<mpl_sequence_tag>;
template <>
struct size_impl<std_pair_tag>;
}
namespace result_of
{
template <typename Sequence>
struct size
: extension::size_impl<typename detail::tag_of<Sequence>::type>::
template apply<Sequence>
{
typedef typename extension::size_impl<typename detail::tag_of<Sequence>::type>::
template apply<Sequence>::type size_application;
BOOST_STATIC_CONSTANT(int, value = size_application::value);
};
}
template <typename Sequence>
inline typename result_of::size<Sequence>::type
size(Sequence const&)
{
typedef typename result_of::size<Sequence>::type result;
return result();
}
}}
#endif

59
include/boost/fusion/sequence/intrinsic/swap.hpp Normal file
View File

@ -0,0 +1,59 @@
/*=============================================================================
Copyright (c) 2001-2006 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 <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/utility/enable_if.hpp>
#include <boost/fusion/sequence/intrinsic/front.hpp>
#include <boost/fusion/sequence/intrinsic/back.hpp>
#include <boost/mpl/and.hpp>
namespace boost { namespace fusion {
namespace result_of
{
template<typename Seq1, typename Seq2>
struct swap
{
typedef void type;
};
}
namespace detail
{
struct swap
{
template<typename Elem>
struct result
{
typedef void type;
};
template<typename Elem>
void operator()(Elem const& e) const
{
using std::swap;
swap(front(e), back(e));
}
};
}
template<typename Seq1, typename Seq2>
typename enable_if<mpl::and_<traits::is_sequence<Seq1>, traits::is_sequence<Seq2> >, void>::type
swap(Seq1& lhs, Seq2& rhs)
{
typedef vector<Seq1&, Seq2&> references;
for_each(zip_view<references>(references(lhs, rhs)), detail::swap());
}
}}
#endif

67
include/boost/fusion/sequence/intrinsic/value_at.hpp Normal file
View File

@ -0,0 +1,67 @@
/*=============================================================================
Copyright (c) 2001-2006 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/mpl/int.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 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<array_tag>;
template <>
struct value_at_impl<mpl_sequence_tag>;
template <>
struct value_at_impl<std_pair_tag>;
}
namespace result_of
{
template <typename Sequence, typename N>
struct value_at
: extension::value_at_impl<typename detail::tag_of<Sequence>::type>::
template apply<Sequence, N>
{};
template <typename Sequence, int N>
struct value_at_c
: fusion::result_of::value_at<Sequence, mpl::int_<N> >
{};
}
}}
#endif

59
include/boost/fusion/sequence/intrinsic/value_at_key.hpp Normal file
View File

@ -0,0 +1,59 @@
/*=============================================================================
Copyright (c) 2001-2006 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/mpl/int.hpp>
#include <boost/fusion/support/tag_of.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct sequence_facade_tag;
struct 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 Sequence, typename Key>
struct apply;
};
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<array_tag>;
template <>
struct value_at_key_impl<mpl_sequence_tag>;
template <>
struct value_at_key_impl<std_pair_tag>;
}
namespace result_of
{
template <typename Sequence, typename N>
struct value_at_key
: extension::value_at_key_impl<typename detail::tag_of<Sequence>::type>::
template apply<Sequence, N>
{};
}
}}
#endif

13
include/boost/fusion/sequence/io.hpp Normal file
View File

@ -0,0 +1,13 @@
/*=============================================================================
Copyright (c) 2001-2006 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_SEQUENCE_IO_10032005_0836)
#define FUSION_SEQUENCE_IO_10032005_0836
#include <boost/fusion/sequence/io/in.hpp>
#include <boost/fusion/sequence/io/out.hpp>
#endif

85
include/boost/fusion/sequence/io/detail/in.hpp Normal file
View File

@ -0,0 +1,85 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 1999-2003 Jeremiah Willcock
Copyright (c) 2001-2006 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_IN_05052005_0121)
#define FUSION_IN_05052005_0121
#include <istream>
#include <boost/fusion/sequence/io/detail/manip.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/equal_to.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename Tag>
struct delimiter_in
{
// read a delimiter
template <typename IS>
static void
read(IS& is, char const* delim, mpl::false_ = mpl::false_())
{
detail::string_ios_manip<Tag, IS> manip(is);
manip.read(delim);
}
template <typename IS>
static void
read(IS& is, char const* delim, mpl::true_)
{
}
};
struct read_sequence_loop
{
template <typename IS, typename First, typename Last>
static void
call(IS& is, First const&, Last const&, mpl::true_)
{
}
template <typename IS, typename First, typename Last>
static void
call(IS& is, First const& first, Last const& last, mpl::false_)
{
result_of::equal_to<
typename result_of::next<First>::type
, Last
>
is_last;
is >> *first;
delimiter_in<tuple_delimiter_tag>::read(is, " ", is_last);
call(is, fusion::next(first), last, is_last);
}
template <typename IS, typename First, typename Last>
static void
call(IS& is, First const& first, Last const& last)
{
result_of::equal_to<First, Last> eq;
call(is, first, last, eq);
}
};
template <typename IS, typename Sequence>
inline void
read_sequence(IS& is, Sequence& seq)
{
delimiter_in<tuple_open_tag>::read(is, "(");
read_sequence_loop::call(is, fusion::begin(seq), fusion::end(seq));
delimiter_in<tuple_close_tag>::read(is, ")");
}
}}}
#endif

316
include/boost/fusion/sequence/io/detail/manip.hpp Normal file
View File

@ -0,0 +1,316 @@
/*=============================================================================
Copyright (c) 1999-2003 Jeremiah Willcock
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 2001-2006 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_MANIP_05052005_1200)
#define FUSION_MANIP_05052005_1200
#include <boost/config.hpp>
#include <string>
#include <vector>
#include <cctype>
// Tuple I/O manipulators
#define FUSION_GET_CHAR_TYPE(T) typename T::char_type
#define FUSION_GET_TRAITS_TYPE(T) typename T::traits_type
#if defined (BOOST_NO_TEMPLATED_STREAMS)
#define FUSION_STRING_OF_STREAM(Stream) std::string
#else
#define FUSION_STRING_OF_STREAM(Stream) \
std::basic_string< \
FUSION_GET_CHAR_TYPE(Stream) \
, FUSION_GET_TRAITS_TYPE(Stream) \
>
#endif
//$$$ these should be part of the public API$$$
//$$$ rename tuple_open, tuple_close and tuple_delimiter to
// open, close and delimeter and add these synonyms to the
// TR1 tuple module.
namespace boost { namespace fusion
{
namespace detail
{
template <typename Tag>
int get_xalloc_index(Tag* = 0)
{
// each Tag will have a unique index
static int index = std::ios::xalloc();
return index;
}
template <typename Stream, typename Tag, typename T>
struct stream_data
{
struct arena
{
~arena()
{
for (
typename std::vector<T*>::iterator i = data.begin()
; i != data.end()
; ++i)
{
delete *i;
}
}
std::vector<T*> data;
};
static void attach(Stream& stream, T const& data)
{
static arena ar; // our arena
ar.data.push_back(new T(data));
stream.pword(get_xalloc_index<Tag>()) = ar.data.back();
}
static T const* get(Stream& stream)
{
return (T const*)stream.pword(get_xalloc_index<Tag>());
}
};
template <typename Tag, typename Stream>
class string_ios_manip
{
public:
typedef FUSION_STRING_OF_STREAM(Stream) string_type;
typedef stream_data<Stream, Tag, string_type> stream_data_t;
string_ios_manip(Stream& str_)
: stream(str_)
{}
void
set(string_type const& s)
{
stream_data_t::attach(stream, s);
}
void
print(char const* default_) const
{
// print a delimiter
string_type const* p = stream_data_t::get(stream);
if (p)
stream << *p;
else
stream << default_;
}
void
read(char const* default_) const
{
// read a delimiter
string_type const* p = stream_data_t::get(stream);
using namespace std;
ws(stream);
if (p)
{
typedef typename string_type::const_iterator iterator;
for (iterator i = p->begin(); i != p->end(); ++i)
check_delim(*i);
}
else
{
while (*default_)
check_delim(*default_++);
}
}
private:
template <typename Char>
void
check_delim(Char c) const
{
if (!isspace(c))
{
if (stream.get() != c)
{
stream.unget();
stream.setstate(std::ios::failbit);
}
}
}
Stream& stream;
};
} // detail
#if defined (BOOST_NO_TEMPLATED_STREAMS)
#define STD_TUPLE_DEFINE_MANIPULATOR(name) \
namespace detail \
{ \
struct name##_tag; \
\
struct name##_type \
{ \
typedef std::string string_type; \
string_type data; \
name##_type(const string_type& d): data(d) {} \
}; \
\
template <typename Stream> \
Stream& operator>>(Stream& s, const name##_type& m) \
{ \
string_ios_manip<name##_tag, Stream>(s).set(m.data); \
return s; \
} \
\
template <typename Stream> \
Stream& operator<<(Stream& s, const name##_type& m) \
{ \
string_ios_manip<name##_tag, Stream>(s).set(m.data); \
return s; \
} \
}
#define STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(name) \
inline detail::name##_type \
name(const std::string& s) \
{ \
return detail::name##_type(s); \
} \
\
inline detail::name##_type \
name(const char* s) \
{ \
return detail::name##_type(std::string(s)); \
} \
\
inline detail::name##_type \
name(char c) \
{ \
return detail::name##_type(std::string(1, c)); \
}
#else // defined(BOOST_NO_TEMPLATED_STREAMS)
#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
#define STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(name) \
template <typename Char, typename Traits> \
inline detail::name##_type<Char, Traits> \
name(const std::basic_string<Char, Traits>& s) \
{ \
return detail::name##_type<Char, Traits>(s); \
} \
\
inline detail::name##_type<char> \
name(char const* s) \
{ \
return detail::name##_type<char>(std::basic_string<char>(s)); \
} \
\
inline detail::name##_type<wchar_t> \
name(wchar_t const* s) \
{ \
return detail::name##_type<wchar_t>(std::basic_string<wchar_t>(s)); \
} \
\
inline detail::name##_type<char> \
name(char c) \
{ \
return detail::name##_type<char>(std::basic_string<char>(1, c)); \
} \
\
inline detail::name##_type<wchar_t> \
name(wchar_t c) \
{ \
return detail::name##_type<wchar_t>(std::basic_string<wchar_t>(1, c)); \
}
#else // defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
#define STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(name) \
template <typename Char, typename Traits> \
inline detail::name##_type<Char, Traits> \
name(const std::basic_string<Char, Traits>& s) \
{ \
return detail::name##_type<Char, Traits>(s); \
} \
\
template <typename Char> \
inline detail::name##_type<Char> \
name(Char s[]) \
{ \
return detail::name##_type<Char>(std::basic_string<Char>(s)); \
} \
\
template <typename Char> \
inline detail::name##_type<Char> \
name(Char const s[]) \
{ \
return detail::name##_type<Char>(std::basic_string<Char>(s)); \
} \
\
template <typename Char> \
inline detail::name##_type<Char> \
name(Char c) \
{ \
return detail::name##_type<Char>(std::basic_string<Char>(1, c)); \
}
#endif
#define STD_TUPLE_DEFINE_MANIPULATOR(name) \
namespace detail \
{ \
struct name##_tag; \
\
template <typename Char, typename Traits = std::char_traits<Char> > \
struct name##_type \
{ \
typedef std::basic_string<Char, Traits> string_type; \
string_type data; \
name##_type(const string_type& d): data(d) {} \
}; \
\
template <typename Stream, typename Char, typename Traits> \
Stream& operator>>(Stream& s, const name##_type<Char,Traits>& m) \
{ \
string_ios_manip<name##_tag, Stream>(s).set(m.data); \
return s; \
} \
\
template <typename Stream, typename Char, typename Traits> \
Stream& operator<<(Stream& s, const name##_type<Char,Traits>& m) \
{ \
string_ios_manip<name##_tag, Stream>(s).set(m.data); \
return s; \
} \
} \
#endif // defined(BOOST_NO_TEMPLATED_STREAMS)
STD_TUPLE_DEFINE_MANIPULATOR(tuple_open)
STD_TUPLE_DEFINE_MANIPULATOR(tuple_close)
STD_TUPLE_DEFINE_MANIPULATOR(tuple_delimiter)
STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(tuple_open)
STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(tuple_close)
STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS(tuple_delimiter)
#undef STD_TUPLE_DEFINE_MANIPULATOR
#undef STD_TUPLE_DEFINE_MANIPULATOR_FUNCTIONS
#undef FUSION_STRING_OF_STREAM
#undef FUSION_GET_CHAR_TYPE
#undef FUSION_GET_TRAITS_TYPE
}}
#endif

85
include/boost/fusion/sequence/io/detail/out.hpp Normal file
View File

@ -0,0 +1,85 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 1999-2003 Jeremiah Willcock
Copyright (c) 2001-2006 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_OUT_05052005_0121)
#define FUSION_OUT_05052005_0121
#include <ostream>
#include <boost/fusion/sequence/io/detail/manip.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/next.hpp>
#include <boost/fusion/iterator/equal_to.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename Tag>
struct delimiter_out
{
// print a delimiter
template <typename OS>
static void
print(OS& os, char const* delim, mpl::false_ = mpl::false_())
{
detail::string_ios_manip<Tag, OS> manip(os);
manip.print(delim);
}
template <typename OS>
static void
print(OS& os, char const* delim, mpl::true_)
{
}
};
struct print_sequence_loop
{
template <typename OS, typename First, typename Last>
static void
call(OS& os, First const&, Last const&, mpl::true_)
{
}
template <typename OS, typename First, typename Last>
static void
call(OS& os, First const& first, Last const& last, mpl::false_)
{
result_of::equal_to<
typename result_of::next<First>::type
, Last
>
is_last;
os << *first;
delimiter_out<tuple_delimiter_tag>::print(os, " ", is_last);
call(os, fusion::next(first), last, is_last);
}
template <typename OS, typename First, typename Last>
static void
call(OS& os, First const& first, Last const& last)
{
result_of::equal_to<First, Last> eq;
call(os, first, last, eq);
}
};
template <typename OS, typename Sequence>
inline void
print_sequence(OS& os, Sequence const& seq)
{
delimiter_out<tuple_open_tag>::print(os, "(");
print_sequence_loop::call(os, fusion::begin(seq), fusion::end(seq));
delimiter_out<tuple_close_tag>::print(os, ")");
}
}}}
#endif

42
include/boost/fusion/sequence/io/in.hpp Normal file
View File

@ -0,0 +1,42 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 1999-2003 Jeremiah Willcock
Copyright (c) 2001-2006 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_IN_05042005_0120)
#define BOOST_IN_05042005_0120
#include <istream>
#include <boost/fusion/sequence/io/detail/in.hpp>
#include <boost/fusion/support/is_sequence.hpp>
namespace boost { namespace fusion
{
template <typename Sequence>
inline std::istream&
in(std::istream& is, Sequence& seq)
{
detail::read_sequence(is, seq);
return is;
}
namespace operators
{
template <typename Sequence>
inline typename
enable_if<
fusion::traits::is_sequence<Sequence>
, std::istream&
>::type
operator>>(std::istream& is, Sequence& seq)
{
return fusion::in(is, seq);
}
}
using operators::operator>>;
}}
#endif

44
include/boost/fusion/sequence/io/out.hpp Normal file
View File

@ -0,0 +1,44 @@
/*=============================================================================
Copyright (c) 1999-2003 Jaakko J<>rvi
Copyright (c) 1999-2003 Jeremiah Willcock
Copyright (c) 2001-2006 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_OUT_05042005_0120)
#define BOOST_OUT_05042005_0120
#include <ostream>
#include <boost/fusion/sequence/io/detail/out.hpp>
#include <boost/fusion/support/is_sequence.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/or.hpp>
namespace boost { namespace fusion
{
template <typename Sequence>
inline std::ostream&
out(std::ostream& os, Sequence& seq)
{
detail::print_sequence(os, seq);
return os;
}
namespace operators
{
template <typename Sequence>
inline typename
enable_if<
fusion::traits::is_sequence<Sequence>
, std::ostream&
>::type
operator<<(std::ostream& os, Sequence const& seq)
{
return fusion::out(os, seq);
}
}
using operators::operator<<;
}}
#endif

27
include/boost/fusion/sequence/sequence_facade.hpp Normal file
View File

@ -0,0 +1,27 @@
/*=============================================================================
Copyright (c) 2001-2006 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_SEQUENCE_FACADE_09252006_1044)
#define FUSION_SEQUENCE_FACADE_09252006_1044
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/mpl/bool.hpp>
namespace boost { namespace fusion
{
struct sequence_facade_tag;
template <typename Derived, typename Category, typename IsView = mpl::false_>
struct sequence_facade : sequence_base<Derived>
{
typedef sequence_facade_tag fusion_tag;
typedef Derived derived_type;
typedef Category category;
typedef IsView is_view;
};
}}
#endif

14
include/boost/fusion/sequence/utility.hpp Normal file
View File

@ -0,0 +1,14 @@
//
// Copyright (c) 2006 João Abecasis
//
// 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_SEQUENCE_UTILITY_HPP_INCLUDED)
#define BOOST_FUSION_SEQUENCE_UTILITY_HPP_INCLUDED
# include <boost/fusion/sequence/utility/unpack_args.hpp>
#endif // include guard