copyable_wrapper.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2006-2024 Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2024 Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <functional>
#include <optional>
 
#include <seqan3/core/platform.hpp>
 
namespace seqan3::detail
{
 
template <typename t>
concept boxable = std::copy_constructible<t> && std::is_object_v<t>;
 
template <typename t>
class copyable_wrapper : public std::optional<t>
{
public:
    using std::optional<t>::optional;                               
    using std::optional<t>::operator=;                              
    constexpr copyable_wrapper(copyable_wrapper const &) = default; 
    constexpr copyable_wrapper(copyable_wrapper &&) = default;      
    constexpr ~copyable_wrapper() = default;                        
 
    constexpr copyable_wrapper() noexcept(std::is_nothrow_default_constructible_v<t>)
        requires std::default_initializable<t>
        : copyable_wrapper{std::in_place}
    {}
 
    constexpr copyable_wrapper & operator=(copyable_wrapper const & other)
        noexcept(std::is_nothrow_copy_constructible_v<t>)
        requires (!std::copyable<t>)
    {
        if (this != std::addressof(other))
        {
            if (other)
                this->emplace(*other);
            else
                this->reset();
        }
        return *this;
    }
 
    constexpr copyable_wrapper & operator=(copyable_wrapper && other) noexcept(std::is_nothrow_move_constructible_v<t>)
        requires (!std::movable<t>)
    {
        if (this != std::addressof(other))
        {
            if (other)
                this->emplace(std::move(*other));
            else
                this->reset();
        }
        return *this;
    }
 
    template <typename... args_t>
        requires std::invocable<t, args_t...>
    constexpr decltype(auto) operator()(args_t... args) noexcept(std::is_nothrow_invocable_v<t, args_t...>)
    {
        return std::invoke(this->value(), std::forward<args_t>(args)...);
    }
 
    template <typename... args_t>
        requires std::invocable<t, args_t...>
    constexpr decltype(auto) operator()(args_t... args) const noexcept(std::is_nothrow_invocable_v<t, args_t...>)
    {
        return std::invoke(this->value(), std::forward<args_t>(args)...);
    }
};
 
template <boxable t>
    requires std::copyable<t>
          || (std::is_nothrow_move_constructible_v<t> && std::is_nothrow_copy_constructible_v<t>)
#if SEQAN3_WORKAROUND_DEFAULT_CONSTRUCTIBLE_VIEW // If views must be default constructible, t must also be
                 && std::default_initializable<t>
#endif
             class copyable_wrapper<t>
{
private:
    t value{}; 
 
public:
    constexpr copyable_wrapper()
        requires std::default_initializable<t>
    = default;
 
    constexpr copyable_wrapper(copyable_wrapper const &) = default; 
    constexpr copyable_wrapper(copyable_wrapper &&) = default;      
    constexpr ~copyable_wrapper() = default;                        
 
    constexpr copyable_wrapper & operator=(copyable_wrapper const &)
        requires std::copyable<t>
    = default;
 
    constexpr copyable_wrapper & operator=(copyable_wrapper const & other) noexcept
    {
        // Destroy-then-copy
        if (this != std::addressof(other))
        {
            value.~t();                                       // Call destructor of value
            std::construct_at(std::addressof(value), *other); // Copy construct
        }
        return *this;
    }
 
    constexpr copyable_wrapper & operator=(copyable_wrapper &&)
        requires std::copyable<t>
    = default;
 
    constexpr copyable_wrapper & operator=(copyable_wrapper && other) noexcept
    {
        // Destroy-then-copy
        if (this != std::addressof(other))
        {
            value.~t();                                                  // Call destructor of value
            std::construct_at(std::addressof(value), std::move(*other)); // Move construct
        }
        return *this;
    }
 
    constexpr explicit copyable_wrapper(t const & other) noexcept(std::is_nothrow_copy_constructible_v<t>) :
        value{other}
    {}
 
    constexpr explicit copyable_wrapper(t && other) noexcept(std::is_nothrow_move_constructible_v<t>) :
        value{std::move(other)}
    {}
 
    template <typename... args_t>
        requires std::constructible_from<t, args_t...>
    constexpr explicit copyable_wrapper(std::in_place_t, args_t... args)
        noexcept(std::is_nothrow_constructible_v<t, args_t...>) :
        value{std::forward<args_t>(args)...}
    {}
 
    constexpr bool has_value() const noexcept
    {
        return true; // t is copyable, hence we always store a value.
    }
 
    constexpr t & operator*() noexcept
    {
        return value;
    }
 
    constexpr t const & operator*() const noexcept
    {
        return value;
    }
 
    constexpr t * operator->() noexcept
    {
        return std::addressof(value);
    }
 
    constexpr t const * operator->() const noexcept
    {
        return std::addressof(value);
    }
 
    template <typename... args_t>
        requires std::invocable<t, args_t...>
    constexpr decltype(auto) operator()(args_t... args) noexcept(std::is_nothrow_invocable_v<t, args_t...>)
    {
        return std::invoke(value, std::forward<args_t>(args)...);
    }
 
    template <typename... args_t>
        requires std::invocable<t, args_t...>
    constexpr decltype(auto) operator()(args_t... args) const noexcept(std::is_nothrow_invocable_v<t, args_t...>)
    {
        return std::invoke(value, std::forward<args_t>(args)...);
    }
};
 
template <typename t>
copyable_wrapper(t) -> copyable_wrapper<std::remove_reference_t<t>>;
 
template <typename t>
using copyable_wrapper_t = copyable_wrapper<std::remove_reference_t<t>>;
 
} // namespace seqan3::detail