underlying_type.hpp

#ifndef UVW_UNDERLYING_TYPE_INCLUDE_H
#define UVW_UNDERLYING_TYPE_INCLUDE_H
 
#include <memory>
#include <type_traits>
#include <utility>
#include "loop.h"
 
namespace uvw {
 
template<typename T, typename U>
class UnderlyingType {
    template<typename, typename>
    friend class UnderlyingType;
 
protected:
    struct ConstructorAccess {
        explicit ConstructorAccess(int) {}
    };
 
    template<typename R = U>
    auto get() noexcept {
        return reinterpret_cast<R *>(&resource);
    }
 
    template<typename R = U>
    auto get() const noexcept {
        return reinterpret_cast<const R *>(&resource);
    }
 
    template<typename R, typename... P>
    auto get(UnderlyingType<P...> &other) noexcept {
        return reinterpret_cast<R *>(&other.resource);
    }
 
public:
    explicit UnderlyingType(ConstructorAccess, std::shared_ptr<Loop> ref) noexcept
        : pLoop{std::move(ref)}, resource{} {}
 
    UnderlyingType(const UnderlyingType &) = delete;
    UnderlyingType(UnderlyingType &&) = delete;
 
    virtual ~UnderlyingType() {
        static_assert(std::is_base_of_v<UnderlyingType<T, U>, T>);
    }
 
    UnderlyingType &operator=(const UnderlyingType &) = delete;
    UnderlyingType &operator=(UnderlyingType &&) = delete;
 
    template<typename... Args>
    static std::shared_ptr<T> create(Args &&...args) {
        return std::make_shared<T>(ConstructorAccess{0}, std::forward<Args>(args)...);
    }
 
    Loop &loop() const noexcept {
        return *pLoop;
    }
 
    const U *raw() const noexcept {
        return &resource;
    }
 
    U *raw() noexcept {
        return const_cast<U *>(const_cast<const UnderlyingType *>(this)->raw());
    }
 
private:
    std::shared_ptr<Loop> pLoop;
    U resource;
};
 
} // namespace uvw
 
#endif // UVW_UNDERLYING_TYPE_INCLUDE_H