data.hpp

//SPDX-License-Identifier: LicenseRef-Apache-License-2.0
//Author: Blayne Dennis
 
#ifndef __SIMPLE_THREADING_DATA__
#define __SIMPLE_THREADING_DATA__
 
#include <memory>
#include <typeinfo>
#include <type_traits>
 
#include "utility.hpp"
 
namespace st { // simple thread
 
struct data {
    // default type_info helper struct when unallocated
    struct unset { };
 
    data() : 
        m_type_info(&typeid(unset)), 
        m_data_ptr(data_pointer_t(nullptr, data::no_delete))
    { }
 
    data(data&& rhs) : 
        m_type_info(rhs.m_type_info), 
        m_data_ptr(std::move(rhs.m_data_ptr)) 
    { }
 
    virtual ~data() {}
 
    template <typename T, typename... As>
    static data make(As&&... as) {
        return data(detail::hint<typename std::remove_reference<T>::type>(), std::forward<As>(as)...);
    }
 
    inline data& operator=(data&& rhs) {
        m_type_info = rhs.m_type_info;
        m_data_ptr = std::move(rhs.m_data_ptr);
        return *this;
    }
 
    data(const data& rhs) = delete;
    data& operator=(const data& rhs) = delete;
 
    inline operator bool() const {
        return m_data_ptr.data_pointer_t::operator bool();
    }
 
    inline const std::type_info& type_info() const {
        return *m_type_info;
    }
 
    template <typename T>
    bool is() const {
        return m_data_ptr && *m_type_info == typeid(T);
    }
 
    inline void* get() {
        return m_data_ptr.get();
    }
 
    template <typename T>
    T& cast_to() {
        return *((detail::base<T>*)(get()));
    }
 
    template <typename T>
    bool copy_to(T& t) {
        if(is<T>()) {
            t = cast_to<T>();
            return true;
        } else {
            return false;
        }
    }
 
    template <typename T>
    bool move_to(T& t) {
        if(is<T>()) {
            std::swap(t, cast_to<T>());
            return true;
        } else {
            return false;
        }
    }
 
private:
    typedef void(*deleter_t)(void*);
    typedef std::unique_ptr<void,deleter_t> data_pointer_t;
    typedef void*(*allocator_t)(void*);
 
    template <typename T, typename... As>
    data(detail::hint<T> h, As&&... as) :
        m_type_info(&typeid(T)),
        m_data_ptr(allocate<T>(std::forward<As>(as)...),data::deleter<T>)
    { }
 
    template <typename T, typename... As>
    static void* allocate(As&&... as) {
        return (void*)(new detail::base<T>(std::forward<As>(as)...));
    }
 
    template <typename T>
    static void deleter(void* p) {
        delete (detail::base<T>*)p;
    }
 
    static inline void no_delete(void* p) { }
 
    const std::type_info* m_type_info; // type code
    data_pointer_t m_data_ptr; // stored data 
};
 
}
 
#endif