mirror of
https://github.com/ZeroTier/ZeroTierOne
synced 2025-08-19 13:01:39 -07:00
clang-format this branch
This commit is contained in:
Adam Ierymenko
parent
8b77ef538a
commit
342fa9d33f
135 changed files with 42729 additions and 42439 deletions
846
node/Buffer.hpp
846
node/Buffer.hpp
|
|
@ -46,474 +46,474 @@ namespace ZeroTier {
|
|||
* @tparam C Total capacity
|
||||
*/
|
||||
template <unsigned int C> class Buffer {
|
||||
// I love me!
|
||||
template <unsigned int C2> friend class Buffer;
|
||||
// I love me!
|
||||
template <unsigned int C2> friend class Buffer;
|
||||
|
||||
public:
|
||||
// STL container idioms
|
||||
typedef unsigned char value_type;
|
||||
typedef unsigned char* pointer;
|
||||
typedef const char* const_pointer;
|
||||
typedef char& reference;
|
||||
typedef const char& const_reference;
|
||||
typedef char* iterator;
|
||||
typedef const char* const_iterator;
|
||||
typedef unsigned int size_type;
|
||||
typedef int difference_type;
|
||||
typedef std::reverse_iterator<iterator> reverse_iterator;
|
||||
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
||||
inline iterator begin()
|
||||
{
|
||||
return _b;
|
||||
}
|
||||
inline iterator end()
|
||||
{
|
||||
return (_b + _l);
|
||||
}
|
||||
inline const_iterator begin() const
|
||||
{
|
||||
return _b;
|
||||
}
|
||||
inline const_iterator end() const
|
||||
{
|
||||
return (_b + _l);
|
||||
}
|
||||
inline reverse_iterator rbegin()
|
||||
{
|
||||
return reverse_iterator(begin());
|
||||
}
|
||||
inline reverse_iterator rend()
|
||||
{
|
||||
return reverse_iterator(end());
|
||||
}
|
||||
inline const_reverse_iterator rbegin() const
|
||||
{
|
||||
return const_reverse_iterator(begin());
|
||||
}
|
||||
inline const_reverse_iterator rend() const
|
||||
{
|
||||
return const_reverse_iterator(end());
|
||||
}
|
||||
// STL container idioms
|
||||
typedef unsigned char value_type;
|
||||
typedef unsigned char* pointer;
|
||||
typedef const char* const_pointer;
|
||||
typedef char& reference;
|
||||
typedef const char& const_reference;
|
||||
typedef char* iterator;
|
||||
typedef const char* const_iterator;
|
||||
typedef unsigned int size_type;
|
||||
typedef int difference_type;
|
||||
typedef std::reverse_iterator<iterator> reverse_iterator;
|
||||
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
||||
inline iterator begin()
|
||||
{
|
||||
return _b;
|
||||
}
|
||||
inline iterator end()
|
||||
{
|
||||
return (_b + _l);
|
||||
}
|
||||
inline const_iterator begin() const
|
||||
{
|
||||
return _b;
|
||||
}
|
||||
inline const_iterator end() const
|
||||
{
|
||||
return (_b + _l);
|
||||
}
|
||||
inline reverse_iterator rbegin()
|
||||
{
|
||||
return reverse_iterator(begin());
|
||||
}
|
||||
inline reverse_iterator rend()
|
||||
{
|
||||
return reverse_iterator(end());
|
||||
}
|
||||
inline const_reverse_iterator rbegin() const
|
||||
{
|
||||
return const_reverse_iterator(begin());
|
||||
}
|
||||
inline const_reverse_iterator rend() const
|
||||
{
|
||||
return const_reverse_iterator(end());
|
||||
}
|
||||
|
||||
Buffer() : _l(0)
|
||||
{
|
||||
}
|
||||
Buffer() : _l(0)
|
||||
{
|
||||
}
|
||||
|
||||
Buffer(unsigned int l)
|
||||
{
|
||||
if (l > C) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
_l = l;
|
||||
}
|
||||
Buffer(unsigned int l)
|
||||
{
|
||||
if (l > C) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
_l = l;
|
||||
}
|
||||
|
||||
template <unsigned int C2> Buffer(const Buffer<C2>& b)
|
||||
{
|
||||
*this = b;
|
||||
}
|
||||
template <unsigned int C2> Buffer(const Buffer<C2>& b)
|
||||
{
|
||||
*this = b;
|
||||
}
|
||||
|
||||
Buffer(const void* b, unsigned int l)
|
||||
{
|
||||
copyFrom(b, l);
|
||||
}
|
||||
Buffer(const void* b, unsigned int l)
|
||||
{
|
||||
copyFrom(b, l);
|
||||
}
|
||||
|
||||
template <unsigned int C2> inline Buffer& operator=(const Buffer<C2>& b)
|
||||
{
|
||||
if (unlikely(b._l > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
if (C2 == C) {
|
||||
memcpy(this, &b, sizeof(Buffer<C>));
|
||||
}
|
||||
else {
|
||||
memcpy(_b, b._b, _l = b._l);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
template <unsigned int C2> inline Buffer& operator=(const Buffer<C2>& b)
|
||||
{
|
||||
if (unlikely(b._l > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
if (C2 == C) {
|
||||
memcpy(this, &b, sizeof(Buffer<C>));
|
||||
}
|
||||
else {
|
||||
memcpy(_b, b._b, _l = b._l);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline void copyFrom(const void* b, unsigned int l)
|
||||
{
|
||||
if (unlikely(l > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
memcpy(_b, b, l);
|
||||
_l = l;
|
||||
}
|
||||
inline void copyFrom(const void* b, unsigned int l)
|
||||
{
|
||||
if (unlikely(l > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
memcpy(_b, b, l);
|
||||
_l = l;
|
||||
}
|
||||
|
||||
unsigned char operator[](const unsigned int i) const
|
||||
{
|
||||
if (unlikely(i >= _l)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
return (unsigned char)_b[i];
|
||||
}
|
||||
unsigned char operator[](const unsigned int i) const
|
||||
{
|
||||
if (unlikely(i >= _l)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
return (unsigned char)_b[i];
|
||||
}
|
||||
|
||||
unsigned char& operator[](const unsigned int i)
|
||||
{
|
||||
if (unlikely(i >= _l)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
return ((unsigned char*)_b)[i];
|
||||
}
|
||||
unsigned char& operator[](const unsigned int i)
|
||||
{
|
||||
if (unlikely(i >= _l)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
return ((unsigned char*)_b)[i];
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a raw pointer to a field with bounds checking
|
||||
*
|
||||
* This isn't perfectly safe in that the caller could still overflow
|
||||
* the pointer, but its use provides both a sanity check and
|
||||
* documentation / reminder to the calling code to treat the returned
|
||||
* pointer as being of size [l].
|
||||
*
|
||||
* @param i Index of field in buffer
|
||||
* @param l Length of field in bytes
|
||||
* @return Pointer to field data
|
||||
* @throws std::out_of_range Field extends beyond data size
|
||||
*/
|
||||
unsigned char* field(unsigned int i, unsigned int l)
|
||||
{
|
||||
if (unlikely((i + l) > _l)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
return (unsigned char*)(_b + i);
|
||||
}
|
||||
const unsigned char* field(unsigned int i, unsigned int l) const
|
||||
{
|
||||
if (unlikely((i + l) > _l)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
return (const unsigned char*)(_b + i);
|
||||
}
|
||||
/**
|
||||
* Get a raw pointer to a field with bounds checking
|
||||
*
|
||||
* This isn't perfectly safe in that the caller could still overflow
|
||||
* the pointer, but its use provides both a sanity check and
|
||||
* documentation / reminder to the calling code to treat the returned
|
||||
* pointer as being of size [l].
|
||||
*
|
||||
* @param i Index of field in buffer
|
||||
* @param l Length of field in bytes
|
||||
* @return Pointer to field data
|
||||
* @throws std::out_of_range Field extends beyond data size
|
||||
*/
|
||||
unsigned char* field(unsigned int i, unsigned int l)
|
||||
{
|
||||
if (unlikely((i + l) > _l)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
return (unsigned char*)(_b + i);
|
||||
}
|
||||
const unsigned char* field(unsigned int i, unsigned int l) const
|
||||
{
|
||||
if (unlikely((i + l) > _l)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
return (const unsigned char*)(_b + i);
|
||||
}
|
||||
|
||||
/**
|
||||
* Place a primitive integer value at a given position
|
||||
*
|
||||
* @param i Index to place value
|
||||
* @param v Value
|
||||
* @tparam T Integer type (e.g. uint16_t, int64_t)
|
||||
*/
|
||||
template <typename T> inline void setAt(unsigned int i, const T v)
|
||||
{
|
||||
if (unlikely((i + sizeof(T)) > _l)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
/**
|
||||
* Place a primitive integer value at a given position
|
||||
*
|
||||
* @param i Index to place value
|
||||
* @param v Value
|
||||
* @tparam T Integer type (e.g. uint16_t, int64_t)
|
||||
*/
|
||||
template <typename T> inline void setAt(unsigned int i, const T v)
|
||||
{
|
||||
if (unlikely((i + sizeof(T)) > _l)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
#ifdef ZT_NO_TYPE_PUNNING
|
||||
uint8_t* p = reinterpret_cast<uint8_t*>(_b + i);
|
||||
for (unsigned int x = 1; x <= sizeof(T); ++x) {
|
||||
*(p++) = (uint8_t)(v >> (8 * (sizeof(T) - x)));
|
||||
}
|
||||
uint8_t* p = reinterpret_cast<uint8_t*>(_b + i);
|
||||
for (unsigned int x = 1; x <= sizeof(T); ++x) {
|
||||
*(p++) = (uint8_t)(v >> (8 * (sizeof(T) - x)));
|
||||
}
|
||||
#else
|
||||
T* const ZT_VAR_MAY_ALIAS p = reinterpret_cast<T*>(_b + i);
|
||||
*p = Utils::hton(v);
|
||||
T* const ZT_VAR_MAY_ALIAS p = reinterpret_cast<T*>(_b + i);
|
||||
*p = Utils::hton(v);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a primitive integer value at a given position
|
||||
*
|
||||
* @param i Index to get integer
|
||||
* @tparam T Integer type (e.g. uint16_t, int64_t)
|
||||
* @return Integer value
|
||||
*/
|
||||
template <typename T> inline T at(unsigned int i) const
|
||||
{
|
||||
if (unlikely((i + sizeof(T)) > _l)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
/**
|
||||
* Get a primitive integer value at a given position
|
||||
*
|
||||
* @param i Index to get integer
|
||||
* @tparam T Integer type (e.g. uint16_t, int64_t)
|
||||
* @return Integer value
|
||||
*/
|
||||
template <typename T> inline T at(unsigned int i) const
|
||||
{
|
||||
if (unlikely((i + sizeof(T)) > _l)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
#ifdef ZT_NO_TYPE_PUNNING
|
||||
T v = 0;
|
||||
const uint8_t* p = reinterpret_cast<const uint8_t*>(_b + i);
|
||||
for (unsigned int x = 0; x < sizeof(T); ++x) {
|
||||
v <<= 8;
|
||||
v |= (T) * (p++);
|
||||
}
|
||||
return v;
|
||||
T v = 0;
|
||||
const uint8_t* p = reinterpret_cast<const uint8_t*>(_b + i);
|
||||
for (unsigned int x = 0; x < sizeof(T); ++x) {
|
||||
v <<= 8;
|
||||
v |= (T) * (p++);
|
||||
}
|
||||
return v;
|
||||
#else
|
||||
const T* const ZT_VAR_MAY_ALIAS p = reinterpret_cast<const T*>(_b + i);
|
||||
return Utils::ntoh(*p);
|
||||
const T* const ZT_VAR_MAY_ALIAS p = reinterpret_cast<const T*>(_b + i);
|
||||
return Utils::ntoh(*p);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Append an integer type to this buffer
|
||||
*
|
||||
* @param v Value to append
|
||||
* @tparam T Integer type (e.g. uint16_t, int64_t)
|
||||
* @throws std::out_of_range Attempt to append beyond capacity
|
||||
*/
|
||||
template <typename T> inline void append(const T v)
|
||||
{
|
||||
if (unlikely((_l + sizeof(T)) > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
/**
|
||||
* Append an integer type to this buffer
|
||||
*
|
||||
* @param v Value to append
|
||||
* @tparam T Integer type (e.g. uint16_t, int64_t)
|
||||
* @throws std::out_of_range Attempt to append beyond capacity
|
||||
*/
|
||||
template <typename T> inline void append(const T v)
|
||||
{
|
||||
if (unlikely((_l + sizeof(T)) > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
#ifdef ZT_NO_TYPE_PUNNING
|
||||
uint8_t* p = reinterpret_cast<uint8_t*>(_b + _l);
|
||||
for (unsigned int x = 1; x <= sizeof(T); ++x) {
|
||||
*(p++) = (uint8_t)(v >> (8 * (sizeof(T) - x)));
|
||||
}
|
||||
uint8_t* p = reinterpret_cast<uint8_t*>(_b + _l);
|
||||
for (unsigned int x = 1; x <= sizeof(T); ++x) {
|
||||
*(p++) = (uint8_t)(v >> (8 * (sizeof(T) - x)));
|
||||
}
|
||||
#else
|
||||
T* const ZT_VAR_MAY_ALIAS p = reinterpret_cast<T*>(_b + _l);
|
||||
*p = Utils::hton(v);
|
||||
T* const ZT_VAR_MAY_ALIAS p = reinterpret_cast<T*>(_b + _l);
|
||||
*p = Utils::hton(v);
|
||||
#endif
|
||||
_l += sizeof(T);
|
||||
}
|
||||
_l += sizeof(T);
|
||||
}
|
||||
|
||||
/**
|
||||
* Append a run of bytes
|
||||
*
|
||||
* @param c Character value to append
|
||||
* @param n Number of times to append
|
||||
* @throws std::out_of_range Attempt to append beyond capacity
|
||||
*/
|
||||
inline void append(unsigned char c, unsigned int n)
|
||||
{
|
||||
if (unlikely((_l + n) > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
for (unsigned int i = 0; i < n; ++i) {
|
||||
_b[_l++] = (char)c;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Append a run of bytes
|
||||
*
|
||||
* @param c Character value to append
|
||||
* @param n Number of times to append
|
||||
* @throws std::out_of_range Attempt to append beyond capacity
|
||||
*/
|
||||
inline void append(unsigned char c, unsigned int n)
|
||||
{
|
||||
if (unlikely((_l + n) > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
for (unsigned int i = 0; i < n; ++i) {
|
||||
_b[_l++] = (char)c;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Append secure random bytes
|
||||
*
|
||||
* @param n Number of random bytes to append
|
||||
*/
|
||||
inline void appendRandom(unsigned int n)
|
||||
{
|
||||
if (unlikely((_l + n) > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
Utils::getSecureRandom(_b + _l, n);
|
||||
_l += n;
|
||||
}
|
||||
/**
|
||||
* Append secure random bytes
|
||||
*
|
||||
* @param n Number of random bytes to append
|
||||
*/
|
||||
inline void appendRandom(unsigned int n)
|
||||
{
|
||||
if (unlikely((_l + n) > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
Utils::getSecureRandom(_b + _l, n);
|
||||
_l += n;
|
||||
}
|
||||
|
||||
/**
|
||||
* Append a C-array of bytes
|
||||
*
|
||||
* @param b Data
|
||||
* @param l Length
|
||||
* @throws std::out_of_range Attempt to append beyond capacity
|
||||
*/
|
||||
inline void append(const void* b, unsigned int l)
|
||||
{
|
||||
if (unlikely((_l + l) > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
memcpy(_b + _l, b, l);
|
||||
_l += l;
|
||||
}
|
||||
/**
|
||||
* Append a C-array of bytes
|
||||
*
|
||||
* @param b Data
|
||||
* @param l Length
|
||||
* @throws std::out_of_range Attempt to append beyond capacity
|
||||
*/
|
||||
inline void append(const void* b, unsigned int l)
|
||||
{
|
||||
if (unlikely((_l + l) > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
memcpy(_b + _l, b, l);
|
||||
_l += l;
|
||||
}
|
||||
|
||||
/**
|
||||
* Append a C string including null termination byte
|
||||
*
|
||||
* @param s C string
|
||||
* @throws std::out_of_range Attempt to append beyond capacity
|
||||
*/
|
||||
inline void appendCString(const char* s)
|
||||
{
|
||||
for (;;) {
|
||||
if (unlikely(_l >= C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
if (! (_b[_l++] = *(s++))) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Append a C string including null termination byte
|
||||
*
|
||||
* @param s C string
|
||||
* @throws std::out_of_range Attempt to append beyond capacity
|
||||
*/
|
||||
inline void appendCString(const char* s)
|
||||
{
|
||||
for (;;) {
|
||||
if (unlikely(_l >= C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
if (! (_b[_l++] = *(s++))) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Append a buffer
|
||||
*
|
||||
* @param b Buffer to append
|
||||
* @tparam C2 Capacity of second buffer (typically inferred)
|
||||
* @throws std::out_of_range Attempt to append beyond capacity
|
||||
*/
|
||||
template <unsigned int C2> inline void append(const Buffer<C2>& b)
|
||||
{
|
||||
append(b._b, b._l);
|
||||
}
|
||||
/**
|
||||
* Append a buffer
|
||||
*
|
||||
* @param b Buffer to append
|
||||
* @tparam C2 Capacity of second buffer (typically inferred)
|
||||
* @throws std::out_of_range Attempt to append beyond capacity
|
||||
*/
|
||||
template <unsigned int C2> inline void append(const Buffer<C2>& b)
|
||||
{
|
||||
append(b._b, b._l);
|
||||
}
|
||||
|
||||
/**
|
||||
* Increment size and return pointer to field of specified size
|
||||
*
|
||||
* Nothing is actually written to the memory. This is a shortcut
|
||||
* for addSize() followed by field() to reference the previous
|
||||
* position and the new size.
|
||||
*
|
||||
* @param l Length of field to append
|
||||
* @return Pointer to beginning of appended field of length 'l'
|
||||
*/
|
||||
inline char* appendField(unsigned int l)
|
||||
{
|
||||
if (unlikely((_l + l) > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
char* r = _b + _l;
|
||||
_l += l;
|
||||
return r;
|
||||
}
|
||||
/**
|
||||
* Increment size and return pointer to field of specified size
|
||||
*
|
||||
* Nothing is actually written to the memory. This is a shortcut
|
||||
* for addSize() followed by field() to reference the previous
|
||||
* position and the new size.
|
||||
*
|
||||
* @param l Length of field to append
|
||||
* @return Pointer to beginning of appended field of length 'l'
|
||||
*/
|
||||
inline char* appendField(unsigned int l)
|
||||
{
|
||||
if (unlikely((_l + l) > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
char* r = _b + _l;
|
||||
_l += l;
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
* Increment size by a given number of bytes
|
||||
*
|
||||
* The contents of new space are undefined.
|
||||
*
|
||||
* @param i Bytes to increment
|
||||
* @throws std::out_of_range Capacity exceeded
|
||||
*/
|
||||
inline void addSize(unsigned int i)
|
||||
{
|
||||
if (unlikely((i + _l) > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
_l += i;
|
||||
}
|
||||
/**
|
||||
* Increment size by a given number of bytes
|
||||
*
|
||||
* The contents of new space are undefined.
|
||||
*
|
||||
* @param i Bytes to increment
|
||||
* @throws std::out_of_range Capacity exceeded
|
||||
*/
|
||||
inline void addSize(unsigned int i)
|
||||
{
|
||||
if (unlikely((i + _l) > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
_l += i;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set size of data in buffer
|
||||
*
|
||||
* The contents of new space are undefined.
|
||||
*
|
||||
* @param i New size
|
||||
* @throws std::out_of_range Size larger than capacity
|
||||
*/
|
||||
inline void setSize(const unsigned int i)
|
||||
{
|
||||
if (unlikely(i > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
_l = i;
|
||||
}
|
||||
/**
|
||||
* Set size of data in buffer
|
||||
*
|
||||
* The contents of new space are undefined.
|
||||
*
|
||||
* @param i New size
|
||||
* @throws std::out_of_range Size larger than capacity
|
||||
*/
|
||||
inline void setSize(const unsigned int i)
|
||||
{
|
||||
if (unlikely(i > C)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
_l = i;
|
||||
}
|
||||
|
||||
/**
|
||||
* Move everything after 'at' to the buffer's front and truncate
|
||||
*
|
||||
* @param at Truncate before this position
|
||||
* @throws std::out_of_range Position is beyond size of buffer
|
||||
*/
|
||||
inline void behead(const unsigned int at)
|
||||
{
|
||||
if (! at) {
|
||||
return;
|
||||
}
|
||||
if (unlikely(at > _l)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
::memmove(_b, _b + at, _l -= at);
|
||||
}
|
||||
/**
|
||||
* Move everything after 'at' to the buffer's front and truncate
|
||||
*
|
||||
* @param at Truncate before this position
|
||||
* @throws std::out_of_range Position is beyond size of buffer
|
||||
*/
|
||||
inline void behead(const unsigned int at)
|
||||
{
|
||||
if (! at) {
|
||||
return;
|
||||
}
|
||||
if (unlikely(at > _l)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
::memmove(_b, _b + at, _l -= at);
|
||||
}
|
||||
|
||||
/**
|
||||
* Erase something from the middle of the buffer
|
||||
*
|
||||
* @param start Starting position
|
||||
* @param length Length of block to erase
|
||||
* @throws std::out_of_range Position plus length is beyond size of buffer
|
||||
*/
|
||||
inline void erase(const unsigned int at, const unsigned int length)
|
||||
{
|
||||
const unsigned int endr = at + length;
|
||||
if (unlikely(endr > _l)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
::memmove(_b + at, _b + endr, _l - endr);
|
||||
_l -= length;
|
||||
}
|
||||
/**
|
||||
* Erase something from the middle of the buffer
|
||||
*
|
||||
* @param start Starting position
|
||||
* @param length Length of block to erase
|
||||
* @throws std::out_of_range Position plus length is beyond size of buffer
|
||||
*/
|
||||
inline void erase(const unsigned int at, const unsigned int length)
|
||||
{
|
||||
const unsigned int endr = at + length;
|
||||
if (unlikely(endr > _l)) {
|
||||
throw ZT_EXCEPTION_OUT_OF_BOUNDS;
|
||||
}
|
||||
::memmove(_b + at, _b + endr, _l - endr);
|
||||
_l -= length;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set buffer data length to zero
|
||||
*/
|
||||
inline void clear()
|
||||
{
|
||||
_l = 0;
|
||||
}
|
||||
/**
|
||||
* Set buffer data length to zero
|
||||
*/
|
||||
inline void clear()
|
||||
{
|
||||
_l = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Zero buffer up to size()
|
||||
*/
|
||||
inline void zero()
|
||||
{
|
||||
memset(_b, 0, _l);
|
||||
}
|
||||
/**
|
||||
* Zero buffer up to size()
|
||||
*/
|
||||
inline void zero()
|
||||
{
|
||||
memset(_b, 0, _l);
|
||||
}
|
||||
|
||||
/**
|
||||
* Zero unused capacity area
|
||||
*/
|
||||
inline void zeroUnused()
|
||||
{
|
||||
memset(_b + _l, 0, C - _l);
|
||||
}
|
||||
/**
|
||||
* Zero unused capacity area
|
||||
*/
|
||||
inline void zeroUnused()
|
||||
{
|
||||
memset(_b + _l, 0, C - _l);
|
||||
}
|
||||
|
||||
/**
|
||||
* Unconditionally and securely zero buffer's underlying memory
|
||||
*/
|
||||
inline void burn()
|
||||
{
|
||||
Utils::burn(_b, sizeof(_b));
|
||||
}
|
||||
/**
|
||||
* Unconditionally and securely zero buffer's underlying memory
|
||||
*/
|
||||
inline void burn()
|
||||
{
|
||||
Utils::burn(_b, sizeof(_b));
|
||||
}
|
||||
|
||||
/**
|
||||
* @return Constant pointer to data in buffer
|
||||
*/
|
||||
inline const void* data() const
|
||||
{
|
||||
return _b;
|
||||
}
|
||||
/**
|
||||
* @return Constant pointer to data in buffer
|
||||
*/
|
||||
inline const void* data() const
|
||||
{
|
||||
return _b;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return Non-constant pointer to data in buffer
|
||||
*/
|
||||
inline void* unsafeData()
|
||||
{
|
||||
return _b;
|
||||
}
|
||||
/**
|
||||
* @return Non-constant pointer to data in buffer
|
||||
*/
|
||||
inline void* unsafeData()
|
||||
{
|
||||
return _b;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return Size of data in buffer
|
||||
*/
|
||||
inline unsigned int size() const
|
||||
{
|
||||
return _l;
|
||||
}
|
||||
/**
|
||||
* @return Size of data in buffer
|
||||
*/
|
||||
inline unsigned int size() const
|
||||
{
|
||||
return _l;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return Capacity of buffer
|
||||
*/
|
||||
inline unsigned int capacity() const
|
||||
{
|
||||
return C;
|
||||
}
|
||||
/**
|
||||
* @return Capacity of buffer
|
||||
*/
|
||||
inline unsigned int capacity() const
|
||||
{
|
||||
return C;
|
||||
}
|
||||
|
||||
template <unsigned int C2> inline bool operator==(const Buffer<C2>& b) const
|
||||
{
|
||||
return ((_l == b._l) && (! memcmp(_b, b._b, _l)));
|
||||
}
|
||||
template <unsigned int C2> inline bool operator!=(const Buffer<C2>& b) const
|
||||
{
|
||||
return ((_l != b._l) || (memcmp(_b, b._b, _l)));
|
||||
}
|
||||
template <unsigned int C2> inline bool operator<(const Buffer<C2>& b) const
|
||||
{
|
||||
return (memcmp(_b, b._b, std::min(_l, b._l)) < 0);
|
||||
}
|
||||
template <unsigned int C2> inline bool operator>(const Buffer<C2>& b) const
|
||||
{
|
||||
return (b < *this);
|
||||
}
|
||||
template <unsigned int C2> inline bool operator<=(const Buffer<C2>& b) const
|
||||
{
|
||||
return ! (b < *this);
|
||||
}
|
||||
template <unsigned int C2> inline bool operator>=(const Buffer<C2>& b) const
|
||||
{
|
||||
return ! (*this < b);
|
||||
}
|
||||
template <unsigned int C2> inline bool operator==(const Buffer<C2>& b) const
|
||||
{
|
||||
return ((_l == b._l) && (! memcmp(_b, b._b, _l)));
|
||||
}
|
||||
template <unsigned int C2> inline bool operator!=(const Buffer<C2>& b) const
|
||||
{
|
||||
return ((_l != b._l) || (memcmp(_b, b._b, _l)));
|
||||
}
|
||||
template <unsigned int C2> inline bool operator<(const Buffer<C2>& b) const
|
||||
{
|
||||
return (memcmp(_b, b._b, std::min(_l, b._l)) < 0);
|
||||
}
|
||||
template <unsigned int C2> inline bool operator>(const Buffer<C2>& b) const
|
||||
{
|
||||
return (b < *this);
|
||||
}
|
||||
template <unsigned int C2> inline bool operator<=(const Buffer<C2>& b) const
|
||||
{
|
||||
return ! (b < *this);
|
||||
}
|
||||
template <unsigned int C2> inline bool operator>=(const Buffer<C2>& b) const
|
||||
{
|
||||
return ! (*this < b);
|
||||
}
|
||||
|
||||
private:
|
||||
char ZT_VAR_MAY_ALIAS _b[C];
|
||||
unsigned int _l;
|
||||
char ZT_VAR_MAY_ALIAS _b[C];
|
||||
unsigned int _l;
|
||||
};
|
||||
|
||||
} // namespace ZeroTier
|
||||
} // namespace ZeroTier
|
||||
|
||||
#endif
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue