mirror/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout.git synced 2025-05-10 09:23:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix weed type_traits

Browse source
This commit is contained in:
bolero-MURAKAMI 2013-03-25 12:43:47 +09:00
parent f712788cce
commit c78e1d0e6d
27 changed files with 279 additions and 306 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
sprout/type_traits/float_promote.hpp
View file

@ -11,9 +11,9 @@ namespace sprout {
struct float_promote1 struct float_promote1
: public std::conditional< : public std::conditional<
std::is_floating_point<T>::value, std::is_floating_point<T>::value,
sprout::identity<T>, T,
sprout::identity<double> double
>::type >
{ {
static_assert( static_assert(
std::is_arithmetic<T>::value, std::is_arithmetic<T>::value,
@ -25,13 +25,13 @@ namespace sprout {
struct float_promote2 struct float_promote2
: public std::conditional< : public std::conditional<
(std::is_same<T, long double>::value || std::is_same<U, long double>::value), (std::is_same<T, long double>::value || std::is_same<U, long double>::value),
sprout::identity<long double>, long double,
typename std::conditional< typename std::conditional<
(std::is_same<T, float>::value && std::is_same<U, float>::value), (std::is_same<T, float>::value && std::is_same<U, float>::value),
float, float,
double double
> >::type
>::type >
{ {
static_assert( static_assert(
std::is_arithmetic<T>::value && std::is_arithmetic<U>::value, std::is_arithmetic<T>::value && std::is_arithmetic<U>::value,

16
sprout/type_traits/is_c_str.hpp
View file

@ -40,22 +40,6 @@ namespace sprout {
struct is_c_str<char32_t[N]> struct is_c_str<char32_t[N]>
: public std::true_type : public std::true_type
{}; {};
template<std::size_t N>
struct is_c_str<char const[N]>
: public std::true_type
{};
template<std::size_t N>
struct is_c_str<wchar_t const[N]>
: public std::true_type
{};
template<std::size_t N>
struct is_c_str<char16_t const[N]>
: public std::true_type
{};
template<std::size_t N>
struct is_c_str<char32_t const[N]>
: public std::true_type
{};
#if SPROUT_USE_TEMPLATE_ALIASES #if SPROUT_USE_TEMPLATE_ALIASES
template<typename T> template<typename T>

76
sprout/weed/attr_cnv/result_of/bitwise_or.hpp
View file

@ -7,6 +7,7 @@
#include <sprout/array/array.hpp> #include <sprout/array/array.hpp>
#include <sprout/tuple/tuple.hpp> #include <sprout/tuple/tuple.hpp>
#include <sprout/variant/variant.hpp> #include <sprout/variant/variant.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/unused.hpp> #include <sprout/weed/unused.hpp>
#include <sprout/weed/traits/type/is_char_type.hpp> #include <sprout/weed/traits/type/is_char_type.hpp>
#include <sprout/weed/detail/is_same_container.hpp> #include <sprout/weed/detail/is_same_container.hpp>
@ -36,14 +37,13 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_same_container<T, U>::value sprout::weed::detail::is_same_container<T, U>::value
>::type >::type
> { >
public: : public std::conditional<
typedef typename std::conditional<
!(sprout::tuples::tuple_size<T>::value < sprout::tuples::tuple_size<U>::value), !(sprout::tuples::tuple_size<T>::value < sprout::tuples::tuple_size<U>::value),
T, T,
U U
>::type type; >
}; {};
// container<V, N> | V -> container<V, N ? N : 1> // container<V, N> | V -> container<V, N ? N : 1>
template<typename T, typename U> template<typename T, typename U>
struct bitwise_or< struct bitwise_or<
@ -52,14 +52,13 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_container_and_elem<T, U>::value sprout::weed::detail::is_container_and_elem<T, U>::value
>::type >::type
> { >
public: : public std::conditional<
typedef typename std::conditional<
sprout::container_traits<T>::static_size != 0, sprout::container_traits<T>::static_size != 0,
T, T,
typename sprout::container_transform_traits<T>::template rebind_size<1>::type typename sprout::container_transform_traits<T>::template rebind_size<1>::type
>::type type; >
}; {};
// V | container<V, N> -> container<V, N ? N : 1> // V | container<V, N> -> container<V, N ? N : 1>
template<typename T, typename U> template<typename T, typename U>
struct bitwise_or< struct bitwise_or<
@ -68,14 +67,13 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_elem_and_container<T, U>::value sprout::weed::detail::is_elem_and_container<T, U>::value
>::type >::type
> { >
public: : public std::conditional<
typedef typename std::conditional<
sprout::container_traits<T>::static_size != 0, sprout::container_traits<T>::static_size != 0,
U, U,
typename sprout::container_transform_traits<U>::template rebind_size<1>::type typename sprout::container_transform_traits<U>::template rebind_size<1>::type
>::type type; >
}; {};
// tuple<Vs...> | tuple<Ws...> -> tuple<max(Vs..., Ws...)> // tuple<Vs...> | tuple<Ws...> -> tuple<max(Vs..., Ws...)>
template<typename T, typename U> template<typename T, typename U>
struct bitwise_or< struct bitwise_or<
@ -84,14 +82,13 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_both_tuple<T, U>::value sprout::weed::detail::is_both_tuple<T, U>::value
>::type >::type
> { >
public: : public std::conditional<
typedef typename std::conditional<
!(sprout::tuples::tuple_size<T>::value < sprout::tuples::tuple_size<U>::value), !(sprout::tuples::tuple_size<T>::value < sprout::tuples::tuple_size<U>::value),
T, T,
U U
>::type type; >
}; {};
// V | V -> V // V | V -> V
template<typename T, typename U> template<typename T, typename U>
struct bitwise_or< struct bitwise_or<
@ -100,10 +97,9 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_same_elem<T, U>::value sprout::weed::detail::is_same_elem<T, U>::value
>::type >::type
> { >
public: : public sprout::identity<T>
typedef T type; {};
};
// V | W -> variant<V, W> // V | W -> variant<V, W>
template<typename T, typename U> template<typename T, typename U>
struct bitwise_or< struct bitwise_or<
@ -112,10 +108,9 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_different_elem<T, U>::value sprout::weed::detail::is_different_elem<T, U>::value
>::type >::type
> { >
public: : public sprout::identity<sprout::variant<T, U> >
typedef sprout::variant<T, U> type; {};
};
// V | unused -> container<V, 1> // V | unused -> container<V, 1>
template<typename T, typename U> template<typename T, typename U>
struct bitwise_or< struct bitwise_or<
@ -124,14 +119,13 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_elem_and_unused<T, U>::value sprout::weed::detail::is_elem_and_unused<T, U>::value
>::type >::type
> { >
public: : public std::conditional<
typedef typename std::conditional<
sprout::weed::traits::is_char_type<T>::value, sprout::weed::traits::is_char_type<T>::value,
sprout::basic_string<T, 1>, sprout::basic_string<T, 1>,
sprout::array<T, 1> sprout::array<T, 1>
>::type type; >
}; {};
// unused | V -> container<V, 1> // unused | V -> container<V, 1>
template<typename T, typename U> template<typename T, typename U>
struct bitwise_or< struct bitwise_or<
@ -140,14 +134,13 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_unused_and_elem<T, U>::value sprout::weed::detail::is_unused_and_elem<T, U>::value
>::type >::type
> { >
public: : public std::conditional<
typedef typename std::conditional<
sprout::weed::traits::is_char_type<U>::value, sprout::weed::traits::is_char_type<U>::value,
sprout::basic_string<U, 1>, sprout::basic_string<U, 1>,
sprout::array<U, 1> sprout::array<U, 1>
>::type type; >
}; {};
// unused | unused -> unused // unused | unused -> unused
template<typename T, typename U> template<typename T, typename U>
struct bitwise_or< struct bitwise_or<
@ -156,10 +149,9 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_both_unused<T, U>::value sprout::weed::detail::is_both_unused<T, U>::value
>::type >::type
> { >
public: : public sprout::identity<sprout::weed::unused>
typedef sprout::weed::unused type; {};
};
} // namespace result_of } // namespace result_of
} // namespace attr_cnv } // namespace attr_cnv
} // namespace weed } // namespace weed

8
sprout/weed/attr_cnv/result_of/negate.hpp
View file

@ -3,6 +3,7 @@
#include <type_traits> #include <type_traits>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/unused.hpp> #include <sprout/weed/unused.hpp>
#include <sprout/weed/traits/type/is_unused.hpp> #include <sprout/weed/traits/type/is_unused.hpp>
@ -22,10 +23,9 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::traits::is_unused<T>::value sprout::weed::traits::is_unused<T>::value
>::type >::type
> { >
public: : public sprout::identity<sprout::weed::unused>
typedef sprout::weed::unused type; {};
};
} // namespace result_of } // namespace result_of
} // namespace attr_cnv } // namespace attr_cnv
} // namespace weed } // namespace weed

80
sprout/weed/attr_cnv/result_of/shift_left.hpp
View file

@ -11,6 +11,7 @@
#include <sprout/tuple/operation/append_back.hpp> #include <sprout/tuple/operation/append_back.hpp>
#include <sprout/tuple/operation/push_back.hpp> #include <sprout/tuple/operation/push_back.hpp>
#include <sprout/tuple/operation/push_front.hpp> #include <sprout/tuple/operation/push_front.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/unused.hpp> #include <sprout/weed/unused.hpp>
#include <sprout/weed/traits/type/is_char_type.hpp> #include <sprout/weed/traits/type/is_char_type.hpp>
#include <sprout/weed/detail/is_same_container.hpp> #include <sprout/weed/detail/is_same_container.hpp>
@ -42,10 +43,9 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_same_container<T, U>::value sprout::weed::detail::is_same_container<T, U>::value
>::type >::type
> { >
public: : public sprout::fixed::result_of::append_back<T, U>
typedef typename sprout::fixed::result_of::append_back<T, U>::type type; {};
};
// container<V, N> >> V -> container<V, N + 1> // container<V, N> >> V -> container<V, N + 1>
template<typename T, typename U> template<typename T, typename U>
struct shift_left< struct shift_left<
@ -54,10 +54,9 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_container_and_elem<T, U>::value sprout::weed::detail::is_container_and_elem<T, U>::value
>::type >::type
> { >
public: : public sprout::fixed::result_of::push_back<T, U>
typedef typename sprout::fixed::result_of::push_back<T, U>::type type; {};
};
// V >> container<V, N> -> container<V, N + 1> // V >> container<V, N> -> container<V, N + 1>
template<typename T, typename U> template<typename T, typename U>
struct shift_left< struct shift_left<
@ -66,10 +65,9 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_elem_and_container<T, U>::value sprout::weed::detail::is_elem_and_container<T, U>::value
>::type >::type
> { >
public: : public sprout::fixed::result_of::push_front<T, U>
typedef typename sprout::fixed::result_of::push_front<T, U>::type type; {};
};
// tuple<Vs...> >> tuple<Ws...> -> tuple<Vs..., Ws...> // tuple<Vs...> >> tuple<Ws...> -> tuple<Vs..., Ws...>
template<typename T, typename U> template<typename T, typename U>
struct shift_left< struct shift_left<
@ -78,10 +76,9 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_both_tuple<T, U>::value sprout::weed::detail::is_both_tuple<T, U>::value
>::type >::type
> { >
public: : public sprout::tuples::result_of::append_back<T, U>
typedef typename sprout::tuples::result_of::append_back<T, U>::type type; {};
};
// tuple<Vs...> >> V -> tuple<Vs..., V> // tuple<Vs...> >> V -> tuple<Vs..., V>
template<typename T, typename U> template<typename T, typename U>
struct shift_left< struct shift_left<
@ -90,10 +87,9 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_tuple_and_elem<T, U>::value sprout::weed::detail::is_tuple_and_elem<T, U>::value
>::type >::type
> { >
public: : public sprout::tuples::result_of::push_back<T, U>
typedef typename sprout::tuples::result_of::push_back<T, U>::type type; {};
};
// V >> tuple<Vs...> -> tuple<V, Vs...> // V >> tuple<Vs...> -> tuple<V, Vs...>
template<typename T, typename U> template<typename T, typename U>
struct shift_left< struct shift_left<
@ -102,10 +98,9 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_elem_and_tuple<T, U>::value sprout::weed::detail::is_elem_and_tuple<T, U>::value
>::type >::type
> { >
public: : public sprout::tuples::result_of::push_front<T, U>
typedef typename sprout::tuples::result_of::push_front<T, U>::type type; {};
};
// V >> V -> container<V, 2> // V >> V -> container<V, 2>
template<typename T, typename U> template<typename T, typename U>
struct shift_left< struct shift_left<
@ -114,14 +109,13 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_same_elem<T, U>::value sprout::weed::detail::is_same_elem<T, U>::value
>::type >::type
> { >
public: : public std::conditional<
typedef typename std::conditional<
sprout::weed::traits::is_char_type<T>::value, sprout::weed::traits::is_char_type<T>::value,
sprout::basic_string<T, 2>, sprout::basic_string<T, 2>,
sprout::array<T, 2> sprout::array<T, 2>
>::type type; >
}; {};
// V >> W -> tuple<V, W> // V >> W -> tuple<V, W>
template<typename T, typename U> template<typename T, typename U>
struct shift_left< struct shift_left<
@ -130,10 +124,9 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_different_elem<T, U>::value sprout::weed::detail::is_different_elem<T, U>::value
>::type >::type
> { >
public: : public sprout::identity<sprout::tuples::tuple<T, U> >
typedef sprout::tuples::tuple<T, U> type; {};
};
// V >> unused -> V // V >> unused -> V
template<typename T, typename U> template<typename T, typename U>
struct shift_left< struct shift_left<
@ -142,10 +135,9 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_elem_and_unused<T, U>::value sprout::weed::detail::is_elem_and_unused<T, U>::value
>::type >::type
> { >
public: : public sprout::identity<T>
typedef T type; {};
};
// unused >> V -> V // unused >> V -> V
template<typename T, typename U> template<typename T, typename U>
struct shift_left< struct shift_left<
@ -154,10 +146,9 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_unused_and_elem<T, U>::value sprout::weed::detail::is_unused_and_elem<T, U>::value
>::type >::type
> { >
public: : public sprout::identity<U>
typedef U type; {};
};
// unused >> unused -> unused // unused >> unused -> unused
template<typename T, typename U> template<typename T, typename U>
struct shift_left< struct shift_left<
@ -166,10 +157,9 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::detail::is_both_unused<T, U>::value sprout::weed::detail::is_both_unused<T, U>::value
>::type >::type
> { >
public: : public sprout::identity<sprout::weed::unused>
typedef sprout::weed::unused type; {};
};
} // namespace result_of } // namespace result_of
} // namespace attr_cnv } // namespace attr_cnv
} // namespace weed } // namespace weed

26
sprout/weed/attr_cnv/result_of/times.hpp
View file

@ -7,6 +7,7 @@
#include <sprout/string.hpp> #include <sprout/string.hpp>
#include <sprout/array/array.hpp> #include <sprout/array/array.hpp>
#include <sprout/algorithm/string/join.hpp> #include <sprout/algorithm/string/join.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/unused.hpp> #include <sprout/weed/unused.hpp>
#include <sprout/weed/traits/type/is_char_type.hpp> #include <sprout/weed/traits/type/is_char_type.hpp>
#include <sprout/weed/traits/type/is_container.hpp> #include <sprout/weed/traits/type/is_container.hpp>
@ -30,12 +31,11 @@ namespace sprout {
Limit != std::size_t(-1) Limit != std::size_t(-1)
&& sprout::weed::traits::is_container<T>::value && sprout::weed::traits::is_container<T>::value
>::type >::type
> { >
public: : public sprout::algorithm::result_of::join<
typedef typename sprout::algorithm::result_of::join<
sprout::array<T, Limit> sprout::array<T, Limit>
>::type type; >
}; {};
// times<N>(V) -> container<V, N> // times<N>(V) -> container<V, N>
template<std::size_t Limit, typename T> template<std::size_t Limit, typename T>
struct times< struct times<
@ -46,14 +46,13 @@ namespace sprout {
&& !sprout::weed::traits::is_container<T>::value && !sprout::weed::traits::is_container<T>::value
&& !sprout::weed::traits::is_unused<T>::value && !sprout::weed::traits::is_unused<T>::value
>::type >::type
> { >
public: : public std::conditional<
typedef typename std::conditional<
sprout::weed::traits::is_char_type<T>::value, sprout::weed::traits::is_char_type<T>::value,
sprout::basic_string<T, Limit>, sprout::basic_string<T, Limit>,
sprout::array<T, Limit> sprout::array<T, Limit>
>::type type; >
}; {};
// times<N>(unused) -> unused // times<N>(unused) -> unused
template<std::size_t Limit, typename T> template<std::size_t Limit, typename T>
struct times< struct times<
@ -62,10 +61,9 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::traits::is_unused<T>::value sprout::weed::traits::is_unused<T>::value
>::type >::type
> { >
public: : public sprout::identity<sprout::weed::unused>
typedef sprout::weed::unused type; {};
};
} // namespace result_of } // namespace result_of
} // namespace attr_cnv } // namespace attr_cnv
} // namespace weed } // namespace weed

32
sprout/weed/detail/c_str_as_string.hpp
View file

@ -4,17 +4,41 @@
#include <type_traits> #include <type_traits>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/string.hpp> #include <sprout/string.hpp>
#include <sprout/type_traits/identity.hpp>
namespace sprout { namespace sprout {
namespace weed { namespace weed {
namespace detail { namespace detail {
template<typename T> template<typename T>
struct c_str_as_string; struct c_str_as_string;
template<typename T>
struct c_str_as_string<T const>
: public sprout::weed::detail::c_str_as_string<T>
{};
template<typename T>
struct c_str_as_string<T volatile>
: public sprout::weed::detail::c_str_as_string<T>
{};
template<typename T>
struct c_str_as_string<T const volatile>
: public sprout::weed::detail::c_str_as_string<T>
{};
template<typename T, std::size_t N> template<typename T, std::size_t N>
struct c_str_as_string<T const[N]> { struct c_str_as_string<T[N]>
public: : public sprout::identity<sprout::basic_string<T, N - 1> >
typedef sprout::basic_string<T, N - 1> type; {};
}; template<typename T, std::size_t N>
struct c_str_as_string<T const[N]>
: public sprout::identity<sprout::basic_string<T, N - 1> >
{};
template<typename T, std::size_t N>
struct c_str_as_string<T volatile[N]>
: public sprout::identity<sprout::basic_string<T, N - 1> >
{};
template<typename T, std::size_t N>
struct c_str_as_string<T const volatile[N]>
: public sprout::identity<sprout::basic_string<T, N - 1> >
{};
} // namespace detail } // namespace detail
} // namespace weed } // namespace weed
} // namespace sprout } // namespace sprout

15
sprout/weed/parser/auxiliary/eoi.hpp
View file

@ -3,6 +3,7 @@
#include <cstddef> #include <cstddef>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/unused.hpp> #include <sprout/weed/unused.hpp>
#include <sprout/weed/parser_result.hpp> #include <sprout/weed/parser_result.hpp>
#include <sprout/weed/parser/parser_base.hpp> #include <sprout/weed/parser/parser_base.hpp>
@ -17,15 +18,13 @@ namespace sprout {
{ {
public: public:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct attribute { struct attribute
public: : public sprout::identity<sprout::weed::unused>
typedef sprout::weed::unused type; {};
};
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct result { struct result
public: : public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> >
typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type; {};
};
public: public:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
SPROUT_CONSTEXPR typename result<Context, Iterator>::type operator()( SPROUT_CONSTEXPR typename result<Context, Iterator>::type operator()(

15
sprout/weed/parser/auxiliary/eol.hpp
View file

@ -4,6 +4,7 @@
#include <cstddef> #include <cstddef>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/iterator/next.hpp> #include <sprout/iterator/next.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/unused.hpp> #include <sprout/weed/unused.hpp>
#include <sprout/weed/parser_result.hpp> #include <sprout/weed/parser_result.hpp>
#include <sprout/weed/parser/parser_base.hpp> #include <sprout/weed/parser/parser_base.hpp>
@ -18,15 +19,13 @@ namespace sprout {
{ {
public: public:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct attribute { struct attribute
public: : public sprout::identity<sprout::weed::unused>
typedef sprout::weed::unused type; {};
};
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct result { struct result
public: : public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> >
typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type; {};
};
public: public:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
SPROUT_CONSTEXPR typename result<Context, Iterator>::type operator()( SPROUT_CONSTEXPR typename result<Context, Iterator>::type operator()(

15
sprout/weed/parser/auxiliary/eps.hpp
View file

@ -3,6 +3,7 @@
#include <cstddef> #include <cstddef>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/unused.hpp> #include <sprout/weed/unused.hpp>
#include <sprout/weed/parser_result.hpp> #include <sprout/weed/parser_result.hpp>
#include <sprout/weed/parser/parser_base.hpp> #include <sprout/weed/parser/parser_base.hpp>
@ -17,15 +18,13 @@ namespace sprout {
{ {
public: public:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct attribute { struct attribute
public: : public sprout::identity<sprout::weed::unused>
typedef sprout::weed::unused type; {};
};
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct result { struct result
public: : public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> >
typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type; {};
};
public: public:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
SPROUT_CONSTEXPR typename result<Context, Iterator>::type operator()( SPROUT_CONSTEXPR typename result<Context, Iterator>::type operator()(

43
sprout/weed/parser/char/char.hpp
View file

@ -5,6 +5,7 @@
#include <type_traits> #include <type_traits>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/iterator/next.hpp> #include <sprout/iterator/next.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/unused.hpp> #include <sprout/weed/unused.hpp>
#include <sprout/weed/parser_result.hpp> #include <sprout/weed/parser_result.hpp>
#include <sprout/weed/parser/parser_base.hpp> #include <sprout/weed/parser/parser_base.hpp>
@ -22,15 +23,13 @@ namespace sprout {
{ {
public: public:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct attribute { struct attribute
public: : public sprout::identity<sprout::weed::unused>
typedef sprout::weed::unused type; {};
};
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct result { struct result
public: : public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> >
typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type; {};
};
private: private:
T t_; T t_;
public: public:
@ -81,15 +80,13 @@ namespace sprout {
{ {
public: public:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct attribute { struct attribute
public: : public sprout::identity<typename std::iterator_traits<Iterator>::value_type>
typedef typename std::iterator_traits<Iterator>::value_type type; {};
};
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct result { struct result
public: : public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> >
typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type; {};
};
private: private:
T t_; T t_;
public: public:
@ -122,15 +119,13 @@ namespace sprout {
{ {
public: public:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct attribute { struct attribute
public: : public sprout::identity<typename std::iterator_traits<Iterator>::value_type>
typedef typename std::iterator_traits<Iterator>::value_type type; {};
};
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct result { struct result
public: : public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> >
typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type; {};
};
public: public:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
SPROUT_CONSTEXPR typename result<Context, Iterator>::type operator()( SPROUT_CONSTEXPR typename result<Context, Iterator>::type operator()(

17
sprout/weed/parser/char/char_class.hpp
View file

@ -5,6 +5,7 @@
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/iterator/next.hpp> #include <sprout/iterator/next.hpp>
#include <sprout/ctype/ascii.hpp> #include <sprout/ctype/ascii.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/unused.hpp> #include <sprout/weed/unused.hpp>
#include <sprout/weed/parser_result.hpp> #include <sprout/weed/parser_result.hpp>
#include <sprout/weed/parser/parser_base.hpp> #include <sprout/weed/parser/parser_base.hpp>
@ -18,19 +19,17 @@ namespace sprout {
{ \ { \
public: \ public: \
template<typename Context, typename Iterator> \ template<typename Context, typename Iterator> \
struct attribute { \ struct attribute \
public: \ : public std::conditional< \
typedef typename std::conditional< \
Nil, \ Nil, \
sprout::weed::unused, \ sprout::weed::unused, \
typename std::iterator_traits<Iterator>::value_type \ typename std::iterator_traits<Iterator>::value_type \
>::type type; \ > \
}; \ {}; \
template<typename Context, typename Iterator> \ template<typename Context, typename Iterator> \
struct result { \ struct result \
public: \ : public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> > \
typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type; \ {}; \
}; \
public: \ public: \
template<typename Context, typename Iterator> \ template<typename Context, typename Iterator> \
SPROUT_CONSTEXPR typename result<Context, Iterator>::type operator()( \ SPROUT_CONSTEXPR typename result<Context, Iterator>::type operator()( \

8
sprout/weed/parser/directive/as_array.hpp
View file

@ -4,6 +4,7 @@
#include <cstddef> #include <cstddef>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/array/array.hpp> #include <sprout/array/array.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/parser_result.hpp> #include <sprout/weed/parser_result.hpp>
#include <sprout/weed/expr/make_terminal_or_expr.hpp> #include <sprout/weed/expr/make_terminal_or_expr.hpp>
#include <sprout/weed/expr/eval.hpp> #include <sprout/weed/expr/eval.hpp>
@ -32,10 +33,9 @@ namespace sprout {
typedef sprout::array<attr_type, 1> type; typedef sprout::array<attr_type, 1> type;
}; };
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct result { struct result
public: : public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> >
typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type; {};
};
private: private:
typedef typename sprout::weed::traits::terminal_or_expr_of<Parser>::type expr_type; typedef typename sprout::weed::traits::terminal_or_expr_of<Parser>::type expr_type;
private: private:

8
sprout/weed/parser/directive/as_tuple.hpp
View file

@ -4,6 +4,7 @@
#include <cstddef> #include <cstddef>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/tuple/tuple.hpp> #include <sprout/tuple/tuple.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/parser_result.hpp> #include <sprout/weed/parser_result.hpp>
#include <sprout/weed/expr/make_terminal_or_expr.hpp> #include <sprout/weed/expr/make_terminal_or_expr.hpp>
#include <sprout/weed/expr/eval.hpp> #include <sprout/weed/expr/eval.hpp>
@ -32,10 +33,9 @@ namespace sprout {
typedef sprout::tuples::tuple<attr_type> type; typedef sprout::tuples::tuple<attr_type> type;
}; };
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct result { struct result
public: : public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> >
typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type; {};
};
private: private:
typedef typename sprout::weed::traits::terminal_or_expr_of<Parser>::type expr_type; typedef typename sprout::weed::traits::terminal_or_expr_of<Parser>::type expr_type;
private: private:

15
sprout/weed/parser/directive/omit.hpp
View file

@ -3,6 +3,7 @@
#include <cstddef> #include <cstddef>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/unused.hpp> #include <sprout/weed/unused.hpp>
#include <sprout/weed/parser_result.hpp> #include <sprout/weed/parser_result.hpp>
#include <sprout/weed/expr/make_terminal_or_expr.hpp> #include <sprout/weed/expr/make_terminal_or_expr.hpp>
@ -22,15 +23,13 @@ namespace sprout {
{ {
public: public:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct attribute { struct attribute
public: : public sprout::identity<sprout::weed::unused>
typedef sprout::weed::unused type; {};
};
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct result { struct result
public: : public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> >
typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type; {};
};
private: private:
typedef typename sprout::weed::traits::terminal_or_expr_of<Parser>::type expr_type; typedef typename sprout::weed::traits::terminal_or_expr_of<Parser>::type expr_type;
private: private:

17
sprout/weed/parser/directive/repeat.hpp
View file

@ -3,6 +3,7 @@
#include <cstddef> #include <cstddef>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/parser_result.hpp> #include <sprout/weed/parser_result.hpp>
#include <sprout/weed/expr/make_terminal_or_expr.hpp> #include <sprout/weed/expr/make_terminal_or_expr.hpp>
#include <sprout/weed/expr/eval.hpp> #include <sprout/weed/expr/eval.hpp>
@ -142,18 +143,16 @@ namespace sprout {
}; };
public: public:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct attribute { struct attribute
public: : public sprout::weed::attr_cnv::result_of::times<
typedef typename sprout::weed::attr_cnv::result_of::times<
sprout::weed::traits::limit_of<Parser, Iterator, Context>::value, sprout::weed::traits::limit_of<Parser, Iterator, Context>::value,
typename sprout::weed::traits::attribute_of<Parser, Iterator, Context>::type typename sprout::weed::traits::attribute_of<Parser, Iterator, Context>::type
>::type type; >
}; {};
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct result { struct result
public: : public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> >
typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type; {};
};
private: private:
typedef typename sprout::weed::traits::terminal_or_expr_of<Parser>::type expr_type; typedef typename sprout::weed::traits::terminal_or_expr_of<Parser>::type expr_type;
private: private:

15
sprout/weed/parser/directive/replace.hpp
View file

@ -3,6 +3,7 @@
#include <cstddef> #include <cstddef>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/unused.hpp> #include <sprout/weed/unused.hpp>
#include <sprout/weed/parser_result.hpp> #include <sprout/weed/parser_result.hpp>
#include <sprout/weed/expr/make_terminal_or_expr.hpp> #include <sprout/weed/expr/make_terminal_or_expr.hpp>
@ -23,15 +24,13 @@ namespace sprout {
public: public:
typedef T value_type; typedef T value_type;
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct attribute { struct attribute
public: : public sprout::identity<value_type>
typedef value_type type; {};
};
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct result { struct result
public: : public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> >
typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type; {};
};
private: private:
typedef typename sprout::weed::traits::terminal_or_expr_of<Parser>::type expr_type; typedef typename sprout::weed::traits::terminal_or_expr_of<Parser>::type expr_type;
private: private:

15
sprout/weed/parser/lim.hpp
View file

@ -3,6 +3,7 @@
#include <cstddef> #include <cstddef>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/parser_result.hpp> #include <sprout/weed/parser_result.hpp>
#include <sprout/weed/limited.hpp> #include <sprout/weed/limited.hpp>
#include <sprout/weed/expr/make_terminal_or_expr.hpp> #include <sprout/weed/expr/make_terminal_or_expr.hpp>
@ -25,15 +26,13 @@ namespace sprout {
SPROUT_STATIC_CONSTEXPR std::size_t limit = Limit; SPROUT_STATIC_CONSTEXPR std::size_t limit = Limit;
public: public:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct attribute { struct attribute
public: : public sprout::weed::traits::attribute_of<Parser, Iterator, Context>
typedef typename sprout::weed::traits::attribute_of<Parser, Iterator, Context>::type type; {};
};
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct result { struct result
public: : public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> >
typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type; {};
};
private: private:
typedef typename sprout::weed::traits::terminal_or_expr_of<Parser>::type expr_type; typedef typename sprout::weed::traits::terminal_or_expr_of<Parser>::type expr_type;
private: private:

15
sprout/weed/parser/numeric/int_p.hpp
View file

@ -6,6 +6,7 @@
#include <sprout/iterator/next.hpp> #include <sprout/iterator/next.hpp>
#include <sprout/tuple/tuple.hpp> #include <sprout/tuple/tuple.hpp>
#include <sprout/integer/integer_digits.hpp> #include <sprout/integer/integer_digits.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/unused.hpp> #include <sprout/weed/unused.hpp>
#include <sprout/weed/parser_result.hpp> #include <sprout/weed/parser_result.hpp>
#include <sprout/weed/parser/parser_base.hpp> #include <sprout/weed/parser/parser_base.hpp>
@ -32,15 +33,13 @@ namespace sprout {
; ;
public: public:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct attribute { struct attribute
public: : public sprout::identity<IntType>
typedef IntType type; {};
};
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct result { struct result
public: : public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> >
typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type; {};
};
private: private:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
SPROUT_CONSTEXPR typename result<Context, Iterator>::type make_result( SPROUT_CONSTEXPR typename result<Context, Iterator>::type make_result(

15
sprout/weed/parser/numeric/uint_p.hpp
View file

@ -6,6 +6,7 @@
#include <sprout/iterator/next.hpp> #include <sprout/iterator/next.hpp>
#include <sprout/tuple/tuple.hpp> #include <sprout/tuple/tuple.hpp>
#include <sprout/integer/integer_digits.hpp> #include <sprout/integer/integer_digits.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/unused.hpp> #include <sprout/weed/unused.hpp>
#include <sprout/weed/parser_result.hpp> #include <sprout/weed/parser_result.hpp>
#include <sprout/weed/parser/parser_base.hpp> #include <sprout/weed/parser/parser_base.hpp>
@ -32,15 +33,13 @@ namespace sprout {
; ;
public: public:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct attribute { struct attribute
public: : public sprout::identity<UIntType>
typedef UIntType type; {};
};
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct result { struct result
public: : public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> >
typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type; {};
};
private: private:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
SPROUT_CONSTEXPR typename result<Context, Iterator>::type make_result( SPROUT_CONSTEXPR typename result<Context, Iterator>::type make_result(

29
sprout/weed/parser/string/string.hpp
View file

@ -9,6 +9,7 @@
#include <sprout/container/size.hpp> #include <sprout/container/size.hpp>
#include <sprout/iterator/operation.hpp> #include <sprout/iterator/operation.hpp>
#include <sprout/algorithm/equal.hpp> #include <sprout/algorithm/equal.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/unused.hpp> #include <sprout/weed/unused.hpp>
#include <sprout/weed/parser_result.hpp> #include <sprout/weed/parser_result.hpp>
#include <sprout/weed/parser/parser_base.hpp> #include <sprout/weed/parser/parser_base.hpp>
@ -27,15 +28,13 @@ namespace sprout {
{ {
public: public:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct attribute { struct attribute
public: : public sprout::identity<sprout::weed::unused>
typedef sprout::weed::unused type; {};
};
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct result { struct result
public: : public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> >
typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type; {};
};
private: private:
T t_; T t_;
public: public:
@ -102,15 +101,13 @@ namespace sprout {
{ {
public: public:
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct attribute { struct attribute
public: : public sprout::identity<T>
typedef T type; {};
};
template<typename Context, typename Iterator> template<typename Context, typename Iterator>
struct result { struct result
public: : public sprout::identity<sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> >
typedef sprout::weed::parser_result<Iterator, typename attribute<Context, Iterator>::type> type; {};
};
private: private:
T t_; T t_;
public: public:

20
sprout/weed/traits/expr/expr_of.hpp
View file

@ -3,6 +3,7 @@
#include <type_traits> #include <type_traits>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/type_traits/remove_shallow_cvref.hpp> #include <sprout/type_traits/remove_shallow_cvref.hpp>
#include <sprout/weed/expr/expr_fwd.hpp> #include <sprout/weed/expr/expr_fwd.hpp>
#include <sprout/weed/traits/expr/terminal_or_expr_of.hpp> #include <sprout/weed/traits/expr/terminal_or_expr_of.hpp>
@ -14,15 +15,16 @@ namespace sprout {
// expr_of // expr_of
// //
template<typename Tag, typename... Args> template<typename Tag, typename... Args>
struct expr_of { struct expr_of
public: : public sprout::identity<
typedef sprout::weed::expr< sprout::weed::expr<
Tag, Tag,
typename sprout::weed::traits::terminal_or_expr_of< typename sprout::weed::traits::terminal_or_expr_of<
typename sprout::remove_shallow_cvref<Args>::type typename sprout::remove_shallow_cvref<Args>::type
>::type... >::type...
> type; >
}; >
{};
} // namespace traits } // namespace traits
} // namespace weed } // namespace weed
} // namespace sprout } // namespace sprout

8
sprout/weed/traits/expr/tag_of.hpp
View file

@ -3,6 +3,7 @@
#include <type_traits> #include <type_traits>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/weed/traits/expr/is_expr.hpp> #include <sprout/weed/traits/expr/is_expr.hpp>
namespace sprout { namespace sprout {
@ -23,10 +24,9 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::traits::is_expr<Expr>::value sprout::weed::traits::is_expr<Expr>::value
>::type >::type
> { >
public: : public sprout::identity<typename Expr::expr_tag>
typedef typename Expr::expr_tag type; {};
};
} // namespace traits } // namespace traits
} // namespace weed } // namespace weed
} // namespace sprout } // namespace sprout

35
sprout/weed/traits/expr/terminal_of.hpp
View file

@ -3,6 +3,7 @@
#include <type_traits> #include <type_traits>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/type_traits/identity.hpp>
#include <sprout/type_traits/remove_shallow_cvref.hpp> #include <sprout/type_traits/remove_shallow_cvref.hpp>
#include <sprout/weed/expr/expr_fwd.hpp> #include <sprout/weed/expr/expr_fwd.hpp>
#include <sprout/weed/expr/tag.hpp> #include <sprout/weed/expr/tag.hpp>
@ -25,13 +26,14 @@ namespace sprout {
typename sprout::remove_shallow_cvref<Arg>::type typename sprout::remove_shallow_cvref<Arg>::type
>::value >::value
>::type >::type
> { >
public: : public sprout::identity<
typedef sprout::weed::expr< sprout::weed::expr<
sprout::weed::tag::terminal, sprout::weed::tag::terminal,
typename sprout::remove_shallow_cvref<Arg>::type typename sprout::remove_shallow_cvref<Arg>::type
> type; >
}; >
{};
template<typename Arg> template<typename Arg>
struct terminal_of< struct terminal_of<
Arg, Arg,
@ -40,15 +42,16 @@ namespace sprout {
typename sprout::remove_shallow_cvref<Arg>::type typename sprout::remove_shallow_cvref<Arg>::type
>::value >::value
>::type >::type
> { >
public: : public sprout::identity<
typedef sprout::weed::expr< sprout::weed::expr<
sprout::weed::tag::terminal, sprout::weed::tag::terminal,
typename sprout::weed::detail::c_str_as_string< typename sprout::weed::detail::c_str_as_string<
typename sprout::remove_shallow_cvref<Arg>::type typename sprout::remove_shallow_cvref<Arg>::type
>::type >::type
> type; >
}; >
{};
} // namespace traits } // namespace traits
} // namespace weed } // namespace weed
} // namespace sprout } // namespace sprout

13
sprout/weed/traits/expr/terminal_or_expr_of.hpp
View file

@ -14,16 +14,15 @@ namespace sprout {
// terminal_or_expr_of // terminal_or_expr_of
// //
template<typename Arg> template<typename Arg>
struct terminal_or_expr_of { struct terminal_or_expr_of
public: : public std::conditional<
typedef typename std::conditional<
sprout::weed::traits::is_expr< sprout::weed::traits::is_expr<
typename sprout::remove_shallow_cvref<Arg>::type typename sprout::remove_shallow_cvref<Arg>::type
>::value, >::value,
typename sprout::remove_shallow_cvref<Arg>::type, sprout::remove_shallow_cvref<Arg>,
typename sprout::weed::traits::terminal_of<Arg>::type sprout::weed::traits::terminal_of<Arg>
>::type type; >::type
}; {};
} // namespace traits } // namespace traits
} // namespace weed } // namespace weed
} // namespace sprout } // namespace sprout

15
sprout/weed/traits/parser/attribute_of.hpp
View file

@ -3,6 +3,7 @@
#include <type_traits> #include <type_traits>
#include <sprout/config.hpp> #include <sprout/config.hpp>
#include <sprout/weed/traits/expr/is_expr.hpp>
#include <sprout/weed/unused.hpp> #include <sprout/weed/unused.hpp>
#include <sprout/weed/expr/expr.hpp> #include <sprout/weed/expr/expr.hpp>
#include <sprout/weed/expr/tag.hpp> #include <sprout/weed/expr/tag.hpp>
@ -37,10 +38,9 @@ namespace sprout {
&& !sprout::weed::traits::is_c_str<T>::value && !sprout::weed::traits::is_c_str<T>::value
&& !sprout::weed::traits::is_string<T>::value && !sprout::weed::traits::is_string<T>::value
>::type >::type
> { >
public: : public T::template attribute<Context, Iterator>
typedef typename T::template attribute<Context, Iterator>::type type; {};
};
template<typename T, typename Iterator, typename Context> template<typename T, typename Iterator, typename Context>
struct attribute_of< struct attribute_of<
T, T,
@ -49,10 +49,9 @@ namespace sprout {
typename std::enable_if< typename std::enable_if<
sprout::weed::traits::is_expr<T>::value sprout::weed::traits::is_expr<T>::value
>::type >::type
> { >
public: : public sprout::identity<typename Context::template eval<T>::attribute_type>
typedef typename Context::template eval<T>::attribute_type type; {};
};
template<typename T, typename Iterator, typename Context> template<typename T, typename Iterator, typename Context>
struct attribute_of< struct attribute_of<
T, T,

2
sprout/weed/traits/parser/is_parser.hpp
View file

@ -52,6 +52,7 @@ namespace sprout {
T, T,
typename std::enable_if< typename std::enable_if<
sprout::weed::traits::is_c_str<T>::value sprout::weed::traits::is_c_str<T>::value
&& !std::is_const<T>::value
>::type >::type
> >
: public std::true_type : public std::true_type
@ -61,7 +62,6 @@ namespace sprout {
T, T,
typename std::enable_if< typename std::enable_if<
std::is_const<T>::value std::is_const<T>::value
&& !std::is_array<T>::value
>::type >::type
> >
: public sprout::weed::traits::is_parser< : public sprout::weed::traits::is_parser<