hxutility.h

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"
 
#if HX_CPLUSPLUS
extern "C" {
 
// 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
#endif
 
// -- C Utilities --------------------------------------------------------------

void hxfloat_dump(const float* address_, size_t floats_) hxattr_nonnull(1) hxattr_cold;

void hxhex_dump(const void* address_, size_t bytes_, bool pretty_) hxattr_nonnull(1) hxattr_cold;
 
#if HX_CPLUSPLUS
} // extern "C"
 
HX_NS_BEGIN_
 
// -- C and C++ Utilities ------------------------------------------------------

template<typename T_, hxsize_t N_> hxattr_nodiscard constexpr
hxsize_t hxsize(T_ (&)[N_]) { return N_; }
 
// -- C++ SFINAE ---------------------------------------------------------------
// Substitution Failure Is Not An Error. enable_if checks.

template<bool condition_, typename type_=void> struct hxenable_if_ { };
template<typename type_> struct hxenable_if_<true, type_> { using type = type_; };

template<bool condition_, typename type_=void>
using hxenable_if_t = typename hxenable_if_<condition_, type_>::type;

class hxnullptr_t {
public:
    template<typename T_> constexpr operator T_*() const { return 0; }
    template<typename T_, typename M_> constexpr operator M_ T_::*() const { return 0; }
private:
    // No address-of operator.
    void operator&(void) const = delete;
};

hxinline_constexpr hxnullptr_t hxnullptr{};

template<typename T_> struct hxremove_cv_ { using type = T_; };
template<typename T_> struct hxremove_cv_<const T_> { using type = T_; };
template<typename T_> struct hxremove_cv_<volatile T_> { using type = T_; };
template<typename T_> struct hxremove_cv_<const volatile T_> { using type = T_; };

template<typename T_> using hxremove_cv_t = typename hxremove_cv_<T_>::type;

template<typename T_> struct hxremove_pointer_ { using type = T_; };
template<typename T_> struct hxremove_pointer_<T_*> { using type = T_; };
template<typename T_> struct hxremove_pointer_<T_* const> { using type = T_; };
template<typename T_> struct hxremove_pointer_<T_* volatile> { using type = T_; };
template<typename T_> struct hxremove_pointer_<T_* const volatile> { using type = T_; };

template<typename T_> using hxremove_pointer_t = typename hxremove_pointer_<T_>::type;

template<typename T_> struct hxremove_reference_       { using type = T_; };
template<typename T_> struct hxremove_reference_<T_&>  { using type = T_; };
template<typename T_> struct hxremove_reference_<T_&&> { using type = T_; };

template<typename T_> using hxremove_reference_t = typename hxremove_reference_<T_>::type;

template<typename T_> using hxremove_cvref_t = hxremove_cv_t<hxremove_reference_t<T_>>;

template<typename T_> T_&& hxdeclval(void) noexcept;

struct hxtrue_t { constexpr static bool value = true; };
struct hxfalse_t { constexpr static bool value = false; };

template<typename T_, typename U_>
struct hxbinds_directly {
private:
    static hxtrue_t test_(T_&);
    static hxfalse_t test_(T_&&);
    static hxfalse_t test_(...);
public:
#if defined _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4244 4267)
#endif
    constexpr static bool value = decltype(test_(hxdeclval<U_&>()))::value;
#if defined _MSC_VER
#pragma warning(pop)
#endif
};

template<typename T_> struct hxis_array : public hxfalse_t { };
template<typename T_, size_t size_> struct hxis_array<T_[size_]> : public hxtrue_t { };
template<typename T_> struct hxis_array<T_[]> : public hxtrue_t { };

template<typename T_> struct hxis_const : public hxfalse_t { };
template<typename T_> struct hxis_const<const T_> : public hxtrue_t { };

