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

Removed file/folder

Browse Source 
[SVN r40230]
This commit is contained in:
Joel de Guzman
2007-10-20 23:49:46 +00:00
parent 66cc9bbc28
commit 13b01b0bfe
474 changed files with 0 additions and 25526 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
include/boost/fusion/support/category_of.hpp
View File

@ -1,112 +0,0 @@
/*=============================================================================
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_CATEGORY_OF_07202005_0308)
#define FUSION_CATEGORY_OF_07202005_0308
#include <boost/fusion/support/detail/category_of.hpp>
#include <boost/fusion/support/tag_of.hpp>
#include <boost/type_traits/is_base_of.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct boost_tuple_tag; // boost::tuples::tuple tag
struct array_tag; // boost::array tag
struct mpl_sequence_tag; // mpl sequence tag
struct std_pair_tag; // std::pair tag
struct incrementable_traversal_tag {};
struct single_pass_traversal_tag
: incrementable_traversal_tag {};
struct forward_traversal_tag
: single_pass_traversal_tag {};
struct bidirectional_traversal_tag
: forward_traversal_tag {};
struct random_access_traversal_tag
: bidirectional_traversal_tag {};
struct associative_sequence_tag {};
namespace extension
{
template<typename Tag>
struct category_of_impl
{
template<typename T>
struct apply : detail::fusion_category_of<T> {};
};
template <>
struct category_of_impl<boost_tuple_tag>;
template <>
struct category_of_impl<array_tag>;
template <>
struct category_of_impl<mpl_sequence_tag>;
template <>
struct category_of_impl<std_pair_tag>;
}
namespace traits
{
template <typename T>
struct category_of
: extension::category_of_impl<typename fusion::detail::tag_of<T>::type>::
template apply<T>
{};
template <typename T>
struct is_associative
: is_base_of<
associative_sequence_tag
, typename category_of<T>::type>
{};
template <typename T>
struct is_incrementable
: is_base_of<
incrementable_traversal_tag
, typename category_of<T>::type>
{};
template <typename T>
struct is_single_pass
: is_base_of<
single_pass_traversal_tag
, typename category_of<T>::type>
{};
template <typename T>
struct is_forward
: is_base_of<
forward_traversal_tag
, typename category_of<T>::type>
{};
template <typename T>
struct is_bidirectional
: is_base_of<
bidirectional_traversal_tag
, typename category_of<T>::type>
{};
template <typename T>
struct is_random_access
: is_base_of<
random_access_traversal_tag
, typename category_of<T>::type>
{};
}
}}
#endif

87
include/boost/fusion/support/deduce.hpp
View File

@ -1,87 +0,0 @@
/*=============================================================================
Copyright (c) 2007 Tobias Schwinger
Use modification and distribution are subject to the Boost Software
License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt).
==============================================================================*/
#if !defined(BOOST_FUSION_SUPPORT_DEDUCE_HPP_INCLUDED)
#define BOOST_FUSION_SUPPORT_DEDUCE_HPP_INCLUDED
#include <boost/ref.hpp>
namespace boost { namespace fusion { namespace traits
{
template <typename T> struct deduce;
//----- ---- --- -- - - - -
// Non-references pass unchanged
template <typename T>
struct deduce
{
typedef T type;
};
// Keep references on mutable LValues
template <typename T>
struct deduce<T &>
{
typedef T & type;
};
template <typename T>
struct deduce<T volatile&>
{
typedef T volatile& type;
};
// Store away potential RValues
template <typename T>
struct deduce<T const&>
{
typedef T type;
};
template <typename T>
struct deduce<T const volatile&>
{
typedef T type;
};
// Unwrap Boost.RefS (referencee cv is deduced)
template <typename T>
struct deduce<reference_wrapper<T> & >
{
typedef T& type;
};
template <typename T>
struct deduce<reference_wrapper<T> const & >
{
typedef T& type;
};
// Keep references on arrays, even if const
template <typename T, int N>
struct deduce<const T(&)[N]>
{
typedef const T(&type)[N];
};
template <typename T, int N>
struct deduce<const volatile T(&)[N]>
{
typedef const volatile T(&type)[N];
};
}}}
#endif

43
include/boost/fusion/support/deduce_sequence.hpp
View File

