tg2sip/libtgvoip/Buffers.h

275 lines
5.9 KiB
C++

//
// libtgvoip is free and unencumbered public domain software.
// For more information, see http://unlicense.org or the UNLICENSE file
// you should have received with this source code distribution.
//
#ifndef LIBTGVOIP_BUFFERINPUTSTREAM_H
#define LIBTGVOIP_BUFFERINPUTSTREAM_H
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <stdexcept>
#include <array>
#include <limits>
#include <stddef.h>
#include "threading.h"
#include "utils.h"
namespace tgvoip{
class Buffer;
class BufferInputStream{
public:
BufferInputStream(const unsigned char* data, size_t length);
BufferInputStream(const Buffer& buffer);
~BufferInputStream();
void Seek(size_t offset);
size_t GetLength();
size_t GetOffset();
size_t Remaining();
unsigned char ReadByte();
int64_t ReadInt64();
int32_t ReadInt32();
int16_t ReadInt16();
int32_t ReadTlLength();
void ReadBytes(unsigned char* to, size_t count);
void ReadBytes(Buffer& to);
BufferInputStream GetPartBuffer(size_t length, bool advance);
private:
void EnsureEnoughRemaining(size_t need);
const unsigned char* buffer;
size_t length;
size_t offset;
};
class BufferOutputStream{
friend class Buffer;
public:
TGVOIP_DISALLOW_COPY_AND_ASSIGN(BufferOutputStream);
BufferOutputStream(size_t size);
BufferOutputStream(unsigned char* buffer, size_t size);
~BufferOutputStream();
void WriteByte(unsigned char byte);
void WriteInt64(int64_t i);
void WriteInt32(int32_t i);
void WriteInt16(int16_t i);
void WriteBytes(const unsigned char* bytes, size_t count);
void WriteBytes(const Buffer& buffer);
void WriteBytes(const Buffer& buffer, size_t offset, size_t count);
unsigned char* GetBuffer();
size_t GetLength();
void Reset();
void Rewind(size_t numBytes);
BufferOutputStream& operator=(BufferOutputStream&& other){
if(this!=&other){
if(!bufferProvided && buffer)
free(buffer);
buffer=other.buffer;
offset=other.offset;
size=other.size;
bufferProvided=other.bufferProvided;
other.buffer=NULL;
}
return *this;
}
private:
void ExpandBufferIfNeeded(size_t need);
unsigned char* buffer=NULL;
size_t size;
size_t offset;
bool bufferProvided;
};
class BufferPool{
public:
TGVOIP_DISALLOW_COPY_AND_ASSIGN(BufferPool);
BufferPool(unsigned int size, unsigned int count);
~BufferPool();
unsigned char* Get();
void Reuse(unsigned char* buffer);
size_t GetSingleBufferSize();
size_t GetBufferCount();
private:
uint64_t usedBuffers;
int bufferCount;
size_t size;
unsigned char* buffers[64];
Mutex mutex;
};
class Buffer{
public:
Buffer(size_t capacity){
if(capacity>0)
data=(unsigned char *) malloc(capacity);
else
data=NULL;
length=capacity;
};
TGVOIP_DISALLOW_COPY_AND_ASSIGN(Buffer); // use Buffer::CopyOf to copy contents explicitly
Buffer(Buffer&& other) noexcept {
data=other.data;
length=other.length;
other.data=NULL;
};
Buffer(BufferOutputStream&& stream){
data=stream.buffer;
length=stream.offset;
stream.buffer=NULL;
}
Buffer(){
data=NULL;
length=0;
}
~Buffer(){
if(data)
free(data);
data=NULL;
};
Buffer& operator=(Buffer&& other){
if(this!=&other){
if(data)
free(data);
data=other.data;
length=other.length;
other.data=NULL;
}
return *this;
}
unsigned char& operator[](size_t i){
if(i>=length)
throw std::out_of_range("");
return data[i];
}
const unsigned char& operator[](size_t i) const{
if(i>=length)
throw std::out_of_range("");
return data[i];
}
unsigned char* operator*(){
return data;
}
const unsigned char* operator*() const{
return data;
}
void CopyFrom(const Buffer& other, size_t count, size_t srcOffset=0, size_t dstOffset=0){
if(!other.data)
throw std::invalid_argument("CopyFrom can't copy from NULL");
if(other.length<srcOffset+count || length<dstOffset+count)
throw std::out_of_range("Out of offset+count bounds of either buffer");
memcpy(data+dstOffset, other.data+srcOffset, count);
}
void CopyFrom(const void* ptr, size_t dstOffset, size_t count){
if(length<dstOffset+count)
throw std::out_of_range("Offset+count is out of bounds");
memcpy(data+dstOffset, ptr, count);
}
void Resize(size_t newSize){
data=(unsigned char *) realloc(data, newSize);
length=newSize;
}
size_t Length() const{
return length;
}
bool IsEmpty() const{
return length==0;
}
static Buffer CopyOf(const Buffer& other){
Buffer buf(other.length);
buf.CopyFrom(other, other.length);
return buf;
}
private:
unsigned char* data;
size_t length;
};
template <typename T, size_t size, typename AVG_T=T> class HistoricBuffer{
public:
HistoricBuffer(){
std::fill(data.begin(), data.end(), (T)0);
}
AVG_T Average(){
AVG_T avg=(AVG_T)0;
for(T& i:data){
avg+=i;
}
return avg/(AVG_T)size;
}
AVG_T Average(size_t firstN){
AVG_T avg=(AVG_T)0;
for(size_t i=0;i<firstN;i++){
avg+=(*this)[i];
}
return avg/(AVG_T)firstN;
}
AVG_T NonZeroAverage(){
AVG_T avg=(AVG_T)0;
int nonZeroCount=0;
for(T& i:data){
if(i!=0){
nonZeroCount++;
avg+=i;
}
}
if(nonZeroCount==0)
return (AVG_T)0;
return avg/(AVG_T)nonZeroCount;
}
void Add(T el){
data[offset]=el;
offset=(offset+1)%size;
}
T Min(){
T min=std::numeric_limits<T>::max();
for(T& i:data){
if(i<min)
min=i;
}
return min;
}
T Max(){
T max=std::numeric_limits<T>::min();
for(T& i:data){
if(i>max)
max=i;
}
return max;
}
void Reset(){
std::fill(data.begin(), data.end(), (T)0);
offset=0;
}
T& operator[](size_t i){
assert(i<size);
// [0] should return the most recent entry, [1] the one before it, and so on
ptrdiff_t _i=offset-i-1;
if(_i<0)
_i=size+_i;
return data[_i];
}
private:
std::array<T, size> data;
ptrdiff_t offset=0;
};
}
#endif //LIBTGVOIP_BUFFERINPUTSTREAM_H