Compiler Explorer

Source code

#include <array>
#include <memory>
#include <type_traits>

namespace detail {
    /// By moving the destruction into a dedicated function, we can store its address as the destructor 
    /// and use that address to do a type-check on access.
    template<typename T>
    constexpr auto destroy_as( const void* target ) -> void {
        const auto* ptr = std::launder( static_cast<const T*>(target) );
        std::destroy_at(ptr);
    }

template<typename T>
    constexpr auto copy_from_as( const void* source, void* destination ) -> void {
        const auto* const src = std::launder( static_cast<const T*>(source) );
        auto* const  dst = static_cast<T*>(destination);
        std::construct_at( dst, *src );
    }

template<typename T>
    constexpr auto move_from_as( void* source, void* destination ) -> void{
        auto* const src = std::launder( static_cast<T*>(source) );
        auto* const dst = static_cast<T*>(destination);
        std::construct_at( dst, std::move(*src) );
    }
}

class Safe_Storage_Exception : std::runtime_error {
    using std::runtime_error::runtime_error;
};

template<typename Source, typename Dest>
using transfer_const_t = std::conditional_t<std::is_const_v<Source>, std::add_const_t<Dest>, Dest>;

/// This class also supports Copy + Move by storing additional pointers
template<std::size_t Size, std::size_t Alignment>
class Transferable_Safe_Storage;

