mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2024-08-17 01:10:28 +03:00
AK: Remove CircularDuplexStream
This commit is contained in:
parent
f15aa539be
commit
7526f9a8b7
Notes:
sideshowbarker
2024-07-17 03:35:24 +09:00
Author: https://github.com/timschumi Commit: https://github.com/SerenityOS/serenity/commit/7526f9a8b7 Pull-request: https://github.com/SerenityOS/serenity/pull/17008
@ -1,125 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2020, the SerenityOS developers.
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <AK/CircularQueue.h>
|
||||
#include <AK/Stream.h>
|
||||
|
||||
namespace AK {
|
||||
|
||||
// FIXME: There are a lot of raw loops here, that's not necessary an issue but it
|
||||
// has to be verified that the optimizer is able to insert memcpy instead.
|
||||
template<size_t Capacity>
|
||||
class CircularDuplexStream : public AK::DuplexStream {
|
||||
public:
|
||||
size_t write(ReadonlyBytes bytes) override
|
||||
{
|
||||
auto const nwritten = min(bytes.size(), Capacity - m_queue.size());
|
||||
|
||||
for (size_t idx = 0; idx < nwritten; ++idx)
|
||||
m_queue.enqueue(bytes[idx]);
|
||||
|
||||
m_total_written += nwritten;
|
||||
return nwritten;
|
||||
}
|
||||
|
||||
bool write_or_error(ReadonlyBytes bytes) override
|
||||
{
|
||||
if (Capacity - m_queue.size() < bytes.size()) {
|
||||
set_recoverable_error();
|
||||
return false;
|
||||
}
|
||||
|
||||
auto const nwritten = write(bytes);
|
||||
VERIFY(nwritten == bytes.size());
|
||||
return true;
|
||||
}
|
||||
|
||||
size_t read(Bytes bytes) override
|
||||
{
|
||||
if (has_any_error())
|
||||
return 0;
|
||||
|
||||
auto const nread = min(bytes.size(), m_queue.size());
|
||||
|
||||
for (size_t idx = 0; idx < nread; ++idx)
|
||||
bytes[idx] = m_queue.dequeue();
|
||||
|
||||
return nread;
|
||||
}
|
||||
|
||||
size_t read(Bytes bytes, size_t seekback)
|
||||
{
|
||||
if (seekback > Capacity || seekback > m_total_written) {
|
||||
set_recoverable_error();
|
||||
return 0;
|
||||
}
|
||||
|
||||
auto const nread = min(bytes.size(), seekback);
|
||||
|
||||
for (size_t idx = 0; idx < nread; ++idx) {
|
||||
auto const index = (m_total_written - seekback + idx) % Capacity;
|
||||
bytes[idx] = m_queue.m_storage[index];
|
||||
}
|
||||
|
||||
return nread;
|
||||
}
|
||||
|
||||
bool read_or_error(Bytes bytes) override
|
||||
{
|
||||
if (m_queue.size() < bytes.size()) {
|
||||
set_recoverable_error();
|
||||
return false;
|
||||
}
|
||||
|
||||
read(bytes);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool discard_or_error(size_t count) override
|
||||
{
|
||||
if (m_queue.size() < count) {
|
||||
set_recoverable_error();
|
||||
return false;
|
||||
}
|
||||
|
||||
for (size_t idx = 0; idx < count; ++idx)
|
||||
m_queue.dequeue();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool unreliable_eof() const override { return eof(); }
|
||||
bool eof() const { return m_queue.size() == 0; }
|
||||
|
||||
size_t remaining_contiguous_space() const
|
||||
{
|
||||
return min(Capacity - m_queue.size(), m_queue.capacity() - (m_queue.head_index() + m_queue.size()) % Capacity);
|
||||
}
|
||||
|
||||
Bytes reserve_contiguous_space(size_t count)
|
||||
{
|
||||
VERIFY(count <= remaining_contiguous_space());
|
||||
|
||||
Bytes bytes { m_queue.m_storage + (m_queue.head_index() + m_queue.size()) % Capacity, count };
|
||||
|
||||
m_queue.m_size += count;
|
||||
m_total_written += count;
|
||||
|
||||
return bytes;
|
||||
}
|
||||
|
||||
private:
|
||||
CircularQueue<u8, Capacity> m_queue;
|
||||
size_t m_total_written { 0 };
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#if USING_AK_GLOBALLY
|
||||
using AK::CircularDuplexStream;
|
||||
#endif
|
@ -14,8 +14,6 @@ namespace AK {
|
||||
|
||||
template<typename T, size_t Capacity>
|
||||
class CircularQueue {
|
||||
friend CircularDuplexStream<Capacity>;
|
||||
|
||||
public:
|
||||
CircularQueue() = default;
|
||||
|
||||
|
@ -48,9 +48,6 @@ class InputBitStream;
|
||||
class OutputBitStream;
|
||||
class OutputMemoryStream;
|
||||
|
||||
template<size_t Capacity>
|
||||
class CircularDuplexStream;
|
||||
|
||||
template<typename T>
|
||||
class Span;
|
||||
|
||||
@ -159,7 +156,6 @@ using AK::Bitmap;
|
||||
using AK::ByteBuffer;
|
||||
using AK::Bytes;
|
||||
using AK::CircularBuffer;
|
||||
using AK::CircularDuplexStream;
|
||||
using AK::CircularQueue;
|
||||
using AK::DeprecatedFlyString;
|
||||
using AK::DeprecatedString;
|
||||
|
@ -16,7 +16,6 @@ set(AK_TEST_SOURCES
|
||||
TestChecked.cpp
|
||||
TestCircularBuffer.cpp
|
||||
TestCircularDeque.cpp
|
||||
TestCircularDuplexStream.cpp
|
||||
TestCircularQueue.cpp
|
||||
TestComplex.cpp
|
||||
TestDeprecatedString.cpp
|
||||
|
@ -1,63 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2020, the SerenityOS developers.
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#include <LibTest/TestCase.h>
|
||||
|
||||
#include <AK/CircularDuplexStream.h>
|
||||
|
||||
TEST_CASE(works_like_a_queue)
|
||||
{
|
||||
constexpr size_t capacity = 32;
|
||||
|
||||
CircularQueue<u8, capacity> queue;
|
||||
CircularDuplexStream<capacity> stream;
|
||||
|
||||
for (size_t idx = 0; idx < capacity; ++idx) {
|
||||
queue.enqueue(static_cast<u8>(idx % 256));
|
||||
stream << static_cast<u8>(idx % 256);
|
||||
}
|
||||
|
||||
for (size_t idx = 0; idx < capacity; ++idx) {
|
||||
u8 byte = 0;
|
||||
stream >> byte;
|
||||
|
||||
EXPECT_EQ(queue.dequeue(), byte);
|
||||
}
|
||||
|
||||
EXPECT(stream.eof());
|
||||
}
|
||||
|
||||
TEST_CASE(overwritting_is_well_defined)
|
||||
{
|
||||
constexpr size_t half_capacity = 16;
|
||||
constexpr size_t capacity = 2 * half_capacity;
|
||||
|
||||
CircularDuplexStream<capacity> stream;
|
||||
|
||||
for (size_t idx = 0; idx < capacity; ++idx)
|
||||
stream << static_cast<u8>(idx % 256);
|
||||
|
||||
Array<u8, half_capacity> buffer;
|
||||
stream >> buffer;
|
||||
|
||||
for (size_t idx = 0; idx < half_capacity; ++idx)
|
||||
EXPECT_EQ(buffer[idx], idx % 256);
|
||||
|
||||
for (size_t idx = 0; idx < half_capacity; ++idx)
|
||||
stream << static_cast<u8>(idx % 256);
|
||||
|
||||
for (size_t idx = 0; idx < capacity; ++idx) {
|
||||
u8 byte = 0;
|
||||
stream >> byte;
|
||||
|
||||
if (idx < half_capacity)
|
||||
EXPECT_EQ(byte, half_capacity + idx % 256);
|
||||
else
|
||||
EXPECT_EQ(byte, idx % 256 - half_capacity);
|
||||
}
|
||||
|
||||
EXPECT(stream.eof());
|
||||
}
|
Loading…
Reference in New Issue
Block a user