memory.hpp

// Copyright Take Vos 2019-2021.
// 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 "required.hpp"
#include "assert.hpp"
#include <concepts>
#include <memory>
#include <vector>
#include <map>
#include <unordered_map>
#include <type_traits>
#include <string.h>
 
hi_warning_push();
// C26474: Don't cast between pointer types when the conversion could be implicit (type.1).
// False positive, template with potential two different pointer types.
hi_warning_ignore_msvc(26474);
 
namespace hi::inline v1 {
 
[[nodiscard]] bool equal_ptr(auto *p1, auto *p2) noexcept
{
    return static_cast<void *>(p1) == static_cast<void *>(p2);
}
 
template<typename T, typename U>
void memswap(T& dst, U& src)
{
    static_assert(sizeof(T) == sizeof(U), "memswap requires both objects of equal size");
    std::byte tmp[sizeof(T)];
    memcpy(tmp, &src, sizeof(T));
    memcpy(&src, &dst, sizeof(U));
    memcpy(&dst, tmp, sizeof(T));
}
 
template<typename InputIt, typename T>
T *placement_copy(InputIt src, T *dst)
{
    hi_axiom(dst != nullptr);
    return new (dst) T(*src);
}
 
template<typename InputIt, typename T>
void placement_copy(InputIt src_first, InputIt src_last, T *dst_first)
{
    hi_axiom(src_first != dst_first);
    hi_axiom(src_last >= src_first);
 
    auto src = src_first;
    auto dst = dst_first;
    while (src != src_last) {
        placement_copy(src++, dst++);
    }
}
 
template<typename T>
T *placement_move(T *src, T *dst)
{
    hi_axiom(src != nullptr);
    hi_axiom(dst != nullptr);
 
    auto dst_ = new (dst) T(std::move(*src));
    std::destroy_at(src);
    return dst_;
}
 
template<typename T>
void placement_move_within_array(T *src_first, T *src_last, T *dst_first)
{
    hi_axiom(src_last >= src_first);
 
    if (src_first < dst_first) {
        auto dst_last = dst_first + (src_last - src_first);
 
        auto src = src_last;
        auto dst = dst_last;
        while (src != src_first) {
            placement_move(--src, --dst);
        }
 
    } else if (src_first > dst_first) {
        auto src = src_first;
        auto dst = dst_first;
        while (src != src_last) {
            placement_move(src++, dst++);
        }
 
    } else {
        // When src_first and dst_first are equal then no movement is necessary.
        ;
    }
}
 
template<typename T>
void placement_move(T *src, T *src_last, T *dst)
{
    hi_axiom(src_last >= src);
 
    while (src != src_last) {
        placement_move(src++, dst++);
    }
}
 
template<typename It, typename... Args>
void construct(It first, It last, Args const&...args)
{
    for (auto it = first; it != last; ++it) {
        std::construct_at(std::addressof(*it), args...);
    }
}
 
template<typename T>
constexpr bool is_aligned(T *p)
{
    return (reinterpret_cast<ptrdiff_t>(p) % std::alignment_of<T>::value) == 0;
}
 
template<std::unsigned_integral T>
constexpr T floor(T value, T alignment) noexcept
{
    return (value / alignment) * alignment;
}
 
template<std::unsigned_integral T>
constexpr T ceil(T value, T alignment) noexcept
{
    return floor(value + (alignment - 1), alignment);
}
 
template<typename T>
constexpr T *ceil(T *ptr, std::size_t alignment) noexcept
{
    hilet aligned_byte_offset = ceil(reinterpret_cast<uintptr_t>(ptr), static_cast<uintptr_t>(alignment));
    return reinterpret_cast<T *>(aligned_byte_offset);
}
 
template<typename T>
constexpr T *floor(T *ptr, std::size_t alignment) noexcept
{
    hilet aligned_byte_offset = floor(reinterpret_cast<uintptr_t>(ptr), static_cast<uintptr_t>(alignment));
    return reinterpret_cast<T *>(aligned_byte_offset);
}
 
inline void *advance_bytes(void *ptr, std::ptrdiff_t distance) noexcept
{
    hi_axiom(ptr != nullptr);
    return static_cast<char *>(ptr) + distance;
}
 
inline void const *advance_bytes(void const *ptr, std::ptrdiff_t distance) noexcept
{
    hi_axiom(ptr != nullptr);
    return static_cast<char const *>(ptr) + distance;
}
 
template<typename T>
inline void cleanupWeakPointers(std::vector<std::weak_ptr<T>>& v) noexcept
{
    auto i = v.begin();
    while (i != v.end()) {
        if (i->expired()) {
            i = v.erase(i);
        } else {
            i++;
        }
    }
}
 
template<typename K, typename T>
inline void cleanupWeakPointers(std::unordered_map<K, std::weak_ptr<T>>& v) noexcept
{
    auto i = v.begin();
    while (i != v.end()) {
        if (i->second.expired()) {
            i = v.erase(i);
        } else {
            i++;
        }
    }
}
 
template<typename K, typename T>
inline void cleanupWeakPointers(std::unordered_map<K, std::vector<std::weak_ptr<T>>>& v) noexcept
{
    auto i = v.begin();
    while (i != v.end()) {
        cleanupWeakPointers(i->second);
        if (i->second.size() == 0) {
            i = v.erase(i);
        } else {
            i++;
        }
    }
}
 
template<typename Value, typename Map, typename Key, typename... Args>
inline std::shared_ptr<Value> try_make_shared(Map& map, Key key, Args... args)
{
    std::shared_ptr<Value> value;
 
    hilet i = map.find(key);
    if (i == map.end()) {
        value = std::make_shared<Value>(std::forward<Args>(args)...);
        map.insert_or_assign(key, value);
    } else {
        value = i->second;
    }
    return value;
}
 
} // namespace hi::inline v1
 
hi_warning_pop();