/// Making the Size and Alignment part of the tempalte interface is much simpler.
/// This class does not support copying or moving it. It can be copy or move constructed from a Transferable though
template<std::size_t Size, std::size_t Alignment>
class Safe_Storage {
public:
    /// Tiny little helper to test if `T` fits into this type.
    template<typename T>
    constexpr static bool can_hold = sizeof(T) <= Size and alignof(T) <= Alignment;

/// Default construction is valid, we hold no object
    Safe_Storage() = default;
protected:
    /// These operations can only be executed by a derived class. (Transferable_Safe_Storage).
    /// Effectively we need them only to copy over the destructor pointer. 
    /// The fact that they copy the stored bytes is irrelevant.
    Safe_Storage(const Safe_Storage&) = default;
    Safe_Storage(Safe_Storage&&) = default;
    Safe_Storage& operator=(const Safe_Storage&) = default;
    Safe_Storage& operator=( Safe_Storage&&) = default;
public:
    /// On destruction we just call reset
    ~Safe_Storage(){
        reset();
    }

/// Define converting constructors, allowing us to go from Transferable -> Non-Transferable
    template<std::size_t Other_Size, std::size_t Other_Alignment>
        requires (Other_Size <= Size and Other_Alignment <= Alignment )
    explicit Safe_Storage( const Transferable_Safe_Storage<Other_Size,Other_Alignment>& other ) {
        copy_from(other);
    }

template<std::size_t Other_Size, std::size_t Other_Alignment>
        requires (Other_Size <= Size and Other_Alignment <= Alignment )
    explicit Safe_Storage( Transferable_Safe_Storage<Other_Size,Other_Alignment>&& other ) {
        move_from(std::move(other));
    }

template<std::size_t Other_Size, std::size_t Other_Alignment>
        requires (Other_Size <= Size and Other_Alignment <= Alignment )
    Safe_Storage& operator=( const Transferable_Safe_Storage<Other_Size,Other_Alignment>& other ) {
        copy_from(other);
        return *this;
    }

template<std::size_t Other_Size, std::size_t Other_Alignment>
        requires (Other_Size <= Size and Other_Alignment <= Alignment )
    Safe_Storage& operator=( Transferable_Safe_Storage<Other_Size,Other_Alignment>&& other ) {
        move_from(std::move(other));
        return *this;
    }

/// Typed constructor that directly constructs T in the storage. This allows us to create objects in place without a factory function.
    /// There also is a deduction guide below that enables the deduction of Size and Alignment from `T`
    template<typename T, typename ... Args>
        requires ( can_hold<T> and std::is_constructible_v<T,Args...> )
    Safe_Storage( std::in_place_type_t<T>, Args&& ... args ) noexcept(std::is_nothrow_constructible_v<T> ) {
        emplace<T>(std::forward<Args>(args) ... );
    }

/// We use the destructor as a hint whether we have a value.
    [[nodiscard]] constexpr auto has_value() const -> bool {
        return destructor_ != nullptr;
    }

/// Function that checks whether we currently hold T
    template<typename T>
        requires can_hold<T>
    [[nodiscard]] constexpr auto is() const noexcept -> bool {
        return destructor_ == &detail::destroy_as<T>;
    }

/// Tries to get a typed pointer, if we currently hold that alternative
    template<typename T,typename Self>
    [[nodiscard]] constexpr auto try_as(this Self& self) noexcept -> transfer_const_t<Self,T>* {
        if ( not self.template is<T>() ) {
            return nullptr;
        }
        return std::launder( reinterpret_cast<transfer_const_t<Self,T>*>(&self.storage_) );
    }

/// Gets a `Base` pointer if the held type is one of `Derived...`
    template<typename Base, typename ... Derived, typename Self>
        requires ( sizeof...(Derived) > 0 and (std::derived_from<Derived,Base> && ...) )
    [[nodiscard]] constexpr auto try_as_polymorphic( this Self& self ) -> transfer_const_t<Self,Base>* {
        transfer_const_t<Self,Base>* r = nullptr;
        const auto good = ( static_cast<bool>(r = self.template try_as<Derived>() ) && ... );
        if ( good ) {
            return r;
        }
        return nullptr;
    }

/// Invokes `F` with the held object, if it is one of `Ts...`
    template<typename ... Ts, typename Self, typename F>
        requires ( std::is_invocable_v<F,Ts> && ... )
    constexpr auto try_invoke_as( this Self&& self, F&& f ) -> bool {
        const auto try_invoke = [&f]<typename Concrete>( Concrete* ptr ) -> bool {
            if ( not ptr ) {
                return false;
            }
            std::forward<F>(f)( std::forward_like<Self>(*ptr) );
            return true;
        };
        return ( try_invoke( self.template try_as<Ts>() ) && ... );
    }

/// Safe access function that checks and returns a typed reference
    template<typename T, typename Self>
    [[nodiscard]] constexpr auto as(this Self& self) -> transfer_const_t<Self,T>& {
        auto* ptr = self.template try_as<T>();
        if ( not ptr ) {
            throw Safe_Storage_Exception{"Trying to access Safe_Storage as a type that is not currently held"};
        }
        return *ptr;
    }

/// Simply function that explicitly destroys the held object. Also useful because we need to re-use this code.
    constexpr auto reset() noexcept -> void {
        if ( has_value() ) {
            destructor_(&storage_);
            destructor_ = nullptr;
        }
    }

/// Function that constructs an object in the storage
    template<typename T, typename ... Args>
        requires ( can_hold<T> and std::is_constructible_v<T,Args...> )
    constexpr auto emplace( Args&& ... args ) noexcept(std::is_nothrow_constructible_v<T,Args...> ) -> T& {
        /// First we need to reset, i.e. destroy the current object
        reset();
        /// Next we consturct the new object
        auto* ptr = std::construct_at( reinterpret_cast<T*>(&storage_), std::forward<Args>(args) ... );
        /// And set the new destructor. Its important you do this after the construction to be exception safe.
        destructor_ = &detail::destroy_as<T>;
        /// As a curtesy, empalce functions generally return a typed reference to the emplaced object
        return *ptr;
    }

protected:
    /// These functions implement the actual tranfering of the contained object.
    template<std::size_t Other_Size, std::size_t Other_Alignment>
        requires (Other_Size <= Size and Other_Alignment <= Alignment )
    auto copy_from( const Transferable_Safe_Storage<Other_Size,Other_Alignment>& other ) -> void;

template<std::size_t Other_Size, std::size_t Other_Alignment>
        requires (Other_Size <= Size and Other_Alignment <= Alignment )
    auto move_from( Transferable_Safe_Storage<Other_Size,Other_Alignment>&& other ) -> void;

/// We can simply align the storage to our requirement and be done
    alignas(Alignment) std::array<std::byte,Size> storage_;
    /// The destructor is held as a typed pointer, because we can use that as a tag.
    using destructor_t = void(*)(const void*);
    destructor_t destructor_ = nullptr;
};

/// Type alias that you could use if you wanted to construct this storage without constructing an object
template<typename T>
using Safe_Storage_for = Safe_Storage<sizeof(T),alignof(T)>;

