not_null.h

Go to the documentation of this file.

// Copyright (c) The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or https://opensource.org/license/mit/.
 
#ifndef BITCOIN_UTIL_NOT_NULL_H
#define BITCOIN_UTIL_NOT_NULL_H
 
#include <attributes.h>
#include <util/check.h>
 
#include <compare>
#include <concepts>
#include <cstddef>
#include <functional>
#include <memory>
#include <type_traits>
#include <utility>
 
namespace util {
 
template <class T>
    requires std::is_class_v<T> && requires(T t) { { t != nullptr } -> std::convertible_to<bool>; }
class NotNull
{
public:
    template <std::convertible_to<T> U>
        requires(!std::same_as<std::remove_cvref_t<U>, NotNull>)
    constexpr explicit NotNull(U&& u) noexcept(std::is_nothrow_constructible_v<T, U&&>)
        : m_ptr(std::forward<U>(u))
    {
        Assert(m_ptr != nullptr);
    }
 
    template <class U>
        requires std::move_constructible<U> && std::constructible_from<T, U&&>
    constexpr explicit(!std::convertible_to<U, T>)
        NotNull(NotNull<U>&& other) noexcept(std::is_nothrow_move_constructible_v<U> && std::is_nothrow_constructible_v<T, U&&>)
        : m_ptr(std::move(other).get())
    {
        Assume(m_ptr != nullptr);
    }
 
    template <class U>
        requires std::convertible_to<const U&, T>
    constexpr NotNull(const NotNull<U>& other) noexcept(std::is_nothrow_constructible_v<T, const U&>)
        : m_ptr(other.get())
    {
        Assume(m_ptr != nullptr);
    }
 
    NotNull(std::nullptr_t) = delete;
    NotNull& operator=(std::nullptr_t) = delete;
 
    constexpr NotNull(NotNull&&) = default;
    constexpr NotNull& operator=(NotNull&&) = default;
    constexpr NotNull(const NotNull&) = default;
    constexpr NotNull& operator=(const NotNull&) = default;
 
    constexpr const T& get() const& noexcept LIFETIMEBOUND { return Assume(m_ptr); }
    constexpr T get() && noexcept(std::is_nothrow_move_constructible_v<T>)
        requires std::move_constructible<T>
    {
        return std::move(Assume(m_ptr));
    }
 
    constexpr decltype(auto) operator->() const LIFETIMEBOUND { return get(); }
    constexpr decltype(auto) operator*() const LIFETIMEBOUND { return *get(); }
 
    constexpr operator T() const& noexcept(std::is_nothrow_copy_constructible_v<T>)
        requires std::copy_constructible<T>
    {
        return get();
    }
    constexpr operator T() && noexcept(std::is_nothrow_move_constructible_v<T>)
        requires std::move_constructible<T>
    {
        return std::move(*this).get();
    }
 
    template <class U>
    constexpr auto operator<=>(const NotNull<U>& other) const
    {
        return std::compare_three_way{}(get(), other.get());
    }
    template <class U>
    constexpr bool operator==(const NotNull<U>& other) const
    {
        return get() == other.get();
    }
 
private:
    T m_ptr;
};
 
template <class T>
NotNull(T) -> NotNull<T>;
 
template <typename T, typename Deleter = std::default_delete<T>>
using NotNullUniquePtr = NotNull<std::unique_ptr<T, Deleter>>;
 
template <typename T>
using NotNullSharedPtr = NotNull<std::shared_ptr<T>>;
 
} // namespace util
 
template <class T>
struct std::hash<util::NotNull<T>> {
    std::size_t operator()(const util::NotNull<T>& v) const noexcept
    {
        return std::hash<T>{}(v.get());
    }
};
 
#endif // BITCOIN_UTIL_NOT_NULL_H