diff options
Diffstat (limited to '')
| -rw-r--r-- | Makefile.am | 1 | ||||
| -rw-r--r-- | src/util/DynamicFifoBuffer.hxx | 147 | ||||
| -rw-r--r-- | src/util/ForeignFifoBuffer.hxx | 219 |
3 files changed, 248 insertions, 119 deletions
diff --git a/Makefile.am b/Makefile.am index cb85dd5ae..212d198cf 100644 --- a/Makefile.am +++ b/Makefile.am @@ -373,6 +373,7 @@ libutil_a_SOURCES = \ src/util/Manual.hxx \ src/util/RefCount.hxx \ src/util/FifoBuffer.hxx \ + src/util/ForeignFifoBuffer.hxx \ src/util/DynamicFifoBuffer.hxx \ src/util/ConstBuffer.hxx \ src/util/WritableBuffer.hxx \ diff --git a/src/util/DynamicFifoBuffer.hxx b/src/util/DynamicFifoBuffer.hxx index f3060dce4..d441b4484 100644 --- a/src/util/DynamicFifoBuffer.hxx +++ b/src/util/DynamicFifoBuffer.hxx @@ -30,14 +30,7 @@ #ifndef FIFO_BUFFER_HPP #define FIFO_BUFFER_HPP -#include "WritableBuffer.hxx" - -#include <utility> -#include <algorithm> - -#include <assert.h> -#include <stddef.h> -#include <stdint.h> +#include "ForeignFifoBuffer.hxx" /** * A first-in-first-out buffer: you can append data at the end, and @@ -45,93 +38,49 @@ * buffer as needed. It is not thread safe. */ template<typename T> -class DynamicFifoBuffer { +class DynamicFifoBuffer : protected ForeignFifoBuffer<T> { public: - typedef size_t size_type; - typedef WritableBuffer<T> Range; - typedef typename Range::pointer_type pointer_type; - typedef typename Range::const_pointer_type const_pointer_type; + typedef typename ForeignFifoBuffer<T>::size_type size_type; + typedef typename ForeignFifoBuffer<T>::pointer_type pointer_type; + typedef typename ForeignFifoBuffer<T>::const_pointer_type const_pointer_type; -protected: - size_type head, tail, capacity; - T *data; - -public: explicit DynamicFifoBuffer(size_type _capacity) - :head(0), tail(0), capacity(_capacity), - data(new T[capacity]) {} + :ForeignFifoBuffer<T>(new T[_capacity], _capacity) {} ~DynamicFifoBuffer() { - delete[] data; + delete[] GetBuffer(); } DynamicFifoBuffer(const DynamicFifoBuffer &) = delete; - size_type GetCapacity() { - return capacity; - } + using ForeignFifoBuffer<T>::IsEmpty; + using ForeignFifoBuffer<T>::IsFull; + using ForeignFifoBuffer<T>::Read; + using ForeignFifoBuffer<T>::Consume; + using ForeignFifoBuffer<T>::Write; + using ForeignFifoBuffer<T>::Append; void Grow(size_type new_capacity) { - assert(new_capacity > capacity); + assert(new_capacity > GetCapacity()); + T *old_data = GetBuffer(); T *new_data = new T[new_capacity]; - std::move(data + head, data + tail, new_data); - delete[] data; - data = new_data; - capacity = new_capacity; - tail -= head; - head = 0; - } - - void Clear() { - head = tail = 0; - } - - bool IsEmpty() const { - return head == tail; - } - - bool IsFull() const { - return head == 0 && tail == capacity; - } - - /** - * Prepares writing. Returns a buffer range which may be written. - * When you are finished, call append(). - */ - Range Write() { - Shift(); - return Range(data + tail, capacity - tail); - } - - /** - * Expands the tail of the buffer, after data has been written to - * the buffer returned by write(). - */ - void Append(size_type n) { - assert(tail <= capacity); - assert(n <= capacity); - assert(tail + n <= capacity); - - tail += n; + ForeignFifoBuffer<T>::MoveBuffer(new_data, new_capacity); + delete[] old_data; } void WantWrite(size_type n) { - if (tail + n <= capacity) - /* enough space after the tail */ + if (ForeignFifoBuffer<T>::WantWrite(n)) + /* we already have enough space */ return; - const size_type in_use = tail - head; + const size_type in_use = Read().size; const size_type required_capacity = in_use + n; - if (capacity >= required_capacity) { - Shift(); - } else { - size_type new_capacity = capacity; - do { - new_capacity <<= 1; - } while (new_capacity < required_capacity); + size_type new_capacity = GetCapacity(); + do { + new_capacity <<= 1; + } while (new_capacity < required_capacity); - Grow(new_capacity); - } + Grow(new_capacity); } /** @@ -140,7 +89,7 @@ public: */ pointer_type Write(size_type n) { WantWrite(n); - return data + tail; + return Write().data; } /** @@ -151,49 +100,9 @@ public: Append(n); } - /** - * Return a buffer range which may be read. The buffer pointer is - * writable, to allow modifications while parsing. - */ - Range Read() { - return Range(data + head, tail - head); - } - - /** - * Marks a chunk as consumed. - */ - void Consume(size_type n) { - assert(tail <= capacity); - assert(head <= tail); - assert(n <= tail); - assert(head + n <= tail); - - head += n; - } - - size_type Read(pointer_type p, size_type n) { - auto range = Read(); - if (n > range.size) - n = range.size; - std::copy_n(range.data, n, p); - Consume(n); - return n; - } - protected: - void Shift() { - if (head == 0) - return; - - assert(head <= capacity); - assert(tail <= capacity); - assert(tail >= head); - - std::move(data + head, data + tail, data); - - tail -= head; - head = 0; - } + using ForeignFifoBuffer<T>::GetBuffer; + using ForeignFifoBuffer<T>::GetCapacity; }; #endif diff --git a/src/util/ForeignFifoBuffer.hxx b/src/util/ForeignFifoBuffer.hxx new file mode 100644 index 000000000..c119fb6d5 --- /dev/null +++ b/src/util/ForeignFifoBuffer.hxx @@ -0,0 +1,219 @@ +/* + * Copyright (C) 2003-2014 Max Kellermann <max@duempel.org> + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef FOREIGN_FIFO_BUFFER_HXX +#define FOREIGN_FIFO_BUFFER_HXX + +#include "WritableBuffer.hxx" + +#include <utility> +#include <algorithm> + +#include <cstddef> + +#include <assert.h> + +/** + * A first-in-first-out buffer: you can append data at the end, and + * read data from the beginning. This class automatically shifts the + * buffer as needed. It is not thread safe. + * + * This class does not manage buffer memory. It will not allocate or + * free any memory, it only manages the contents of an existing buffer + * given to the constructor. + */ +template<typename T> +class ForeignFifoBuffer { +public: + typedef size_t size_type; + typedef WritableBuffer<T> Range; + typedef typename Range::pointer_type pointer_type; + typedef typename Range::const_pointer_type const_pointer_type; + +protected: + size_type head, tail, capacity; + T *data; + +public: + explicit constexpr ForeignFifoBuffer(std::nullptr_t n) + :head(0), tail(0), capacity(0), data(n) {} + + constexpr ForeignFifoBuffer(T *_data, size_type _capacity) + :head(0), tail(0), capacity(_capacity), data(_data) {} + + ForeignFifoBuffer(ForeignFifoBuffer &&src) + :head(src.head), tail(src.tail), + capacity(src.capacity), data(src.data) { + src.SetNull(); + } + + ForeignFifoBuffer &operator=(ForeignFifoBuffer &&src) { + head = src.head; + tail = src.tail; + capacity = src.capacity; + data = src.data; + src.SetNull(); + return *this; + } + + constexpr bool IsNull() const { + return data == nullptr; + } + + constexpr bool IsDefined() const { + return !IsNull(); + } + + T *GetBuffer() { + return data; + } + + constexpr size_type GetCapacity() const { + return capacity; + } + + void SetNull() { + head = tail = 0; + capacity = 0; + data = nullptr; + } + + void SetBuffer(T *_data, size_type _capacity) { + assert(_data != nullptr); + assert(_capacity > 0); + + head = tail = 0; + capacity = _capacity; + data = _data; + } + + void MoveBuffer(T *new_data, size_type new_capacity) { + assert(new_capacity >= tail - head); + + std::move(data + head, data + tail, new_data); + data = new_data; + capacity = new_capacity; + tail -= head; + head = 0; + } + + void Clear() { + head = tail = 0; + } + + constexpr bool IsEmpty() const { + return head == tail; + } + + constexpr bool IsFull() const { + return head == 0 && tail == capacity; + } + + /** + * Prepares writing. Returns a buffer range which may be written. + * When you are finished, call append(). + */ + Range Write() { + Shift(); + return Range(data + tail, capacity - tail); + } + + bool WantWrite(size_type n) { + if (tail + n <= capacity) + /* enough space after the tail */ + return true; + + const size_type in_use = tail - head; + const size_type required_capacity = in_use + n; + if (required_capacity > capacity) + return false; + + Shift(); + assert(tail + n <= capacity); + return true; + } + + /** + * Expands the tail of the buffer, after data has been written to + * the buffer returned by write(). + */ + void Append(size_type n) { + assert(tail <= capacity); + assert(n <= capacity); + assert(tail + n <= capacity); + + tail += n; + } + + /** + * Return a buffer range which may be read. The buffer pointer is + * writable, to allow modifications while parsing. + */ + constexpr Range Read() const { + return Range(data + head, tail - head); + } + + /** + * Marks a chunk as consumed. + */ + void Consume(size_type n) { + assert(tail <= capacity); + assert(head <= tail); + assert(n <= tail); + assert(head + n <= tail); + + head += n; + } + + size_type Read(pointer_type p, size_type n) { + auto range = Read(); + if (n > range.size) + n = range.size; + std::copy_n(range.data, n, p); + Consume(n); + return n; + } + +protected: + void Shift() { + if (head == 0) + return; + + assert(head <= capacity); + assert(tail <= capacity); + assert(tail >= head); + + std::move(data + head, data + tail, data); + + tail -= head; + head = 0; + } +}; + +#endif |