template<typename T_> struct hxis_floating_point_ : public hxfalse_t { };
template<> struct hxis_floating_point_<float> : public hxtrue_t { };
template<> struct hxis_floating_point_<double> : public hxtrue_t { };
template<> struct hxis_floating_point_<long double> : public hxtrue_t { };

template<typename T_>
struct hxis_floating_point : public hxis_floating_point_<hxremove_cv_t<T_>> { };

template<typename T_> struct hxis_integral_ : public hxfalse_t { };
template<> struct hxis_integral_<bool> : public hxtrue_t { };
template<> struct hxis_integral_<char> : public hxtrue_t { };
template<> struct hxis_integral_<signed char> : public hxtrue_t { };
template<> struct hxis_integral_<unsigned char> : public hxtrue_t { };
template<> struct hxis_integral_<wchar_t> : public hxtrue_t { };
template<> struct hxis_integral_<char16_t> : public hxtrue_t { };
template<> struct hxis_integral_<char32_t> : public hxtrue_t { };
#if HX_CPLUSPLUS >= 202002L
template<> struct hxis_integral_<char8_t> : public hxtrue_t { };
#endif
template<> struct hxis_integral_<short> : public hxtrue_t { };
template<> struct hxis_integral_<unsigned short> : public hxtrue_t { };
template<> struct hxis_integral_<int> : public hxtrue_t { };
template<> struct hxis_integral_<unsigned int> : public hxtrue_t { };
template<> struct hxis_integral_<long> : public hxtrue_t { };
template<> struct hxis_integral_<unsigned long> : public hxtrue_t { };
template<> struct hxis_integral_<long long> : public hxtrue_t { };
template<> struct hxis_integral_<unsigned long long> : public hxtrue_t { };

template<typename T_>
struct hxis_integral : public hxis_integral_<hxremove_cv_t<T_>> { };

template<typename T_> struct hxis_lvalue_reference : public hxfalse_t { };
template<typename T_> struct hxis_lvalue_reference<T_&> : public hxtrue_t { };

template<typename T_> struct hxis_pointer_ : public hxfalse_t { };
template<typename T_> struct hxis_pointer_<T_*> : public hxtrue_t { };

template<typename T> struct hxis_pointer : hxis_pointer_<hxremove_cv_t<T>> { };

template<typename T_> struct hxis_reference : public hxfalse_t { };
template<typename T_> struct hxis_reference<T_&>  : public hxtrue_t { };
template<typename T_> struct hxis_reference<T_&&> : public hxtrue_t { };

template<typename T_> struct hxis_rvalue_reference : public hxfalse_t { };
template<typename T_> struct hxis_rvalue_reference<T_&&> : public hxtrue_t { };

template<typename A_, typename B_> struct hxis_same : public hxfalse_t { };
template<typename A_> struct hxis_same<A_, A_> : public hxtrue_t { };

template<typename T_> struct hxis_void_ : public hxfalse_t { };
template<> struct hxis_void_<void> : public hxtrue_t { };

template<typename T_> struct hxis_void : public hxis_void_<hxremove_cv_t<T_>> { };

template<typename T_> struct hxrestrict_t_ { using type = T_; };
template<typename T_> struct hxrestrict_t_<T_*> { using type = T_* hxrestrict; };
template<typename T_> struct hxrestrict_t_<T_* const> { using type = T_* const hxrestrict; };

template<typename T_> using hxrestrict_t = typename hxrestrict_t_<T_>::type;

hxattr_nodiscard constexpr bool hxisgraph(char ch_) {
    return ((static_cast<unsigned char>(ch_) - 0x21u) < 0x5eu)
        || ((static_cast<unsigned char>(ch_) & 0x80u) != 0u);
}

hxattr_nodiscard constexpr bool hxisspace(char ch_) {
    return ch_ == ' ' || (static_cast<unsigned char>(ch_) - 0x09u) < 0x05u;
}

