/tmp/bitcoin/src/util/not_null.h

Source
// 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 {

/// NotNull is intended to be used to denote that a smart pointer type can not
/// hold a nullptr value.
///
/// The type is more useful, the earlier in the lifetime of a pointer it is
/// used. So instead of passing an existing pointer into NotNull, it is
/// recommended to use the type when creating the smart pointer. E.g.:
///
/// util::NotNull p{std::make_shared<Thing>()};
///
/// This makes it obvious that a pointer really is not null and that the
/// constructor will not fail.
///
/// NotNull does *not* support raw pointers.
/// The C++ language provides raw references for this use case, and the C++
/// standard library provides std::reference_wrapper, where raw references can
/// not be used.
///
/// This type is movable, meaning that the inner pointer *is* null after a
/// move. Clang-tidy static analysis is used to enforce use-after-move
/// violations, so that the null should never be observed. Moreover, the
/// runtime Assume check in the get() member function will ensure the same.
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

Coverage Report

Created: 2026-10-07 13:27