boostorg/fusion
1
0
Fork 1
mirror of https://github.com/boostorg/fusion.git synced 2025-07-16 05:42:20 +02:00
Code Issues Packages Projects Releases Wiki Activity

vc7.1 bugfix (ICE)

Browse Source 
[SVN r36918]
This commit is contained in:
Joel de Guzman
2007-02-09 12:16:39 +00:00
parent 693200182f
commit 94c2c0e526
7 changed files with 128 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
include/boost/fusion/sequence/container/deque/deque.hpp
View File

@ -22,6 +22,7 @@
#include <boost/type_traits/add_reference.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/fusion/sequence/container/deque/deque_fwd.hpp>
#include <boost/fusion/sequence/container/deque/detail/value_at_impl.hpp>
#include <boost/fusion/sequence/container/deque/detail/at_impl.hpp>
#include <boost/fusion/sequence/container/deque/detail/begin_impl.hpp>
@ -35,12 +36,9 @@ namespace boost { namespace fusion {
struct deque_tag;
struct void_;
template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(FUSION_MAX_DEQUE_SIZE, typename T, void_)>
struct deque;
template<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, typename T)>
struct deque
:
:
detail::deque_keyed_values<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, T)>::type,
sequence_base<deque<BOOST_PP_ENUM_PARAMS(FUSION_MAX_DEQUE_SIZE, T)> >
{
@ -54,7 +52,7 @@ namespace boost { namespace fusion {
#include <boost/fusion/sequence/container/deque/detail/deque_forward_ctor.hpp>
deque()
deque()
{}
explicit deque(typename add_reference<typename add_const<T0>::type>::type t0)

25
include/boost/fusion/sequence/container/deque/deque_fwd.hpp Normal file
View File

@ -0,0 +1,25 @@
/*=============================================================================
Copyright (c) 2005-2007 Joel de Guzman
Copyright (c) 2005-2007 Dan Marsden
Use, modification and distribution is 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(FUSION_DEQUE_FORWARD_02092007_0749)
#define FUSION_DEQUE_FORWARD_02092007_0749
#include <boost/fusion/sequence/container/deque/limits.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
namespace boost { namespace fusion
{
struct void_;
template<
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
FUSION_MAX_DEQUE_SIZE, typename T, void_)>
struct deque;
}}
#endif

92
include/boost/fusion/sequence/intrinsic/mpl/detail/as.hpp
View File

@ -8,56 +8,74 @@
#if !defined(FUSION_AS_10022005_1442)
#define FUSION_AS_10022005_1442
#include <boost/fusion/sequence/conversion.hpp>
namespace boost { namespace fusion { namespace detail
namespace boost { namespace fusion
{
template <typename Tag>
struct as_impl;
template <>
struct as_impl<cons_tag>
namespace result_of
{
template <typename Sequence>
struct apply : result_of::as_list<Sequence> {};
};
struct as_list;
template <>
struct as_impl<map_tag>
{
template <typename Sequence>
struct apply : result_of::as_map<Sequence> {};
};
struct as_map;
template <>
struct as_impl<set_tag>
{
template <typename Sequence>
struct apply : result_of::as_set<Sequence> {};
};
struct as_set;
template <>
struct as_impl<vector_tag>
{
template <typename Sequence>
struct apply : result_of::as_vector<Sequence> {};
};
struct as_vector;
template<>
struct as_impl<deque_tag>
{
template <typename Sequence>
struct apply : result_of::as_deque<Sequence> {};
};
struct as_deque;
}
template <typename Tag, typename Sequence>
struct as
namespace detail
{
typedef typename
as_impl<Tag>::template apply<Sequence>::type
type;
};
template <typename Tag>
struct as_impl;
}}}
template <>
struct as_impl<cons_tag>
{
template <typename Sequence>
struct apply : result_of::as_list<Sequence> {};
};
template <>
struct as_impl<map_tag>
{
template <typename Sequence>
struct apply : result_of::as_map<Sequence> {};
};
template <>
struct as_impl<set_tag>
{
template <typename Sequence>
struct apply : result_of::as_set<Sequence> {};
};
template <>
struct as_impl<vector_tag>
{
template <typename Sequence>
struct apply : result_of::as_vector<Sequence> {};
};
template<>
struct as_impl<deque_tag>
{
template <typename Sequence>
struct apply : result_of::as_deque<Sequence> {};
};
template <typename Tag, typename Sequence>
struct as
{
typedef typename
as_impl<Tag>::template apply<Sequence>::type
type;
};
}
}}
#endif

41
include/boost/fusion/sequence/intrinsic/mpl/detail/clear.hpp
View File

@ -8,25 +8,40 @@
#if !defined(FUSION_CLEAR_10022005_1442)
#define FUSION_CLEAR_10022005_1442
#include <boost/fusion/sequence/container.hpp>
#include <boost/fusion/sequence/container/vector/vector_fwd.hpp>
#include <boost/fusion/sequence/container/list/list_fwd.hpp>
#include <boost/fusion/sequence/container/map/map_fwd.hpp>
#include <boost/fusion/sequence/container/set/set_fwd.hpp>
#include <boost/fusion/sequence/container/deque/deque_fwd.hpp>
namespace boost { namespace fusion { namespace detail
namespace boost { namespace fusion
{
template <typename Tag>
struct clear;
struct cons_tag;
struct map_tag;
struct set_tag;
struct vector_tag;
struct deque_tag;
template <>
struct clear<cons_tag> : mpl::identity<list<> > {};
namespace detail
{
template <typename Tag>
struct clear;
template <>
struct clear<map_tag> : mpl::identity<map<> > {};
template <>
struct clear<cons_tag> : mpl::identity<list<> > {};
template <>
struct clear<set_tag> : mpl::identity<set<> > {};
template <>
struct clear<map_tag> : mpl::identity<map<> > {};
template <>
struct clear<vector_tag> : mpl::identity<vector<> > {};
template <>
struct clear<set_tag> : mpl::identity<set<> > {};
}}}
template <>
struct clear<vector_tag> : mpl::identity<vector<> > {};
template <>
struct clear<deque_tag> : mpl::identity<deque<> > {};
}
}}
#endif

3
include/boost/fusion/sequence/view/transform_view/detail/deref_impl.hpp
View File

@ -68,7 +68,8 @@ namespace boost { namespace fusion
return i.f(*i.first1, *i.first2);
}
};
}; }
};
}
}}
#endif

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

@ -62,7 +62,7 @@ namespace boost { namespace fusion
{
template <typename T>
struct category_of
: extension::category_of_impl<typename detail::tag_of<T>::type>::
: extension::category_of_impl<typename fusion::detail::tag_of<T>::type>::
template apply<T>
{};
@ -70,42 +70,42 @@ namespace boost { namespace fusion
struct is_associative
: is_base_of<
associative_sequence_tag
, typename category_of<T>::type>
, typename category_of<T>::type>
{};
template <typename T>
struct is_incrementable
: is_base_of<
incrementable_traversal_tag
, typename category_of<T>::type>
, typename category_of<T>::type>
{};
template <typename T>
struct is_single_pass
: is_base_of<
single_pass_traversal_tag
, typename category_of<T>::type>
, typename category_of<T>::type>
{};
template <typename T>
struct is_forward
: is_base_of<
forward_traversal_tag
, typename category_of<T>::type>
{};
, typename category_of<T>::type>
{};
template <typename T>
struct is_bidirectional
: is_base_of<
bidirectional_traversal_tag
, typename category_of<T>::type>
{};
, typename category_of<T>::type>
{};
template <typename T>
struct is_random_access
: is_base_of<
random_access_traversal_tag
, typename category_of<T>::type>
, typename category_of<T>::type>
{};
}
}}

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

@ -11,7 +11,7 @@
#include <boost/fusion/support/detail/is_view.hpp>
#include <boost/fusion/support/tag_of.hpp>
namespace boost { namespace fusion
namespace boost { namespace fusion
{
// Special tags:
struct sequence_facade_tag;
@ -54,8 +54,8 @@ namespace boost { namespace fusion
namespace traits
{
template <typename T>
struct is_view :
extension::is_view_impl<typename detail::tag_of<T>::type>::
struct is_view :
extension::is_view_impl<typename fusion::detail::tag_of<T>::type>::
template apply<T>::type
{};
}