/// Deduction buide that mains the first construction in main work
template<typename T, typename ... Args>
Safe_Storage( std::in_place_type_t<T>, Args ... ) -> Safe_Storage<sizeof(T),alignof(T)>;

/// A Transferable_Safe_Storage is a Safe_Storage.
/// You can make an argument that this should be a private base in order to statically find an erroneous usage such as
///     auto o = Transferable_Safe_Storage{ std::in_place_t<std::string> };
///     using base = Safe_Storage_for<std::string>{};
///     o.base::emplace<int>();
/// This would leave the copy-constructors in place, resuting in an attemp to copy an int and raw memory as if it were a string.
/// Alternatively you could destroy contained objects when copying/moving out, but that defeats the purpose.
/// Realistically this scenarion is not happening, as it requires willful malice on the part of the user.
template<std::size_t Size, std::size_t Alignment>
class Transferable_Safe_Storage : public Safe_Storage<Size,Alignment> {
    /// Make base members usable directly
    using Base = Safe_Storage<Size,Alignment>;
    using Base::destructor_;
    using Base::storage_;
public:
    Transferable_Safe_Storage() = default;
    /// Copy/move operations of this type are now public and implemented via a copy_from override.
    Transferable_Safe_Storage( const Transferable_Safe_Storage& other ) {
        this->copy_from(other);
    }
    Transferable_Safe_Storage( Transferable_Safe_Storage&& other ) {
        this->move_from(std::move(other));
    }
    Transferable_Safe_Storage& operator=( const Transferable_Safe_Storage& other ) {
        this->copy_from(other);
        return *this;
    }
    Transferable_Safe_Storage& operator=( Transferable_Safe_Storage&& other ) {
        this->move_from(std::move(other));
        return *this;
    }
    template<typename T, typename ... Args>
        requires ( Base::template can_hold<T> and std::is_constructible_v<T,Args...> )
    Transferable_Safe_Storage( std::in_place_type_t<T>, Args&& ... args ) noexcept(std::is_nothrow_constructible_v<T> ) {
        emplace<T>(std::forward<Args>(args) ... );
    }

/// We also have copy/move operations from other sizes
    template<std::size_t Other_Size, std::size_t Other_Alignment>
        requires (Other_Size <= Size and Other_Alignment <= Alignment )
    Transferable_Safe_Storage( const Transferable_Safe_Storage<Other_Size,Other_Alignment>& other ) {
        this->copy_from(other);
    }
    template<std::size_t Other_Size, std::size_t Other_Alignment>
        requires (Other_Size <= Size and Other_Alignment <= Alignment )
    Transferable_Safe_Storage( Transferable_Safe_Storage<Other_Size,Other_Alignment>&& other ) {
        this->move_from(std::move(other));
    }
    template<std::size_t Other_Size, std::size_t Other_Alignment>
        requires (Other_Size <= Size and Other_Alignment <= Alignment )
    Transferable_Safe_Storage& operator=( const Transferable_Safe_Storage<Other_Size,Other_Alignment>& other ) {
        this->copy_from(other);
        return *this;
    }
    template<std::size_t Other_Size, std::size_t Other_Alignment>
        requires (Other_Size <= Size and Other_Alignment <= Alignment )
    Transferable_Safe_Storage& operator=( Transferable_Safe_Storage<Other_Size,Other_Alignment>&& other ) {
        this->move_from(std::move(other));
        return *this;
    }

template<typename T, typename ... Args>
        requires ( Base::template can_hold<T> and std::is_constructible_v<T,Args...> )
    constexpr auto emplace( Args&& ... args ) noexcept(std::is_nothrow_constructible_v<T,Args...> )-> T& {
        auto& ref = Base::template emplace<T>(std::forward<Args>(args) ... );
        copy_ = std::is_copy_constructible_v<T> ? &detail::copy_from_as<T> : nullptr;
        move_ = std::is_move_constructible_v<T> ? &detail::move_from_as<T> : nullptr;
        return ref;
    }

/// We must friend the base class, as its copy_from and move_from need access to the copy/move members
    template<std::size_t Other_Size, std::size_t Other_Alignment>
    friend class Safe_Storage;
private:
    /// an override of the impelemtnation of `copy_from` and `move_from` is required.
    /// We also need to copy/move the pointers for those operations.
    template<std::size_t Other_Size, std::size_t Other_Alignment>
        requires (Other_Size <= Size and Other_Alignment <= Alignment )
    auto copy_from( const Transferable_Safe_Storage<Other_Size,Other_Alignment>& other ) -> void;

using copy_t = void(*)(const void*, void*);
    copy_t copy_;
    using move_t = void(*)(void*, void*);
    move_t move_;
};

