misc.hpp

// Copyright Take Vos 2021-2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "../macros.hpp"
#include <utility>
#include <cstddef>
#include <string>
#include <chrono>
#include <atomic>
#include <string_view>
 
hi_export_module(hikogui.utility.misc);
 
hi_warning_push();
// C26472: Don't use static_cast for arithmetic conversions, Use brace initialization, gsl::narrow_cast or gsl::narrow (type.1).
// We do not have access to narrow_cast in this file.
hi_warning_ignore_msvc(26472);
 
hi_export namespace hi {
inline namespace v1 {
 
using ssize_t = std::ptrdiff_t;
 
constexpr std::size_t operator""_uz(unsigned long long lhs) noexcept
{
    return static_cast<std::size_t>(lhs);
}
 
constexpr std::size_t operator""_zu(unsigned long long lhs) noexcept
{
    return static_cast<std::size_t>(lhs);
}
 
constexpr std::ptrdiff_t operator""_z(unsigned long long lhs) noexcept
{
    return static_cast<std::ptrdiff_t>(lhs);
}
 
template<typename T, typename U>
[[nodiscard]] bool compare_store(T& lhs, U&& rhs) noexcept
{
    if (lhs != rhs) {
        lhs = std::forward<U>(rhs);
        return true;
    } else {
        return false;
    }
}
 
template<typename T, typename U>
[[nodiscard]] bool compare_store(std::atomic<T>& lhs, U&& rhs) noexcept
{
    return lhs.exchange(rhs, std::memory_order::relaxed) != rhs;
}
 
struct unusable_t {
    unusable_t() = delete;
    ~unusable_t() = delete;
    unusable_t(unusable_t const&) = delete;
    unusable_t(unusable_t&&) = delete;
    unusable_t& operator=(unusable_t const&) = delete;
    unusable_t& operator=(unusable_t&&) = delete;
};
 
template<class T, class U>
[[nodiscard]] constexpr auto&& forward_like(U&& x) noexcept
{
    constexpr bool is_adding_const = std::is_const_v<std::remove_reference_t<T>>;
    if constexpr (std::is_lvalue_reference_v<T&&>) {
        if constexpr (is_adding_const) {
            return std::as_const(x);
        } else {
            return static_cast<U&>(x);
        }
    } else {
        if constexpr (is_adding_const) {
            return std::move(std::as_const(x));
        } else {
            return std::move(x);
        }
    }
}
 
template<typename CharT, typename Traits = std::char_traits<CharT>>
[[nodiscard]] inline std::basic_string<CharT, Traits> getline(std::basic_istream<CharT, Traits>& in, size_t max_size) noexcept
{
    auto r = std::basic_string<CharT, Traits>{};
 
    while (r.size() < max_size) {
        auto c = in.get();
        if (c == Traits::eof()) {
            break;
 
        } else if (c == '\r') {
            c = in.get();
            if (c != '\n') {
                in.unget();
            }
            break;
 
        } else if (c == '\n') {
            break;
        }
 
        r += Traits::to_char_type(c);
    }
 
    return r;
}
 
[[nodiscard]] constexpr size_t count(std::string_view haystack, std::string_view needle) noexcept
{
    auto count = 0_uz;
    auto pos = 0_uz;
 
    while (true) {
        auto i = haystack.find(needle, pos);
        if (i == haystack.npos) {
            return count;
        }
 
        ++count;
        pos = i + needle.size();
    }
}
 
[[nodiscard]] constexpr std::string replace(std::string haystack, std::string_view needle, std::string_view replace) noexcept
{
    auto pos = 0_uz;
 
    while (true) {
        auto i = haystack.find(needle, pos);
        if (i == haystack.npos) {
            return haystack;
        }
 
        haystack.replace(i, needle.size(), replace);
        pos = i + replace.size();
    }
}
 
} // namespace v1
} // namespace hi::v1
 
hi_warning_pop();