typedef FilteredPattern filtered_pattern;

typedef typename pseudo_tuple_from_type_list<filtered_pattern>::type

tuple_type;

typedef invoke_policy_base<FilteredPattern> super;

template<class Tuple>

static bool can_invoke(const std::type_info& type_token,

const Tuple& tup) {

typedef typename match_impl_from_type_list<Tuple,Pattern>::type mimpl;

return type_token == typeid(FilteredPattern) || mimpl::_(tup);

}

template<typename PtrType, class Tuple>

static bool prepare_invoke(typename super::tuple_type& result,

const std::type_info& type_token,

bool,

PtrType*,

Tuple& tup) {

typedef typename match_impl_from_type_list<

typename std::remove_const<Tuple>::type,

Pattern

>::type

mimpl;

util::limited_vector<size_t,util::tl_size<FilteredPattern>::value> mv;

if (type_token == typeid(FilteredPattern) || mimpl::_(tup, mv)) {

for (size_t i = 0; i < util::tl_size<FilteredPattern>::value; ++i) {

result[i] = const_cast<void*>(tup.at(mv[i]));

}

return true;

}

return false;

}

const std::type_info& type_token,

bool,

PtrType*,

Tuple& tup) {

return can_invoke(type_token, tup);

for (size_t i = 0; i < sizeof...(Ts); ++i) {

result[i] = const_cast<void*>(tup.at(i));

}

return true;

const std::type_info&,

bool,

PtrType*,

Tuple& tup,

typename std::enable_if<

std::is_same<

typename std::remove_const<Tuple>::type,

detail::abstract_tuple

>::value == false

>::type* = 0) {

std::integral_constant<bool,

util::tl_binary_forall<

typename util::tl_map<

typename Tuple::types,

util::purge_refs

>::type,

util::type_list<Ts...>,

std::is_same

>::value > token;

return prepare_invoke(token, result, tup);

const std::type_info& arg_types,

bool dynamically_typed,

PtrType* native_arg,

Tuple& tup,

typename std::enable_if<

std::is_same<

typename std::remove_const<Tuple>::type,

detail::abstract_tuple

>::value == true

>::type* = 0) {

if (arg_types == typeid(util::type_list<Ts...>)) {

if (native_arg) {

typedef typename std::conditional<

std::is_const<PtrType>::value,

const native_data_type*,

native_data_type*

>::type

cast_type;

auto arg = reinterpret_cast<cast_type>(native_arg);

for (size_t i = 0; i < sizeof...(Ts); ++i) {

result[i] = const_cast<void*>(arg->at(i));

}

return true;

}

// 'fall through'

}

else if (dynamically_typed) {

auto& arr = arr_type::arr;

if (tup.size() != sizeof...(Ts)) {

return false;

}

for (size_t i = 0; i < sizeof...(Ts); ++i) {

if (arr[i] != tup.type_at(i)) {

return false;

}

}

// 'fall through'

}

else return false;

for (size_t i = 0; i < sizeof...(Ts); ++i) {

result[i] = const_cast<void*>(tup.at(i));

}

return true;

const std::type_info&,

bool,

PtrType*,

Tuple&) {

return true;

const Tuple& tup) {

if (arg_types == typeid(util::type_list<Ts...>)) {

return true;

}

typedef detail::static_types_array<Ts...> arr_type;

auto& arr = arr_type::arr;

if (tup.size() < sizeof...(Ts)) {

return false;

}

for (size_t i = 0; i < sizeof...(Ts); ++i) {

if (arr[i] != tup.type_at(i)) {

return false;

}

}

return true;

const std::type_info& arg_types,

bool,

PtrType*,

Tuple& tup) {

if (!can_invoke(arg_types, tup)) return false;

for (size_t i = 0; i < sizeof...(Ts); ++i) {

result[i] = const_cast<void*>(tup.at(i));

}

return true;

const Tuple& tup) {

if (arg_types == typeid(util::type_list<Ts...>)) {

return true;

}

typedef detail::static_types_array<Ts...> arr_type;

auto& arr = arr_type::arr;

if (tup.size() < sizeof...(Ts)) return false;

size_t i = tup.size() - sizeof...(Ts);

size_t j = 0;

while (j < sizeof...(Ts)) {

if (arr[i++] != tup.type_at(j++)) return false;

}

return true;

const std::type_info& arg_types,

bool,

PtrType*,

Tuple& tup) {

if (!can_invoke(arg_types, tup)) return false;

size_t i = tup.size() - sizeof...(Ts);

size_t j = 0;

while (j < sizeof...(Ts)) {

result[j++] = const_cast<void*>(tup.at(i++));

}

return true;

: invoke_policy_impl<

get_wildcard_position<Pattern>(),

Pattern,

typename util::tl_filter_not_type<Pattern,anything>::type> {

template<typename... Ts>

projection_partial_function_pair(Ts&&... args)

: std::pair<Projection,PartialFun>(std::forward<Ts>(args)...) { }

typedef Pattern pattern_type;

typedef typename util::get_callable_trait<Expr>::type ctrait;

typedef typename util::tl_filter_not_type<

Pattern,

anything

>::type

filtered_pattern;

typedef typename util::tl_pad_right<

Transformers,

util::tl_size<filtered_pattern>::value

>::type

padded_transformers;

typedef typename util::tl_map<

filtered_pattern,

std::add_const,

std::add_lvalue_reference

>::type

base_signature;

typedef typename util::tl_map_conditional<

typename util::tl_pad_left<

typename ctrait::arg_types,

util::tl_size<filtered_pattern>::value

>::type,

std::is_lvalue_reference,

false,

std::add_const,

std::add_lvalue_reference

>::type

padded_expr_args;

// override base signature with required argument types of Expr

// and result types of transformation

typedef typename util::tl_zip<

typename util::tl_map<

padded_transformers,

util::get_result_type,

util::rm_option,

std::add_lvalue_reference

>::type,

typename util::tl_zip<

padded_expr_args,

base_signature,

util::left_or_right

>::type,

util::left_or_right

>::type

partial_fun_signature;

// 'inherit' mutable references from partial_fun_signature

// for arguments without transformation

typedef typename util::tl_zip<

typename util::tl_zip<

padded_transformers,

partial_fun_signature,

util::if_not_left

>::type,

base_signature,

util::deduce_ref_type

>::type

projection_signature;

typedef typename projection_from_type_list<

padded_transformers,

projection_signature

>::type

type1;

typedef typename get_tpartial_function<

Expr,

Guard,

partial_fun_signature

>::type

type2;

typedef projection_partial_function_pair<Pattern,type1,type2> type;

typedef typename Fun::result_type result_type;

static constexpr bool value = std::is_same<bool,result_type>::value;

typedef std::integral_constant<bool,value> token_type;

bool&,

std::uint64_t,

minus1l,

const std::type_info&,

bool,

PtrType*,

Tuple&) {

return false;

bool& invoke_res,

std::uint64_t bitmask,

long_constant<N>,

const std::type_info& type_token,

bool is_dynamic,

PtrType* ptr,

Tuple& tup) {

if (unroll_expr(fs, invoke_res, bitmask, long_constant<N-1>{},

type_token, is_dynamic, ptr, tup)) {

return true;

}

if ((bitmask & (0x01 << N)) == 0) return false;

auto& f = get<N>(fs);

typedef typename util::rm_ref<decltype(f)>::type Fun;

typedef typename Fun::pattern_type pattern_type;

typedef detail::invoke_policy<pattern_type> policy;

typename policy::tuple_type targs;

if (policy::prepare_invoke(targs, type_token, is_dynamic, ptr, tup)) {

auto is = util::get_indices(targs);

util::void_type dummy;

typename has_bool_result<typename Fun::second_type>::token_type stoken;

return util::apply_args_prefixed(f.first,

deduce_const(tup, targs),

is,

f.second,

select_if(stoken, invoke_res, dummy));

}

return false;

if (can_unroll_expr(fs, long_constant<N-1l>(), arg_types, tup)) {

return true;

}

auto& f = get<N>(fs);

typedef typename util::rm_ref<decltype(f)>::type Fun;

typedef typename Fun::pattern_type pattern_type;

typedef detail::invoke_policy<pattern_type> policy;

return policy::can_invoke(arg_types, tup);

auto& f = get<N>(fs);

typedef typename util::rm_ref<decltype(f)>::type Fun;

typedef typename Fun::pattern_type pattern_type;

typedef detail::invoke_policy<pattern_type> policy;

std::uint64_t result = policy::can_invoke(tinf, tup) ? (0x01 << N) : 0x00;

return result | calc_bitmask(fs, long_constant<N-1l>(), tinf, tup);

typedef typename mexpr_fwd_<

IsManipulator,

T,

typename detail::implicit_conversions<

typename util::rm_ref<T>::type

>::type

>::type

type;

any_tuple cpy{tup};

cpy.force_detach();

return std::move(cpy);

static_assert(sizeof...(Cs) < 64, "too many functions");

public:

static constexpr bool may_have_timeout = false;

typedef util::type_list<Cs...> cases_list;

static constexpr bool has_manipulator = util::tl_exists<cases_list,is_manipulator_case>::value;

typedef detail::long_constant<sizeof...(Cs)-1l> idx_token_type;

static constexpr idx_token_type idx_token = idx_token_type{};

template<typename... Ts>

match_expr(Ts&&... args) : m_cases(std::forward<Ts>(args)...) {

init();

}

match_expr(match_expr&& other) : m_cases(std::move(other.m_cases)) {

init();

}

match_expr(const match_expr& other) : m_cases(other.m_cases) {

init();

}

inline bool invoke(const any_tuple& tup) {

return invoke_impl(tup);

}

inline bool invoke(any_tuple& tup) {

return invoke_impl(tup);

}

inline bool invoke(any_tuple&& tup) {

any_tuple tmp{tup};

return invoke_impl(tmp);

}

bool can_invoke(const any_tuple& tup) {

auto type_token = tup.type_token();

if (not tup.dynamically_typed()) {

auto bitmask = get_cache_entry(type_token, tup);

return bitmask != 0;

}

return can_unroll_expr(m_cases,

idx_token,

*type_token,

tup);

}

inline bool operator()(const any_tuple& tup) {

return invoke_impl(tup);

}

inline bool operator()(any_tuple& tup) {

return invoke_impl(tup);

}

inline bool operator()(any_tuple&& tup) {

any_tuple tmp{tup};

return invoke_impl(tmp);

}

template<typename... Ts>

bool operator()(Ts&&... args) {

// wraps and applies implicit conversions to args

typedef detail::tdata<

typename detail::mexpr_fwd<

has_manipulator,

Ts

>::type...

>

tuple_type;

tuple_type tup{std::forward<Ts>(args)...};

auto& type_token = typeid(typename tuple_type::types);

auto bitmask = get_cache_entry(&type_token, tup);

// ref_type keeps track of whether this match_expr is a mutator

typedef typename std::conditional<

has_manipulator,

tuple_type&,

const tuple_type&

>::type

ref_type;

// same here

typedef typename std::conditional<

has_manipulator,

void*,

const void*

>::type

ptr_type;

// iterate over cases and return if any case was invoked

bool invoke_result = true;

bool unroll_result = unroll_expr(m_cases,

invoke_result,

bitmask,

idx_token,

type_token,

false, // not dynamically_typed

static_cast<ptr_type>(nullptr),

static_cast<ref_type>(tup));

return unroll_result && invoke_result;

}

template<class... Ds>

match_expr<Cs...,Ds...> or_else(const match_expr<Ds...>& other) const {

detail::tdata<util::rebindable_reference<const Cs>...,

util::rebindable_reference<const Ds>... > all_cases;

rebind_tdata(all_cases, m_cases, other.cases());

return {all_cases};

}

inline const detail::tdata<Cs...>& cases() const {

return m_cases;

}

struct pfun_impl : detail::behavior_impl {

match_expr pfun;

template<typename Arg>

pfun_impl(const Arg& from) : pfun(from) { }

bool invoke(any_tuple& tup) {

return pfun.invoke(tup);

}

bool invoke(const any_tuple& tup) {

return pfun.invoke(tup);

}

bool defined_at(const any_tuple& tup) {

return pfun.can_invoke(tup);

}

typedef typename detail::behavior_impl::pointer pointer;

pointer copy(const generic_timeout_definition& tdef) const {

return new_default_behavior_impl(pfun, tdef.timeout, tdef.handler);

}

};

intrusive_ptr<detail::behavior_impl> as_behavior_impl() const {

return new pfun_impl(*this);

}

private:

// structure: tdata< tdata<type_list<...>, ...>,

// tdata<type_list<...>, ...>,

// ...>

detail::tdata<Cs...> m_cases;

static constexpr size_t cache_size = 10;

typedef std::pair<const std::type_info*,std::uint64_t> cache_element;

util::limited_vector<cache_element,cache_size> m_cache;

// ring buffer like access to m_cache

size_t m_cache_begin;

size_t m_cache_end;

cache_element m_dummy;

static inline void advance_(size_t& i) {

i = (i + 1) % cache_size;

}

inline size_t find_token_pos(const std::type_info* type_token) {

for (size_t i = m_cache_begin ; i != m_cache_end; advance_(i)) {

if (m_cache[i].first == type_token) return i;

}

return m_cache_end;

}

template<class Tuple>

std::uint64_t get_cache_entry(const std::type_info* type_token,

const Tuple& value) {

CPPA_REQUIRE(type_token != nullptr);

if (value.dynamically_typed()) {

return m_dummy.second; // all groups enabled

}

size_t i = find_token_pos(type_token);

// if we didn't found a cache entry ...

if (i == m_cache_end) {

// ... 'create' one (override oldest element in cache if full)

advance_(m_cache_end);

if (m_cache_end == m_cache_begin) advance_(m_cache_begin);

m_cache[i].first = type_token;

m_cache[i].second = calc_bitmask(m_cases,

idx_token,

*type_token,

value);

}

return m_cache[i].second;

}

void init() {

m_dummy.second = std::numeric_limits<std::uint64_t>::max();

m_cache.resize(cache_size);

for (auto& entry : m_cache) { entry.first = nullptr; }

m_cache_begin = m_cache_end = 0;

}

template<class Tuple>

bool invoke_impl(Tuple& tup) {

std::integral_constant<bool,has_manipulator> mutator_token;

// returns either a reference or a new object

typedef decltype(detail::detach_if_needed(tup, mutator_token)) detached;

detached tref = detail::detach_if_needed(tup, mutator_token);

auto& vals = tref.vals();

auto ndp = fetch_native_data(vals, mutator_token);

auto token_ptr = vals->type_token();

auto bitmask = get_cache_entry(token_ptr, *vals);

auto dynamically_typed = vals->dynamically_typed();

bool invoke_result = true; // may be set to false by an invoked functor

bool unroll_result = unroll_expr(m_cases,

invoke_result,

bitmask,

idx_token,

*token_ptr,

dynamically_typed,

ndp,

*vals);

return invoke_result && unroll_result;

}

typename detail::tdata_from_type_list<

typename util::tl_map<

typename util::tl_concat<

typename T::cases_list,

typename Ts::cases_list...

>::type,

gref_wrapped

>::type

>::type

all_cases;

detail::rebind_tdata(all_cases, arg.cases(), args.cases()...);

return {all_cases};

std::integral_constant<bool,util::disjunction<T::may_have_timeout,Ts::may_have_timeout...>::value> token;

// use static call dispatch to select correct function

return concat_expr(token, arg, args...);