hxattr_nodiscard hxinline int hxlog2i(uint32_t i_) {
#if defined _MSC_VER
    unsigned long index_ = 0ul;
    ::_BitScanReverse(&index_, i_);
    return static_cast<int>(index_);
#elif defined __GNUC__ || defined __clang__
    return 31 - __builtin_clz(i_);
#else
    float f_ = static_cast<float>(i_);
    uint32_t bits_ = 0u; ::memcpy(&bits_, &f_, sizeof f_);
    return static_cast<int>((bits_ >> 23) & 0xffu) - 127;
#endif
}

template<typename T_>
hxattr_nodiscard constexpr T_ hxabs(T_ x_) { return (x_ < T_()) ? (T_() - x_) : x_; }

template<typename T_>
hxattr_nodiscard constexpr T_ hxclamp(T_ x_, T_ minimum_, T_ maximum_) {
#if HX_CPLUSPLUS >= 201402L
    hxassertmsg(!(maximum_ < minimum_), "minimum <= maximum");
#endif
    return (x_ < minimum_) ? minimum_ : ((maximum_ < x_) ? maximum_ : x_);
}

template<typename T_>
constexpr T_&& hxforward(hxremove_reference_t<T_>&& x_) {
    static_assert(!hxis_lvalue_reference<T_>::value, "T must be a `T&&` reference");
    return static_cast<T_&&>(x_);
}

template<typename T_>
constexpr T_&& hxforward(hxremove_reference_t<T_>& x_) {
    return static_cast<T_&&>(x_);
}

template<typename T_>
hxattr_nodiscard constexpr T_ hxmax(T_ x_, T_ y_) { return (y_ < x_) ? x_ : y_; }

template<typename T_>
hxattr_nodiscard constexpr T_ hxmin(T_ x_, T_ y_) { return (x_ < y_) ? x_ : y_; }

template<typename T_>
constexpr hxremove_reference_t<T_>&& hxmove(T_&& t_) {
    return static_cast<hxremove_reference_t<T_>&&>(t_);
}

template<typename T_>
hxconstexpr void hxswap(T_& x_, T_& y_) {
    // Provides an optimization hint.
    hxassertmsg(&x_ != &y_, "hxswap No swapping with self");
    T_ t_(hxmove(x_));
    x_ = hxmove(y_);
    y_ = hxmove(t_);
}

template<typename T_>
void hxswap_memcpy(T_& x_, T_& y_) {
    hxassertmsg(&x_ != &y_, "hxswap_memcpy No swapping with self");
    char t_[sizeof x_];
    ::memcpy(t_, &y_, sizeof x_); // NOLINT(bugprone-undefined-memory-manipulation)
    ::memcpy(static_cast<void*>(&y_), &x_, sizeof x_); // NOLINT(bugprone-undefined-memory-manipulation)
    ::memcpy(static_cast<void*>(&x_), t_, sizeof x_); // NOLINT(bugprone-undefined-memory-manipulation)
}
 
HX_NS_END_
#else // !HX_CPLUSPLUS
 
// -- C Macro Utility API - Does it all backwards in heels --------------------

#define hxsize(x_) (sizeof(x_) / sizeof(x_)[0])

#define hxabs(x_) ((x_) < 0 ? (0 - (x_)) : (x_))

#define hxclamp(x_, minimum_, maximum_) \
    ((x_) < (minimum_) ? (minimum_) : ((maximum_) < (x_) ? (maximum_) : (x_)))

#define hxmax(x_, y_) ((y_) < (x_) ? (x_) : (y_))

#define hxmin(x_, y_) ((x_) < (y_) ? (x_) : (y_))

#define hxswap_memcpy(x_,y_) do { \
    char t_[sizeof(x_) == sizeof(y_) ? (int)sizeof(x_) : -1]; \
    memcpy(t_, &(y_), sizeof(x_)); \
    memcpy(&(y_), &(x_), sizeof(x_)); \
    memcpy(&(x_), t_, sizeof(x_)); } while(0)
 
#endif // !HX_CPLUSPLUS