@ -1,43 +0,0 @@
/*=============================================================================
Copyright (c) 2007 Tobias Schwinger
Use modification and distribution are subject to the Boost Software
License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt).
==============================================================================*/
#if !defined(BOOST_FUSION_SUPPORT_DEDUCE_SEQUENCE_HPP_INCLUDED)
#define BOOST_FUSION_SUPPORT_DEDUCE_SEQUENCE_HPP_INCLUDED
#include <boost/fusion/support/deduce.hpp>
#include <boost/fusion/sequence/conversion/as_vector.hpp>
#include <boost/fusion/sequence/intrinsic/mpl.hpp>
#include <boost/mpl/transform.hpp>
namespace boost { namespace fusion { namespace traits
{
template <class Sequence> struct deduce_sequence;
namespace detail
{
struct deducer
{
template <typename T>
struct apply
: fusion::traits::deduce<T>
{ };
};
}
// We cannot use fusion::transform_view here as result_of looses cv qualifiers
// on built in types
template <class Sequence>
struct deduce_sequence
: result_of::as_vector<
typename mpl::transform<Sequence, detail::deducer>::type>
{ };
}}}
#endif

55
include/boost/fusion/support/detail/access.hpp
View File

@ -1,55 +0,0 @@
/*=============================================================================
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_ACCESS_04182005_0737)
#define FUSION_ACCESS_04182005_0737
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/type_traits/is_reference.hpp>
#include <boost/type_traits/remove_cv.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename T>
struct ref_result
{
typedef typename add_reference<typename T::type>::type type;
};
template <typename T>
struct cref_result
{
typedef typename
add_reference<
typename add_const<typename T::type>::type
>::type
type;
};
template <typename T>
struct non_ref_parameter
{
typedef typename boost::remove_cv<T>::type const& type;
};
template <typename T>
struct call_param
{
typedef typename
mpl::eval_if<
is_reference<T>
, mpl::identity<T>
, non_ref_parameter<T>
>::type
type;
};
}}}
#endif

47
include/boost/fusion/support/detail/as_fusion_element.hpp
View File

@ -1,47 +0,0 @@
/*=============================================================================
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_AS_FUSION_ELEMENT_05052005_0338)
#define FUSION_AS_FUSION_ELEMENT_05052005_0338
#include <boost/ref.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename T>
struct as_fusion_element
{
typedef T type;
};
template <typename T>
struct as_fusion_element<reference_wrapper<T> >
{
typedef T& type;
};
template <typename T, int N>
struct as_fusion_element<T[N]>
{
typedef const T(&type)[N];
};
template <typename T, int N>
struct as_fusion_element<volatile T[N]>
{
typedef const volatile T(&type)[N];
};
template <typename T, int N>
struct as_fusion_element<const volatile T[N]>
{
typedef const volatile T(&type)[N];
};
}}}
#endif

19
include/boost/fusion/support/detail/category_of.hpp
View File

@ -1,19 +0,0 @@
/*=============================================================================
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_CATEGORY_OF_07212005_1025)
#define FUSION_CATEGORY_OF_07212005_1025
namespace boost { namespace fusion { namespace detail
{
template <typename T>
struct fusion_category_of
{
typedef typename T::category type;
};
}}}
#endif

17
include/boost/fusion/support/detail/compiler_config.hpp
View File

@ -1,17 +0,0 @@
/*=============================================================================
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_COMPILER_CONFIG_01052006_1200)
#define FUSION_COMPILER_CONFIG_01052006_1200
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
#pragma warning(disable : 4512 4244 4100 4305)
#endif
#endif

27
include/boost/fusion/support/detail/is_mpl_sequence.hpp
View File

@ -1,27 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_DETAIL_IS_MPL_SEQUENCE_29122006_1105)
#define FUSION_DETAIL_IS_MPL_SEQUENCE_29122006_1105
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/mpl/is_sequence.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/not.hpp>
namespace boost { namespace fusion { namespace detail
{
template <typename T>
struct is_mpl_sequence
: mpl::and_<
mpl::not_<is_base_of<sequence_root, T> >
, mpl::is_sequence<T> >
{};
}}}
#endif

19
include/boost/fusion/support/detail/is_view.hpp
View File

@ -1,19 +0,0 @@
/*=============================================================================
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_IS_VIEW_03202006_0018)
#define FUSION_IS_VIEW_03202006_0018
namespace boost { namespace fusion { namespace detail
{
template <typename T>
struct fusion_is_view
{
typedef typename T::is_view type;
};
}}}
#endif

66
include/boost/fusion/support/detail/mpl_iterator_category.hpp
View File

@ -1,66 +0,0 @@
/*=============================================================================
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_MPL_ITERATOR_CATEGORY_07212005_0923)
#define FUSION_MPL_ITERATOR_CATEGORY_07212005_0923
namespace boost { namespace mpl
{
struct forward_iterator_tag;
struct bidirectional_iterator_tag;
struct random_access_iterator_tag;
}}
namespace boost { namespace fusion
{
struct forward_traversal_tag;
struct bidirectional_traversal_tag;
struct random_access_traversal_tag;
}}
namespace boost { namespace fusion { namespace detail
{
template <typename Category>
struct mpl_iterator_category;
template <>
struct mpl_iterator_category<mpl::forward_iterator_tag>
{
typedef forward_traversal_tag type;
};
template <>
struct mpl_iterator_category<mpl::bidirectional_iterator_tag>
{
typedef bidirectional_traversal_tag type;
};
template <>
struct mpl_iterator_category<mpl::random_access_iterator_tag>
{
typedef random_access_traversal_tag type;
};
template <>
struct mpl_iterator_category<forward_traversal_tag>
{
typedef forward_traversal_tag type;
};
template <>
struct mpl_iterator_category<bidirectional_traversal_tag>
{
typedef bidirectional_traversal_tag type;
};
template <>
struct mpl_iterator_category<random_access_traversal_tag>
{
typedef random_access_traversal_tag type;
};
}}}
#endif

16
include/boost/fusion/support/detail/unknown_key.hpp
View File

@ -1,16 +0,0 @@
/*=============================================================================
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_UNKNOWN_KEY_09242005_1219)
#define FUSION_UNKNOWN_KEY_09242005_1219
namespace boost { namespace fusion { namespace detail
{
template <int index>
struct unknown_key {};
}}}
#endif

48
include/boost/fusion/support/ext_/is_segmented.hpp
View File

@ -1,48 +0,0 @@
/*=============================================================================
Copyright (c) 2006 Eric Niebler
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_IS_SEGMENTED_03202006_0015)
#define FUSION_IS_SEGMENTED_03202006_0015
#include <boost/fusion/support/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
struct iterator_range_tag;
namespace extension
{
template<typename Tag>
struct is_segmented_impl
{
template<typename Sequence>
struct apply
: mpl::false_
{};
};
template<>
struct is_segmented_impl<iterator_range_tag>;
}
namespace traits
{
template <typename Sequence>
struct is_segmented
: extension::is_segmented_impl<typename traits::tag_of<Sequence>::type>::
template apply<Sequence>
{
};
}
}}
#endif

20
include/boost/fusion/support/is_iterator.hpp
View File

@ -1,20 +0,0 @@
/*=============================================================================
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_IS_ITERATOR_05062005_1219)
#define FUSION_IS_ITERATOR_05062005_1219
#include <boost/type_traits/is_base_of.hpp>
namespace boost { namespace fusion
{
struct iterator_root;
template <typename T>
struct is_fusion_iterator : is_base_of<iterator_root, T> {};
}}
#endif

65
include/boost/fusion/support/is_sequence.hpp
View File

@ -1,65 +0,0 @@
/*=============================================================================
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_IS_SEQUENCE_05052005_1002)
#define FUSION_IS_SEQUENCE_05052005_1002
#include <boost/type_traits/is_base_of.hpp>
#include <boost/fusion/support/sequence_base.hpp>
#include <boost/fusion/support/tag_of.hpp>
#include <boost/mpl/is_sequence.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/bool.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct non_fusion_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 T>
struct is_sequence_impl
{
template <typename Sequence>
struct apply : is_base_of<sequence_root, Sequence> {};
};
template <>
struct is_sequence_impl<non_fusion_tag>
{
template <typename T>
struct apply : mpl::false_ {};
};
template <>
struct is_sequence_impl<boost_tuple_tag>;
template <>
struct is_sequence_impl<array_tag>;
template <>
struct is_sequence_impl<mpl_sequence_tag>;
template <>
struct is_sequence_impl<std_pair_tag>;
}
namespace traits
{
template <typename T>
struct is_sequence
: extension::is_sequence_impl<typename detail::tag_of<T>::type>::
template apply<T>
{};
}
}}
#endif

63
include/boost/fusion/support/is_view.hpp
View File

@ -1,63 +0,0 @@
/*=============================================================================
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_IS_VIEW_03202006_0015)
#define FUSION_IS_VIEW_03202006_0015
#include <boost/fusion/support/detail/is_view.hpp>
#include <boost/fusion/support/tag_of.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct sequence_facade_tag;
struct boost_tuple_tag; // boost::tuples::tuple tag
struct array_tag; // boost::array tag
struct mpl_sequence_tag; // mpl sequence tag
struct std_pair_tag; // std::pair tag
namespace extension
{
template<typename Tag>
struct is_view_impl
{
template <typename T>
struct apply
: detail::fusion_is_view<T>
{};
};
template <>
struct is_view_impl<sequence_facade_tag>
{
template <typename Sequence>
struct apply : Sequence::is_view {};
};
template <>
struct is_view_impl<boost_tuple_tag>;
template <>
struct is_view_impl<array_tag>;
template <>
struct is_view_impl<mpl_sequence_tag>;
template <>
struct is_view_impl<std_pair_tag>;
}
namespace traits
{
template <typename T>
struct is_view :
extension::is_view_impl<typename fusion::detail::tag_of<T>::type>::
template apply<T>::type
{};
}
}}
#endif

33
include/boost/fusion/support/iterator_base.hpp
View File

@ -1,33 +0,0 @@
/*=============================================================================
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_ITERATOR_BASE_05042005_1008)
#define FUSION_ITERATOR_BASE_05042005_1008
#include <boost/fusion/support/detail/compiler_config.hpp>
namespace boost { namespace fusion
{
struct iterator_root {};
template <typename Iterator>
struct iterator_base : iterator_root
{
Iterator const&
cast() const
{
return static_cast<Iterator const&>(*this);
}
Iterator&
cast()
{
return static_cast<Iterator&>(*this);
}
};
}}
#endif

103
include/boost/fusion/support/pair.hpp
View File

@ -1,103 +0,0 @@
/*=============================================================================
Copyright (c) 2005 Joel de Guzman
Copyright (c) 2006 Tobias Schwinger
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_PAIR_07222005_1203)
#define FUSION_PAIR_07222005_1203
#include <boost/fusion/support/detail/compiler_config.hpp>
#include <boost/fusion/support/detail/access.hpp>
#include <boost/fusion/support/detail/as_fusion_element.hpp>
namespace boost { namespace fusion
{
// A half runtime pair where the first type does not have data
template <typename First, typename Second>
struct pair
{
pair()
: second() {}
pair(typename detail::call_param<Second>::type val)
: second(val) {}
template <typename Second2>
pair(pair<First, Second2> const& rhs)
: second(rhs.second) {}
template <typename Second2>
pair& operator=(pair<First, Second2> const& rhs)
{
second = rhs.second;
return *this;
}
typedef First first_type;
typedef Second second_type;
Second second;
};
namespace result_of
{
template<typename First, typename Second>
struct make_pair
{
typedef fusion::pair<First,
typename detail::as_fusion_element<Second>::type> type;
};
template<class Pair>
struct first
{
typedef typename Pair::first_type type;
};
template<class Pair>
struct second
{
typedef typename Pair::second_type type;
};
}
template <typename First, typename Second>
inline typename result_of::make_pair<First,Second>::type
make_pair(Second const& val)
{
return pair<First, typename detail::as_fusion_element<Second>::type>(val);
}
template <typename OStream, typename First, typename Second>
inline OStream&
operator<<(OStream& os, pair<First, Second> const& p)
{
os << p.second;
return os;
}
template <typename IStream, typename First, typename Second>
inline IStream&
operator>>(IStream& is, pair<First, Second>& p)
{
is >> p.second;
return is;
}
template <typename First, typename SecondL, typename SecondR>
inline bool
operator==(pair<First, SecondL> const& l, pair<First, SecondR> const& r)
{
return l.second == r.second;
}
template <typename First, typename SecondL, typename SecondR>
inline bool
operator!=(pair<First, SecondL> const& l, pair<First, SecondR> const& r)
{
return l.second != r.second;
}
}}
#endif

46
include/boost/fusion/support/sequence_base.hpp
View File

@ -1,46 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2007 Tobias Schwinger
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(FUSION_SEQUENCE_BASE_04182005_0737)
#define FUSION_SEQUENCE_BASE_04182005_0737
#include <boost/fusion/support/detail/compiler_config.hpp>
#include <boost/mpl/begin_end_fwd.hpp>
namespace boost { namespace fusion
{
struct sequence_root {};
template <typename Sequence>
struct sequence_base : sequence_root
{
Sequence const&
derived() const
{
return static_cast<Sequence const&>(*this);
}
Sequence&
derived()
{
return static_cast<Sequence&>(*this);
}
};
struct fusion_sequence_tag;
}}
namespace boost { namespace mpl
{
// Deliberately break mpl::begin, so it doesn't lie that a Fusion sequence
// is not an MPL sequence by returning mpl::void_.
// In other words: Fusion Sequences are always MPL Sequences, but they can
// be incompletely defined.
template<> struct begin_impl< boost::fusion::fusion_sequence_tag >;
}}
#endif

110
include/boost/fusion/support/tag_of.hpp
View File

@ -1,110 +0,0 @@
/*=============================================================================
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_TAG_OF_09232005_0845)
#define FUSION_TAG_OF_09232005_0845
#include <boost/type_traits/remove_const.hpp>
#include <boost/fusion/support/tag_of_fwd.hpp>
#include <boost/fusion/support/detail/is_mpl_sequence.hpp>
#include <boost/mpl/has_xxx.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/if.hpp>
#include <utility>
namespace boost
{
template <typename T, std::size_t N>
class array; // forward
namespace tuples
{
struct null_type;
template <
class T0, class T1, class T2, class T3, class T4,
class T5, class T6, class T7, class T8, class T9
>
class tuple;
template <class Head, class Tail>
struct cons;
}
}
namespace boost { namespace fusion
{
struct non_fusion_tag;
struct mpl_sequence_tag;
namespace detail
{
BOOST_MPL_HAS_XXX_TRAIT_DEF(fusion_tag)
template<typename Sequence>
struct is_specialized
: mpl::false_
{};
template <
class T0, class T1, class T2, class T3, class T4,
class T5, class T6, class T7, class T8, class T9
>
struct is_specialized<tuples::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
: mpl::true_
{};
template <class Head, class Tail>
struct is_specialized<tuples::cons<Head, Tail> >
: mpl::true_
{};
template <>
struct is_specialized<tuples::null_type>
: mpl::true_
{};
template <typename T, std::size_t N>
struct is_specialized<boost::array<T, N> >
: mpl::true_
{};
template<typename T1, typename T2>
struct is_specialized<std::pair<T1, T2> >
: mpl::true_
{};
}
namespace traits
{
template <typename Sequence, typename Active>
struct tag_of
: mpl::if_< detail::is_mpl_sequence<Sequence>,
mpl::identity<mpl_sequence_tag>,
mpl::identity<non_fusion_tag> >::type
{
BOOST_MPL_ASSERT_NOT((detail::is_specialized<Sequence>));
};
template <typename Sequence>
struct tag_of<Sequence, typename boost::enable_if<detail::has_fusion_tag<Sequence> >::type>
{
typedef typename Sequence::fusion_tag type;
};
}
namespace detail
{
template<typename T>
struct tag_of
: traits::tag_of<typename remove_const<T>::type>
{};
}
}}
#endif

20
include/boost/fusion/support/tag_of_fwd.hpp
View File

@ -1,20 +0,0 @@
/*=============================================================================
Copyright (c) 2001-2006 Joel de Guzman
Copyright (c) 2005-2006 Dan Marsden
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#if !defined(BOOST_FUSION_TAG_OF_FWD_31122005_1445)
#define BOOST_FUSION_TAG_OF_FWD_31122005_1445
namespace boost { namespace fusion {
namespace traits
{
template<typename T, typename Active = void>
struct tag_of;
}
}}
#endif

62
include/boost/fusion/support/unused.hpp
View File

@ -1,62 +0,0 @@
/*=============================================================================
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_FUSION_SUPPORT_UNUSED_20070305_1038)
#define BOOST_FUSION_SUPPORT_UNUSED_20070305_1038
#include <boost/config.hpp>
#if defined(BOOST_MSVC)
# pragma warning(push)
# pragma warning(disable: 4522) // multiple assignment operators specified warning
#endif
namespace boost { namespace fusion {
struct unused_type
{
unused_type()
{
}
template <typename T>
unused_type(T const&)
{
}
template <typename T>
unused_type const&
operator=(T const&) const
{
return *this;
}
template <typename T>
unused_type&
operator=(T const&)
{
return *this;
}
unused_type const&
operator=(unused_type const&) const
{
return *this;
}
unused_type&
operator=(unused_type const&)
{
return *this;
}
};
unused_type const unused = unused_type();
}}
#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif
#endif

8
include/boost/fusion/support/void.hpp
View File

@ -1,8 +0,0 @@
#if !defined(BOOST_FUSION_SUPPORT_VOID_20070706_2125)
#define BOOST_FUSION_SUPPORT_VOID_20070706_2125
namespace boost { namespace fusion {
struct void_ {};
}}
#endif