dymokomi/luce-browser-foundation
Source of release 0.6.1
0.6.1 / src / ak / circular_buffer_1.lucb
#==============================================================================================
#
# circular_buffer_1 - CircularBuffer: a ring buffer over a ByteBuffer with seekback
#
# DESCRIPTION:
# Port of AK/CircularBuffer.cpp (lines 1-277) with the declarations of
# AK/CircularBuffer.h, in the .cpp's order. CircularBuffer is non-copyable in the
# donor; the struct here holds its ByteBuffer by value, so a copy shares the storage
# as a C++ move would leave it. AK::memmem over the two read spans is byte_buffer's
# memmem_spans.
#
#==============================================================================================
## Ported from AK/CircularBuffer.cpp:14 AK::CircularBuffer::CircularBuffer.
pub func circular_buffer_construct(this: CircularBuffer*, buffer: ByteBuffer):
this.m_buffer = buffer
this.m_reading_head = 0
this.m_used_space = 0
this.m_seekback_limit = 0
## Ported from AK/CircularBuffer.cpp:19 AK::CircularBuffer::create_empty.
pub func circular_buffer_create_empty(size: usize) -> CircularBuffer!:
let temporary_buffer = try byte_buffer_create_uninitialized(size)
var circular_buffer: CircularBuffer
circular_buffer_construct(&circular_buffer, temporary_buffer)
return circular_buffer
## Ported from AK/CircularBuffer.cpp:28 AK::CircularBuffer::create_initialized.
pub func circular_buffer_create_initialized(buffer: ByteBuffer) -> CircularBuffer!:
var circular_buffer: CircularBuffer
circular_buffer_construct(&circular_buffer, buffer)
circular_buffer.m_used_space = byte_buffer_size(&circular_buffer.m_buffer)
return circular_buffer
## Ported from AK/CircularBuffer.cpp:37 AK::CircularBuffer::empty_space.
pub func circular_buffer_empty_space(this: const CircularBuffer*) -> usize:
return circular_buffer_capacity(this) - this.m_used_space
## Ported from AK/CircularBuffer.cpp:42 AK::CircularBuffer::used_space.
pub func circular_buffer_used_space(this: const CircularBuffer*) -> usize:
return this.m_used_space
## Ported from AK/CircularBuffer.cpp:47 AK::CircularBuffer::capacity.
pub func circular_buffer_capacity(this: const CircularBuffer*) -> usize:
return byte_buffer_size(&this.m_buffer)
## Ported from AK/CircularBuffer.cpp:52 AK::CircularBuffer::seekback_limit.
pub func circular_buffer_seekback_limit(this: const CircularBuffer*) -> usize:
return this.m_seekback_limit
## Ported from AK/CircularBuffer.cpp:57 AK::SearchableCircularBuffer::search_limit.
pub func searchable_circular_buffer_search_limit(this: const SearchableCircularBuffer*) -> usize:
return this.circular_buffer.m_seekback_limit - this.circular_buffer.m_used_space
## Ported from AK/CircularBuffer.cpp:62 AK::CircularBuffer::is_wrapping_around.
pub func circular_buffer_is_wrapping_around(this: const CircularBuffer*) -> bool:
return circular_buffer_capacity(this) <= this.m_reading_head + this.m_used_space
## Ported from AK/CircularBuffer.cpp:67 AK::CircularBuffer::offset_of.
pub func circular_buffer_offset_of(this: const CircularBuffer*, needle: StringView, from_: usize? = none, until: usize? = none) -> usize?:
let read_from = from_ else 0
let read_until = until else this.m_used_space
assert(read_from <= read_until)
var spans: (const u8[])[2]
spans[0] = circular_buffer_next_read_span(this)
let original_span_0_size = spans[0].length
if read_from > 0:
spans[0] = spans[0][min(spans[0].length, read_from)..]
if spans[0].length + read_from > read_until:
spans[0] = spans[0][0..<(read_until - read_from)]
elif circular_buffer_is_wrapping_around(this):
let start = max(original_span_0_size, read_from) - original_span_0_size
let count = min(read_until, this.m_used_space) - original_span_0_size
spans[1] = byte_buffer_span_const(&this.m_buffer)[start..<(start + count)]
var needle_bytes = empty_span[u8]()
if let characters = needle.m_characters:
needle_bytes = u8[]((u8*)characters, needle.m_length)
var maybe_found = memmem_spans(spans, needle_bytes)
if let found = maybe_found:
maybe_found = found + read_from
return maybe_found
## Ported from AK/CircularBuffer.cpp:92 AK::CircularBuffer::clear.
pub func circular_buffer_clear(this: CircularBuffer*):
this.m_reading_head = 0
this.m_used_space = 0
this.m_seekback_limit = 0
## Ported from AK/CircularBuffer.cpp:99 AK::CircularBuffer::next_write_span.
pub func circular_buffer_next_write_span(this: CircularBuffer*) -> u8[]:
let capacity = circular_buffer_capacity(this)
let span = byte_buffer_span(&this.m_buffer)
if circular_buffer_is_wrapping_around(this):
let start = this.m_reading_head + this.m_used_space - capacity
return span[start..<(start + capacity - this.m_used_space)]
let start = this.m_reading_head + this.m_used_space
return span[start..<(start + capacity - (this.m_reading_head + this.m_used_space))]
## Ported from AK/CircularBuffer.cpp:106 AK::CircularBuffer::next_read_span.
pub func circular_buffer_next_read_span(this: const CircularBuffer*, offset: usize = 0) -> const u8[]:
var reading_head = this.m_reading_head
var used_space = this.m_used_space
if offset > 0:
if offset >= used_space:
return empty_span[u8]()
reading_head = (reading_head + offset) % circular_buffer_capacity(this)
used_space -= offset
let count = min(circular_buffer_capacity(this) - reading_head, used_space)
return byte_buffer_span_const(&this.m_buffer)[reading_head..<(reading_head + count)]
## Ported from AK/CircularBuffer.cpp:122 AK::CircularBuffer::next_seekback_span.
pub func circular_buffer_next_seekback_span(this: const CircularBuffer*, distance: usize) -> const u8[]:
let capacity = circular_buffer_capacity(this)
assert(this.m_seekback_limit <= capacity)
assert(distance <= this.m_seekback_limit)
# Note: We are adding the capacity once here to ensure that we can wrap around the negative space by using modulo.
let read_offset = (capacity + this.m_reading_head + this.m_used_space - distance) % capacity
let count = min(capacity - read_offset, distance)
return byte_buffer_span_const(&this.m_buffer)[read_offset..<(read_offset + count)]
## Ported from AK/CircularBuffer.cpp:133 AK::SearchableCircularBuffer::next_search_span.
pub func searchable_circular_buffer_next_search_span(this: const SearchableCircularBuffer*, distance: usize) -> const u8[]:
let base = &this.circular_buffer
let capacity = circular_buffer_capacity(base)
assert(searchable_circular_buffer_search_limit(this) <= capacity)
assert(distance <= searchable_circular_buffer_search_limit(this))
# Note: We are adding the capacity once here to ensure that we can wrap around the negative space by using modulo.
let read_offset = (capacity + base.m_reading_head - distance) % capacity
let count = min(capacity - read_offset, distance)
return byte_buffer_span_const(&base.m_buffer)[read_offset..<(read_offset + count)]
## Ported from AK/CircularBuffer.cpp:144 AK::CircularBuffer::write.
pub func circular_buffer_write(this: CircularBuffer*, bytes: const u8[]) -> usize:
var remaining = bytes.length
while remaining > 0:
let next_span = circular_buffer_next_write_span(this)
if next_span.length == 0:
break
let written_bytes = bytes_copy_trimmed_to(bytes[(bytes.length - remaining)..], next_span)
this.m_used_space += written_bytes
this.m_seekback_limit += written_bytes
if this.m_seekback_limit > circular_buffer_capacity(this):
this.m_seekback_limit = circular_buffer_capacity(this)
remaining -= written_bytes
return bytes.length - remaining
## Ported from AK/CircularBuffer.cpp:167 AK::CircularBuffer::read.
pub func circular_buffer_read(this: CircularBuffer*, bytes: u8[]) -> u8[]:
var remaining = bytes.length
while remaining > 0:
let next_span = circular_buffer_next_read_span(this)
if next_span.length == 0:
break
let written_bytes = bytes_copy_trimmed_to(next_span, bytes[(bytes.length - remaining)..])
this.m_used_space -= written_bytes
this.m_reading_head += written_bytes
if this.m_reading_head >= circular_buffer_capacity(this):
this.m_reading_head -= circular_buffer_capacity(this)
remaining -= written_bytes
return bytes[0..<(bytes.length - remaining)]
## Ported from AK/CircularBuffer.cpp:190 AK::CircularBuffer::read_with_seekback.
# Compared to `read()`, this starts reading from an offset that is `distance` bytes
# before the current write pointer and allows for reading already-read data.
pub func circular_buffer_read_with_seekback(this: const CircularBuffer*, bytes: u8[], distance: usize) -> u8[]!:
if distance > this.m_seekback_limit:
error(ak_error, "Tried a seekback read beyond the seekback limit")
var remaining = bytes.length
var current_distance = distance
while remaining > 0:
let next_span = circular_buffer_next_seekback_span(this, current_distance)
if next_span.length == 0:
break
let written_bytes = bytes_copy_trimmed_to(next_span, bytes[(bytes.length - remaining)..])
current_distance -= written_bytes
remaining -= written_bytes
return bytes[0..<(bytes.length - remaining)]
## Ported from AK/CircularBuffer.cpp:211 AK::CircularBuffer::discard.
pub func circular_buffer_discard(this: CircularBuffer*, discarding_size: usize) -> !:
if this.m_used_space < discarding_size:
error(ak_error, "Can not discard more data than what the buffer contains")
this.m_used_space -= discarding_size
this.m_reading_head = (this.m_reading_head + discarding_size) % circular_buffer_capacity(this)
## Ported from AK/CircularBuffer.cpp:221 AK::CircularBuffer::fill_from_stream.
pub func circular_buffer_fill_from_stream(this: CircularBuffer*, stream: Stream*) -> usize!:
let next_span = circular_buffer_next_write_span(this)
if next_span.length == 0:
return 0
let bytes = try stream_read_some(stream, next_span)
this.m_used_space += bytes.length
this.m_seekback_limit += bytes.length
if this.m_seekback_limit > circular_buffer_capacity(this):
this.m_seekback_limit = circular_buffer_capacity(this)
return bytes.length
## Ported from AK/CircularBuffer.cpp:237 AK::CircularBuffer::flush_to_stream.
pub func circular_buffer_flush_to_stream(this: CircularBuffer*, stream: Stream*) -> usize!:
let next_span = circular_buffer_next_read_span(this)
if next_span.length == 0:
return 0
let written_bytes = try stream_write_some(stream, next_span)
this.m_used_space -= written_bytes
this.m_reading_head += written_bytes
if this.m_reading_head >= circular_buffer_capacity(this):
this.m_reading_head -= circular_buffer_capacity(this)
return written_bytes
## Ported from AK/CircularBuffer.cpp:254 AK::CircularBuffer::copy_from_seekback.
pub func circular_buffer_copy_from_seekback(this: CircularBuffer*, distance: usize, length: usize) -> usize!:
if distance > this.m_seekback_limit:
error(ak_error, "Tried a seekback copy beyond the seekback limit")
var current_distance = distance
var remaining_length = length
while remaining_length > 0:
if circular_buffer_empty_space(this) == 0:
break
let next_span = circular_buffer_next_seekback_span(this, current_distance)
if next_span.length == 0:
break
let length_written = circular_buffer_write(this, next_span[0..<min(next_span.length, remaining_length)])
remaining_length -= length_written
# If we copied right from the end of the seekback area (i.e. our length is larger than the distance)
# and the last copy was one complete "chunk", we can now double the distance to copy twice as much data in one go.
if remaining_length > current_distance and length_written == current_distance:
current_distance *= 2
return length - remaining_length