Method append

app/src/IO/CircularBuffer.h:193–230

 */
template<typename T, Concepts::ByteLike StorageType>
void IO::CircularBuffer<T, StorageType>::append(const T& data)
{
  const qsizetype dataSize = data.size();
  if (dataSize == 0) [[unlikely]]
    return;

  const uint8_t* src = reinterpret_cast<const uint8_t*>(data.data());

  qsizetype copySize = dataSize;
  if (copySize > m_capacity) [[unlikely]] {
    src      += (copySize - m_capacity);
    copySize  = m_capacity;
    m_overflowCount.fetch_add(dataSize - m_capacity, std::memory_order_relaxed);
  }

  const qsizetype head = m_head.load(std::memory_order_acquire);
  const qsizetype tail = m_tail.load(std::memory_order_relaxed);

  qsizetype current_size = (tail >= head) ? (tail - head) : (m_capacity - head + tail);
  qsizetype free_space   = m_capacity - current_size;

  if (copySize > free_space) [[unlikely]] {
    const qsizetype overwrite = copySize - free_space;
    m_overflowCount.fetch_add(overwrite, std::memory_order_relaxed);

    const qsizetype new_head = (head + overwrite) & m_capacityMask;
    m_head.store(new_head, std::memory_order_release);
  }

  const qsizetype firstChunk = std::min(copySize, m_capacity - tail);
  std::memcpy(&m_buffer[tail], src, firstChunk);

  if (copySize > firstChunk) [[unlikely]]
    std::memcpy(&m_buffer[0], src + firstChunk, copySize - firstChunk);

  const qsizetype new_tail = (tail + copySize) & m_capacityMask;
  m_tail.store(new_tail, std::memory_order_release);
}

/**
 * @brief Clears the buffer and modifies its maximum capacity.