hxptr.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 "hxkey.hpp"
 
HX_NS_BEGIN_

template<typename T_, typename deleter_t_=hxdefault_delete>
class hxptr : private deleter_t_ {
public:
    // No arrays allowed because there is no delete[] equivalent. Use hxref for
    // pointer and reference types..
    static_assert(!hxis_array<T_>(), "hxptr does not support array types");
    static_assert(!hxis_reference<T_>(), "hxptr does not support reference types");
    static_assert(!hxis_pointer<T_>(), "hxptr does not support pointer types");

    using element_t = T_;

    hxconstexpr explicit hxptr(T_* ptr_=hxnull, deleter_t_ deleter_=deleter_t_()) noexcept;

    hxconstexpr hxptr(hxnil_t) noexcept : hxptr(hxnull) { } // GCOVR_EXCL_LINE. Constant folded.

    hxconstexpr hxptr(hxptr&& x_) noexcept;

    hxconstexpr ~hxptr(void) noexcept;

    hxconstexpr hxptr& operator=(hxptr&& x_) noexcept;

    hxattr_nodiscard hxconstexpr T_& operator*(void) const;

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

    hxattr_nodiscard hxconstexpr explicit operator bool(void) const;

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

    hxattr_nodiscard hxconstexpr bool operator==(hxnil_t) const;
 
#if HX_CPLUSPLUS < 202002L // C++20 defaults != from ==.
    hxattr_nodiscard hxconstexpr bool operator!=(const hxptr& x_) const;

    hxattr_nodiscard hxconstexpr bool operator!=(hxnil_t) const;
#endif
 
#if HX_CPLUSPLUS >= 202302L
    template<typename self_t_, typename callable_t_>
    hxattr_nodiscard hxconstexpr auto and_then(this self_t_&& self_, callable_t_&& callable_)
        -> hxremove_cvref_t<decltype(hxforward<callable_t_>(callable_)(hxdeclval<T_&>()))>;
#endif // HX_CPLUSPLUS >= 202302L

    hxattr_nodiscard hxconstexpr const deleter_t_& deleter(void) const;
 
    hxattr_nodiscard hxconstexpr deleter_t_& deleter(void);

    template<hxsystem_allocator_t allocator_=hxsystem_allocator_current,
        hxalignment_t alignment_=hxalignment, typename... args_t_>
    T_& emplace(args_t_&&... args_) noexcept;

    hxattr_nodiscard hxconstexpr bool equal(const hxptr& x_) const;

    hxattr_nodiscard hxconstexpr T_* get(void) const { return m_ptr_; }

    hxattr_nodiscard hxhash_t hash(void) const;

    hxattr_nodiscard hxconstexpr bool has_value(void) const { return m_ptr_ != hxnull; }
 
#if HX_CPLUSPLUS >= 202302L
    template<typename self_t_, typename callable_t_>
    hxattr_nodiscard hxconstexpr hxptr or_else(
        this self_t_&& self_, callable_t_&& callable_)
        requires(hxis_rvalue_reference<self_t_&&>() &&
            !hxis_const<hxremove_reference_t<self_t_>>());
#endif // HX_CPLUSPLUS >= 202302L

    hxattr_nodiscard hxconstexpr T_* release(void);

    hxconstexpr void reset(T_* ptr_=hxnull) noexcept;

    hxconstexpr void swap(hxptr& x_) noexcept;

    hxattr_nodiscard hxconstexpr T_& value(void) const;
 
#if HX_CPLUSPLUS >= 202302L
    template<typename self_t_, typename... args_t_>
    hxattr_nodiscard hxconstexpr hxremove_cv_t<T_> value_or(
        this self_t_&& self_, args_t_&&... args_);
#endif // HX_CPLUSPLUS >= 202302L
 
private:
    hxptr(const hxptr&) = delete;
    hxptr& operator=(const hxptr&) = delete;
 
    T_* m_ptr_;
};

template<typename T_, typename deleter_t_=hxdefault_delete,
    hxsystem_allocator_t allocator_=hxsystem_allocator_current,
    hxalignment_t align_=hxalignment, typename U_=T_>
hxattr_nodiscard hxptr<T_, deleter_t_> hxmake_ptr(const U_& value_) noexcept {
    return hxptr<T_, deleter_t_>(::new(hxmalloc_ext(sizeof(T_), allocator_, align_)) T_(value_));
}

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

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