2012-04-29 20:52:25 +02:00
|
|
|
//
|
|
|
|
// FIFOBuffer.h
|
|
|
|
//
|
|
|
|
// $Id: //poco/1.4/Foundation/include/Poco/FIFOBuffer.h#2 $
|
|
|
|
//
|
|
|
|
// Library: Foundation
|
|
|
|
// Package: Core
|
|
|
|
// Module: FIFOBuffer
|
|
|
|
//
|
|
|
|
// Definition of the FIFOBuffer class.
|
|
|
|
//
|
|
|
|
// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
|
|
|
|
// and Contributors.
|
|
|
|
//
|
2014-05-04 21:02:42 +02:00
|
|
|
// SPDX-License-Identifier: BSL-1.0
|
2012-04-29 20:52:25 +02:00
|
|
|
//
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef Foundation_FIFOBuffer_INCLUDED
|
|
|
|
#define Foundation_FIFOBuffer_INCLUDED
|
|
|
|
|
|
|
|
|
|
|
|
#include "Poco/Foundation.h"
|
|
|
|
#include "Poco/Exception.h"
|
|
|
|
#include "Poco/Buffer.h"
|
|
|
|
#include "Poco/BasicEvent.h"
|
|
|
|
#include "Poco/Mutex.h"
|
|
|
|
#include "Poco/Format.h"
|
|
|
|
|
|
|
|
|
|
|
|
namespace Poco {
|
|
|
|
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
class BasicFIFOBuffer
|
|
|
|
/// A simple buffer class with support for re-entrant,
|
|
|
|
/// FIFO-style read/write operations, as well as (optional)
|
|
|
|
/// empty/non-empty/full (i.e. writable/readable) transition
|
2013-01-03 06:19:07 +01:00
|
|
|
/// notifications. Buffer can be flagged with end-of-file and
|
|
|
|
/// error flags, which renders it un-readable/writable.
|
2014-10-03 23:12:42 +02:00
|
|
|
///
|
|
|
|
/// Critical portions of code are protected by a recursive mutex.
|
|
|
|
/// However, to achieve thread-safety in cases where multiple
|
|
|
|
/// member function calls are involved and have to be atomic,
|
|
|
|
/// the mutex must be locked externally.
|
2013-01-03 06:19:07 +01:00
|
|
|
///
|
|
|
|
/// Buffer size, as well as amount of unread data and
|
|
|
|
/// available space introspections are supported as well.
|
2012-04-29 20:52:25 +02:00
|
|
|
///
|
|
|
|
/// This class is useful anywhere where a FIFO functionality
|
|
|
|
/// is needed.
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
typedef T Type;
|
|
|
|
|
2012-05-19 07:16:42 +02:00
|
|
|
mutable Poco::BasicEvent<bool> writable;
|
|
|
|
/// Event indicating "writability" of the buffer,
|
2012-06-07 05:59:13 +02:00
|
|
|
/// triggered as follows:
|
2012-04-29 20:52:25 +02:00
|
|
|
///
|
|
|
|
/// * when buffer transitions from non-full to full,
|
|
|
|
/// Writable event observers are notified, with
|
|
|
|
/// false value as the argument
|
|
|
|
///
|
|
|
|
/// * when buffer transitions from full to non-full,
|
|
|
|
/// Writable event observers are notified, with
|
|
|
|
/// true value as the argument
|
|
|
|
|
2012-05-19 07:16:42 +02:00
|
|
|
mutable Poco::BasicEvent<bool> readable;
|
2012-04-29 20:52:25 +02:00
|
|
|
/// Event indicating "readability" of the buffer,
|
2012-06-07 05:59:13 +02:00
|
|
|
/// triggered as follows:
|
2012-04-29 20:52:25 +02:00
|
|
|
///
|
|
|
|
/// * when buffer transitions from non-empty to empty,
|
|
|
|
/// Readable event observers are notified, with false
|
|
|
|
/// value as the argument
|
|
|
|
///
|
|
|
|
/// * when FIFOBuffer transitions from empty to non-empty,
|
|
|
|
/// Readable event observers are notified, with true value
|
|
|
|
/// as the argument
|
|
|
|
|
|
|
|
BasicFIFOBuffer(std::size_t size, bool notify = false):
|
|
|
|
_buffer(size),
|
|
|
|
_begin(0),
|
|
|
|
_used(0),
|
2013-01-03 06:19:07 +01:00
|
|
|
_notify(notify),
|
|
|
|
_eof(false),
|
|
|
|
_error(false)
|
2012-06-07 05:59:13 +02:00
|
|
|
/// Creates the FIFOBuffer.
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2014-09-10 16:44:36 +02:00
|
|
|
BasicFIFOBuffer(T* pBuffer, std::size_t size, bool notify = false):
|
2012-06-07 05:59:13 +02:00
|
|
|
_buffer(pBuffer, size),
|
|
|
|
_begin(0),
|
|
|
|
_used(0),
|
2013-01-03 06:19:07 +01:00
|
|
|
_notify(notify),
|
|
|
|
_eof(false),
|
|
|
|
_error(false)
|
2012-06-07 05:59:13 +02:00
|
|
|
/// Creates the FIFOBuffer.
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2014-09-10 16:44:36 +02:00
|
|
|
BasicFIFOBuffer(const T* pBuffer, std::size_t size, bool notify = false):
|
2012-06-07 05:59:13 +02:00
|
|
|
_buffer(pBuffer, size),
|
|
|
|
_begin(0),
|
|
|
|
_used(size),
|
2013-01-03 06:19:07 +01:00
|
|
|
_notify(notify),
|
|
|
|
_eof(false),
|
|
|
|
_error(false)
|
2012-06-07 05:59:13 +02:00
|
|
|
/// Creates the FIFOBuffer.
|
2012-04-29 20:52:25 +02:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
~BasicFIFOBuffer()
|
|
|
|
/// Destroys the FIFOBuffer.
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void resize(std::size_t newSize, bool preserveContent = true)
|
|
|
|
/// Resizes the buffer. If preserveContent is true,
|
|
|
|
/// the content of the old buffer is preserved.
|
|
|
|
/// New size can be larger or smaller than
|
|
|
|
/// the current size, but it must not be 0.
|
|
|
|
/// Additionally, if the new length is smaller
|
|
|
|
/// than currently used length and preserveContent
|
|
|
|
/// is true, InvalidAccessException is thrown.
|
|
|
|
{
|
|
|
|
Mutex::ScopedLock lock(_mutex);
|
|
|
|
|
|
|
|
if (preserveContent && (newSize < _used))
|
|
|
|
throw InvalidAccessException("Can not resize FIFO without data loss.");
|
|
|
|
|
|
|
|
std::size_t usedBefore = _used;
|
|
|
|
_buffer.resize(newSize, preserveContent);
|
|
|
|
if (!preserveContent) _used = 0;
|
|
|
|
if (_notify) notify(usedBefore);
|
|
|
|
}
|
|
|
|
|
2012-06-07 05:59:13 +02:00
|
|
|
std::size_t peek(T* pBuffer, std::size_t length) const
|
|
|
|
/// Peeks into the data currently in the FIFO
|
|
|
|
/// without actually extracting it.
|
|
|
|
/// If length is zero, the return is immediate.
|
|
|
|
/// If length is greater than used length,
|
|
|
|
/// it is substituted with the the current FIFO
|
|
|
|
/// used length.
|
|
|
|
///
|
|
|
|
/// Returns the number of elements copied in the
|
|
|
|
/// supplied buffer.
|
|
|
|
{
|
|
|
|
if (0 == length) return 0;
|
|
|
|
Mutex::ScopedLock lock(_mutex);
|
2013-01-03 06:19:07 +01:00
|
|
|
if (!isReadable()) return 0;
|
2012-06-07 05:59:13 +02:00
|
|
|
if (length > _used) length = _used;
|
|
|
|
std::memcpy(pBuffer, _buffer.begin() + _begin, length * sizeof(T));
|
|
|
|
return length;
|
|
|
|
}
|
|
|
|
|
2012-04-29 20:52:25 +02:00
|
|
|
std::size_t peek(Poco::Buffer<T>& buffer, std::size_t length = 0) const
|
|
|
|
/// Peeks into the data currently in the FIFO
|
|
|
|
/// without actually extracting it.
|
|
|
|
/// Resizes the supplied buffer to the size of
|
|
|
|
/// data written to it. If length is not
|
2012-06-07 05:59:13 +02:00
|
|
|
/// supplied by the caller or is greater than length
|
|
|
|
/// of currently used data, the current FIFO used
|
|
|
|
/// data length is substituted for it.
|
2012-04-29 20:52:25 +02:00
|
|
|
///
|
2012-06-07 05:59:13 +02:00
|
|
|
/// Returns the number of elements copied in the
|
|
|
|
/// supplied buffer.
|
2012-04-29 20:52:25 +02:00
|
|
|
{
|
|
|
|
Mutex::ScopedLock lock(_mutex);
|
2013-01-03 06:19:07 +01:00
|
|
|
if (!isReadable()) return 0;
|
2012-04-29 20:52:25 +02:00
|
|
|
if (0 == length || length > _used) length = _used;
|
|
|
|
buffer.resize(length);
|
2012-06-07 05:59:13 +02:00
|
|
|
return peek(buffer.begin(), length);
|
|
|
|
}
|
|
|
|
|
|
|
|
std::size_t read(T* pBuffer, std::size_t length)
|
|
|
|
/// Copies the data currently in the FIFO
|
2015-06-24 04:02:18 +02:00
|
|
|
/// into the supplied buffer, which must be
|
|
|
|
/// preallocated to at least the length size
|
|
|
|
/// before calling this function.
|
2012-06-07 05:59:13 +02:00
|
|
|
///
|
2015-06-24 04:04:59 +02:00
|
|
|
/// Returns the size of the copied data.
|
2012-06-07 05:59:13 +02:00
|
|
|
{
|
2013-01-03 06:19:07 +01:00
|
|
|
if (0 == length) return 0;
|
2012-06-07 05:59:13 +02:00
|
|
|
Mutex::ScopedLock lock(_mutex);
|
2013-01-03 06:19:07 +01:00
|
|
|
if (!isReadable()) return 0;
|
2012-06-07 05:59:13 +02:00
|
|
|
std::size_t usedBefore = _used;
|
|
|
|
std::size_t readLen = peek(pBuffer, length);
|
|
|
|
poco_assert (_used >= readLen);
|
|
|
|
_used -= readLen;
|
|
|
|
if (0 == _used) _begin = 0;
|
|
|
|
else _begin += length;
|
|
|
|
|
|
|
|
if (_notify) notify(usedBefore);
|
|
|
|
|
|
|
|
return readLen;
|
2012-04-29 20:52:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
std::size_t read(Poco::Buffer<T>& buffer, std::size_t length = 0)
|
|
|
|
/// Copies the data currently in the FIFO
|
|
|
|
/// into the supplied buffer.
|
|
|
|
/// Resizes the supplied buffer to the size of
|
|
|
|
/// data written to it.
|
|
|
|
///
|
2015-06-24 04:04:59 +02:00
|
|
|
/// Returns the size of the copied data.
|
2012-04-29 20:52:25 +02:00
|
|
|
{
|
|
|
|
Mutex::ScopedLock lock(_mutex);
|
2013-01-03 06:19:07 +01:00
|
|
|
if (!isReadable()) return 0;
|
2012-04-29 20:52:25 +02:00
|
|
|
std::size_t usedBefore = _used;
|
|
|
|
std::size_t readLen = peek(buffer, length);
|
|
|
|
poco_assert (_used >= readLen);
|
|
|
|
_used -= readLen;
|
|
|
|
if (0 == _used) _begin = 0;
|
|
|
|
else _begin += length;
|
|
|
|
|
|
|
|
if (_notify) notify(usedBefore);
|
|
|
|
|
|
|
|
return readLen;
|
|
|
|
}
|
|
|
|
|
2012-06-07 05:59:13 +02:00
|
|
|
std::size_t write(const T* pBuffer, std::size_t length)
|
2012-04-29 20:52:25 +02:00
|
|
|
/// Writes data from supplied buffer to the FIFO buffer.
|
|
|
|
/// If there is no sufficient space for the whole
|
|
|
|
/// buffer to be written, data up to available
|
|
|
|
/// length is written.
|
|
|
|
/// The length of data to be written is determined from the
|
2012-06-07 05:59:13 +02:00
|
|
|
/// length argument. Function does nothing and returns zero
|
|
|
|
/// if length argument is equal to zero.
|
2012-04-29 20:52:25 +02:00
|
|
|
///
|
|
|
|
/// Returns the length of data written.
|
|
|
|
{
|
2013-01-03 06:19:07 +01:00
|
|
|
if (0 == length) return 0;
|
2012-04-29 20:52:25 +02:00
|
|
|
|
2012-06-07 05:59:13 +02:00
|
|
|
Mutex::ScopedLock lock(_mutex);
|
2013-01-03 06:19:07 +01:00
|
|
|
|
|
|
|
if (!isWritable()) return 0;
|
|
|
|
|
2012-04-29 20:52:25 +02:00
|
|
|
if (_buffer.size() - (_begin + _used) < length)
|
|
|
|
{
|
2015-03-20 05:22:00 +01:00
|
|
|
std::memmove(_buffer.begin(), begin(), _used * sizeof(T));
|
2012-04-29 20:52:25 +02:00
|
|
|
_begin = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::size_t usedBefore = _used;
|
|
|
|
std::size_t available = _buffer.size() - _used - _begin;
|
|
|
|
std::size_t len = length > available ? available : length;
|
2015-03-20 05:22:00 +01:00
|
|
|
std::memcpy(begin() + _used, pBuffer, len * sizeof(T));
|
2012-04-29 20:52:25 +02:00
|
|
|
_used += len;
|
|
|
|
poco_assert (_used <= _buffer.size());
|
|
|
|
if (_notify) notify(usedBefore);
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2012-06-07 05:59:13 +02:00
|
|
|
std::size_t write(const Buffer<T>& buffer, std::size_t length = 0)
|
|
|
|
/// Writes data from supplied buffer to the FIFO buffer.
|
|
|
|
/// If there is no sufficient space for the whole
|
|
|
|
/// buffer to be written, data up to available
|
|
|
|
/// length is written.
|
|
|
|
/// The length of data to be written is determined from the
|
|
|
|
/// length argument or buffer size (when length argument is
|
|
|
|
/// default zero or greater than buffer size).
|
|
|
|
///
|
|
|
|
/// Returns the length of data written.
|
|
|
|
{
|
2014-10-08 06:40:36 +02:00
|
|
|
if (length == 0 || length > buffer.size())
|
|
|
|
length = buffer.size();
|
2012-06-07 05:59:13 +02:00
|
|
|
|
2014-10-08 06:40:36 +02:00
|
|
|
return write(buffer.begin(), length);
|
2012-06-07 05:59:13 +02:00
|
|
|
}
|
|
|
|
|
2012-04-29 20:52:25 +02:00
|
|
|
std::size_t size() const
|
|
|
|
/// Returns the size of the buffer.
|
|
|
|
{
|
|
|
|
return _buffer.size();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::size_t used() const
|
|
|
|
/// Returns the size of the used portion of the buffer.
|
|
|
|
{
|
|
|
|
return _used;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::size_t available() const
|
|
|
|
/// Returns the size of the available portion of the buffer.
|
|
|
|
{
|
2015-02-25 04:07:28 +01:00
|
|
|
return size() - _used;
|
2012-04-29 20:52:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void drain(std::size_t length = 0)
|
|
|
|
/// Drains length number of elements from the buffer.
|
|
|
|
/// If length is zero or greater than buffer current
|
|
|
|
/// content length, buffer is emptied.
|
|
|
|
{
|
2013-01-03 06:19:07 +01:00
|
|
|
Mutex::ScopedLock lock(_mutex);
|
|
|
|
|
2012-04-29 20:52:25 +02:00
|
|
|
std::size_t usedBefore = _used;
|
|
|
|
|
|
|
|
if (0 == length || length >= _used)
|
|
|
|
{
|
|
|
|
_begin = 0;
|
|
|
|
_used = 0;
|
|
|
|
}
|
|
|
|
else
|
2014-10-03 23:12:42 +02:00
|
|
|
{
|
|
|
|
_begin += length;
|
2012-04-29 20:52:25 +02:00
|
|
|
_used -= length;
|
2014-10-03 23:12:42 +02:00
|
|
|
}
|
2012-04-29 20:52:25 +02:00
|
|
|
|
|
|
|
if (_notify) notify(usedBefore);
|
|
|
|
}
|
|
|
|
|
2012-05-19 07:16:42 +02:00
|
|
|
void copy(const T* ptr, std::size_t length)
|
|
|
|
/// Copies the supplied data to the buffer and adjusts
|
|
|
|
/// the used buffer size.
|
|
|
|
{
|
|
|
|
poco_check_ptr(ptr);
|
|
|
|
if (0 == length) return;
|
2013-01-03 06:19:07 +01:00
|
|
|
|
|
|
|
Mutex::ScopedLock lock(_mutex);
|
|
|
|
|
2012-05-19 07:16:42 +02:00
|
|
|
if (length > available())
|
|
|
|
throw Poco::InvalidAccessException("Cannot extend buffer.");
|
2013-01-03 06:19:07 +01:00
|
|
|
|
|
|
|
if (!isWritable())
|
|
|
|
throw Poco::InvalidAccessException("Buffer not writable.");
|
2012-05-19 07:16:42 +02:00
|
|
|
|
2014-10-03 23:12:42 +02:00
|
|
|
std::memcpy(&_buffer[_used], ptr, length * sizeof(T));
|
2013-01-03 06:19:07 +01:00
|
|
|
std::size_t usedBefore = _used;
|
|
|
|
_used += length;
|
|
|
|
if (_notify) notify(usedBefore);
|
2012-05-19 07:16:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void advance(std::size_t length)
|
|
|
|
/// Advances buffer by length elements.
|
|
|
|
/// Should be called AFTER the data
|
|
|
|
/// was copied into the buffer.
|
|
|
|
{
|
2013-01-03 06:19:07 +01:00
|
|
|
Mutex::ScopedLock lock(_mutex);
|
|
|
|
|
2012-05-19 07:16:42 +02:00
|
|
|
if (length > available())
|
|
|
|
throw Poco::InvalidAccessException("Cannot extend buffer.");
|
2013-01-03 06:19:07 +01:00
|
|
|
|
|
|
|
if (!isWritable())
|
|
|
|
throw Poco::InvalidAccessException("Buffer not writable.");
|
2012-05-19 07:16:42 +02:00
|
|
|
|
2015-02-23 01:56:54 +01:00
|
|
|
if (_buffer.size() - (_begin + _used) < length)
|
|
|
|
{
|
2015-03-20 05:22:00 +01:00
|
|
|
std::memmove(_buffer.begin(), begin(), _used * sizeof(T));
|
2015-02-23 01:56:54 +01:00
|
|
|
_begin = 0;
|
|
|
|
}
|
|
|
|
|
2012-05-19 07:16:42 +02:00
|
|
|
std::size_t usedBefore = _used;
|
|
|
|
_used += length;
|
|
|
|
if (_notify) notify(usedBefore);
|
|
|
|
}
|
|
|
|
|
|
|
|
T* begin()
|
|
|
|
/// Returns the pointer to the beginning of the buffer.
|
|
|
|
{
|
2015-02-23 01:56:54 +01:00
|
|
|
Mutex::ScopedLock lock(_mutex);
|
2015-02-22 02:31:44 +01:00
|
|
|
if (_begin != 0)
|
|
|
|
{
|
2015-02-25 04:07:28 +01:00
|
|
|
// Move the data to the start of the buffer so begin() and next()
|
|
|
|
// always return consistent pointers with each other and allow writing
|
|
|
|
// to the end of the buffer.
|
2015-02-22 02:31:44 +01:00
|
|
|
std::memmove(_buffer.begin(), _buffer.begin() + _begin, _used * sizeof(T));
|
|
|
|
_begin = 0;
|
|
|
|
}
|
2012-05-19 07:16:42 +02:00
|
|
|
return _buffer.begin();
|
|
|
|
}
|
|
|
|
|
|
|
|
T* next()
|
|
|
|
/// Returns the pointer to the next available position in the buffer.
|
|
|
|
{
|
2015-02-23 01:56:54 +01:00
|
|
|
Mutex::ScopedLock lock(_mutex);
|
2015-02-25 04:07:28 +01:00
|
|
|
return begin() + _used;
|
2012-05-19 07:16:42 +02:00
|
|
|
}
|
|
|
|
|
2012-04-29 20:52:25 +02:00
|
|
|
T& operator [] (std::size_t index)
|
|
|
|
/// Returns value at index position.
|
|
|
|
/// Throws InvalidAccessException if index is larger than
|
|
|
|
/// the last valid (used) buffer position.
|
|
|
|
{
|
2013-01-03 06:19:07 +01:00
|
|
|
Mutex::ScopedLock lock(_mutex);
|
2012-04-29 20:52:25 +02:00
|
|
|
if (index >= _used)
|
|
|
|
throw InvalidAccessException(format("Index out of bounds: %z (max index allowed: %z)", index, _used - 1));
|
|
|
|
|
|
|
|
return _buffer[_begin + index];
|
|
|
|
}
|
|
|
|
|
|
|
|
const T& operator [] (std::size_t index) const
|
|
|
|
/// Returns value at index position.
|
|
|
|
/// Throws InvalidAccessException if index is larger than
|
|
|
|
/// the last valid (used) buffer position.
|
|
|
|
{
|
2013-01-03 06:19:07 +01:00
|
|
|
Mutex::ScopedLock lock(_mutex);
|
2012-04-29 20:52:25 +02:00
|
|
|
if (index >= _used)
|
|
|
|
throw InvalidAccessException(format("Index out of bounds: %z (max index allowed: %z)", index, _used - 1));
|
|
|
|
|
|
|
|
return _buffer[_begin + index];
|
|
|
|
}
|
|
|
|
|
|
|
|
const Buffer<T>& buffer() const
|
|
|
|
/// Returns const reference to the underlying buffer.
|
|
|
|
{
|
|
|
|
return _buffer;
|
|
|
|
}
|
2013-01-03 06:19:07 +01:00
|
|
|
|
|
|
|
void setError(bool error = true)
|
|
|
|
/// Sets the error flag on the buffer and empties it.
|
|
|
|
/// If notifications are enabled, they will be triggered
|
|
|
|
/// if appropriate.
|
|
|
|
///
|
|
|
|
/// Setting error flag to true prevents reading and writing
|
|
|
|
/// to the buffer; to re-enable FIFOBuffer for reading/writing,
|
|
|
|
/// the error flag must be set to false.
|
|
|
|
{
|
|
|
|
if (error)
|
|
|
|
{
|
|
|
|
bool f = false;
|
|
|
|
Mutex::ScopedLock lock(_mutex);
|
|
|
|
if (error && isReadable() && _notify) readable.notify(this, f);
|
|
|
|
if (error && isWritable() && _notify) writable.notify(this, f);
|
|
|
|
_error = error;
|
|
|
|
_used = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
bool t = true;
|
|
|
|
Mutex::ScopedLock lock(_mutex);
|
|
|
|
_error = false;
|
|
|
|
if (_notify && !_eof) writable.notify(this, t);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isValid() const
|
|
|
|
/// Returns true if error flag is not set on the buffer,
|
|
|
|
/// otherwise returns false.
|
|
|
|
{
|
|
|
|
return !_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
void setEOF(bool eof = true)
|
|
|
|
/// Sets end-of-file flag on the buffer.
|
|
|
|
///
|
|
|
|
/// Setting EOF flag to true prevents writing to the
|
|
|
|
/// buffer; reading from the buffer will still be
|
|
|
|
/// allowed until all data present in the buffer at the
|
|
|
|
/// EOF set time is drained. After that, to re-enable
|
|
|
|
/// FIFOBuffer for reading/writing, EOF must be
|
|
|
|
/// set to false.
|
|
|
|
///
|
|
|
|
/// Setting EOF flag to false clears EOF state if it
|
|
|
|
/// was previously set. If EOF was not set, it has no
|
|
|
|
/// effect.
|
|
|
|
{
|
|
|
|
Mutex::ScopedLock lock(_mutex);
|
|
|
|
bool flag = !eof;
|
|
|
|
if (_notify) writable.notify(this, flag);
|
|
|
|
_eof = eof;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool hasEOF() const
|
|
|
|
/// Returns true if EOF flag has been set.
|
|
|
|
{
|
|
|
|
return _eof;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isEOF() const
|
|
|
|
/// Returns true if EOF flag has been set and buffer is empty.
|
|
|
|
{
|
|
|
|
return isEmpty() && _eof;
|
|
|
|
}
|
2012-04-29 20:52:25 +02:00
|
|
|
|
|
|
|
bool isEmpty() const
|
2013-01-03 06:19:07 +01:00
|
|
|
/// Returns true is buffer is empty, false otherwise.
|
2012-04-29 20:52:25 +02:00
|
|
|
{
|
|
|
|
return 0 == _used;
|
|
|
|
}
|
|
|
|
|
2012-06-07 05:59:13 +02:00
|
|
|
bool isFull() const
|
|
|
|
/// Returns true is buffer is full, false otherwise.
|
|
|
|
{
|
|
|
|
return size() == _used;
|
|
|
|
}
|
|
|
|
|
2013-01-03 06:19:07 +01:00
|
|
|
bool isReadable() const
|
|
|
|
/// Returns true if buffer contains data and is not
|
|
|
|
/// in error state.
|
|
|
|
{
|
|
|
|
return !isEmpty() && isValid();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isWritable() const
|
|
|
|
/// Returns true if buffer is not full and is not
|
|
|
|
/// in error state.
|
|
|
|
{
|
|
|
|
return !isFull() && isValid() && !_eof;
|
|
|
|
}
|
|
|
|
|
2012-06-07 05:59:13 +02:00
|
|
|
void setNotify(bool notify = true)
|
|
|
|
/// Enables/disables notifications.
|
|
|
|
{
|
|
|
|
_notify = notify;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool getNotify() const
|
|
|
|
/// Returns true if notifications are enabled, false otherwise.
|
|
|
|
{
|
|
|
|
return _notify;
|
|
|
|
}
|
|
|
|
|
2014-10-03 23:12:42 +02:00
|
|
|
Mutex& mutex()
|
|
|
|
/// Returns reference to mutex.
|
|
|
|
{
|
|
|
|
return _mutex;
|
|
|
|
}
|
|
|
|
|
2012-04-29 20:52:25 +02:00
|
|
|
private:
|
|
|
|
void notify(std::size_t usedBefore)
|
|
|
|
{
|
|
|
|
bool t = true, f = false;
|
|
|
|
if (usedBefore == 0 && _used > 0)
|
2012-05-19 07:16:42 +02:00
|
|
|
readable.notify(this, t);
|
2012-04-29 20:52:25 +02:00
|
|
|
else if (usedBefore > 0 && 0 == _used)
|
2012-05-19 07:16:42 +02:00
|
|
|
readable.notify(this, f);
|
2012-04-29 20:52:25 +02:00
|
|
|
|
|
|
|
if (usedBefore == _buffer.size() && _used < _buffer.size())
|
2012-05-19 07:16:42 +02:00
|
|
|
writable.notify(this, t);
|
2012-04-29 20:52:25 +02:00
|
|
|
else if (usedBefore < _buffer.size() && _used == _buffer.size())
|
2012-05-19 07:16:42 +02:00
|
|
|
writable.notify(this, f);
|
2012-04-29 20:52:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
BasicFIFOBuffer();
|
|
|
|
BasicFIFOBuffer(const BasicFIFOBuffer&);
|
|
|
|
BasicFIFOBuffer& operator = (const BasicFIFOBuffer&);
|
|
|
|
|
|
|
|
Buffer<T> _buffer;
|
|
|
|
std::size_t _begin;
|
|
|
|
std::size_t _used;
|
|
|
|
bool _notify;
|
|
|
|
mutable Mutex _mutex;
|
2013-01-03 06:19:07 +01:00
|
|
|
bool _eof;
|
|
|
|
bool _error;
|
2012-04-29 20:52:25 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// We provide an instantiation for char
|
|
|
|
//
|
|
|
|
typedef BasicFIFOBuffer<char> FIFOBuffer;
|
|
|
|
|
|
|
|
|
|
|
|
} // namespace Poco
|
|
|
|
|
|
|
|
|
|
|
|
#endif // Foundation_FIFOBuffer_INCLUDED
|