Commit db48145f authored by Dominik Charousset's avatar Dominik Charousset

maintenance

parent 6cbdec38
......@@ -38,6 +38,7 @@
#include "cppa/cow_tuple.hpp"
#include "cppa/util/rm_ref.hpp"
#include "cppa/util/comparable.hpp"
#include "cppa/util/is_iterable.hpp"
#include "cppa/detail/tuple_view.hpp"
......@@ -55,6 +56,7 @@ class any_tuple {
public:
typedef cow_ptr<detail::abstract_tuple> value_ptr;
typedef detail::abstract_tuple::const_iterator const_iterator;
/**
......@@ -74,8 +76,6 @@ class any_tuple {
template<typename... Args>
any_tuple(cow_tuple<Args...>&& t) : m_vals(std::move(t.m_vals)) { }
explicit any_tuple(detail::abstract_tuple*);
/**
* @brief Move constructor.
*/
......@@ -143,9 +143,9 @@ class any_tuple {
inline const_iterator end() const { return m_vals->end(); }
inline cow_ptr<detail::abstract_tuple>& vals() { return m_vals; }
inline const cow_ptr<detail::abstract_tuple>& vals() const { return m_vals; }
inline const cow_ptr<detail::abstract_tuple>& cvals() const { return m_vals; }
inline value_ptr& vals() { return m_vals; }
inline const value_ptr& vals() const { return m_vals; }
inline const value_ptr& cvals() const { return m_vals; }
inline const std::type_info* type_token() const {
return m_vals->type_token();
......@@ -179,66 +179,63 @@ class any_tuple {
typedef typename detail::implicit_conversions<vtype>::type converted;
static_assert(util::is_legal_tuple_type<converted>::value,
"T is not a valid tuple type");
typedef typename std::remove_reference<T>::type plain_type;
static constexpr bool can_optimize =
std::is_same<converted, vtype>::value
&& std::is_reference<T>::value
&& !std::is_const<typename std::remove_reference<T>::type>::value;
&& !std::is_const<plain_type>::value;
std::integral_constant<bool, can_optimize> token;
return any_tuple{simple_view(std::forward<T>(value), token)};
}
void force_detach() {
m_vals.detach();
}
inline void force_detach() { m_vals.detach(); }
void reset();
explicit any_tuple(detail::abstract_tuple*);
private:
cow_ptr<detail::abstract_tuple> m_vals;
value_ptr m_vals;
explicit any_tuple(const cow_ptr<detail::abstract_tuple>& vals);
explicit any_tuple(const value_ptr& vals);
typedef detail::abstract_tuple* tup_ptr;
typedef detail::abstract_tuple* abstract_ptr;
template<typename T>
static inline tup_ptr simple_view(T& value,
std::integral_constant<bool, true>) {
static inline abstract_ptr simple_view(T& value, std::true_type) {
return new detail::tuple_view<T>(&value);
}
template<typename First, typename Second>
static inline tup_ptr simple_view(std::pair<First, Second>& p,
std::integral_constant<bool, true>) {
static inline abstract_ptr simple_view(std::pair<First, Second>& p,
std::true_type) {
return new detail::tuple_view<First, Second>(&p.first, &p.second);
}
template<typename T>
static inline tup_ptr simple_view(T&& value,
std::integral_constant<bool, false>) {
static inline abstract_ptr simple_view(T&& value, std::false_type) {
typedef typename util::rm_ref<T>::type vtype;
typedef typename detail::implicit_conversions<vtype>::type converted;
return new detail::tuple_vals<converted>(std::forward<T>(value));
}
template<typename First, typename Second>
static inline any_tuple view(std::pair<First, Second> p,
std::integral_constant<bool, false>) {
static inline any_tuple view(std::pair<First, Second> p, std::false_type) {
return new detail::tuple_vals<First, Second>(std::move(p.first),
std::move(p.second));
}
template<typename T>
static inline detail::abstract_tuple* container_view(T& value,
std::integral_constant<bool, true>) {
static inline abstract_ptr container_view(T& value, std::true_type) {
return new detail::container_tuple_view<T>(&value);
}
template<typename T>
static inline detail::abstract_tuple* container_view(T&& value,
std::integral_constant<bool, false>) {
static inline abstract_ptr container_view(T&& value, std::false_type) {
typedef typename util::rm_ref<T>::type ctype;
return new detail::container_tuple_view<T>(new ctype(std::forward<T>(value)), true);
auto cptr = new ctype(std::forward<T>(value));
return new detail::container_tuple_view<T>(cptr, true);
}
};
......
......@@ -39,6 +39,9 @@ namespace cppa { namespace detail {
std::string to_uniform_name(const std::string& demangled_name);
std::string to_uniform_name(const std::type_info& tinfo);
template<class T>
inline std::string to_uniform_name() { return to_uniform_name(typeid(T)); }
} } // namespace cppa::detail
#endif // CPPA_TO_UNIFORM_NAME_HPP
......@@ -84,8 +84,6 @@ class uniform_type_info_map {
// maps sizeof(-integer_type-) to { signed-names-set, unsigned-names-set }
int_map m_ints;
};
} } // namespace cppa::detail
......
......@@ -32,28 +32,23 @@
#include "cppa/detail/empty_tuple.hpp"
#include "cppa/detail/singleton_manager.hpp"
namespace {
namespace cppa {
inline cppa::detail::empty_tuple* s_empty_tuple() {
return cppa::detail::singleton_manager::get_empty_tuple();
namespace {
inline detail::empty_tuple* s_empty_tuple() {
return detail::singleton_manager::get_empty_tuple();
}
} // namespace <anonymous>
namespace cppa {
any_tuple::any_tuple() : m_vals(s_empty_tuple()) { }
any_tuple::any_tuple() : m_vals(s_empty_tuple()) {
}
any_tuple::any_tuple(detail::abstract_tuple* ptr) : m_vals(ptr) {
}
any_tuple::any_tuple(detail::abstract_tuple* ptr) : m_vals(ptr) { }
any_tuple::any_tuple(any_tuple&& other) : m_vals(s_empty_tuple()) {
m_vals.swap(other.m_vals);
}
any_tuple::any_tuple(const cow_ptr<detail::abstract_tuple>& vals) : m_vals(vals) {
}
any_tuple::any_tuple(const value_ptr& vals) : m_vals(vals) { }
any_tuple& any_tuple::operator=(any_tuple&& other) {
m_vals.swap(other.m_vals);
......
......@@ -38,14 +38,14 @@
#include "cppa/local_actor.hpp"
#include "cppa/thread_mapped_actor.hpp"
namespace cppa {
namespace {
boost::thread_specific_ptr<cppa::local_actor> t_this_actor(&cppa::self_type::cleanup_fun);
boost::thread_specific_ptr<local_actor> t_this_actor(&self_type::cleanup_fun);
} // namespace <anonymous>
namespace cppa {
void self_type::cleanup_fun(cppa::local_actor* what) {
if (what) {
auto ptr = dynamic_cast<thread_mapped_actor*>(what);
......
......@@ -63,19 +63,6 @@ void shared_spinlock::lock() {
void shared_spinlock::lock_upgrade() {
unlock_shared();
lock();
/*
long v = m_flag.load();
for (;;) {
if (v != 1) {
//std::this_thread::yield();
v = m_flag.load();
}
else if (m_flag.compare_exchange_weak(v, min_long)) {
return;
}
// else: next iteration
}
*/
}
void shared_spinlock::unlock() {
......
......@@ -136,7 +136,8 @@ class string_serializer : public serializer {
throw std::runtime_error("expected uint64 value after @atom");
}
// write atoms as strings instead of integer values
auto av = static_cast<atom_value>(get<std::uint64_t>(value)); (pt_writer(out))(to_string(av));
auto av = static_cast<atom_value>(get<std::uint64_t>(value));
(pt_writer(out))(to_string(av));
}
else {
value.apply(pt_writer(out));
......@@ -207,8 +208,12 @@ class string_deserializer : public deserializer {
case '{':
case '}':
case ' ':
case ',': return true;
default : return false;
case ',': {
return true;
}
default: {
return false;
}
}
});
}
......@@ -284,8 +289,7 @@ class string_deserializer : public deserializer {
size_t begin_sequence() {
integrity_check();
consume('{');
auto list_end = std::find(m_pos, m_str.end(), '}');
return std::count(m_pos, list_end, ',') + 1;
return std::count(m_pos, std::find(m_pos, m_str.end(), '}'), ',') + 1;
}
void end_sequence() {
......
This diff is collapsed.
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