Commit aa09f262 authored by Dominik Charousset's avatar Dominik Charousset

maintenance

parent 3af4eb8f
......@@ -141,10 +141,13 @@ class any_tuple
inline const_iterator end() const { return m_vals->end(); }
std::type_info const& impl_type() const;
cow_ptr<detail::abstract_tuple> const& vals() const;
inline std::type_info const* values_type_list() const
{
return m_vals->values_type_list();
}
};
inline bool operator==(any_tuple const& lhs, any_tuple const& rhs)
......
......@@ -31,6 +31,8 @@
#ifndef LIBCPPA_ANYTHING_HPP
#define LIBCPPA_ANYTHING_HPP
#include <type_traits>
namespace cppa {
/**
......@@ -48,6 +50,13 @@ inline bool operator!=(anything const&, anything const&)
return false;
}
template<typename T>
struct is_anything
{
static constexpr bool value = std::is_same<T, anything>::value;
};
} // namespace cppa
#endif // ANYTHING_HPP
......@@ -56,8 +56,8 @@ struct abstract_tuple : ref_counted
virtual abstract_tuple* copy() const = 0;
virtual void const* at(size_t pos) const = 0;
virtual uniform_type_info const* type_at(size_t pos) const = 0;
// type of the implementation class
virtual std::type_info const& impl_type() const = 0;
// type_list of values or nullptr
virtual std::type_info const* values_type_list() const = 0;
bool equals(abstract_tuple const& other) const;
......
......@@ -102,19 +102,9 @@ class decorated_tuple : public abstract_tuple
return m_decorated->type_at(m_mapping[pos]);
}
virtual std::type_info const& impl_type() const
std::type_info const* values_type_list() const
{
return typeid(decorated_tuple);
}
cow_pointer_type& decorated()
{
return m_decorated;
}
cow_pointer_type const& decorated() const
{
return m_decorated;
return detail::static_type_list<ElementTypes...>::list;
}
private:
......
......@@ -47,6 +47,7 @@ struct empty_tuple : abstract_tuple
bool equals(abstract_tuple const& other) const;
uniform_type_info const* type_at(size_t) const;
std::type_info const& impl_type() const;
std::type_info const* values_type_list() const;
};
......
......@@ -68,7 +68,7 @@ class object_array : public abstract_tuple
uniform_type_info const* type_at(size_t pos) const;
std::type_info const& impl_type() const;
std::type_info const* values_type_list() const;
};
......
......@@ -52,13 +52,11 @@ enum class tuple_cast_impl_id
};
// covers wildcard_in_between and multiple_wildcards
template<pattern_characteristic, class Result, typename... T>
template<wildcard_position, class Result, typename... T>
struct tuple_cast_impl
{
static constexpr size_t size =
util::tl_count_not<
util::type_list<T...>,
util::tbind<std::is_same, anything>::type>::value;
util::tl_count_not<util::type_list<T...>, is_anything>::value;
typedef util::fixed_vector<size_t, size> mapping_vector;
template<class Tuple>
inline static option<Result> _(Tuple const& tup)
......@@ -77,7 +75,7 @@ struct tuple_cast_impl
};
template<class Result, typename... T>
struct tuple_cast_impl<pattern_characteristic::no_wildcard, Result, T...>
struct tuple_cast_impl<wildcard_position::nil, Result, T...>
{
template<class Tuple>
static inline option<Result> _(Tuple const& tup)
......@@ -94,13 +92,13 @@ struct tuple_cast_impl<pattern_characteristic::no_wildcard, Result, T...>
};
template<class Result, typename... T>
struct tuple_cast_impl<pattern_characteristic::trailing_wildcard, Result, T...>
: tuple_cast_impl<pattern_characteristic::no_wildcard, Result, T...>
struct tuple_cast_impl<wildcard_position::trailing, Result, T...>
: tuple_cast_impl<wildcard_position::nil, Result, T...>
{
};
template<class Result, typename... T>
struct tuple_cast_impl<pattern_characteristic::leading_wildcard, Result, T...>
struct tuple_cast_impl<wildcard_position::leading, Result, T...>
{
template<class Tuple>
inline static option<Result> _(Tuple const& tup)
......
......@@ -112,9 +112,9 @@ class tuple_vals : public abstract_tuple
return abstract_tuple::equals(other);
}
std::type_info const& impl_type() const
std::type_info const* values_type_list() const
{
return typeid(tuple_vals);
return detail::static_type_list<ElementTypes...>::list;
}
};
......
......@@ -5,7 +5,6 @@
#include "cppa/type_value_pair.hpp"
#include "cppa/util/tbind.hpp"
#include "cppa/util/type_list.hpp"
#include "cppa/util/is_builtin.hpp"
......@@ -159,12 +158,13 @@ struct types_array : types_array_impl<util::tl_forall<util::type_list<T...>,
{
static constexpr size_t size = sizeof...(T);
typedef util::type_list<T...> types;
typedef typename util::tl_filter_not<types, util::tbind<std::is_same, anything>::type>::type
typedef typename util::tl_filter_not<types, is_anything>::type
filtered_types;
static constexpr size_t filtered_size = filtered_types::size;
inline bool has_values() const { return false; }
};
// utility for singleton-like access to a types_array
template<typename... T>
struct static_types_array
{
......@@ -183,6 +183,16 @@ struct static_types_array_from_type_list<util::type_list<T...>>
typedef static_types_array<T...> type;
};
// utility for singleton-like access to a type_info instance of a type_list
template<typename... T>
struct static_type_list
{
static std::type_info const* list;
};
template<typename... T>
std::type_info const* static_type_list<T...>::list = &typeid(util::type_list<T...>);
} } // namespace cppa::detail
#endif // TYPES_ARRAY_HPP
......@@ -52,7 +52,7 @@ class any_tuple;
class invoke_rules;
class timed_invoke_rules;
typedef std::list<detail::invokable_ptr> invokable_list;
typedef std::vector<detail::invokable_ptr> invokable_list;
/**
* @brief Base of {@link timed_invoke_rules} and {@link invoke_rules}.
......
......@@ -36,7 +36,6 @@
#include "cppa/pattern.hpp"
#include "cppa/anything.hpp"
#include "cppa/any_tuple.hpp"
#include "cppa/util/tbind.hpp"
#include "cppa/util/type_list.hpp"
#include "cppa/detail/tuple_vals.hpp"
......@@ -46,34 +45,27 @@
namespace cppa {
enum class pattern_characteristic
{
no_wildcard,
trailing_wildcard,
leading_wildcard,
wildcard_in_between,
multiple_wildcards
};
namespace detail {
template<typename Types>
constexpr pattern_characteristic get_pattern_characteristic()
{
return util::tl_exists<Types, util::tbind<std::is_same, anything>::type>::value
? ((util::tl_count<Types, util::tbind<std::is_same, anything>::type>::value == 1)
? (std::is_same<typename Types::head, anything>::value
? pattern_characteristic::leading_wildcard
: (std::is_same<typename Types::back, anything>::value
? pattern_characteristic::trailing_wildcard
: pattern_characteristic::wildcard_in_between))
: pattern_characteristic::multiple_wildcards)
: pattern_characteristic::no_wildcard;
}
typedef std::integral_constant<wildcard_position,
wildcard_position::nil>
no_wildcard;
bool tmatch(no_wildcard,
std::type_info const* tuple_value_type_list,
any_tuple::const_iterator const& tuple_begin,
any_tuple::const_iterator const& tuple_end,
std::type_info const* pattern_type_list,
type_value_pair_const_iterator pattern_begin,
type_value_pair_const_iterator pattern_end);
} // namespace detail
namespace detail {
template<pattern_characteristic, typename...> struct matcher;
template<wildcard_position, typename...> struct matcher;
} // namespace detail
template<pattern_characteristic PC, typename... Ts>
template<wildcard_position PC, typename... Ts>
struct match_impl;
/**
......@@ -83,7 +75,7 @@ template<typename... Ts>
inline bool match(any_tuple const& tup)
{
typedef util::type_list<Ts...> tl;
return match_impl<get_pattern_characteristic<tl>(), Ts...>::_(tup);
return match_impl<get_wildcard_position<tl>(), Ts...>::_(tup);
}
/**
......@@ -95,10 +87,10 @@ inline bool match(any_tuple const& tup,
size_t,
util::tl_count_not<
util::type_list<Ts...>,
util::tbind<std::is_same, anything>::type>::value>& mv)
is_anything>::value>& mv)
{
typedef util::type_list<Ts...> tl;
return match_impl<get_pattern_characteristic<tl>(), Ts...>::_(tup, mv);
return match_impl<get_wildcard_position<tl>(), Ts...>::_(tup, mv);
}
/**
......@@ -108,7 +100,7 @@ template<typename... Ts>
inline bool match(any_tuple const& tup, pattern<Ts...> const& ptrn)
{
typedef util::type_list<Ts...> tl;
return match_impl<get_pattern_characteristic<tl>(), Ts...>::_(tup, ptrn);
return match_impl<get_wildcard_position<tl>(), Ts...>::_(tup, ptrn);
}
/**
......@@ -120,13 +112,13 @@ inline bool match(any_tuple const& tup,
typename pattern<Ts...>::mapping_vector& mv)
{
typedef util::type_list<Ts...> tl;
return match_impl<get_pattern_characteristic<tl>(), Ts...>::_(tup,
return match_impl<get_wildcard_position<tl>(), Ts...>::_(tup,
ptrn,
mv);
}
// implementation for zero or one wildcards
template<pattern_characteristic PC, typename... Ts>
template<wildcard_position PC, typename... Ts>
struct match_impl
{
static inline bool _(any_tuple const& tup)
......@@ -161,9 +153,9 @@ struct match_impl
// implementation for multiple wildcards
template<typename... Ts>
struct match_impl<pattern_characteristic::multiple_wildcards, Ts...>
struct match_impl<wildcard_position::multiple, Ts...>
{
static constexpr auto PC = pattern_characteristic::multiple_wildcards;
static constexpr auto PC = wildcard_position::multiple;
static inline bool _(any_tuple const& tup)
{
......@@ -209,19 +201,19 @@ struct match_impl<pattern_characteristic::multiple_wildcards, Ts...>
namespace detail {
template<typename... T>
struct matcher<pattern_characteristic::no_wildcard, T...>
struct matcher<wildcard_position::nil, T...>
{
static inline bool tmatch(any_tuple const& tup)
{
// match implementation type if possible
auto& impl_typeid = tup.impl_type();
if ( impl_typeid == typeid(tuple_vals<T...>)
|| impl_typeid == typeid(decorated_tuple<T...>))
auto vals = tup.values_type_list();
auto prns = detail::static_type_list<T...>::list;
if (vals == prns || *vals == *prns)
{
return true;
}
// always use a full dynamic match for object arrays
else if ( impl_typeid == typeid(detail::object_array)
else if (*vals == typeid(detail::object_array)
&& tup.size() == sizeof...(T))
{
auto& tarr = detail::static_types_array<T...>::arr;
......@@ -236,9 +228,8 @@ struct matcher<pattern_characteristic::no_wildcard, T...>
{
if (tmatch(tup))
{
size_t i = 0;
mv.resize(sizeof...(T));
std::generate(mv.begin(), mv.end(), [&]() { return i++; });
std::iota(mv.begin(), mv.end(), 0);
return true;
}
return false;
......@@ -252,7 +243,7 @@ struct matcher<pattern_characteristic::no_wildcard, T...>
};
template<typename... T>
struct matcher<pattern_characteristic::trailing_wildcard, T...>
struct matcher<wildcard_position::trailing, T...>
{
static constexpr size_t size = sizeof...(T) - 1;
......@@ -273,9 +264,8 @@ struct matcher<pattern_characteristic::trailing_wildcard, T...>
{
if (tmatch(tup))
{
size_t i = 0;
mv.resize(size);
std::generate(mv.begin(), mv.end(), [&]() { return i++; });
std::iota(mv.begin(), mv.end(), 0);
return true;
}
return false;
......@@ -290,7 +280,7 @@ struct matcher<pattern_characteristic::trailing_wildcard, T...>
};
template<>
struct matcher<pattern_characteristic::leading_wildcard, anything>
struct matcher<wildcard_position::leading, anything>
{
static inline bool tmatch(any_tuple const&)
{
......@@ -307,7 +297,7 @@ struct matcher<pattern_characteristic::leading_wildcard, anything>
};
template<typename... T>
struct matcher<pattern_characteristic::leading_wildcard, T...>
struct matcher<wildcard_position::leading, T...>
{
static constexpr size_t size = sizeof...(T) - 1;
......@@ -331,9 +321,8 @@ struct matcher<pattern_characteristic::leading_wildcard, T...>
{
if (tmatch(tup))
{
size_t i = tup.size() - size;
mv.resize(size);
std::generate(mv.begin(), mv.end(), [&]() { return i++; });
std::iota(mv.begin(), mv.end(), tup.size() - size);
return true;
}
return false;
......@@ -350,7 +339,7 @@ struct matcher<pattern_characteristic::leading_wildcard, T...>
};
template<typename... T>
struct matcher<pattern_characteristic::wildcard_in_between, T...>
struct matcher<wildcard_position::in_between, T...>
{
static constexpr int signed_wc_pos =
util::tl_find<util::type_list<T...>, anything>::value;
......@@ -389,14 +378,12 @@ struct matcher<pattern_characteristic::wildcard_in_between, T...>
if (tmatch(tup))
{
// first range
size_t i = 0;
mv.resize(size - 1);
auto begin = mv.begin();
std::generate(begin, begin + wc_pos, [&]() { return i++; });
std::iota(begin, begin + wc_pos, 0);
// second range
i = tup.size() - (size - (wc_pos + 1));
begin = mv.begin() + wc_pos;
std::generate(begin, mv.end(), [&]() { return i++; });
std::iota(begin, mv.end(), tup.size() - (size - (wc_pos + 1)));
return true;
}
return false;
......@@ -421,11 +408,10 @@ struct matcher<pattern_characteristic::wildcard_in_between, T...>
};
template<typename... T>
struct matcher<pattern_characteristic::multiple_wildcards, T...>
struct matcher<wildcard_position::multiple, T...>
{
static constexpr size_t wc_count =
util::tl_count<util::type_list<T...>,
util::tbind<std::is_same, anything>::type>::value;
util::tl_count<util::type_list<T...>, is_anything>::value;
static_assert(sizeof...(T) > wc_count, "only wildcards given");
......
......@@ -43,7 +43,6 @@
#include "cppa/type_value_pair.hpp"
#include "cppa/uniform_type_info.hpp"
#include "cppa/util/tbind.hpp"
#include "cppa/util/type_list.hpp"
#include "cppa/util/arg_match_t.hpp"
#include "cppa/util/fixed_vector.hpp"
......@@ -56,6 +55,29 @@
namespace cppa {
enum class wildcard_position
{
nil,
trailing,
leading,
in_between,
multiple
};
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
? wildcard_position::leading
: (std::is_same<typename Types::back, anything>::value
? wildcard_position::trailing
: wildcard_position::in_between))
: wildcard_position::multiple)
: wildcard_position::nil;
}
template<class ExtendedType, class BasicType>
ExtendedType* extend_pattern(BasicType const* p);
......@@ -77,7 +99,7 @@ class pattern
typedef util::type_list<Types...> types;
typedef typename util::tl_filter_not<types, util::tbind<std::is_same, anything>::type>::type
typedef typename util::tl_filter_not<types, is_anything>::type
filtered_types;
static constexpr size_t filtered_size = filtered_types::size;
......
......@@ -52,7 +52,7 @@ auto tuple_cast(any_tuple const& tup, pattern<T...> const& p)
typedef typename pattern<T...>::filtered_types filtered_types;
typedef typename tuple_from_type_list<filtered_types>::type tuple_type;
static constexpr auto impl =
get_pattern_characteristic<util::type_list<T...>>();
get_wildcard_position<util::type_list<T...>>();
return detail::tuple_cast_impl<impl, tuple_type, T...>::_(tup, p);
}
......@@ -61,16 +61,14 @@ template<typename... T>
auto tuple_cast(any_tuple const& tup)
-> option<
typename tuple_from_type_list<
typename util::tl_filter_not<
util::type_list<T...>,
util::tbind<std::is_same, anything>::type
>::type
typename util::tl_filter_not<util::type_list<T...>,
is_anything>::type
>::type>
{
typedef decltype(tuple_cast<T...>(tup)) result_type;
typedef typename result_type::value_type tuple_type;
static constexpr auto impl =
get_pattern_characteristic<util::type_list<T...>>();
get_wildcard_position<util::type_list<T...>>();
return detail::tuple_cast_impl<impl, tuple_type, T...>::_(tup);
}
......
......@@ -111,11 +111,6 @@ any_tuple& any_tuple::operator=(any_tuple&& other)
return *this;
}
std::type_info const& any_tuple::impl_type() const
{
return m_vals->impl_type();
}
size_t any_tuple::size() const
{
return m_vals->size();
......
......@@ -63,9 +63,9 @@ bool empty_tuple::equals(const abstract_tuple& other) const
return other.size() == 0;
}
std::type_info const& empty_tuple::impl_type() const
std::type_info const* empty_tuple::values_type_list() const
{
return typeid(empty_tuple);
return &typeid(empty_tuple);
}
} } // namespace cppa::detail
......@@ -87,7 +87,9 @@ timed_invoke_rules::timed_invoke_rules(invokable_list&& lhs,
timed_invoke_rules&& rhs)
: super(std::move(lhs)), m_ti(std::move(rhs.m_ti))
{
m_list.splice(m_list.begin(), rhs.m_list);
std::move(rhs.m_list.begin(), rhs.m_list.end(), std::back_inserter(m_list));
rhs.m_list.clear();
//m_list.splice(m_list.begin(), rhs.m_list);
}
timed_invoke_rules& timed_invoke_rules::operator=(timed_invoke_rules&& other)
......@@ -126,7 +128,8 @@ invoke_rules::invoke_rules(std::unique_ptr<detail::invokable>&& arg)
invoke_rules& invoke_rules::splice(invokable_list&& ilist)
{
m_list.splice(m_list.end(), ilist);
std::move(ilist.begin(), ilist.end(), std::back_inserter(m_list));
ilist.clear();
return *this;
}
......@@ -142,7 +145,8 @@ timed_invoke_rules invoke_rules::splice(timed_invoke_rules&& other)
invoke_rules invoke_rules::operator,(invoke_rules&& other)
{
m_list.splice(m_list.end(), other.m_list);
splice(std::move(other));
//m_list.splice(m_list.end(), other.m_list);
return std::move(m_list);
}
......
......@@ -67,9 +67,9 @@ uniform_type_info const* object_array::type_at(size_t pos) const
return m_elements[pos].type();
}
std::type_info const& object_array::impl_type() const
std::type_info const* object_array::values_type_list() const
{
return typeid(object_array);
return &typeid(object_array);
}
} } // namespace cppa::detail
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