Commit dc768236 authored by Dominik Charousset's avatar Dominik Charousset

Coding style nitpicks

parent a82a0356
...@@ -35,21 +35,16 @@ ...@@ -35,21 +35,16 @@
namespace caf { namespace caf {
namespace detail { namespace detail {
class lifted_fun_zipper { struct lifted_fun_zipper {
public:
template <class F, typename T> template <class F, typename T>
auto operator()(const F& fun, T& arg) -> decltype(fun(arg)) const { auto operator()(const F& fun, T& arg) -> decltype(fun(arg)) const {
return fun(arg); return fun(arg);
} }
// forward everything as reference if no guard/transformation is set // forward everything as reference if no guard/transformation is set
template <class T> template <class T>
auto operator()(const unit_t&, T& arg) const -> decltype(std::ref(arg)) { auto operator()(const unit_t&, T& arg) const -> decltype(std::ref(arg)) {
return std::ref(arg); return std::ref(arg);
} }
}; };
template <class T> template <class T>
...@@ -67,62 +62,64 @@ inline bool has_none() { ...@@ -67,62 +62,64 @@ inline bool has_none() {
} }
template <class T, class... Ts> template <class T, class... Ts>
inline bool has_none(const T&, const Ts&... vs) { bool has_none(const T&, const Ts&... vs) {
return has_none(vs...); return has_none(vs...);
} }
template <class T, class... Ts> template <class T, class... Ts>
inline bool has_none(const optional<T>& v, const Ts&... vs) { bool has_none(const optional<T>& v, const Ts&... vs) {
return !v || has_none(vs...); return !v || has_none(vs...);
} }
// allows F to have fewer arguments than the lifted_fun calling it // allows F to have fewer arguments than the lifted_fun calling it
template <class R, typename F> template <class R, typename F>
class lifted_fun_invoker { class lifted_fun_invoker {
public:
using arg_types = typename get_callable_trait<F>::arg_types; using arg_types = typename get_callable_trait<F>::arg_types;
static constexpr size_t num_args = tl_size<arg_types>::value; static constexpr size_t num_args = tl_size<arg_types>::value;
public: lifted_fun_invoker(F& fun) : f(fun) {
// nop
lifted_fun_invoker(F& fun) : f(fun) {} }
template <class... Ts> template <class... Ts>
typename std::enable_if<sizeof...(Ts) == num_args, R>::type typename std::enable_if<sizeof...(Ts) == num_args, R>::type
operator()(Ts&... vs) const { operator()(Ts&... vs) const {
if (has_none(vs...)) return none; if (has_none(vs...)) {
return none;
}
return f(unopt(vs)...); return f(unopt(vs)...);
} }
template <class T, class... Ts> template <class T, class... Ts>
typename std::enable_if<(sizeof...(Ts) + 1 > num_args), R>::type typename std::enable_if<(sizeof...(Ts) + 1 > num_args), R>::type
operator()(T& v, Ts&... vs) const { operator()(T& v, Ts&... vs) const {
if (has_none(v)) return none; if (has_none(v)) {
return none;
}
return (*this)(vs...); return (*this)(vs...);
} }
private: private:
F& f; F& f;
}; };
template <class F> template <class F>
class lifted_fun_invoker<bool, F> { class lifted_fun_invoker<bool, F> {
public:
using arg_types = typename get_callable_trait<F>::arg_types; using arg_types = typename get_callable_trait<F>::arg_types;
static constexpr size_t num_args = tl_size<arg_types>::value; static constexpr size_t num_args = tl_size<arg_types>::value;
public: lifted_fun_invoker(F& fun) : f(fun) {
// nop
lifted_fun_invoker(F& fun) : f(fun) {} }
template <class... Ts> template <class... Ts>
typename std::enable_if<sizeof...(Ts) == num_args, bool>::type typename std::enable_if<sizeof...(Ts) == num_args, bool>::type
operator()(Ts&&... vs) const { operator()(Ts&&... vs) const {
if (has_none(vs...)) return false; if (has_none(vs...)) {
return false;
}
f(unopt(vs)...); f(unopt(vs)...);
return true; return true;
} }
...@@ -130,14 +127,14 @@ class lifted_fun_invoker<bool, F> { ...@@ -130,14 +127,14 @@ class lifted_fun_invoker<bool, F> {
template <class T, class... Ts> template <class T, class... Ts>
typename std::enable_if<(sizeof...(Ts) + 1 > num_args), bool>::type typename std::enable_if<(sizeof...(Ts) + 1 > num_args), bool>::type
operator()(T&& arg, Ts&&... vs) const { operator()(T&& arg, Ts&&... vs) const {
if (has_none(arg)) return false; if (has_none(arg)) {
return false;
}
return (*this)(vs...); return (*this)(vs...);
} }
private: private:
F& f; F& f;
}; };
/** /**
...@@ -181,7 +178,9 @@ class lifted_fun { ...@@ -181,7 +178,9 @@ class lifted_fun {
lifted_fun& operator=(const lifted_fun&) = default; lifted_fun& operator=(const lifted_fun&) = default;
lifted_fun(F f) : m_fun(std::move(f)) {} lifted_fun(F f) : m_fun(std::move(f)) {
// nop
}
lifted_fun(F f, projections ps) : m_fun(std::move(f)), m_ps(std::move(ps)) { lifted_fun(F f, projections ps) : m_fun(std::move(f)), m_ps(std::move(ps)) {
// nop // nop
......
...@@ -160,7 +160,7 @@ class invoke_policy { ...@@ -160,7 +160,7 @@ class invoke_policy {
if (ref_opt) { if (ref_opt) {
auto fhdl = fetch_response_promise(self, hdl); auto fhdl = fetch_response_promise(self, hdl);
behavior inner = *ref_opt; behavior inner = *ref_opt;
*ref_opt = behavior { ref_opt->assign(
others() >> [=] { others() >> [=] {
// inner is const inside this lambda and mutable a C++14 feature // inner is const inside this lambda and mutable a C++14 feature
behavior cpy = inner; behavior cpy = inner;
...@@ -169,7 +169,7 @@ class invoke_policy { ...@@ -169,7 +169,7 @@ class invoke_policy {
fhdl.deliver(*inner_res); fhdl.deliver(*inner_res);
} }
} }
}; );
} }
} else { } else {
// respond by using the result of 'fun' // respond by using the result of 'fun'
......
...@@ -24,9 +24,10 @@ ...@@ -24,9 +24,10 @@
#include "caf/detail/type_traits.hpp" #include "caf/detail/type_traits.hpp"
#include "caf/detail/variant_data.hpp" #include "caf/detail/variant_data.hpp"
#define CAF_VARIANT_CASE(x) \ #define CAF_VARIANT_CASE(x) \
case x: return visitor(from.get(std::integral_constant<int, \ case x: \
x < max_type_id ? x : max_type_id >())) return visitor(from.get( \
std::integral_constant<int, (x < max_type_id ? x : max_type_id)>()))
namespace caf { namespace caf {
...@@ -36,7 +37,7 @@ struct variant_assign_helper { ...@@ -36,7 +37,7 @@ struct variant_assign_helper {
T& lhs; T& lhs;
variant_assign_helper(T& lhs_ref) : lhs(lhs_ref) { } variant_assign_helper(T& lhs_ref) : lhs(lhs_ref) { }
template <class U> template <class U>
inline void operator()(const U& rhs) const { void operator()(const U& rhs) const {
lhs = rhs; lhs = rhs;
} }
}; };
...@@ -47,17 +48,18 @@ struct variant_move_helper { ...@@ -47,17 +48,18 @@ struct variant_move_helper {
T& lhs; T& lhs;
variant_move_helper(T& lhs_ref) : lhs(lhs_ref) { } variant_move_helper(T& lhs_ref) : lhs(lhs_ref) { }
template <class U> template <class U>
inline void operator()(U& rhs) const { void operator()(U& rhs) const {
lhs = std::move(rhs); lhs = std::move(rhs);
} }
}; };
template <class T, typename U, template <class T, class U,
bool Enable = std::is_integral<T>::value && std::is_integral<U>::value> bool Enable = std::is_integral<T>::value
&& std::is_integral<U>::value>
struct is_equal_int_type { struct is_equal_int_type {
static constexpr bool value = static constexpr bool value = sizeof(T) == sizeof(U)
sizeof(T) == sizeof(U) && std::is_signed<T>::value
&& std::is_signed<T>::value == std::is_signed<U>::value; == std::is_signed<U>::value;
}; };
template <class T, typename U> template <class T, typename U>
...@@ -70,26 +72,25 @@ struct is_equal_int_type<T, U, false> : std::false_type { }; ...@@ -70,26 +72,25 @@ struct is_equal_int_type<T, U, false> : std::false_type { };
* `uint8_t != unsigned char on some compilers. * `uint8_t != unsigned char on some compilers.
*/ */
template <class T, typename U> template <class T, typename U>
struct is_same_ish : std::conditional< struct is_same_ish
std::is_same<T, U>::value, : std::conditional<
std::true_type, std::is_same<T, U>::value,
is_equal_int_type<T, U> std::true_type,
>::type { }; is_equal_int_type<T, U>
>::type { };
/** /**
* A variant represents always a valid value of one of the types `Ts...`. * A variant represents always a valid value of one of the types `Ts...`.
*/ */
template <class... Ts> template <class... Ts>
class variant { class variant {
public: public:
using types = detail::type_list<Ts...>; using types = detail::type_list<Ts...>;
static constexpr int max_type_id = sizeof...(Ts) - 1; static constexpr int max_type_id = sizeof...(Ts) - 1;
static_assert(!detail::tl_exists<types, std::is_reference>::value, static_assert(!detail::tl_exists<types, std::is_reference>::value,
"Cannot create a variant of references"); "Cannot create a variant of references");
variant& operator=(const variant& other) { variant& operator=(const variant& other) {
variant_assign_helper<variant> helper{*this}; variant_assign_helper<variant> helper{*this};
...@@ -134,20 +135,19 @@ class variant { ...@@ -134,20 +135,19 @@ class variant {
} }
/** @cond PRIVATE */ /** @cond PRIVATE */
template <int Pos> template <int Pos>
inline bool is(std::integral_constant<int, Pos>) const { bool is(std::integral_constant<int, Pos>) const {
return m_type == Pos; return m_type == Pos;
} }
template <int Pos> template <int Pos>
inline const typename detail::tl_at<types, Pos>::type& const typename detail::tl_at<types, Pos>::type&
get(std::integral_constant<int, Pos> token) const { get(std::integral_constant<int, Pos> token) const {
return m_data.get(token); return m_data.get(token);
} }
template <int Pos> template <int Pos>
inline typename detail::tl_at<types, Pos>::type& typename detail::tl_at<types, Pos>::type&
get(std::integral_constant<int, Pos> token) { get(std::integral_constant<int, Pos> token) {
return m_data.get(token); return m_data.get(token);
} }
...@@ -161,11 +161,9 @@ class variant { ...@@ -161,11 +161,9 @@ class variant {
typename Visitor::result_type apply(Visitor& visitor) { typename Visitor::result_type apply(Visitor& visitor) {
return apply_impl(*this, visitor); return apply_impl(*this, visitor);
} }
/** @endcond */ /** @endcond */
private: private:
template <class Self, typename Visitor> template <class Self, typename Visitor>
static typename Visitor::result_type apply_impl(Self& from, Visitor& visitor) { static typename Visitor::result_type apply_impl(Self& from, Visitor& visitor) {
switch (from.m_type) { switch (from.m_type) {
...@@ -222,30 +220,29 @@ class variant { ...@@ -222,30 +220,29 @@ class variant {
} }
template <class... Us> template <class... Us>
inline void set(const variant<Us...>& other) { void set(const variant<Us...>& other) {
using namespace detail; using namespace detail;
static_assert(tl_is_strict_subset<type_list<Us...>, types>::value, static_assert(tl_is_strict_subset<type_list<Us...>, types>::value,
"cannot set variant of type A to variant of type B " "cannot set variant of type A to variant of type B "
"unless the element types of A are a strict subset of " "unless the element types of A are a strict subset of "
"the element types of B"); "the element types of B");
variant_assign_helper<variant> helper{*this}; variant_assign_helper<variant> helper{*this};
other.apply(helper); other.apply(helper);
} }
template <class... Us> template <class... Us>
inline void set(variant<Us...>&& other) { void set(variant<Us...>&& other) {
using namespace detail; using namespace detail;
static_assert(tl_is_strict_subset<type_list<Us...>, types>::value, static_assert(tl_is_strict_subset<type_list<Us...>, types>::value,
"cannot set variant of type A to variant of type B " "cannot set variant of type A to variant of type B "
"unless the element types of A are a strict subset of " "unless the element types of A are a strict subset of "
"the element types of B"); "the element types of B");
variant_move_helper<variant> helper{*this}; variant_move_helper<variant> helper{*this};
other.apply(helper); other.apply(helper);
} }
int m_type; int m_type;
detail::variant_data<typename lift_void<Ts>::type...> m_data; detail::variant_data<typename lift_void<Ts>::type...> m_data;
}; };
/** /**
...@@ -254,9 +251,10 @@ class variant { ...@@ -254,9 +251,10 @@ class variant {
template <class T, class... Us> template <class T, class... Us>
T& get(variant<Us...>& value) { T& get(variant<Us...>& value) {
using namespace detail; using namespace detail;
constexpr int type_id = tl_find_if<type_list<Us...>, constexpr int type_id = tl_find_if<
tbind<is_same_ish, T>::template type type_list<Us...>,
>::value; tbind<is_same_ish, T>::template type
>::value;
std::integral_constant<int, type_id> token; std::integral_constant<int, type_id> token;
// silence compiler error about "binding to unrelated types" such as // silence compiler error about "binding to unrelated types" such as
// 'signed char' to 'char' (which is obvious bullshit) // 'signed char' to 'char' (which is obvious bullshit)
...@@ -278,11 +276,14 @@ const T& get(const variant<Us...>& value) { ...@@ -278,11 +276,14 @@ const T& get(const variant<Us...>& value) {
template <class T, class... Us> template <class T, class... Us>
T* get(variant<Us...>* value) { T* get(variant<Us...>* value) {
using namespace detail; using namespace detail;
constexpr int type_id = tl_find_if<type_list<Us...>, constexpr int type_id = tl_find_if<
tbind<is_same_ish, T>::template type type_list<Us...>,
>::value; tbind<is_same_ish, T>::template type
>::value;
std::integral_constant<int, type_id> token; std::integral_constant<int, type_id> token;
if (value->is(token)) return &get<T>(*value); if (value->is(token)) {
return &get<T>(*value);
}
return nullptr; return nullptr;
} }
......
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