环缓冲托管实现

// 这个缓冲将被用作ring_buffer测试
class x_buffer
{
private:
#pragma pack(1)
typedef struct {
volatile size_t _rd;
volatile size_t _wd;
volatile size_t _size;
volatile bool   _empty;
char _data[1];
}x_buffer_data, *x_buffer_data_ptr;

x_buffer_data_ptr _buffer_data;
public:
x_buffer()
:_buffer_data(nullptr)
{}
x_buffer(size_t size)
{
_buffer_data = (x_buffer_data_ptr)( new char(size + sizeof(x_buffer_data)) );
_buffer_data->_size = size;
_buffer_data._rd = _buffer_data._wd = 0;
_buffer_data._empty = true;
memset(_buffer_data->_data, 0, _buffer_data->_size);
}
char* base(){return _buffer_data._data;}
const char* base(){return _buffer_data._data;}
size_t capacity(){return _buffer_data._size();}
size_t rd(){return _buffer_data._rd;}
char* rd_ptr(){return base() + _buffer_data._rd;}
void set_rd(size_t rd_){_buffer_data._rd = rd_;}
size_t wd(){return _buffer_data._wd;}
char* wd_ptr(){return base() + _buffer_data._wd;}
void set_wd(size_t wd_){_buffer_data._wd = wd_;}
bool empty(){return _buffer_data._empty;}
void set_empty(bool empty_){_buffer_data._empty = empty_;}
};

// ring托管类
template<class _Buffer>
class ring_buffer
{
private:
_Buffer _buffer;

public:
ring_buffer(){}
ring_buffer(const _Buffer& buffer):_buffer(buffer){}
~ring_buffer(){}
void assign(_Buffer&& buffer){_buffer = std::forward<_Buffer>(buffer);}

// 写入内容
size_t write(const char* value, size_t len)
{
if (_buffer.wd() == _buffer.rd() && !_buffer.empty())
return -1;
if (_buffer.wd() > _buffer.rd()
&& _buffer.capacity() + 1 - _buffer.wd() < len
&& _buffer.capacity() + 1 - _buffer.wd() + _buffer.rd() <= len)
return -1;
else if (_buffer.wd() < _buffer.rd() && _buffer.rd() <= _buffer.wd() + len)
return -1;

if (_buffer.capacity() >= _buffer.wd() + len)
{
memcpy(_buffer.wd_ptr(), value, len);
_buffer.set_wd(_buffer.wd() + len);
}
else
{
size_t sublen = _buffer.capacity() - _buffer.wd();
memcpy(_buffer.wd_ptr(), value, sublen);
memcpy(_buffer.base(), value + sublen, len - sublen);
_Buffer.set_wd(len - sublen);
}
if (_buffer.wd() == _buffer.rd())
_buffer.set_empty(false);
return len;
}
size_t write(const char* value)
{
return write(value, strlen(value));
}
// 读取指定长度
size_t read(const char* value, size_t len)
{
if (_buffer.wd() == _buffer.rd() && _buffer.empty())
return -1;
else if (_buffer.wd() > _buffer.rd() && _buffer.wd() < len + _buffer.rd())
return -1;
else if (_buffer.capacity() - _buffer.rd() < len && _buffer.wd() + (_buffer.capacity() - _buffer.rd()) < len)
return -1;

if (_buffer.capacity() >= _buffer.rd() + len)
{
memcpy(value, _buffer.rd_ptr(), len);
_buffer.set_rd(_buffer.rd() + len);
}
else
{
size_t sublen = _buffer.capacity() - _buffer.rd();
memcpy(value, _buffer.rd_ptr(), sublen);
memcpy(value + sublen, _buffer.base(), len - sublen);
_buffer.set_rd(len - sublen);
}
if (_buffer.wd() == _buffer.rd())
_buffer.set_empty(true);
return len;
}
// 读取全部
size_t read(const char* value)
{
if (_buffer.wd() == _buffer.rd() && _buffer.empty())
return -1;

size_t len = 0;
if (_buffer.wd() > _buffer.rd())
{
memcpy(value, _buffer.rd_ptr(), _buffer.wd() - _buffer.rd());
len = _buffer.wd() - _buffer.rd();
}
else
{
size_t sublen = _buffer.capacity() - _buffer.rd();
memcpy(value, _buffer.rd_ptr(), sublen);
memcpy(value + sublen, _buffer.base(), _buffer.wd());
len = sublen + _buffer.wd();
}
_buffer.set_rd(_buffer.wd());
_buffer.set_empty(true);
return len;
}
};

解释：期望实现一个环形缓冲托管方法，可以托管任何buffer（主要用作共享内存，所以类型用了char）

除了托管上面的测试buff，还可以用在一些static_buffer上面。譬如：template<size_t size>class static_buffer{char _data[size];.....}。

规定了被托管对象一定要有的一些函数成员。