Martin Slachta
127 lines
3.4 KiB
C++
127 lines
3.4 KiB
C++
#pragma once
|
|
|
|
#include <cstring>
|
|
#include <optional>
|
|
#include <span>
|
|
#include <spdlog/spdlog.h>
|
|
#include <vector>
|
|
|
|
namespace tw::net {
|
|
|
|
/**
|
|
* Circular byte buffer.
|
|
*/
|
|
class RingByteBuffer {
|
|
public:
|
|
RingByteBuffer(std::span<std::byte> target, bool is_for_reading) : buffer(target), writeOffset(is_for_reading ? target.size() : 0) {}
|
|
|
|
size_t peek_bytes(void* dst, size_t size, size_t offset = 0) {
|
|
if(remaining_read() - offset < size) {
|
|
return 0;
|
|
}
|
|
|
|
size_t cursor = (readOffset + offset) % buffer.size();
|
|
|
|
if(cursor + size <= buffer.size()) {
|
|
std::memcpy(dst, buffer.data() + cursor, size);
|
|
} else {
|
|
size_t firstPart = buffer.size() - cursor;
|
|
std::memcpy(dst, buffer.data() + cursor, firstPart);
|
|
std::memcpy((std::byte*)dst + firstPart, buffer.data(), size - firstPart);
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
template<typename T>
|
|
size_t pop_bytes(T* dst) {
|
|
return pop_bytes(dst, sizeof(T));
|
|
}
|
|
|
|
size_t pop_bytes(void* dst, size_t size) {
|
|
size_t peeked = peek_bytes(dst, size);
|
|
if(peeked < size) {
|
|
return 0;
|
|
}
|
|
|
|
skip(size);
|
|
return size;
|
|
}
|
|
|
|
size_t pop_bytes(std::span<std::byte> dst) {
|
|
return pop_bytes(dst.data(), dst.size());
|
|
}
|
|
|
|
template<typename T>
|
|
size_t write_bytes(const T *data) {
|
|
return write_bytes((void*)data, sizeof(T));
|
|
}
|
|
|
|
size_t write_bytes(void* data, size_t size) {
|
|
return write_bytes(std::span<const std::byte>{(std::byte*)data, (std::byte*)data + size});
|
|
}
|
|
|
|
size_t write_bytes(std::span<const std::byte> data) {
|
|
if(remaining_write() < data.size()) {
|
|
return 0;
|
|
}
|
|
|
|
if(writeOffset + data.size() <= buffer.size()) {
|
|
std::memcpy(buffer.data() + writeOffset, data.data(), data.size());
|
|
writeOffset += data.size();
|
|
} else {
|
|
size_t firstPart = buffer.size() - writeOffset;
|
|
std::memcpy(buffer.data() + writeOffset, data.data(), firstPart);
|
|
std::memcpy(buffer.data(), data.data() + firstPart, data.size() - firstPart);
|
|
writeOffset = (writeOffset + data.size()) % buffer.size();
|
|
}
|
|
|
|
return data.size();
|
|
}
|
|
|
|
size_t remaining_write() const {
|
|
if(writeOffset >= readOffset) {
|
|
return buffer.size() - writeOffset + readOffset;
|
|
} else {
|
|
return readOffset - writeOffset;
|
|
}
|
|
}
|
|
|
|
size_t remaining_read() const {
|
|
if(writeOffset >= readOffset) {
|
|
return writeOffset - readOffset;
|
|
}
|
|
|
|
return buffer.size() - readOffset + writeOffset;
|
|
}
|
|
|
|
void reset() {
|
|
readOffset = 0;
|
|
writeOffset = 0;
|
|
}
|
|
|
|
void skip(size_t bytes) {
|
|
readOffset = (readOffset + std::min(bytes, remaining_read())) % buffer.size();
|
|
spdlog::info("New read offset: {}", readOffset);
|
|
}
|
|
|
|
void skip_write(size_t bytes) {
|
|
writeOffset = (writeOffset + std::min(bytes, remaining_write())) % buffer.size();
|
|
}
|
|
|
|
std::span<std::byte> get_next_available_block() {
|
|
if (writeOffset >= readOffset) {
|
|
return std::span(buffer.data() + writeOffset, buffer.size() - writeOffset);
|
|
} else {
|
|
return std::span(buffer.data() + writeOffset, readOffset - writeOffset);
|
|
}
|
|
}
|
|
|
|
private:
|
|
std::span<std::byte> buffer;
|
|
size_t readOffset = 0;
|
|
size_t writeOffset = 0;
|
|
};
|
|
|
|
} // namespace tw::net
|