hxref.hpp

Go to the documentation of this file.

#pragma once
// SPDX-FileCopyrightText: © 2017-2026 Adrian Johnston.
// SPDX-License-Identifier: MIT
// This file is licensed under the MIT license found in the LICENSE.md file.

 
#include "libhatchet.h"
 
static_assert(HX_CPLUSPLUS >= 202302L, "hxref.hpp requires C++23");
 
// HX_USE_MACROS_WITH_MODULE allows including macros alongside the module.
#if HX_USE_MACROS_WITH_MODULE
#error Header does not provide macros alone.
#endif
 
#include "hxexpected.hpp"
 
HX_NS_BEGIN_

template<typename T_> class hxref;
 
// Used to prevent the lvalue binding constructor from hijacking converting
// construction paths.
template<typename> struct hxis_hxref_ : hxfalse_t { };
template<typename U_> struct hxis_hxref_<hxref<U_>> : hxtrue_t { };

template<typename T_>
class hxref {
public:
    // Use hxremove_reference_t<T> if needed.
    static_assert(!hxis_reference<T_>(), "hxref does not support reference types");

    using value_t = T_&;

    hxref(void) : m_value_(hxnull) { }

    hxref(hxnil_t) : m_value_(hxnull) { }

    template<typename U_, hxenable_if_t<
        !hxis_hxref_<hxremove_cvref_t<U_>>::value &&
        !hxis_hxexpected_<hxremove_cvref_t<U_>>::value &&
        hxbinds_directly<T_, U_>(), bool> = true>
    hxref(U_& value_);

    template<typename E_>
    hxref(hxexpected<T_, E_>& x_);

    hxattr_nodiscard T_& operator*(void) const;

    hxattr_nodiscard T_* operator->(void) const;

    hxattr_nodiscard explicit operator bool(void) const { return m_value_ != hxnull; }

    hxref& operator=(hxnil_t) { m_value_ = hxnull; return *this; }

    template<typename U_, hxenable_if_t<
        !hxis_hxref_<hxremove_cvref_t<U_>>::value &&
        !hxis_hxexpected_<hxremove_cvref_t<U_>>::value &&
        hxbinds_directly<T_, U_>(), bool> = true>
    hxref& operator=(U_& value_);

    hxattr_nodiscard bool operator==(const hxref& x_) const { return this->equal(x_); }

    hxattr_nodiscard bool operator==(hxnil_t) const { return m_value_ == hxnull; }

    hxattr_nodiscard bool operator==(const T_& value_) const;

    template<typename self_t_, typename callable_t_>
    hxattr_nodiscard auto and_then(this self_t_&& self_, callable_t_&& callable_)
        -> hxremove_cvref_t<decltype(hxforward<callable_t_>(callable_)(hxdeclval<T_&>()))>;

    hxattr_nodiscard bool equal(const hxref& x_) const;

    hxattr_nodiscard bool has_value(void) const { return m_value_ != hxnull; }

    hxattr_nodiscard hxhash_t hash(void) const;

    template<typename self_t_, typename callable_t_>
    hxattr_nodiscard hxref or_else(this self_t_&& self_, callable_t_&& callable_);

    void reset(void) { m_value_ = hxnull; }

    void swap(hxref& x_) noexcept;

    hxattr_nodiscard T_& value(void) const;

    template<typename self_t_, typename... args_t_>
    hxattr_nodiscard hxremove_cv_t<T_> value_or(
        this self_t_&& self_, args_t_&&... args_);
 
private:
    T_* m_value_;
};

template<typename T_, typename U_=T_, hxenable_if_t<hxbinds_directly<T_, U_>(), bool> = true>
hxattr_nodiscard hxref<T_> hxmake_ref(U_& value_) { return hxref<T_>(value_); }

template<typename T_>
class hxkey_equal_t<hxref<T_> > {
public:
    hxattr_nodiscard hxinline hxattr_flatten
    bool operator()(
            const hxref<T_>& x_, const hxref<T_>& y_) const {
        return x_.equal(y_);
    }
};

template<typename T_>
class hxkey_hash_t<hxref<T_> > {
public:
    hxattr_nodiscard hxinline hxattr_flatten
    hxhash_t operator()(const hxref<T_>& ref_) const {
        return ref_.hash();
    }
};
 
#include "detail/hxref.inl"
HX_NS_END_