Commit 96871ee5 authored by Dominik Charousset's avatar Dominik Charousset

maintenance & type_list interface changes

the type_list interface changed and the class itself no longer has
any members, tl_size<>, tl_head<>, etc. must be used instead;
these "template functions" also work with any variadic template class;
this patch also changes some code parts to be more consistent with
libcppa's coding style and naming convention
parent 6614afd3
......@@ -165,9 +165,9 @@ class cow_tuple<Head, Tail...> {
template<typename TypeList>
struct cow_tuple_from_type_list;
template<typename... Types>
struct cow_tuple_from_type_list< util::type_list<Types...> > {
typedef cow_tuple<Types...> type;
template<typename... Ts>
struct cow_tuple_from_type_list< util::type_list<Ts...> > {
typedef cow_tuple<Ts...> type;
};
#ifdef CPPA_DOCUMENTATION
......@@ -207,15 +207,15 @@ cow_tuple<Args...> make_cow_tuple(Args&&... args);
#else
template<size_t N, typename... Types>
const typename util::at<N, Types...>::type& get(const cow_tuple<Types...>& tup) {
typedef typename util::at<N, Types...>::type result_type;
template<size_t N, typename... Ts>
const typename util::at<N, Ts...>::type& get(const cow_tuple<Ts...>& tup) {
typedef typename util::at<N, Ts...>::type result_type;
return *reinterpret_cast<const result_type*>(tup.at(N));
}
template<size_t N, typename... Types>
typename util::at<N, Types...>::type& get_ref(cow_tuple<Types...>& tup) {
typedef typename util::at<N, Types...>::type result_type;
template<size_t N, typename... Ts>
typename util::at<N, Ts...>::type& get_ref(cow_tuple<Ts...>& tup) {
typedef typename util::at<N, Ts...>::type result_type;
return *reinterpret_cast<result_type*>(tup.mutable_at(N));
}
......@@ -234,9 +234,9 @@ make_cow_tuple(Args&&... args) {
* @returns @p true if @p lhs and @p rhs are equal; otherwise @p false.
* @relates cow_tuple
*/
template<typename... LhsTypes, typename... RhsTypes>
inline bool operator==(const cow_tuple<LhsTypes...>& lhs,
const cow_tuple<RhsTypes...>& rhs) {
template<typename... LhsTs, typename... RhsTs>
inline bool operator==(const cow_tuple<LhsTs...>& lhs,
const cow_tuple<RhsTs...>& rhs) {
return util::compare_tuples(lhs, rhs);
}
......@@ -247,9 +247,9 @@ inline bool operator==(const cow_tuple<LhsTypes...>& lhs,
* @returns @p true if @p lhs and @p rhs are not equal; otherwise @p false.
* @relates cow_tuple
*/
template<typename... LhsTypes, typename... RhsTypes>
inline bool operator!=(const cow_tuple<LhsTypes...>& lhs,
const cow_tuple<RhsTypes...>& rhs) {
template<typename... LhsTs, typename... RhsTs>
inline bool operator!=(const cow_tuple<LhsTs...>& lhs,
const cow_tuple<RhsTs...>& rhs) {
return !(lhs == rhs);
}
......
......@@ -49,17 +49,17 @@
namespace cppa { namespace detail {
template<typename... ElementTypes>
template<typename... Ts>
class decorated_tuple : public abstract_tuple {
typedef abstract_tuple super;
static_assert(sizeof...(ElementTypes) > 0,
static_assert(sizeof...(Ts) > 0,
"decorated_tuple is not allowed to be empty");
public:
typedef util::fixed_vector<size_t, sizeof...(ElementTypes)> vector_type;
typedef util::fixed_vector<size_t, sizeof...(Ts)> vector_type;
typedef cow_ptr<abstract_tuple> cow_pointer_type;
......@@ -79,7 +79,7 @@ class decorated_tuple : public abstract_tuple {
}
virtual size_t size() const {
return sizeof...(ElementTypes);
return sizeof...(Ts);
}
virtual decorated_tuple* copy() const {
......@@ -97,7 +97,7 @@ class decorated_tuple : public abstract_tuple {
}
const std::type_info* type_token() const {
return static_type_list<ElementTypes...>::list;
return static_type_list<Ts...>::list;
}
private:
......@@ -111,8 +111,8 @@ class decorated_tuple : public abstract_tuple {
# ifdef CPPA_DEBUG
const cow_pointer_type& ptr = m_decorated; // prevent detaching
# endif
CPPA_REQUIRE(ptr->size() >= sizeof...(ElementTypes));
CPPA_REQUIRE(v.size() == sizeof...(ElementTypes));
CPPA_REQUIRE(ptr->size() >= sizeof...(Ts));
CPPA_REQUIRE(v.size() == sizeof...(Ts));
CPPA_REQUIRE(*(std::max_element(v.begin(), v.end())) < ptr->size());
}
......@@ -121,10 +121,10 @@ class decorated_tuple : public abstract_tuple {
# ifdef CPPA_DEBUG
const cow_pointer_type& ptr = m_decorated; // prevent detaching
# endif
CPPA_REQUIRE((ptr->size() - offset) >= sizeof...(ElementTypes));
CPPA_REQUIRE((ptr->size() - offset) >= sizeof...(Ts));
CPPA_REQUIRE(offset > 0);
size_t i = offset;
m_mapping.resize(sizeof...(ElementTypes));
m_mapping.resize(sizeof...(Ts));
std::generate(m_mapping.begin(), m_mapping.end(), [&]() {return i++;});
}
......@@ -137,9 +137,9 @@ class decorated_tuple : public abstract_tuple {
template<typename TypeList>
struct decorated_cow_tuple_from_type_list;
template<typename... Types>
struct decorated_cow_tuple_from_type_list< util::type_list<Types...> > {
typedef decorated_tuple<Types...> type;
template<typename... Ts>
struct decorated_cow_tuple_from_type_list< util::type_list<Ts...> > {
typedef decorated_tuple<Ts...> type;
};
} } // namespace cppa::detail
......
......@@ -55,7 +55,7 @@ class event_based_actor_impl : public event_based_actor {
void on_exit() {
typedef typename util::get_arg_types<CleanupFun>::types arg_types;
std::integral_constant<size_t, arg_types::size> token;
std::integral_constant<size_t, util::tl_size<arg_types>::value> token;
on_exit_impl(m_on_exit, token);
}
......
......@@ -31,26 +31,28 @@
#ifndef CPPA_PSEUDO_TUPLE_HPP
#define CPPA_PSEUDO_TUPLE_HPP
#include <cstddef>
#include "cppa/util/at.hpp"
namespace cppa { namespace detail {
// tuple-like access to an array of void pointers
template<typename... T>
struct pseudo_tuple {
typedef void* ptr_type;
typedef const void* const_ptr_type;
typedef void* pointer;
typedef const void* const_pointer;
ptr_type data[sizeof...(T) > 0 ? sizeof...(T) : 1];
pointer data[sizeof...(T) > 0 ? sizeof...(T) : 1];
inline const_ptr_type at(size_t p) const {
inline const_pointer at(size_t p) const {
return data[p];
}
inline ptr_type mutable_at(size_t p) {
return const_cast<ptr_type>(data[p]);
inline pointer mutable_at(size_t p) {
return const_cast<pointer>(data[p]);
}
inline void*& operator[](size_t p) {
inline pointer& operator[](size_t p) {
return data[p];
}
};
......@@ -67,16 +69,16 @@ struct pseudo_tuple_from_type_list<util::type_list<Ts...> > {
namespace cppa {
template<size_t N, typename... Tn>
const typename util::at<N, Tn...>::type& get(const detail::pseudo_tuple<Tn...>& tv) {
static_assert(N < sizeof...(Tn), "N >= tv.size()");
return *reinterpret_cast<const typename util::at<N, Tn...>::type*>(tv.at(N));
template<size_t N, typename... Ts>
const typename util::at<N, Ts...>::type& get(const detail::pseudo_tuple<Ts...>& tv) {
static_assert(N < sizeof...(Ts), "N >= tv.size()");
return *reinterpret_cast<const typename util::at<N, Ts...>::type*>(tv.at(N));
}
template<size_t N, typename... Tn>
typename util::at<N, Tn...>::type& get_ref(detail::pseudo_tuple<Tn...>& tv) {
static_assert(N < sizeof...(Tn), "N >= tv.size()");
return *reinterpret_cast<typename util::at<N, Tn...>::type*>(tv.mutable_at(N));
template<size_t N, typename... Ts>
typename util::at<N, Ts...>::type& get_ref(detail::pseudo_tuple<Ts...>& tv) {
static_assert(N < sizeof...(Ts), "N >= tv.size()");
return *reinterpret_cast<typename util::at<N, Ts...>::type*>(tv.mutable_at(N));
}
} // namespace cppa
......
......@@ -427,16 +427,16 @@ mk_tdata(Args&&... args) {
return {std::forward<Args>(args)...};
}
template<size_t N, typename... Tn>
const typename util::at<N, Tn...>::type& get(const detail::tdata<Tn...>& tv) {
static_assert(N < sizeof...(Tn), "N >= tv.size()");
return static_cast<const typename detail::tdata_upcast_helper<N, Tn...>::type&>(tv).head;
template<size_t N, typename... Ts>
const typename util::at<N, Ts...>::type& get(const detail::tdata<Ts...>& tv) {
static_assert(N < sizeof...(Ts), "N >= tv.size()");
return static_cast<const typename detail::tdata_upcast_helper<N, Ts...>::type&>(tv).head;
}
template<size_t N, typename... Tn>
typename util::at<N, Tn...>::type& get_ref(detail::tdata<Tn...>& tv) {
static_assert(N < sizeof...(Tn), "N >= tv.size()");
return static_cast<typename detail::tdata_upcast_helper<N, Tn...>::type&>(tv).head;
template<size_t N, typename... Ts>
typename util::at<N, Ts...>::type& get_ref(detail::tdata<Ts...>& tv) {
static_assert(N < sizeof...(Ts), "N >= tv.size()");
return static_cast<typename detail::tdata_upcast_helper<N, Ts...>::type&>(tv).head;
}
} // namespace cppa
......
......@@ -42,19 +42,19 @@
namespace cppa { namespace detail {
template<typename... ElementTypes>
template<typename... Ts>
class tuple_vals : public abstract_tuple {
static_assert(sizeof...(ElementTypes) > 0,
static_assert(sizeof...(Ts) > 0,
"tuple_vals is not allowed to be empty");
typedef abstract_tuple super;
public:
typedef tdata<ElementTypes...> data_type;
typedef tdata<Ts...> data_type;
typedef types_array<ElementTypes...> element_types;
typedef types_array<Ts...> element_types;
tuple_vals(const tuple_vals&) = default;
......@@ -80,7 +80,7 @@ class tuple_vals : public abstract_tuple {
}
size_t size() const {
return sizeof...(ElementTypes);
return sizeof...(Ts);
}
tuple_vals* copy() const {
......@@ -112,26 +112,26 @@ class tuple_vals : public abstract_tuple {
}
const std::type_info* type_token() const {
return detail::static_type_list<ElementTypes...>::list;
return detail::static_type_list<Ts...>::list;
}
private:
data_type m_data;
static types_array<ElementTypes...> m_types;
static types_array<Ts...> m_types;
};
template<typename... ElementTypes>
types_array<ElementTypes...> tuple_vals<ElementTypes...>::m_types;
template<typename... Ts>
types_array<Ts...> tuple_vals<Ts...>::m_types;
template<typename TypeList>
struct tuple_vals_from_type_list;
template<typename... Types>
struct tuple_vals_from_type_list< util::type_list<Types...> > {
typedef tuple_vals<Types...> type;
template<typename... Ts>
struct tuple_vals_from_type_list< util::type_list<Ts...> > {
typedef tuple_vals<Ts...> type;
};
} } // namespace cppa::detail
......
......@@ -48,19 +48,19 @@ struct tuple_view_copy_helper {
}
};
template<typename... ElementTypes>
template<typename... Ts>
class tuple_view : public abstract_tuple {
static_assert(sizeof...(ElementTypes) > 0,
static_assert(sizeof...(Ts) > 0,
"tuple_vals is not allowed to be empty");
typedef abstract_tuple super;
public:
typedef tdata<ElementTypes*...> data_type;
typedef tdata<Ts*...> data_type;
typedef types_array<ElementTypes...> element_types;
typedef types_array<Ts...> element_types;
tuple_view() = delete;
tuple_view(const tuple_view&) = delete;
......@@ -68,7 +68,7 @@ class tuple_view : public abstract_tuple {
/**
* @warning @p tuple_view does @b NOT takes ownership for given pointers
*/
tuple_view(ElementTypes*... args)
tuple_view(Ts*... args)
: super(tuple_impl_info::statically_typed), m_data(args...) {
}
......@@ -81,13 +81,13 @@ class tuple_view : public abstract_tuple {
}
size_t size() const {
return sizeof...(ElementTypes);
return sizeof...(Ts);
}
abstract_tuple* copy() const {
auto result = new tuple_vals<ElementTypes...>;
auto result = new tuple_vals<Ts...>;
tuple_view_copy_helper f{result};
util::static_foreach<0, sizeof...(ElementTypes)>::_(m_data, f);
util::static_foreach<0, sizeof...(Ts)>::_(m_data, f);
return result;
}
......@@ -107,19 +107,19 @@ class tuple_view : public abstract_tuple {
}
const std::type_info* type_token() const {
return detail::static_type_list<ElementTypes...>::list;
return detail::static_type_list<Ts...>::list;
}
private:
data_type m_data;
static types_array<ElementTypes...> m_types;
static types_array<Ts...> m_types;
};
template<typename... ElementTypes>
types_array<ElementTypes...> tuple_view<ElementTypes...>::m_types;
template<typename... Ts>
types_array<Ts...> tuple_view<Ts...>::m_types;
} } // namespace cppa::detail
......
......@@ -161,7 +161,7 @@ struct types_array : types_array_impl<util::tl_forall<util::type_list<T...>,
typedef util::type_list<T...> types;
typedef typename util::tl_filter_not<types, is_anything>::type
filtered_types;
static constexpr size_t filtered_size = filtered_types::size;
static constexpr size_t filtered_size = util::tl_size<filtered_types>::value;
inline bool has_values() const { return false; }
};
......
......@@ -113,16 +113,15 @@ class value_guard {
return true;
}
template<typename Head, typename Arg0, typename... Args>
static inline bool _eval(const Head& head, const tdata<>&,
template<typename T0, typename Arg0, typename... Args>
static inline bool _eval(const T0& head, const tdata<>&,
const Arg0& arg0, const Args&...) {
return cmp(head, arg0);
}
template<typename Head,
typename Tail0, typename... Tail,
template<typename T0, typename T1, typename... Ts,
typename Arg0, typename... Args>
static inline bool _eval(const Head& head, const tdata<Tail0,Tail...>& tail,
static inline bool _eval(const T0& head, const tdata<T1,Ts...>& tail,
const Arg0& arg0, const Args&... args) {
return cmp(head, arg0) && _eval(tail.head, tail.tail(), args...);
}
......
......@@ -34,6 +34,7 @@
// functions are documented in the implementation headers
#ifndef CPPA_DOCUMENTATION
#include <tuple>
#include <cstddef>
#include "cppa/util/at.hpp"
......@@ -54,32 +55,56 @@ template<typename...> struct type_list;
template<typename...> class cow_tuple;
// forward declaration of get(const detail::tdata<...>&)
template<size_t N, typename... Tn>
const typename util::at<N, Tn...>::type& get(const detail::tdata<Tn...>&);
template<size_t N, typename... Ts>
const typename util::at<N, Ts...>::type& get(const detail::tdata<Ts...>&);
// forward declarations of get(const tuple<...>&)
template<size_t N, typename... Tn>
const typename util::at<N, Tn...>::type& get(const cow_tuple<Tn...>&);
template<size_t N, typename... Ts>
const typename util::at<N, Ts...>::type& get(const cow_tuple<Ts...>&);
// forward declarations of get(detail::pseudo_tuple<...>&)
template<size_t N, typename... Tn>
const typename util::at<N, Tn...>::type& get(const detail::pseudo_tuple<Tn...>& tv);
template<size_t N, typename... Ts>
const typename util::at<N, Ts...>::type& get(const detail::pseudo_tuple<Ts...>& tv);
// forward declarations of get(util::type_list<...>&)
template<size_t N, typename... Ts>
typename util::at<N, Ts...>::type get(const util::type_list<Ts...>&);
// forward declarations of get_ref(detail::tdata<...>&)
template<size_t N, typename... Tn>
typename util::at<N, Tn...>::type& get_ref(detail::tdata<Tn...>&);
template<size_t N, typename... Ts>
typename util::at<N, Ts...>::type& get_ref(detail::tdata<Ts...>&);
// forward declarations of get_ref(tuple<...>&)
template<size_t N, typename... Tn>
typename util::at<N, Tn...>::type& get_ref(cow_tuple<Tn...>&);
template<size_t N, typename... Ts>
typename util::at<N, Ts...>::type& get_ref(cow_tuple<Ts...>&);
// forward declarations of get_ref(detail::pseudo_tuple<...>&)
template<size_t N, typename... Tn>
typename util::at<N, Tn...>::type& get_ref(detail::pseudo_tuple<Tn...>& tv);
template<size_t N, typename... Ts>
typename util::at<N, Ts...>::type& get_ref(detail::pseudo_tuple<Ts...>& tv);
// support get_ref access to std::tuple
template<size_t Pos, typename... Ts>
inline auto get_ref(std::tuple<Ts...>& tup) -> decltype(std::get<Pos>(tup)) {
return std::get<Pos>(tup);
}
/**
* @brief This function grants either const or non-const access to @p tup,
* depending on the cv-qualifier of @p tup.
*/
template<size_t Pos, class Tuple>
inline auto get_cv_aware(Tuple& tup) -> decltype(get_ref<Pos>(tup)) {
return get_ref<Pos>(tup);
}
/**
* @brief This function grants either const or non-const access to @p tup,
* depending on the cv-qualifier of @p tup.
*/
template<size_t Pos, class Tuple>
inline auto get_cv_aware(const Tuple& tup) -> decltype(get<Pos>(tup)) {
return get<Pos>(tup);
}
} // namespace cppa
......
......@@ -208,7 +208,7 @@ template<bool EvaluateSubResult> // default = false
struct run_case_impl {
template<class Case, typename T>
static inline bool _(Case& target, std::vector<T>& vec, bool&) {
return unwind_and_call<0, Case::pattern_type::size>::_(target, vec);
return unwind_and_call<0, util::tl_size<typename Case::pattern_type>::value>::_(target, vec);
}
};
......@@ -217,7 +217,7 @@ struct run_case_impl<true> {
template<class Case, typename T>
static inline bool _(Case& target, std::vector<T>& vec, bool& match_returned_false) {
bool sub_result;
if (unwind_and_call<0, Case::pattern_type::size>::_(target, sub_result, vec)) {
if (unwind_and_call<0, util::tl_size<typename Case::pattern_type>::value>::_(target, sub_result, vec)) {
if (sub_result == false) {
match_returned_false = true;
}
......@@ -234,7 +234,7 @@ size_t run_case(std::vector<T>& vec,
InputIterator& pos,
const InputIterator& end,
Case& target) {
static constexpr size_t num_args = Case::pattern_type::size;
static constexpr size_t num_args = util::tl_size<typename Case::pattern_type>::value;
typedef typename Case::second_type partial_fun_type;
typedef typename partial_fun_type::result_type result_type;
typedef typename partial_fun_type::arg_types arg_types;
......@@ -275,7 +275,7 @@ class stream_matcher {
template<typename... Cases>
bool operator()(match_expr<Cases...>& expr) {
while (m_pos != m_end) {
if (!unwind_and_call<0, match_expr<Cases...>::cases_list::size>::_(m_cache, m_pos, m_end, expr)) {
if (!unwind_and_call<0, util::tl_size<typename match_expr<Cases...>::cases_list>::value>::_(m_cache, m_pos, m_end, expr)) {
return false;
}
}
......
......@@ -74,13 +74,13 @@ struct invoke_policy_impl {
>::type
mimpl;
util::fixed_vector<size_t, filtered_pattern::size> mv;
util::fixed_vector<size_t, util::tl_size<filtered_pattern>::value> mv;
if (type_token == typeid(filtered_pattern) || mimpl::_(tup, mv)) {
typedef typename pseudo_tuple_from_type_list<filtered_pattern>::type
ttup_type;
ttup_type ttup;
// if we strip const here ...
for (size_t i = 0; i < filtered_pattern::size; ++i) {
for (size_t i = 0; i < util::tl_size<filtered_pattern>::value; ++i) {
ttup[i] = const_cast<void*>(tup.at(mv[i]));
}
// ... we restore it here again
......@@ -192,10 +192,10 @@ struct invoke_policy_impl<wildcard_position::nil,
}
else if (timpl == detail::dynamically_typed) {
auto& arr = arr_type::arr;
if (tup.size() != filtered_pattern::size) {
if (tup.size() != util::tl_size<filtered_pattern>::value) {
return false;
}
for (size_t i = 0; i < filtered_pattern::size; ++i) {
for (size_t i = 0; i < util::tl_size<filtered_pattern>::value; ++i) {
if (arr[i] != tup.type_at(i)) {
return false;
}
......@@ -262,10 +262,10 @@ struct invoke_policy_impl<wildcard_position::trailing,
}
typedef detail::static_types_array<Ts...> arr_type;
auto& arr = arr_type::arr;
if (tup.size() < filtered_pattern::size) {
if (tup.size() < util::tl_size<filtered_pattern>::value) {
return false;
}
for (size_t i = 0; i < filtered_pattern::size; ++i) {
for (size_t i = 0; i < util::tl_size<filtered_pattern>::value; ++i) {
if (arr[i] != tup.type_at(i)) {
return false;
}
......@@ -310,12 +310,12 @@ struct invoke_policy_impl<wildcard_position::leading,
}
typedef detail::static_types_array<Ts...> arr_type;
auto& arr = arr_type::arr;
if (tup.size() < filtered_pattern::size) {
if (tup.size() < util::tl_size<filtered_pattern>::value) {
return false;
}
size_t i = tup.size() - filtered_pattern::size;
size_t i = tup.size() - util::tl_size<filtered_pattern>::value;
size_t j = 0;
while (j < filtered_pattern::size) {
while (j < util::tl_size<filtered_pattern>::value) {
if (arr[i++] != tup.type_at(j++)) {
return false;
}
......@@ -332,9 +332,9 @@ struct invoke_policy_impl<wildcard_position::leading,
if (!can_invoke(arg_types, tup)) return false;
typedef pseudo_tuple<Ts...> ttup_type;
ttup_type ttup;
size_t i = tup.size() - filtered_pattern::size;
size_t i = tup.size() - util::tl_size<filtered_pattern>::value;
size_t j = 0;
while (j < filtered_pattern::size) {
while (j < util::tl_size<filtered_pattern>::value) {
ttup[j++] = const_cast<void*>(tup.at(i++));
}
// ensure const-correctness
......@@ -381,7 +381,7 @@ struct get_case_ {
typedef typename util::tl_pad_right<
Transformers,
filtered_pattern::size
util::tl_size<filtered_pattern>::value
>::type
padded_transformers;
......@@ -395,7 +395,7 @@ struct get_case_ {
typedef typename util::tl_map_conditional<
typename util::tl_pad_left<
typename ctrait::arg_types,
filtered_pattern::size
util::tl_size<filtered_pattern>::value
>::type,
std::is_lvalue_reference,
false,
......@@ -512,7 +512,7 @@ struct invoke_helper2 {
//static_assert(false, "foo");
Token token;
invoke_helper3<Data> fun{data};
return util::static_foreach<0, Token::size>
return util::static_foreach<0, util::tl_size<Token>::value>
::eval_or(token, fun, std::forward<Args>(args)...);
}
};
......@@ -531,7 +531,7 @@ struct invoke_helper {
// thus, can be invoked from same data
template<class Token, typename... Args>
bool operator()(Token, Args&&... args) {
typedef typename Token::head type_pair;
typedef typename util::tl_head<Token>::type type_pair;
typedef typename type_pair::second leaf_pair;
if (bitfield & 0x01) {
// next invocation step
......@@ -552,7 +552,7 @@ struct can_invoke_helper {
can_invoke_helper(std::uint64_t& mbitfield) : bitfield(mbitfield), i(0) { }
template<class Token, typename... Args>
void operator()(Token, Args&&... args) {
typedef typename Token::head type_pair;
typedef typename util::tl_head<Token>::type type_pair;
typedef typename type_pair::second leaf_pair;
typedef invoke_policy<typename leaf_pair::pattern_type> impl;
if (impl::can_invoke(std::forward<Args>(args)...)) {
......@@ -647,7 +647,7 @@ class match_expr {
eval_order token;
std::uint64_t tmp = 0;
detail::can_invoke_helper fun{tmp};
util::static_foreach<0, eval_order::size>
util::static_foreach<0, util::tl_size<eval_order>::value>
::_(token, fun, type_token, tup);
return tmp != 0;
}
......@@ -691,7 +691,7 @@ class match_expr {
eval_order token;
detail::invoke_helper<decltype(m_cases)> fun{m_cases, enabled_begin};
return util::static_foreach<0, eval_order::size>
return util::static_foreach<0, util::tl_size<eval_order>::value>
::eval_or(token,
fun,
type_token,
......@@ -788,7 +788,7 @@ class match_expr {
m_cache[i].second = 0;
eval_order token;
detail::can_invoke_helper fun{m_cache[i].second};
util::static_foreach<0, eval_order::size>
util::static_foreach<0, util::tl_size<eval_order>::value>
::_(token, fun, *type_token, value);
}
return m_cache[i].second;
......@@ -807,7 +807,7 @@ class match_expr {
auto bitfield = get_cache_entry(type_token, vals);
eval_order token;
detail::invoke_helper<decltype(m_cases)> fun{m_cases, bitfield};
return util::static_foreach<0, eval_order::size>
return util::static_foreach<0, util::tl_size<eval_order>::value>
::eval_or(token,
fun,
*type_token,
......
......@@ -122,8 +122,10 @@ struct disjunct_rvalue_builders {
template<class Guard, class Transformers, class Pattern>
struct rvalue_builder {
typedef typename util::tl_back<Pattern>::type back_type;
static constexpr bool is_complete =
!std::is_same<util::arg_match_t, typename Pattern::back>::value;
!std::is_same<util::arg_match_t,back_type>::value;
typedef typename util::tl_apply<Transformers, tdata>::type fun_container;
......@@ -198,8 +200,8 @@ template<bool IsCallable, typename T>
struct pattern_type_ {
typedef util::get_callable_trait<T> ctrait;
typedef typename ctrait::arg_types args;
static_assert(args::size == 1, "only unary functions allowed");
typedef typename util::rm_ref<typename args::head>::type type;
static_assert(util::tl_size<args>::value == 1, "only unary functions allowed");
typedef typename util::rm_ref<typename util::tl_head<args>::type>::type type;
};
template<typename T>
......
......@@ -83,7 +83,7 @@ class tpartial_function {
}
result_type operator()(Args... args) const {
return util::apply_args<Result, ctrait_args::size, sizeof...(Args)>
return util::apply_args<Result, util::tl_size<ctrait_args>::value, sizeof...(Args)>
::_(m_expr, args...);
}
......@@ -109,7 +109,7 @@ struct get_tpartial_function<Expr, Guard,
typedef typename util::get_callable_trait<Expr>::type ctrait;
typedef typename ctrait::arg_types arg_types;
static_assert(arg_types::size <= sizeof...(Args),
static_assert(util::tl_size<arg_types>::value <= sizeof...(Args),
"Functor takes too much arguments");
typedef typename get_tpartial_function<
......
......@@ -33,16 +33,16 @@
namespace cppa { namespace util {
template<size_t N, typename... Tn>
template<size_t N, typename... Ts>
struct at;
template<size_t N, typename T0, typename... Tn>
struct at<N, T0, Tn...> {
typedef typename at<N-1, Tn...>::type type;
template<size_t N, typename T0, typename... Ts>
struct at<N, T0, Ts...> {
typedef typename at<N-1, Ts...>::type type;
};
template<typename T0, typename... Tn>
struct at<0, T0, Tn...> {
template<typename T0, typename... Ts>
struct at<0, T0, Ts...> {
typedef T0 type;
};
......
......@@ -38,10 +38,10 @@
namespace cppa { namespace detail {
template<size_t N, template<typename...> class Tuple, typename... Types>
const typename util::at<N, Types...>::type&
do_get(const Tuple<Types...>& t) {
return ::cppa::get<N, Types...>(t);
template<size_t N, template<typename...> class Tuple, typename... Ts>
const typename util::at<N, Ts...>::type&
do_get(const Tuple<Ts...>& t) {
return ::cppa::get<N, Ts...>(t);
}
template<size_t N, typename LhsTuple, typename RhsTuple>
......@@ -63,32 +63,32 @@ struct cmp_helper<0, LhsTuple, RhsTuple> {
namespace cppa { namespace util {
template<template<typename...> class LhsTuple, typename... LhsTypes,
template<typename...> class RhsTuple, typename... RhsTypes>
bool compare_tuples(const LhsTuple<LhsTypes...>& lhs,
const RhsTuple<RhsTypes...>& rhs) {
static_assert(sizeof...(LhsTypes) == sizeof...(RhsTypes),
template<template<typename...> class LhsTuple, typename... LhsTs,
template<typename...> class RhsTuple, typename... RhsTs>
bool compare_tuples(const LhsTuple<LhsTs...>& lhs,
const RhsTuple<RhsTs...>& rhs) {
static_assert(sizeof...(LhsTs) == sizeof...(RhsTs),
"could not compare tuples of different size");
static_assert(tl_binary_forall<
type_list<LhsTypes...>,
type_list<RhsTypes...>,
type_list<LhsTs...>,
type_list<RhsTs...>,
is_comparable
>::value,
"types of lhs are not comparable to the types of rhs");
return detail::cmp_helper<(sizeof...(LhsTypes) - 1),
LhsTuple<LhsTypes...>,
RhsTuple<RhsTypes...>>::cmp(lhs, rhs);
return detail::cmp_helper<(sizeof...(LhsTs) - 1),
LhsTuple<LhsTs...>,
RhsTuple<RhsTs...>>::cmp(lhs, rhs);
}
template<template<typename...> class LhsTuple, typename... LhsTypes,
template<typename...> class RhsTuple, typename... RhsTypes>
bool compare_first_elements(const LhsTuple<LhsTypes...>& lhs,
const RhsTuple<RhsTypes...>& rhs) {
template<template<typename...> class LhsTuple, typename... LhsTs,
template<typename...> class RhsTuple, typename... RhsTs>
bool compare_first_elements(const LhsTuple<LhsTs...>& lhs,
const RhsTuple<RhsTs...>& rhs) {
typedef typename tl_zip<
util::type_list<LhsTypes...>,
util::type_list<RhsTypes...>
util::type_list<LhsTs...>,
util::type_list<RhsTs...>
>::type
zipped_types;
......@@ -96,8 +96,8 @@ bool compare_first_elements(const LhsTuple<LhsTypes...>& lhs,
"types of lhs are not comparable to the types of rhs");
return detail::cmp_helper<(zipped_types::size - 1),
LhsTuple<LhsTypes...>,
RhsTuple<RhsTypes...>>::cmp(lhs, rhs);
LhsTuple<LhsTs...>,
RhsTuple<RhsTs...>>::cmp(lhs, rhs);
}
} } // namespace cppa::util
......
......@@ -38,9 +38,9 @@ namespace cppa { namespace util {
template<typename... BooleanConstants>
struct conjunction;
template<typename Head, typename... Tail>
struct conjunction<Head, Tail...>
: std::integral_constant<bool, Head::value && conjunction<Tail...>::value> {
template<typename T0, typename... Ts>
struct conjunction<T0, Ts...>
: std::integral_constant<bool, T0::value && conjunction<Ts...>::value> {
};
template<>
......
......@@ -41,8 +41,8 @@ struct element_at;
/**
* @brief Returns the n-th template parameter of @p C.
*/
template<size_t N, template<typename...> class C, typename... Tn>
struct element_at<N, C<Tn...>> : at<N, Tn...> {
template<size_t N, template<typename...> class C, typename... Ts>
struct element_at<N, C<Ts...>> : at<N, Ts...> {
};
} } // namespace cppa::util
......
This diff is collapsed.
......@@ -59,9 +59,9 @@ template<typename Types>
constexpr wildcard_position get_wildcard_position() {
return util::tl_exists<Types, is_anything>::value
? ((util::tl_count<Types, is_anything>::value == 1)
? (std::is_same<typename Types::head, anything>::value
? (std::is_same<typename util::tl_head<Types>::type, anything>::value
? wildcard_position::leading
: (std::is_same<typename Types::back, anything>::value
: (std::is_same<typename util::tl_back<Types>::type, anything>::value
? wildcard_position::trailing
: wildcard_position::in_between))
: wildcard_position::multiple)
......
......@@ -51,6 +51,7 @@ void event_based_actor::dequeue_response(behavior&, message_id_t) {
}
resume_result event_based_actor::resume(util::fiber*) {
CPPA_REQUIRE(m_state.load() == abstract_scheduled_actor::ready);
scoped_self_setter sss{this};
auto done_cb = [&]() {
m_state.store(abstract_scheduled_actor::done);
......
......@@ -26,16 +26,16 @@ int main() {
CPPA_CHECK((is_same<float, element_at<1, l1>::type>::value));
CPPA_CHECK((is_same<std::string, element_at<2, l1>::type>::value));
CPPA_CHECK(l1::size == 3);
CPPA_CHECK(l1::size == r1::size);
CPPA_CHECK(tl_size<l1>::value == 3);
CPPA_CHECK(tl_size<l1>::value == tl_size<r1>::value);
CPPA_CHECK((is_same<element_at<0, l1>::type, element_at<2, r1>::type>::value));
CPPA_CHECK((is_same<element_at<1, l1>::type, element_at<1, r1>::type>::value));
CPPA_CHECK((is_same<element_at<2, l1>::type, element_at<0, r1>::type>::value));
typedef tl_concat<type_list<int>, l1>::type l2;
CPPA_CHECK((is_same<int, l2::head>::value));
CPPA_CHECK((is_same<l1, l2::tail>::value));
CPPA_CHECK((is_same<int, tl_head<l2>::type>::value));
CPPA_CHECK((is_same<l1, tl_tail<l2>::type>::value));
return CPPA_TEST_RESULT;
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment