#include <pthread.h>

#include "cppa/self.hpp"

#include "cppa/any_tuple.hpp"

#include "cppa/scheduler.hpp"

#include "cppa/local_actor.hpp"

#include "cppa/thread_mapped_actor.hpp"

namespace cppa {

namespace {

pthread_key_t s_key;

pthread_once_t s_key_once = PTHREAD_ONCE_INIT;

local_actor* tss_constructor() {

local_actor* result = detail::memory::create<thread_mapped_actor>();

result->ref();

get_scheduler()->register_converted_context(result);

return result;

}

void tss_destructor(void* vptr) {

if (vptr) self_type::cleanup_fun(reinterpret_cast<local_actor*>(vptr));

}

void tss_make_key() {

pthread_key_create(&s_key, tss_destructor);

}

local_actor* tss_get() {

pthread_once(&s_key_once, tss_make_key);

return reinterpret_cast<local_actor*>(pthread_getspecific(s_key));

}

local_actor* tss_release() {

pthread_once(&s_key_once, tss_make_key);

auto result = reinterpret_cast<local_actor*>(pthread_getspecific(s_key));

if (result) {

pthread_setspecific(s_key, nullptr);

}

return result;

}

local_actor* tss_get_or_create() {

pthread_once(&s_key_once, tss_make_key);

auto result = reinterpret_cast<local_actor*>(pthread_getspecific(s_key));

if (!result) {

result = tss_constructor();

pthread_setspecific(s_key, reinterpret_cast<void*>(result));

}

return result;

}

void tss_reset(local_actor* ptr, bool inc_ref_count = true) {

}

} // namespace <anonymous>

bool operator==(const actor_ptr& lhs, const self_type& rhs) {

return lhs.get() == rhs.get();

}

bool operator!=(const self_type& lhs, const actor_ptr& rhs) {

return lhs.get() != rhs.get();

}

void self_type::cleanup_fun(cppa::local_actor* what) {

}

void self_type::set_impl(self_type::pointer ptr) {

tss_reset(ptr);

}

self_type::pointer self_type::get_impl() {

return tss_get_or_create();

}

actor* self_type::convert_impl() {

return get_impl();

}

self_type::pointer self_type::get_unchecked_impl() {

return tss_get();

}

void self_type::adopt_impl(self_type::pointer ptr) {

tss_reset(ptr, false);

}

self_type::pointer self_type::release_impl() {

return tss_release();

}

} // namespace cppa