Commit b5df6ac7 authored by neverlord's avatar neverlord

bugfix

parent d305b645
......@@ -178,10 +178,10 @@ template<typename... X>
void tdata_set(tdata<X...>&, tdata<> const&) { }
template<typename... X, typename... Y>
void tdata_set(tdata<X...>& rhs, tdata<Y...> const& lhs)
void tdata_set(tdata<X...>& lhs, tdata<Y...> const& rhs)
{
rhs.head = lhs.head;
tdata_set(rhs.tail(), lhs.tail());
lhs.head = rhs.head;
tdata_set(lhs.tail(), rhs.tail());
}
template<size_t N, typename... Tn>
......
......@@ -107,21 +107,21 @@ class invoke_rule_builder
typedef typename pattern_type::tuple_view_type tuple_view_type;
template<typename F>
invoke_rules cr_rules(F&& f, std::integral_constant<bool,true>)
invoke_rules cr_rules(F&& f, std::integral_constant<bool, true>)
{
typedef invokable_impl<tuple_view_type, pattern_type, F> impl;
return invokable_ptr(new impl(std::move(m_ptr),std::forward<F>(f)));
}
template<typename F>
invoke_rules cr_rules(F&& f, std::integral_constant<bool,false>)
invoke_rules cr_rules(F&& f, std::integral_constant<bool, false>)
{
using namespace ::cppa::util;
typedef typename get_callable_trait<F>::type ctrait;
typedef typename ctrait::arg_types raw_types;
static_assert(raw_types::size > 0, "functor has no arguments");
typedef typename tl_apply<raw_types,rm_ref>::type new_types;
typedef typename concat_type_lists<converted_types,new_types>::type types;
typedef typename tl_concat<converted_types,new_types>::type types;
typedef typename pattern_from_type_list<types>::type epattern;
typedef typename epattern::tuple_view_type tuple_view_type;
typedef invokable_impl<tuple_view_type, epattern, F> impl;
......
......@@ -48,8 +48,6 @@
namespace cppa {
struct dont_initialize_pattern { };
template<typename... Types>
class pattern
{
......@@ -61,8 +59,6 @@ class pattern
public:
pattern(dont_initialize_pattern const&) { }
static constexpr size_t size = sizeof...(Types);
typedef util::type_list<Types...> types;
......@@ -155,19 +151,26 @@ template<typename... Types>
detail::types_array<Types...> pattern<Types...>::m_utis;
template<class ExtendedType, class BasicType>
ExtendedType* extend_pattern(BasicType* p)
ExtendedType* extend_pattern(BasicType const* p)
{
ExtendedType* et = new ExtendedType(dont_initialize_pattern());
et->m_data = p->m_data;
ExtendedType* et = new ExtendedType;
detail::tdata_set(et->m_data, p->m_data);
//et->m_data = p->m_data;
for (size_t i = 0; i < BasicType::size; ++i)
{
et->m_data_ptr[i] = (p->m_data_ptr[i]) ? et->m_data.at(i)
: nullptr;
if (p->m_data_ptr[i] != nullptr)
{
}
//et->m_data_ptr[i] = (p->m_data_ptr[i]) ? et->m_data.at(i)
// : nullptr;
}
for (size_t i = BasicType::size; i < ExtendedType::size; ++i)
/*
for (size_t j = BasicType::size; j < ExtendedType::size; ++j)
{
et->m_data_ptr[i] = nullptr;
et->m_data_ptr[j] = nullptr;
}
*/
return et;
}
......
......@@ -37,28 +37,6 @@ typedef std::pair<int,int> foobar;
static detail::types_array<int,anything,float> arr1;
static detail::types_array<int,anything,foobar> arr2;
/*
template<typename... P>
auto tuple_cast(any_tuple const& tup, pattern<P...> const& p) -> util::option<typename tuple_from_type_list<typename pattern<P...>::filtered_types>::type>
{
typedef typename pattern<P...>::filtered_types filtered_types;
typedef typename tuple_from_type_list<filtered_types>::type tuple_type;
util::option<tuple_type> result;
typename pattern<P...>::mapping_vector mv;
if (p(tup, &mv))
{
if (mv.size() == tup.size()) // perfect match
{
result = tuple_type::from(tup.vals());
}
else
{
result = tuple_type::from(new detail::decorated_tuple<filtered_types::size>(tup.vals(), mv));
}
}
return std::move(result);
}*/
struct match_helper
{
any_tuple const& what;
......
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