hxoptional.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 "hxutility.h"
#include "hxkey.hpp"
 
HX_NS_BEGIN_

template<typename T_> class hxoptional;
 
namespace hxdetail_ {
// Used to prevent forwarding constructors from hijacking converting-copy
// construction paths.
template<typename> struct hxis_hxoptional_ : hxfalse_t { };
template<typename U_> struct hxis_hxoptional_<hxoptional<U_>> : hxtrue_t { };
}

struct hxnullopt_t {
    // GCOVR_EXCL_START
    explicit constexpr hxnullopt_t(int) { }
    // GCOVR_EXCL_STOP
};

hxinline_constexpr hxnullopt_t hxnullopt{0};

template<typename T_>
class hxoptional {
public:
    // These are for safety. Use hxref for pointer and reference types.
    static_assert(!hxis_reference<T_>::value, "hxoptional does not support reference types");
    static_assert(!hxis_pointer<T_>::value, "hxoptional does not support pointer types");

    using value_type = T_;

    hxoptional(void) : m_engaged_(false) { }

    hxoptional(hxnullopt_t) : m_engaged_(false) { }

    hxoptional(const hxoptional& other_) noexcept;

    hxoptional(hxoptional&& other_) noexcept;

    template<typename U_>
    hxoptional(const hxoptional<U_>& other_) noexcept;

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

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

    ~hxoptional(void) { reset(); }

    hxattr_nodiscard T_& operator*(void);

    hxattr_nodiscard const T_& operator*(void) const;

    hxattr_nodiscard T_* operator->(void);

    hxattr_nodiscard const T_* operator->(void) const;

    hxattr_nodiscard operator bool(void) const { return m_engaged_; }

    hxoptional& operator=(const hxoptional& other_) noexcept;

    hxoptional& operator=(hxoptional&& other_) noexcept;

    hxoptional& operator=(hxnullopt_t) { reset(); return *this; }

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

    template<typename U_>
    hxoptional& operator=(const hxoptional<U_>& other_) noexcept;

    template<typename U_>
    hxoptional& operator=(hxoptional<U_>&& other_) noexcept;

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

    hxattr_nodiscard bool operator==(hxnullopt_t) const { return !m_engaged_; }

    hxattr_nodiscard bool operator==(const T_& value_) const;
 
#if HX_CPLUSPLUS < 202002L // C++20 defaults != from ==.
    hxattr_nodiscard bool operator!=(const hxoptional& 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_)
        -> hxremove_cvref_t<decltype(hxforward<function_t_>(callable_)(hxdeclval<T_&>()))>;

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

    template<typename... args_t_>
    T_& emplace(args_t_&&... args_) noexcept;

    hxattr_nodiscard bool has_value(void) const { return m_engaged_; }

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

    void reset(void) noexcept;

    void swap(hxoptional& other_) noexcept;

    hxattr_nodiscard T_& value(void);

    hxattr_nodiscard const T_& value(void) const;

    template<typename U_=T_>
    hxattr_nodiscard T_ value_or(U_&& default_value_) const;
 
private:
    alignas(T_) char m_storage_[sizeof(T_)];
    bool m_engaged_;
};

template<typename T_>
hxattr_nodiscard hxoptional<hxremove_cvref_t<T_>> hxmake_optional(T_&& value_) {
    return hxoptional<hxremove_cvref_t<T_>>(hxforward<T_>(value_));
}

template<typename T_, typename... args_t_>
hxattr_nodiscard hxoptional<T_> hxmake_optional(args_t_&&... args_) {
    hxoptional<T_> result_;
    result_.emplace(hxforward<args_t_>(args_)...);
    return result_;
}

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