flow_memory_algorithm.h

Go to the documentation of this file.

#pragma once
#include <cassert>
#include <iterator>
#include <memory>
 
namespace flow {

  template <typename AllocatorType, std::input_iterator InputIt, std::forward_iterator OutputIt>
  OutputIt uninitializedForward(AllocatorType& allocator, InputIt first, InputIt last, OutputIt dest) {
    for (; first != last; ++first, ++dest) {
      std::allocator_traits<AllocatorType>::construct(allocator, std::addressof(*dest), *first);
    }
    return dest;
  }

  template <typename AllocatorType, std::input_iterator InputIt, std::forward_iterator OutputIt>
  OutputIt uninitializedMove(AllocatorType& allocator, InputIt first, InputIt last, OutputIt dest) noexcept {
    return uninitializedForward(allocator, std::move_iterator(first), std::move_iterator(last), dest);
  }

  template <typename AllocatorType, std::forward_iterator OutputIt, typename ...Args>
  OutputIt uninitializedEmplace(AllocatorType& allocator, OutputIt first, OutputIt last, const Args&... args) {
    for (; first != last; ++first) {
      std::allocator_traits<AllocatorType>::construct(allocator, std::addressof(*first), args...);
    }
    return first;
  }

  template <typename AllocatorType, std::forward_iterator OutputIt, typename T>
  OutputIt uninitializedFill(AllocatorType& allocator, OutputIt first, OutputIt last, const T& value) {
    return uninitializedEmplace(allocator, first, last, value);
  }

  template <typename AllocatorType, std::forward_iterator InputIt>
  void destroyElements(AllocatorType& allocator, InputIt first, InputIt last) noexcept {
    for (; first != last; ++first) {
      std::allocator_traits<AllocatorType>::destroy(allocator, std::addressof(*first));
    }
  }

  template <typename AllocatorType, std::input_iterator InputIt, std::forward_iterator OutputIt>
  OutputIt uninitializedForwardN(AllocatorType& allocator, InputIt first, std::size_t count, OutputIt dest) {
    for (std::size_t i = 0; i < count; ++i, ++first, ++dest) {
      std::allocator_traits<AllocatorType>::construct(allocator, std::addressof(*dest), *first);
    }
    return dest;
  }

  template <typename AllocatorType, std::input_iterator InputIt, std::forward_iterator OutputIt>
  OutputIt uninitializedMoveN(AllocatorType& allocator, InputIt first, std::size_t count, OutputIt dest) noexcept {
    return uninitializedForwardN(allocator, std::move_iterator(first), count, dest);
  }

  template <typename AllocatorType, std::forward_iterator OutputIt, typename ...Args>
  OutputIt uninitializedEmplaceN(AllocatorType& allocator, OutputIt first, std::size_t count, const Args&... args) {
    for (std::size_t i = 0; i < count; ++i, ++first) {
      std::allocator_traits<AllocatorType>::construct(allocator, std::addressof(*first), args...);
    }
    return first;
  }

  template <typename AllocatorType, std::forward_iterator OutputIt, typename T>
  OutputIt uninitializedFillN(AllocatorType& allocator, OutputIt first, std::size_t count, const T& value) {
    return uninitializedEmplaceN(allocator, first, count, value);
  }

  template <typename AllocatorType, std::forward_iterator InputIt>
  void destroyElementsN(AllocatorType& allocator, InputIt first, std::size_t count) noexcept {
    for (std::size_t i = 0; i < count; ++i, ++first) {
      std::allocator_traits<AllocatorType>::destroy(allocator, std::addressof(*first));
    }
  }

  template <typename AllocatorType, typename T>
  void deleteBuffer(AllocatorType& allocator, T* buffer, std::size_t size, std::size_t capacity) noexcept {
    destroyElementsN(allocator, buffer, size);
    std::allocator_traits<AllocatorType>::deallocate(allocator, buffer, capacity);
  }

  template <typename T, typename U>
  std::size_t pointerDistance(const T* first, const U* last) {
    assert(first <= last && "first pointer address must be smaller than the last pointer address");
    return reinterpret_cast<const std::byte*>(last) - reinterpret_cast<const std::byte*>(first);
  }

  template <typename Header>
  Header* alignWithHeader(std::size_t alignment, std::size_t size, void*& buffer, std::size_t& capacity) noexcept {
 
    // https://stackoverflow.com/questions/46457449/is-it-always-the-case-that-sizeoft-alignoft-for-all-object-types-t
    assert(size >= alignment && "size is smaller than its alignment");
    if (capacity < sizeof(Header) + size) {
      return nullptr;
    }
 
    // Set the block alignment to be at least as big as the header alignment.
    alignment = std::max(alignment, alignof(Header));
 
    // Reserve at least sizeof(Header) before the allocated block.
    void* allocatedBlock = reinterpret_cast<Header*>(buffer) + 1;
    std::size_t capacityAfterHeader = capacity - sizeof(Header);
    if (!std::align(alignment, size, allocatedBlock, capacityAfterHeader)) {
      return nullptr;
    }
 
    // Calculate the address of the header.
    Header* header = reinterpret_cast<Header*>(allocatedBlock) - 1;
    assert(reinterpret_cast<std::uintptr_t>(header) % alignof(Header) == 0 && "allocated buffer is not aligned with the header");
 
    capacity -= pointerDistance(buffer, header);
    buffer = header;
    return header;
  }
 
}