#include <typeinfo>

#include "cppa/primitive_variant.hpp"

#include "cppa/detail/type_to_ptype.hpp"

namespace cppa {

namespace {

template<class T>

void ptv_del(T&,

typename std::enable_if<std::is_arithmetic<T>::value>::type* = 0) {

// arithmetic types don't need destruction

}

template<class T>

void ptv_del(T& what,

typename std::enable_if<!std::is_arithmetic<T>::value>::type* = 0) {

what.~T();

}

struct destroyer {

};

struct type_reader {

};

struct comparator {

};

struct initializer {

};

struct setter {

};

struct mover {

};

} // namespace <anonymous>

primitive_variant::primitive_variant() : m_ptype(pt_null) { }

primitive_variant::primitive_variant(primitive_type ptype) : m_ptype(pt_null) {

util::pt_dispatch(ptype, initializer(*this));

}

primitive_variant::primitive_variant(const primitive_variant& other)

: m_ptype(pt_null) {

other.apply(setter(*this));

}

primitive_variant::primitive_variant(primitive_variant&& other)

: m_ptype(pt_null) {

other.apply(mover(*this));

}

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

other.apply(setter(*this));

return *this;

}

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

other.apply(mover(*this));

return *this;

}

bool equal(const primitive_variant& lhs, const primitive_variant& rhs) {

}

const std::type_info& primitive_variant::type() const {

type_reader tr;

apply(tr);

return (tr.tinfo == nullptr) ? typeid(void) : *tr.tinfo;

}

primitive_variant::~primitive_variant() {

destroy();

}

void primitive_variant::destroy() {

apply(destroyer());

m_ptype = pt_null;

}

} // namespace cppa