2021-12-10 19:15:48 +08:00
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// A multi-platform support c++11 library with focus on asynchronous socket I/O for any
|
|
|
|
// client application.
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*
|
|
|
|
The MIT License (MIT)
|
|
|
|
|
|
|
|
Copyright (c) 2012-2021 HALX99
|
|
|
|
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
|
|
in the Software without restriction, including without limitation the rights
|
|
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
|
|
|
|
The above copyright notice and this permission notice shall be included in all
|
|
|
|
copies or substantial portions of the Software.
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
SOFTWARE.
|
|
|
|
|
2021-12-11 13:02:56 +08:00
|
|
|
The byte_buffer concepts:
|
2021-12-10 19:15:48 +08:00
|
|
|
a. The memory model is similar to to std::vector<char>, std::string
|
2021-12-11 13:02:56 +08:00
|
|
|
b. Use c realloc to manage memory
|
|
|
|
c. Implemented operations: resize(without fill), resize_fit, attach/detach(stl not support)
|
2021-12-10 19:15:48 +08:00
|
|
|
*/
|
2021-12-11 13:02:56 +08:00
|
|
|
#ifndef YASIO__BYTE_BUFFER_HPP
|
|
|
|
#define YASIO__BYTE_BUFFER_HPP
|
2021-12-10 19:15:48 +08:00
|
|
|
#include <stddef.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <memory>
|
|
|
|
#include <vector>
|
2021-12-11 13:02:56 +08:00
|
|
|
#include <type_traits>
|
2021-12-11 20:15:29 +08:00
|
|
|
#include <exception>
|
|
|
|
#include <stdexcept>
|
2021-12-11 13:02:56 +08:00
|
|
|
#include "yasio/compiler/feature_test.hpp"
|
2021-12-10 19:15:48 +08:00
|
|
|
|
|
|
|
namespace yasio
|
|
|
|
{
|
2021-12-11 20:15:29 +08:00
|
|
|
struct default_allocator {
|
|
|
|
static void* reallocate(void* oldBlock, size_t /*oldSize*/, size_t newSize) { return ::realloc(oldBlock, newSize); }
|
|
|
|
};
|
|
|
|
template <typename _Elem, typename _Alloc = default_allocator>
|
2021-12-10 19:15:48 +08:00
|
|
|
class basic_byte_buffer final {
|
|
|
|
static_assert(sizeof(_Elem) == 1, "The basic_byte_buffer only accept type which is char or unsigned char!");
|
|
|
|
|
|
|
|
public:
|
|
|
|
using pointer = _Elem*;
|
|
|
|
using const_pointer = const _Elem*;
|
|
|
|
using size_type = size_t;
|
|
|
|
basic_byte_buffer() {}
|
2021-12-11 20:15:29 +08:00
|
|
|
explicit basic_byte_buffer(size_t count) { resize(count); }
|
|
|
|
basic_byte_buffer(size_t count, _Elem val) { resize(count, val); }
|
|
|
|
basic_byte_buffer(size_t count, std::true_type /*fit?*/) { resize_fit(count); }
|
|
|
|
basic_byte_buffer(size_t count, _Elem val, std::true_type /*fit?*/) { resize_fit(count, val); }
|
2021-12-10 19:15:48 +08:00
|
|
|
basic_byte_buffer(const void* first, const void* last) { assign(first, last); }
|
|
|
|
basic_byte_buffer(const basic_byte_buffer& rhs) { assign(rhs.begin(), rhs.end()); };
|
|
|
|
basic_byte_buffer(basic_byte_buffer&& rhs) noexcept
|
|
|
|
{
|
|
|
|
memcpy(this, &rhs, sizeof(rhs));
|
|
|
|
memset(&rhs, 0, sizeof(rhs));
|
|
|
|
}
|
|
|
|
basic_byte_buffer(const std::vector<_Elem>& rhs) { assign(rhs.data(), rhs.data() + rhs.size()); }
|
2021-12-11 13:02:56 +08:00
|
|
|
~basic_byte_buffer() { shrink_to_fit(0); }
|
2021-12-10 19:15:48 +08:00
|
|
|
basic_byte_buffer& operator=(const basic_byte_buffer& rhs) { return assign(rhs.begin(), rhs.end()); }
|
|
|
|
basic_byte_buffer& operator=(basic_byte_buffer&& rhs) noexcept { return this->swap(rhs); }
|
|
|
|
basic_byte_buffer& assign(const void* first, const void* last)
|
|
|
|
{
|
2021-12-11 13:02:56 +08:00
|
|
|
clear();
|
|
|
|
insert(this->end(), first, last);
|
2021-12-10 19:15:48 +08:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
basic_byte_buffer& swap(basic_byte_buffer& rhs) noexcept
|
|
|
|
{
|
2021-12-11 13:02:56 +08:00
|
|
|
char _Tmp[sizeof(rhs)];
|
|
|
|
memcpy(_Tmp, &rhs, sizeof(rhs));
|
|
|
|
memcpy(&rhs, this, sizeof(rhs));
|
|
|
|
memcpy(this, _Tmp, sizeof(_Tmp));
|
2021-12-10 19:15:48 +08:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
void insert(_Elem* where, const void* first, const void* last)
|
|
|
|
{
|
2021-12-11 13:02:56 +08:00
|
|
|
auto count = (const _Elem*)last - (const _Elem*)first;
|
2021-12-10 19:15:48 +08:00
|
|
|
if (count > 0)
|
|
|
|
{
|
2021-12-11 13:02:56 +08:00
|
|
|
auto insertion_pos = where - _Myfirst;
|
|
|
|
auto old_size = _Mylast - _Myfirst;
|
|
|
|
resize(old_size + count);
|
|
|
|
if (insertion_pos >= old_size)
|
|
|
|
memcpy(_Myfirst + old_size, first, count);
|
2021-12-10 19:15:48 +08:00
|
|
|
else if (insertion_pos >= 0)
|
|
|
|
{
|
2021-12-11 13:02:56 +08:00
|
|
|
where = _Myfirst + insertion_pos;
|
2021-12-10 19:15:48 +08:00
|
|
|
auto move_to = where + count;
|
2021-12-11 13:02:56 +08:00
|
|
|
memmove(move_to, where, _Mylast - move_to);
|
2021-12-10 19:15:48 +08:00
|
|
|
memcpy(where, first, count);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void push_back(_Elem v)
|
|
|
|
{
|
2021-12-11 13:02:56 +08:00
|
|
|
resize(this->size() + 1);
|
|
|
|
*(_Mylast - 1) = v;
|
2021-12-10 19:15:48 +08:00
|
|
|
}
|
|
|
|
_Elem& front()
|
|
|
|
{
|
|
|
|
if (!this->empty())
|
|
|
|
return *_Myfirst;
|
|
|
|
else
|
|
|
|
throw std::out_of_range("byte_buffer: out of range!");
|
|
|
|
}
|
2021-12-11 13:02:56 +08:00
|
|
|
_Elem& back()
|
|
|
|
{
|
|
|
|
if (!this->empty())
|
|
|
|
return *(_Mylast - 1);
|
|
|
|
else
|
|
|
|
throw std::out_of_range("byte_buffer: out of range!");
|
|
|
|
}
|
2021-12-10 19:15:48 +08:00
|
|
|
_Elem* begin() noexcept { return _Myfirst; }
|
|
|
|
_Elem* end() noexcept { return _Mylast; }
|
|
|
|
const _Elem* begin() const noexcept { return _Myfirst; }
|
|
|
|
const _Elem* end() const noexcept { return _Mylast; }
|
|
|
|
pointer data() noexcept { return _Myfirst; }
|
|
|
|
const_pointer data() const noexcept { return _Myfirst; }
|
2021-12-11 13:02:56 +08:00
|
|
|
size_t capacity() const noexcept { return _Myend - _Myfirst; }
|
|
|
|
size_t size() const noexcept { return _Mylast - _Myfirst; }
|
|
|
|
void clear() noexcept { _Mylast = _Myfirst; }
|
|
|
|
void shrink_to_fit() { shrink_to_fit(this->size()); }
|
|
|
|
bool empty() const noexcept { return _Mylast == _Myfirst; }
|
|
|
|
void resize(size_t new_size, _Elem val)
|
2021-12-10 19:15:48 +08:00
|
|
|
{
|
2021-12-11 13:02:56 +08:00
|
|
|
auto old_size = this->size();
|
|
|
|
resize(new_size);
|
|
|
|
if (old_size < new_size)
|
|
|
|
memset(_Myfirst + old_size, val, new_size - old_size);
|
2021-12-10 19:15:48 +08:00
|
|
|
}
|
2021-12-11 13:02:56 +08:00
|
|
|
void resize(size_t new_size)
|
2021-12-10 19:15:48 +08:00
|
|
|
{
|
2021-12-11 13:02:56 +08:00
|
|
|
if (this->capacity() < new_size)
|
|
|
|
_Reallocate_exactly(new_size * 3 / 2);
|
|
|
|
_Mylast = _Myfirst + new_size;
|
2021-12-10 19:15:48 +08:00
|
|
|
}
|
2021-12-11 20:15:29 +08:00
|
|
|
void resize_fit(size_t new_size, _Elem val)
|
|
|
|
{
|
|
|
|
auto old_size = this->size();
|
|
|
|
resize_fit(new_size);
|
|
|
|
if (old_size < new_size)
|
|
|
|
memset(_Myfirst + old_size, val, new_size - old_size);
|
|
|
|
}
|
2021-12-11 13:02:56 +08:00
|
|
|
void resize_fit(size_t new_size)
|
2021-12-10 19:15:48 +08:00
|
|
|
{
|
2021-12-11 13:02:56 +08:00
|
|
|
if (this->capacity() < new_size)
|
|
|
|
_Reallocate_exactly(new_size);
|
2021-12-10 19:15:48 +08:00
|
|
|
_Mylast = _Myfirst + new_size;
|
|
|
|
}
|
2021-12-11 13:02:56 +08:00
|
|
|
void shrink_to_fit(size_t new_size)
|
2021-12-10 19:15:48 +08:00
|
|
|
{
|
2021-12-11 13:02:56 +08:00
|
|
|
if (this->capacity() != new_size)
|
|
|
|
_Reallocate_exactly(new_size);
|
2021-12-10 19:15:48 +08:00
|
|
|
_Mylast = _Myfirst + new_size;
|
|
|
|
}
|
2021-12-11 13:02:56 +08:00
|
|
|
void reserve(size_t new_cap)
|
|
|
|
{
|
|
|
|
if (this->capacity() < new_cap)
|
|
|
|
{
|
|
|
|
auto cur_size = this->size();
|
|
|
|
_Reallocate_exactly(new_cap);
|
|
|
|
_Mylast = _Myfirst + cur_size;
|
|
|
|
}
|
|
|
|
}
|
2021-12-11 20:15:29 +08:00
|
|
|
const _Elem& operator[](size_t index) const
|
|
|
|
{
|
|
|
|
if (index < this->size())
|
|
|
|
return _Myfirst[index];
|
|
|
|
throw std::out_of_range("byte_buffer: out of range!");
|
|
|
|
}
|
|
|
|
_Elem& operator[](size_t index)
|
|
|
|
{
|
|
|
|
if (index < this->size())
|
|
|
|
return _Myfirst[index];
|
|
|
|
throw std::out_of_range("byte_buffer: out of range!");
|
|
|
|
}
|
2021-12-10 19:15:48 +08:00
|
|
|
void attach(void* ptr, size_t len) noexcept
|
|
|
|
{
|
|
|
|
if (ptr)
|
|
|
|
{
|
2021-12-11 13:02:56 +08:00
|
|
|
shrink_to_fit(0);
|
2021-12-10 19:15:48 +08:00
|
|
|
_Myfirst = (_Elem*)ptr;
|
|
|
|
_Myend = _Mylast = _Myfirst + len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
template <typename _TSIZE>
|
|
|
|
_Elem* detach(_TSIZE& len) noexcept
|
|
|
|
{
|
|
|
|
auto ptr = _Myfirst;
|
|
|
|
len = static_cast<_TSIZE>(this->size());
|
|
|
|
memset(this, 0, sizeof(*this));
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2021-12-11 13:02:56 +08:00
|
|
|
void _Reallocate_exactly(size_t new_cap)
|
2021-12-10 19:15:48 +08:00
|
|
|
{
|
2021-12-11 20:15:29 +08:00
|
|
|
auto new_block = (_Elem*)_Alloc::reallocate(_Myfirst, _Myend - _Myfirst, new_cap);
|
2021-12-11 13:02:56 +08:00
|
|
|
if (new_block || 0 == new_cap)
|
|
|
|
_Myfirst = new_block;
|
2021-12-10 19:15:48 +08:00
|
|
|
else
|
2021-12-11 13:02:56 +08:00
|
|
|
throw std::bad_alloc{};
|
|
|
|
_Myend = _Myfirst + new_cap;
|
2021-12-10 19:15:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
_Elem* _Myfirst = nullptr;
|
|
|
|
_Elem* _Mylast = nullptr;
|
|
|
|
_Elem* _Myend = nullptr;
|
|
|
|
};
|
|
|
|
using sbyte_buffer = basic_byte_buffer<char>;
|
|
|
|
using byte_buffer = basic_byte_buffer<uint8_t>;
|
|
|
|
} // namespace yasio
|
2021-12-11 13:02:56 +08:00
|
|
|
#endif
|