#include <atomic>

#include <iostream>

#include "cppa/scheduler.hpp"

#include "cppa/exception.hpp"

#include "cppa/any_tuple.hpp"

#include "cppa/local_actor.hpp"

#include "cppa/thread_mapped_actor.hpp"

#include "cppa/detail/actor_count.hpp"

#include "cppa/detail/empty_tuple.hpp"

#include "cppa/detail/group_manager.hpp"

#include "cppa/detail/actor_registry.hpp"

#include "cppa/detail/network_manager.hpp"

#include "cppa/detail/singleton_manager.hpp"

#include "cppa/detail/thread_pool_scheduler.hpp"

#include "cppa/detail/uniform_type_info_map.hpp"

namespace {

using namespace cppa;

using namespace cppa::detail;

std::atomic<uniform_type_info_map*> s_uniform_type_info_map;

std::atomic<network_manager*> s_network_manager;

std::atomic<actor_registry*> s_actor_registry;

std::atomic<group_manager*> s_group_manager;

std::atomic<empty_tuple*> s_empty_tuple;

std::atomic<scheduler*> s_scheduler;

template<typename T>

void stop_and_kill(std::atomic<T*>& ptr) {

}

template<typename T>

T* lazy_get(std::atomic<T*>& ptr, bool register_atexit_fun = false) {

T* result = ptr.load(std::memory_order_seq_cst);

if (result == nullptr) {

auto tmp = new T;

if (ptr.compare_exchange_strong(result, tmp, std::memory_order_seq_cst)) {

return tmp;

}

else {

delete tmp;

return lazy_get(ptr, register_atexit_fun);

}

/*

static_cast<void>(register_atexit_fun); // keep compiler happy

}

return result;

}

} // namespace <anonymous>

namespace cppa { namespace detail {

actor_registry* singleton_manager::get_actor_registry() {

return lazy_get(s_actor_registry);

}

uniform_type_info_map* singleton_manager::get_uniform_type_info_map() {

return lazy_get(s_uniform_type_info_map, true);

}

group_manager* singleton_manager::get_group_manager() {

return lazy_get(s_group_manager);

}

scheduler* singleton_manager::get_scheduler() {

return s_scheduler.load();

}

bool singleton_manager::set_scheduler(scheduler* ptr) {

}

network_manager* singleton_manager::get_network_manager() {

network_manager* result = s_network_manager.load();

if (result == nullptr) {

scheduler* s = new thread_pool_scheduler;

// set_scheduler sets s_network_manager

set_scheduler(s);

return get_network_manager();

}

return result;

}

empty_tuple* singleton_manager::get_empty_tuple() {

empty_tuple* result = s_empty_tuple.load();

if (result == nullptr) {

auto tmp = new empty_tuple;

if (s_empty_tuple.compare_exchange_weak(result, tmp) == false) {

delete tmp;

}

else {

result = tmp;

result->ref();

}

}

return result;

}

} } // namespace cppa::detail