/// Type alias that you could use if you wanted to construct this storage without constructing an object
template<typename T>
using Transferable_Safe_Storage_for = Transferable_Safe_Storage<sizeof(T),alignof(T)>;

/// Deduction buide that mains the first construction in main work
template<typename T, typename ... Args>
Transferable_Safe_Storage( std::in_place_type_t<T>, Args ... ) -> Transferable_Safe_Storage<sizeof(T),alignof(T)>;

/// The base-class copy/move operations simply invoke the function or throw if it does not exist.
template<std::size_t Size, std::size_t Alignment>
template<std::size_t Other_Size, std::size_t Other_Alignment>
    requires (Other_Size <= Size and Other_Alignment <= Alignment )
auto Safe_Storage<Size,Alignment>::copy_from( const Transferable_Safe_Storage<Other_Size,Other_Alignment>& other ) -> void {
    if ( other.copy_ == nullptr ) {
        destructor_ = nullptr;
        throw Safe_Storage_Exception{"source object is not copyable"};
    }
    reset();
    other.copy_(&other.storage_, &storage_);
    destructor_ = other.destructor_;
}

template<std::size_t Size, std::size_t Alignment>
template<std::size_t Other_Size, std::size_t Other_Alignment>
    requires (Other_Size <= Size and Other_Alignment <= Alignment )
auto Safe_Storage<Size,Alignment>::move_from( Transferable_Safe_Storage<Other_Size,Other_Alignment>&& other ) -> void {
    if ( other.move_ == nullptr ) {
        throw Safe_Storage_Exception{"source object is not movable"};
    }
    reset();    
    other.move_(&other.storage_, &storage_);
    destructor_ = other.destructor_;
}

/// The derived copy/move implementations delegate to the base for the actual object transfer and then copy the pointers
template<std::size_t Size, std::size_t Alignment>
template<std::size_t Other_Size, std::size_t Other_Alignment>
    requires (Other_Size <= Size and Other_Alignment <= Alignment )
auto Transferable_Safe_Storage<Size,Alignment>::copy_from( const Transferable_Safe_Storage<Other_Size,Other_Alignment>& other ) -> void {
    Base::copy_from(other);
    copy_ = other.copy_;
    move_ = other.move_;
}

template<std::size_t Size, std::size_t Alignment>
template<std::size_t Other_Size, std::size_t Other_Alignment>
    requires (Other_Size <= Size and Other_Alignment <= Alignment )
auto Transferable_Safe_Storage<Size,Alignment>::move_from( Transferable_Safe_Storage<Other_Size,Other_Alignment>&& other ) -> void {
    Base::move_from(std::move(other));
    copy_ = other.copy_;
    move_ = other.move_;
}

#include <cassert>

/// A type that just tells us about its life-cycle
struct Noisy {
    Noisy() { std::puts(__PRETTY_FUNCTION__); }
    Noisy(const Noisy&) { std::puts(__PRETTY_FUNCTION__); }
    Noisy(Noisy&&) { std::puts(__PRETTY_FUNCTION__); }
    Noisy& operator=(const Noisy&) { std::puts(__PRETTY_FUNCTION__); return *this; }
    Noisy& operator=( Noisy&&) { std::puts(__PRETTY_FUNCTION__); return *this; }
    Noisy( auto ...){ std::puts(__PRETTY_FUNCTION__); }
    ~Noisy() { std::puts(__PRETTY_FUNCTION__); }
    /// Dummy member, so it has the size&alignment of int
    int placeholder;
};

auto f(Noisy) {
    std::puts(__PRETTY_FUNCTION__);
};

int main() {
    auto o = Transferable_Safe_Storage{ std::in_place_type<Noisy> };

assert((o.try_as_polymorphic<Noisy,Noisy>()));
    
    assert(o.try_invoke_as<Noisy>( f ));

/// We can copy construct these objects
    auto o2 = o;
    /// or move assign
    o = std::move(o2);
}