#include <algorithm>

#include "cppa/config.hpp"

#include "cppa/object.hpp"

#include "cppa/uniform_type_info.hpp"

#include "cppa/util/void_type.hpp"

#include "cppa/detail/types_array.hpp"

namespace {

cppa::util::void_type s_void;

inline const cppa::uniform_type_info* tvoid() {

return cppa::detail::static_types_array<cppa::util::void_type>::arr[0];

}

} // namespace <anonymous>

namespace cppa {

void object::swap(object& other) {

std::swap(m_value, other.m_value);

std::swap(m_type, other.m_type);

}

object::object(void* val, const uniform_type_info* utype)

}

object::object() : m_value(&s_void), m_type(tvoid()) {

}

object::~object() {

if (m_value != &s_void) m_type->delete_instance(m_value);

}

object::object(const object& other) {

}

object::object(object&& other) : m_value(&s_void), m_type(tvoid()) {

swap(other);

}

object& object::operator=(object&& other) {

object tmp(std::move(other));

swap(tmp);

return *this;

}

object& object::operator=(const object& other) {

object tmp(other);

swap(tmp);

return *this;

}

bool operator==(const object& lhs, const object& rhs) {

if (lhs.type() == rhs.type()) {

// values might both point to s_void if lhs and rhs are "empty"

return lhs.value() == rhs.value()

|| lhs.type()->equals(lhs.value(), rhs.value());

}

return false;

}

const uniform_type_info* object::type() const {

return m_type;

}

const void* object::value() const {

return m_value;

}

void* object::mutable_value() {

return m_value;

}

} // namespace cppa