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"
 
// 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 "hxoptional.hpp"
 
HX_NS_BEGIN_

template<typename T_> class hxref;
 
namespace hxdetail_ {
// 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_>::value, "hxref does not support reference types");

    using value_type = T_&;

    hxref(void) : m_value_(hxnull) { }

    hxref(hxnullopt_t) : m_value_(hxnull) { }

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

    template<typename U_, hxenable_if_t<
        !hxis_same<U_, T_>::value, bool> = true>
    hxref(const hxref<U_>& other_);

    template<typename U_>
    hxref(hxoptional<U_>& other_);

    hxattr_nodiscard T_& operator*(void) const;

    hxattr_nodiscard T_* operator->(void) const;

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

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

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

    hxattr_nodiscard bool operator==(const hxref& rhs_) const;

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

    hxattr_nodiscard bool operator==(const T_& value_) const;
 
#if HX_CPLUSPLUS < 202002L // C++20 defaults != from ==.
    hxattr_nodiscard bool operator!=(const hxref& rhs_) const { return !(*this == rhs_); }

    hxattr_nodiscard bool operator!=(hxnullopt_t nullopt_) const { return !(*this == nullopt_); }

    hxattr_nodiscard bool operator!=(const T_& value_) const { return !(*this == value_); }
#endif

    template<typename function_t_>
    hxattr_nodiscard auto and_then(function_t_&& callable_) const
        -> hxremove_cvref_t<decltype(hxforward<function_t_>(callable_)(hxdeclval<T_&>()))>;

    template<typename U_>
    T_& emplace(U_& value_);

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

    template<typename function_t_>
    hxattr_nodiscard hxref or_else(function_t_&& callable_) const;

    void reset(void) { m_value_ = hxnull; }

    void swap(hxref& other_) noexcept;

    hxattr_nodiscard T_& value(void) const;

    template<typename U_=hxremove_cv_t<T_>>
    hxattr_nodiscard hxremove_cv_t<T_> value_or(U_&& default_value_) const;
 
private:
    T_* m_value_;
};

template<typename T_>
hxattr_nodiscard hxhash_t hxkey_hash(const hxref<T_>& ref_) {
    return ref_.has_value() ? hxkey_hash(*ref_) : hxhash_t{1u};
}
 
#include "detail/hxref.inl"
HX_NS_END_