unsafe_any.hpp

// Copyright (C) 2022 by Camden Mannett.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "arg_router/config.hpp"
 
#include <cstring>
#include <functional>
 
namespace arg_router::utility
{
template <std::size_t SmallObjectOptimisationSize = sizeof(std::size_t)>
// NOLINTNEXTLINE(*-special-member-functions)
class unsafe_any_t
{
    using ptr_type = void*;
    using aligned_storage_type = std::aligned_storage_t<SmallObjectOptimisationSize>;
 
    template <typename T>
    constexpr static bool use_internal_storage = (sizeof(T) <= sizeof(aligned_storage_type));
 
public:
    constexpr unsafe_any_t() = default;
 
    template <typename T,
              typename = std::enable_if_t<use_internal_storage<T> &&
                                          !std::is_same_v<std::decay_t<T>, unsafe_any_t>>>
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
    unsafe_any_t(T&& value) noexcept
    {
        using value_type = std::decay_t<T>;
 
        // Build in buffer
        new (&storage_.buffer) value_type(std::forward<T>(value));
 
        copier_ = [](const storage_type& storage) -> unsafe_any_t {
            return *reinterpret_cast<const value_type*>(&storage.buffer);
        };
        destroyer_ = [](storage_type& storage) {
            auto ptr = reinterpret_cast<value_type*>(&storage.buffer);
            ptr->~value_type();
        };
    }
 
    template <typename T,
              typename Allocator = config::allocator<std::decay_t<T>>,
              typename = std::enable_if_t<!use_internal_storage<T> &&
                                          !std::is_same_v<std::decay_t<T>, unsafe_any_t>>>
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
    unsafe_any_t(T&& value, Allocator alloc = Allocator{})
    {
        using value_type = std::decay_t<T>;
 
        // Build using memory from allocator
        storage_.ptr = alloc.allocate(1);
        new (storage_.ptr) value_type(std::forward<T>(value));
 
        copier_ = [](const storage_type& storage) -> unsafe_any_t {
            return *reinterpret_cast<const value_type*>(storage.ptr);
        };
        destroyer_ = [alloc = std::move(alloc)](storage_type& storage) mutable noexcept {
            auto s_ptr = reinterpret_cast<value_type*>(storage.ptr);
 
            std::allocator_traits<Allocator>::destroy(alloc, s_ptr);
            alloc.deallocate(s_ptr, 1);
            storage.ptr = nullptr;
        };
    }
 
    unsafe_any_t(unsafe_any_t&& other) noexcept { swap(*this, other); }
 
    unsafe_any_t(const unsafe_any_t& other)
    {
        auto new_any = other.copier_(other.storage_);
        swap(*this, new_any);
    }
 
    unsafe_any_t& operator=(unsafe_any_t other) noexcept
    {
        swap(*this, other);
        return *this;
    }
 
    ~unsafe_any_t() noexcept
    {
        if (destroyer_) {
            destroyer_(storage_);
        }
    }
 
    [[nodiscard]] bool has_value() const noexcept { return !!destroyer_; }
 
    template <typename T, typename DecayType = std::decay_t<T>>
    [[nodiscard]] std::decay_t<T>& get() noexcept
    {
        using value_type = std::decay_t<T>;
 
        if constexpr (use_internal_storage<value_type>) {
            return *reinterpret_cast<value_type*>(&storage_.buffer);
        } else {
            return *reinterpret_cast<value_type*>(storage_.ptr);
        }
    }
 
    template <typename T>
    [[nodiscard]] auto get() const noexcept
        -> std::conditional_t<(sizeof(T) <= sizeof(std::size_t)) && std::is_copy_constructible_v<T>,
                              std::decay_t<T>,
                              const std::decay_t<T>&>
    {
        using value_type = std::decay_t<T>;
 
        if constexpr (use_internal_storage<value_type>) {
            return *reinterpret_cast<const value_type*>(&storage_.buffer);
        } else {
            return *reinterpret_cast<const value_type*>(storage_.ptr);
        }
    }
 
    friend void swap(unsafe_any_t& a, unsafe_any_t& b) noexcept
    {
        using std::swap;
 
        swap(a.storage_, b.storage_);
        swap(a.copier_, b.copier_);
        swap(a.destroyer_, b.destroyer_);
    }
 
private:
    union storage_type {
        constexpr storage_type() noexcept : ptr{nullptr} {}
 
        ptr_type ptr;
        aligned_storage_type buffer;
    };
 
    storage_type storage_;
    std::function<unsafe_any_t(const storage_type&)> copier_;
    std::function<void(storage_type&)> destroyer_;
};
 
using unsafe_any = unsafe_any_t<sizeof(std::string_view)>;
}  // namespace arg_router::utility