689 lines
17 KiB
D
689 lines
17 KiB
D
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
/**
|
|
* Copyright: Eugene Wissner 2016-2017.
|
|
* License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
|
|
* Mozilla Public License, v. 2.0).
|
|
* Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
|
|
*/
|
|
module tanya.container.buffer;
|
|
|
|
import std.traits;
|
|
import tanya.memory;
|
|
|
|
version (unittest)
|
|
{
|
|
private int fillBuffer(ubyte[] buffer,
|
|
in size_t size,
|
|
int start = 0,
|
|
int end = 10) @nogc pure nothrow
|
|
in
|
|
{
|
|
assert(start < end);
|
|
}
|
|
body
|
|
{
|
|
auto numberRead = end - start;
|
|
for (ubyte i; i < numberRead; ++i)
|
|
{
|
|
buffer[i] = cast(ubyte) (start + i);
|
|
}
|
|
return numberRead;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Self-expanding buffer, that can be used with functions returning the number
|
|
* of the read bytes.
|
|
*
|
|
* This buffer supports asynchronous reading. It means you can pass a new chunk
|
|
* to an asynchronous read function during you are working with already
|
|
* available data. But only one asynchronous call at a time is supported. Be
|
|
* sure to call $(D_PSYMBOL ReadBuffer.clear()) before you append the result
|
|
* of the pended asynchronous call.
|
|
*
|
|
* Params:
|
|
* T = Buffer type.
|
|
*/
|
|
struct ReadBuffer(T = ubyte)
|
|
if (isScalarType!T)
|
|
{
|
|
/// Internal buffer.
|
|
private T[] buffer_;
|
|
|
|
/// Filled buffer length.
|
|
private size_t length_;
|
|
|
|
/// Start of available data.
|
|
private size_t start;
|
|
|
|
/// Last position returned with $(D_KEYWORD []).
|
|
private size_t ring;
|
|
|
|
/// Available space.
|
|
private immutable size_t minAvailable = 1024;
|
|
|
|
/// Size by which the buffer will grow.
|
|
private immutable size_t blockSize = 8192;
|
|
|
|
invariant
|
|
{
|
|
assert(length_ <= buffer_.length);
|
|
assert(blockSize > 0);
|
|
assert(minAvailable > 0);
|
|
}
|
|
|
|
/**
|
|
* Creates a new read buffer.
|
|
*
|
|
* Params:
|
|
* size = Initial buffer size and the size by which the buffer
|
|
* will grow.
|
|
* minAvailable = minimal size should be always available to fill.
|
|
* So it will reallocate if $(D_INLINECODE
|
|
* $(D_PSYMBOL free) < $(D_PARAM minAvailable)).
|
|
* allocator = Allocator.
|
|
*/
|
|
this(in size_t size,
|
|
in size_t minAvailable = 1024,
|
|
shared Allocator allocator = defaultAllocator) @trusted
|
|
{
|
|
this(allocator);
|
|
this.minAvailable = minAvailable;
|
|
this.blockSize = size;
|
|
buffer_ = cast(T[]) allocator_.allocate(size * T.sizeof);
|
|
}
|
|
|
|
/// Ditto.
|
|
this(shared Allocator allocator)
|
|
in
|
|
{
|
|
assert(allocator_ is null);
|
|
}
|
|
body
|
|
{
|
|
allocator_ = allocator;
|
|
}
|
|
|
|
/**
|
|
* Deallocates the internal buffer.
|
|
*/
|
|
~this() @trusted
|
|
{
|
|
allocator.deallocate(buffer_);
|
|
}
|
|
|
|
///
|
|
unittest
|
|
{
|
|
ReadBuffer!ubyte b;
|
|
assert(b.capacity == 0);
|
|
assert(b.length == 0);
|
|
}
|
|
|
|
/**
|
|
* Returns: The size of the internal buffer.
|
|
*/
|
|
@property size_t capacity() const
|
|
{
|
|
return buffer_.length;
|
|
}
|
|
|
|
/**
|
|
* Returns: Data size.
|
|
*/
|
|
@property size_t length() const
|
|
{
|
|
return length_ - start;
|
|
}
|
|
|
|
/// Ditto.
|
|
alias opDollar = length;
|
|
|
|
/**
|
|
* Clears the buffer.
|
|
*
|
|
* Returns: $(D_KEYWORD this).
|
|
*/
|
|
void clear()
|
|
{
|
|
start = length_ = ring;
|
|
}
|
|
|
|
/**
|
|
* Returns: Available space.
|
|
*/
|
|
@property size_t free() const
|
|
{
|
|
return length > ring ? capacity - length : capacity - ring;
|
|
}
|
|
|
|
///
|
|
unittest
|
|
{
|
|
ReadBuffer!ubyte b;
|
|
size_t numberRead;
|
|
|
|
assert(b.free == 0);
|
|
|
|
// Fills the buffer with values 0..10
|
|
numberRead = fillBuffer(b[], b.free, 0, 10);
|
|
b += numberRead;
|
|
assert(b.free == b.blockSize - numberRead);
|
|
b.clear();
|
|
assert(b.free == b.blockSize);
|
|
}
|
|
|
|
/**
|
|
* Appends some data to the buffer.
|
|
*
|
|
* Params:
|
|
* length = Number of the bytes read.
|
|
*
|
|
* Returns: $(D_KEYWORD this).
|
|
*/
|
|
ref ReadBuffer opOpAssign(string op)(in size_t length)
|
|
if (op == "+")
|
|
{
|
|
length_ += length;
|
|
ring = start;
|
|
return this;
|
|
}
|
|
|
|
///
|
|
unittest
|
|
{
|
|
ReadBuffer!ubyte b;
|
|
size_t numberRead;
|
|
ubyte[] result;
|
|
|
|
// Fills the buffer with values 0..10
|
|
numberRead = fillBuffer(b[], b.free, 0, 10);
|
|
b += numberRead;
|
|
|
|
result = b[0 .. $];
|
|
assert(result[0] == 0);
|
|
assert(result[1] == 1);
|
|
assert(result[9] == 9);
|
|
b.clear();
|
|
|
|
// It shouldn't overwrite, but append another 5 bytes to the buffer
|
|
numberRead = fillBuffer(b[], b.free, 0, 10);
|
|
b += numberRead;
|
|
|
|
numberRead = fillBuffer(b[], b.free, 20, 25);
|
|
b += numberRead;
|
|
|
|
result = b[0..$];
|
|
assert(result[0] == 0);
|
|
assert(result[1] == 1);
|
|
assert(result[9] == 9);
|
|
assert(result[10] == 20);
|
|
assert(result[14] == 24);
|
|
}
|
|
|
|
/**
|
|
* Params:
|
|
* start = Start position.
|
|
* end = End position.
|
|
*
|
|
* Returns: Array between $(D_PARAM start) and $(D_PARAM end).
|
|
*/
|
|
T[] opSlice(in size_t start, in size_t end)
|
|
{
|
|
return buffer_[this.start + start .. this.start + end];
|
|
}
|
|
|
|
/**
|
|
* Returns a free chunk of the buffer.
|
|
*
|
|
* Add ($(D_KEYWORD +=)) the number of the read bytes after using it.
|
|
*
|
|
* Returns: A free chunk of the buffer.
|
|
*/
|
|
T[] opIndex()
|
|
{
|
|
if (start > 0)
|
|
{
|
|
auto ret = buffer_[0 .. start];
|
|
ring = 0;
|
|
return ret;
|
|
}
|
|
else
|
|
{
|
|
if (capacity - length < minAvailable)
|
|
{
|
|
void[] buf = buffer_;
|
|
immutable cap = capacity;
|
|
() @trusted {
|
|
allocator.reallocate(buf, (cap + blockSize) * T.sizeof);
|
|
buffer_ = cast(T[]) buf;
|
|
}();
|
|
}
|
|
ring = length_;
|
|
return buffer_[length_ .. $];
|
|
}
|
|
}
|
|
|
|
///
|
|
unittest
|
|
{
|
|
ReadBuffer!ubyte b;
|
|
size_t numberRead;
|
|
ubyte[] result;
|
|
|
|
// Fills the buffer with values 0..10
|
|
numberRead = fillBuffer(b[], b.free, 0, 10);
|
|
b += numberRead;
|
|
|
|
assert(b.length == 10);
|
|
result = b[0 .. $];
|
|
assert(result[0] == 0);
|
|
assert(result[9] == 9);
|
|
b.clear();
|
|
assert(b.length == 0);
|
|
}
|
|
|
|
mixin DefaultAllocator;
|
|
}
|
|
|
|
private unittest
|
|
{
|
|
static assert(is(ReadBuffer!int));
|
|
}
|
|
|
|
/**
|
|
* Circular, self-expanding buffer with overflow support. Can be used with
|
|
* functions returning the number of the transferred bytes.
|
|
*
|
|
* The buffer is optimized for situations where you read all the data from it
|
|
* at once (without writing to it occasionally). It can become ineffective if
|
|
* you permanently keep some data in the buffer and alternate writing and
|
|
* reading, because it may allocate and move elements.
|
|
*
|
|
* Params:
|
|
* T = Buffer type.
|
|
*/
|
|
struct WriteBuffer(T = ubyte)
|
|
if (isScalarType!T)
|
|
{
|
|
/// Internal buffer.
|
|
private T[] buffer_;
|
|
|
|
/// Buffer start position.
|
|
private size_t start;
|
|
|
|
/// Buffer ring area size. After this position begins buffer overflow area.
|
|
private size_t ring;
|
|
|
|
/// Size by which the buffer will grow.
|
|
private immutable size_t blockSize;
|
|
|
|
/// The position of the free area in the buffer.
|
|
private size_t position;
|
|
|
|
invariant
|
|
{
|
|
assert(blockSize > 0);
|
|
// Position can refer to an element outside the buffer if the buffer is full.
|
|
assert(position <= buffer_.length);
|
|
}
|
|
|
|
/**
|
|
* Params:
|
|
* size = Initial buffer size and the size by which the buffer will
|
|
* grow.
|
|
* allocator = Allocator.
|
|
*
|
|
* Precondition: $(D_INLINECODE size > 0 && allocator !is null)
|
|
*/
|
|
this(in size_t size, shared Allocator allocator = defaultAllocator) @trusted
|
|
in
|
|
{
|
|
assert(size > 0);
|
|
assert(allocator !is null);
|
|
}
|
|
body
|
|
{
|
|
blockSize = size;
|
|
ring = size - 1;
|
|
allocator_ = allocator;
|
|
buffer_ = cast(T[]) allocator_.allocate(size * T.sizeof);
|
|
}
|
|
|
|
@disable this();
|
|
|
|
/**
|
|
* Deallocates the internal buffer.
|
|
*/
|
|
~this()
|
|
{
|
|
allocator.deallocate(buffer_);
|
|
}
|
|
|
|
/**
|
|
* Returns: The size of the internal buffer.
|
|
*/
|
|
@property size_t capacity() const
|
|
{
|
|
return buffer_.length;
|
|
}
|
|
|
|
/**
|
|
* Note that $(D_PSYMBOL length) doesn't return the real length of the data,
|
|
* but only the array length that will be returned with $(D_PSYMBOL opIndex)
|
|
* next time. Be sure to call $(D_PSYMBOL opIndex) and set $(D_KEYWORD +=)
|
|
* until $(D_PSYMBOL length) returns 0.
|
|
*
|
|
* Returns: Data size.
|
|
*/
|
|
@property size_t length() const
|
|
{
|
|
if (position > ring || position < start) // Buffer overflowed
|
|
{
|
|
return ring - start + 1;
|
|
}
|
|
else
|
|
{
|
|
return position - start;
|
|
}
|
|
}
|
|
|
|
/// Ditto.
|
|
alias opDollar = length;
|
|
|
|
///
|
|
unittest
|
|
{
|
|
auto b = WriteBuffer!ubyte(4);
|
|
ubyte[3] buf = [48, 23, 255];
|
|
|
|
b ~= buf;
|
|
assert(b.length == 3);
|
|
b += 2;
|
|
assert(b.length == 1);
|
|
|
|
b ~= buf;
|
|
assert(b.length == 2);
|
|
b += 2;
|
|
assert(b.length == 2);
|
|
|
|
b ~= buf;
|
|
assert(b.length == 5);
|
|
b += b.length;
|
|
assert(b.length == 0);
|
|
}
|
|
|
|
/**
|
|
* Returns: Available space.
|
|
*/
|
|
@property size_t free() const
|
|
{
|
|
return capacity - length;
|
|
}
|
|
|
|
/**
|
|
* Appends data to the buffer.
|
|
*
|
|
* Params:
|
|
* buffer = Buffer chunk got with $(D_PSYMBOL opIndex).
|
|
*/
|
|
ref WriteBuffer opOpAssign(string op)(in T[] buffer)
|
|
if (op == "~")
|
|
{
|
|
size_t end, start;
|
|
|
|
if (position >= this.start && position <= ring)
|
|
{
|
|
auto afterRing = ring + 1;
|
|
|
|
end = position + buffer.length;
|
|
if (end > afterRing)
|
|
{
|
|
end = afterRing;
|
|
}
|
|
start = end - position;
|
|
buffer_[position .. end] = buffer[0 .. start];
|
|
if (end == afterRing)
|
|
{
|
|
position = this.start == 0 ? afterRing : 0;
|
|
}
|
|
else
|
|
{
|
|
position = end;
|
|
}
|
|
}
|
|
|
|
// Check if we have some free space at the beginning
|
|
if (start < buffer.length && position < this.start)
|
|
{
|
|
end = position + buffer.length - start;
|
|
if (end > this.start)
|
|
{
|
|
end = this.start;
|
|
}
|
|
auto areaEnd = end - position + start;
|
|
buffer_[position .. end] = buffer[start .. areaEnd];
|
|
position = end == this.start ? ring + 1 : end - position;
|
|
start = areaEnd;
|
|
}
|
|
|
|
// And if we still haven't found any place, save the rest in the overflow area
|
|
if (start < buffer.length)
|
|
{
|
|
end = position + buffer.length - start;
|
|
if (end > capacity)
|
|
{
|
|
auto newSize = (end / blockSize * blockSize + blockSize) * T.sizeof;
|
|
() @trusted {
|
|
void[] buf = buffer_;
|
|
allocator.reallocate(buf, newSize);
|
|
buffer_ = cast(T[]) buf;
|
|
}();
|
|
}
|
|
buffer_[position .. end] = buffer[start .. $];
|
|
position = end;
|
|
if (this.start == 0)
|
|
{
|
|
ring = capacity - 1;
|
|
}
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
///
|
|
unittest
|
|
{
|
|
auto b = WriteBuffer!ubyte(4);
|
|
ubyte[3] buf = [48, 23, 255];
|
|
|
|
b ~= buf;
|
|
assert(b.capacity == 4);
|
|
assert(b.buffer_[0] == 48 && b.buffer_[1] == 23 && b.buffer_[2] == 255);
|
|
|
|
b += 2;
|
|
b ~= buf;
|
|
assert(b.capacity == 4);
|
|
assert(b.buffer_[0] == 23 && b.buffer_[1] == 255
|
|
&& b.buffer_[2] == 255 && b.buffer_[3] == 48);
|
|
|
|
b += 2;
|
|
b ~= buf;
|
|
assert(b.capacity == 8);
|
|
assert(b.buffer_[0] == 23 && b.buffer_[1] == 255
|
|
&& b.buffer_[2] == 48 && b.buffer_[3] == 23 && b.buffer_[4] == 255);
|
|
}
|
|
|
|
///
|
|
unittest
|
|
{
|
|
auto b = WriteBuffer!ubyte(2);
|
|
ubyte[3] buf = [48, 23, 255];
|
|
|
|
b ~= buf;
|
|
assert(b.start == 0);
|
|
assert(b.capacity == 4);
|
|
assert(b.ring == 3);
|
|
assert(b.position == 3);
|
|
}
|
|
|
|
/**
|
|
* Sets how many bytes were written. It will shrink the buffer
|
|
* appropriately. Always call it after $(D_PSYMBOL opIndex).
|
|
*
|
|
* Params:
|
|
* length = Length of the written data.
|
|
*
|
|
* Returns: $(D_KEYWORD this).
|
|
*/
|
|
ref WriteBuffer opOpAssign(string op)(in size_t length)
|
|
if (op == "+")
|
|
in
|
|
{
|
|
assert(length <= this.length);
|
|
}
|
|
body
|
|
{
|
|
auto afterRing = ring + 1;
|
|
auto oldStart = start;
|
|
|
|
if (length <= 0)
|
|
{
|
|
return this;
|
|
}
|
|
else if (position <= afterRing)
|
|
{
|
|
start += length;
|
|
if (start > 0 && position == afterRing)
|
|
{
|
|
position = oldStart;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
auto overflow = position - afterRing;
|
|
|
|
if (overflow > length)
|
|
{
|
|
immutable afterLength = afterRing + length;
|
|
buffer_[start .. start + length] = buffer_[afterRing .. afterLength];
|
|
buffer_[afterRing .. afterLength] = buffer_[afterLength .. position];
|
|
position -= length;
|
|
}
|
|
else if (overflow == length)
|
|
{
|
|
buffer_[start .. start + overflow] = buffer_[afterRing .. position];
|
|
position -= overflow;
|
|
}
|
|
else
|
|
{
|
|
buffer_[start .. start + overflow] = buffer_[afterRing .. position];
|
|
position = overflow;
|
|
}
|
|
start += length;
|
|
|
|
if (start == position)
|
|
{
|
|
if (position != afterRing)
|
|
{
|
|
position = 0;
|
|
}
|
|
start = 0;
|
|
ring = capacity - 1;
|
|
}
|
|
}
|
|
if (start > ring)
|
|
{
|
|
start = 0;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
///
|
|
unittest
|
|
{
|
|
auto b = WriteBuffer!ubyte(6);
|
|
ubyte[6] buf = [23, 23, 255, 128, 127, 9];
|
|
|
|
b ~= buf;
|
|
assert(b.length == 6);
|
|
b += 2;
|
|
assert(b.length == 4);
|
|
b += 4;
|
|
assert(b.length == 0);
|
|
}
|
|
|
|
/**
|
|
* Returns a chunk with data.
|
|
*
|
|
* After calling it, set $(D_KEYWORD +=) to the length could be
|
|
* written.
|
|
*
|
|
* $(D_PSYMBOL opIndex) may return only part of the data. You may need
|
|
* to call it and set $(D_KEYWORD +=) several times until
|
|
* $(D_PSYMBOL length) is 0. If all the data can be written,
|
|
* maximally 3 calls are required.
|
|
*
|
|
* Returns: A chunk of data buffer.
|
|
*/
|
|
T[] opSlice(in size_t start, in size_t end)
|
|
{
|
|
immutable internStart = this.start + start;
|
|
|
|
if (position > ring || position < start) // Buffer overflowed
|
|
{
|
|
return buffer_[this.start .. ring + 1 - length + end];
|
|
}
|
|
else
|
|
{
|
|
return buffer_[this.start .. this.start + end];
|
|
}
|
|
}
|
|
|
|
///
|
|
unittest
|
|
{
|
|
auto b = WriteBuffer!ubyte(6);
|
|
ubyte[6] buf = [23, 23, 255, 128, 127, 9];
|
|
|
|
b ~= buf;
|
|
assert(b[0 .. $] == buf[0 .. 6]);
|
|
b += 2;
|
|
|
|
assert(b[0 .. $] == buf[2 .. 6]);
|
|
|
|
b ~= buf;
|
|
assert(b[0 .. $] == buf[2 .. 6]);
|
|
b += b.length;
|
|
|
|
assert(b[0 .. $] == buf[0 .. 6]);
|
|
b += b.length;
|
|
}
|
|
|
|
/**
|
|
* After calling it, set $(D_KEYWORD +=) to the length could be
|
|
* written.
|
|
*
|
|
* $(D_PSYMBOL opIndex) may return only part of the data. You may need
|
|
* to call it and set $(D_KEYWORD +=) several times until
|
|
* $(D_PSYMBOL length) is 0. If all the data can be written,
|
|
* maximally 3 calls are required.
|
|
*
|
|
* Returns: A chunk of data buffer.
|
|
*/
|
|
T[] opIndex()
|
|
{
|
|
return opSlice(0, length);
|
|
}
|
|
|
|
mixin DefaultAllocator;
|
|
}
|
|
|
|
private unittest
|
|
{
|
|
static assert(is(typeof(WriteBuffer!int(5))));
|
|
}
|