Skip to content

TDengine
TDengine

taosdata / TDengine
1 年多 前同步成功

通知 1185
Star 22016
Fork 4786
TDengine
TDengine
提交 3311fec1 编写于 作者: H Hongze Cheng
浏览文件
操作

refact

上级 7c564581
隐藏空白更改
内联 并排
Showing with 243 addition and 261 deletion
include/util/tbuffer.h
浏览文件 @ 3311fec1
...@@ -71,102 +71,102 @@ int main( int argc, char** argv ) { ...@@ -71,102 +71,102 @@ int main( int argc, char** argv ) {
*/ */
typedef struct SBufferReader { typedef struct SBufferReader {
bool endian; bool endian;
const char* data; const char* data;
size_t pos; size_t pos;
size_t size; size_t size;
} SBufferReader; } SBufferReader;
typedef struct SBufferWriter { typedef struct SBufferWriter {
bool endian; bool endian;
char* data; char* data;
size_t pos; size_t pos;
size_t size; size_t size;
void* (*allocator)( void*, size_t ); void* (*allocator)(void*, size_t);
} SBufferWriter; } SBufferWriter;
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// common functions & macros for both reader & writer // common functions & macros for both reader & writer
#define tbufTell( buf ) ((buf)->pos) #define tbufTell(buf) ((buf)->pos)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// reader functions & macros // reader functions & macros
// *Endian*, if true, reader functions of primitive types will do 'ntoh' automatically // *Endian*, if true, reader functions of primitive types will do 'ntoh' automatically
#define tbufInitReader( Data, Size, Endian ) {.endian = (Endian), .data = (Data), .pos = 0, .size = ((Data) == NULL ? 0 :(Size))} #define tbufInitReader(Data, Size, Endian) \
{ .endian = (Endian), .data = (Data), .pos = 0, .size = ((Data) == NULL ? 0 : (Size)) }
size_t tbufSkip( SBufferReader* buf, size_t size );
size_t tbufSkip(SBufferReader* buf, size_t size);
const char* tbufRead( SBufferReader* buf, size_t size );
void tbufReadToBuffer( SBufferReader* buf, void* dst, size_t size ); const char* tbufRead(SBufferReader* buf, size_t size);
const char* tbufReadString( SBufferReader* buf, size_t* len ); void tbufReadToBuffer(SBufferReader* buf, void* dst, size_t size);
size_t tbufReadToString( SBufferReader* buf, char* dst, size_t size ); const char* tbufReadString(SBufferReader* buf, size_t* len);
const char* tbufReadBinary( SBufferReader* buf, size_t *len ); size_t tbufReadToString(SBufferReader* buf, char* dst, size_t size);
size_t tbufReadToBinary( SBufferReader* buf, void* dst, size_t size ); const char* tbufReadBinary(SBufferReader* buf, size_t* len);
size_t tbufReadToBinary(SBufferReader* buf, void* dst, size_t size);
bool tbufReadBool( SBufferReader* buf );
char tbufReadChar( SBufferReader* buf ); bool tbufReadBool(SBufferReader* buf);
int8_t tbufReadInt8( SBufferReader* buf ); char tbufReadChar(SBufferReader* buf);
uint8_t tbufReadUint8( SBufferReader* buf ); int8_t tbufReadInt8(SBufferReader* buf);
int16_t tbufReadInt16( SBufferReader* buf ); uint8_t tbufReadUint8(SBufferReader* buf);
uint16_t tbufReadUint16( SBufferReader* buf ); int16_t tbufReadInt16(SBufferReader* buf);
int32_t tbufReadInt32( SBufferReader* buf ); uint16_t tbufReadUint16(SBufferReader* buf);
uint32_t tbufReadUint32( SBufferReader* buf ); int32_t tbufReadInt32(SBufferReader* buf);
int64_t tbufReadInt64( SBufferReader* buf ); uint32_t tbufReadUint32(SBufferReader* buf);
uint64_t tbufReadUint64( SBufferReader* buf ); int64_t tbufReadInt64(SBufferReader* buf);
float tbufReadFloat( SBufferReader* buf ); uint64_t tbufReadUint64(SBufferReader* buf);
double tbufReadDouble( SBufferReader* buf ); float tbufReadFloat(SBufferReader* buf);
double tbufReadDouble(SBufferReader* buf);
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// writer functions & macros // writer functions & macros
// *Allocator*, function to allocate memory, will use 'realloc' if NULL // *Allocator*, function to allocate memory, will use 'realloc' if NULL
// *Endian*, if true, writer functions of primitive types will do 'hton' automatically // *Endian*, if true, writer functions of primitive types will do 'hton' automatically
#define tbufInitWriter( Allocator, Endian ) {.endian = (Endian), .data = NULL, .pos = 0, .size = 0, .allocator = ((Allocator) == NULL ? realloc : (Allocator))} #define tbufInitWriter(Allocator, Endian) \
void tbufCloseWriter( SBufferWriter* buf ); { .endian = (Endian), .data = NULL, .pos = 0, .size = 0, .allocator = ((Allocator) == NULL ? realloc : (Allocator)) }
void tbufCloseWriter(SBufferWriter* buf);
void tbufEnsureCapacity( SBufferWriter* buf, size_t size );
size_t tbufReserve( SBufferWriter* buf, size_t size ); void tbufEnsureCapacity(SBufferWriter* buf, size_t size);
char* tbufGetData( SBufferWriter* buf, bool takeOver ); size_t tbufReserve(SBufferWriter* buf, size_t size);
char* tbufGetData(SBufferWriter* buf, bool takeOver);
void tbufWrite( SBufferWriter* buf, const void* data, size_t size );
void tbufWriteAt( SBufferWriter* buf, size_t pos, const void* data, size_t size ); void tbufWrite(SBufferWriter* buf, const void* data, size_t size);
void tbufWriteStringLen( SBufferWriter* buf, const char* str, size_t len ); void tbufWriteAt(SBufferWriter* buf, size_t pos, const void* data, size_t size);
void tbufWriteString( SBufferWriter* buf, const char* str ); void tbufWriteStringLen(SBufferWriter* buf, const char* str, size_t len);
void tbufWriteString(SBufferWriter* buf, const char* str);
// the prototype of tbufWriteBinary and tbufWrite are identical // the prototype of tbufWriteBinary and tbufWrite are identical
// the difference is: tbufWriteBinary writes the length of the data to the buffer // the difference is: tbufWriteBinary writes the length of the data to the buffer
// first, then the actual data, which means the reader don't need to know data // first, then the actual data, which means the reader don't need to know data
// size before read. Write only write the data itself, which means the reader // size before read. Write only write the data itself, which means the reader
// need to know data size before read. // need to know data size before read.
void tbufWriteBinary( SBufferWriter* buf, const void* data, size_t len ); void tbufWriteBinary(SBufferWriter* buf, const void* data, size_t len);
void tbufWriteBool( SBufferWriter* buf, bool data ); void tbufWriteBool(SBufferWriter* buf, bool data);
void tbufWriteBoolAt( SBufferWriter* buf, size_t pos, bool data ); void tbufWriteBoolAt(SBufferWriter* buf, size_t pos, bool data);
void tbufWriteChar( SBufferWriter* buf, char data ); void tbufWriteChar(SBufferWriter* buf, char data);
void tbufWriteCharAt( SBufferWriter* buf, size_t pos, char data ); void tbufWriteCharAt(SBufferWriter* buf, size_t pos, char data);
void tbufWriteInt8( SBufferWriter* buf, int8_t data ); void tbufWriteInt8(SBufferWriter* buf, int8_t data);
void tbufWriteInt8At( SBufferWriter* buf, size_t pos, int8_t data ); void tbufWriteInt8At(SBufferWriter* buf, size_t pos, int8_t data);
void tbufWriteUint8( SBufferWriter* buf, uint8_t data ); void tbufWriteUint8(SBufferWriter* buf, uint8_t data);
void tbufWriteUint8At( SBufferWriter* buf, size_t pos, uint8_t data ); void tbufWriteUint8At(SBufferWriter* buf, size_t pos, uint8_t data);
void tbufWriteInt16( SBufferWriter* buf, int16_t data ); void tbufWriteInt16(SBufferWriter* buf, int16_t data);
void tbufWriteInt16At( SBufferWriter* buf, size_t pos, int16_t data ); void tbufWriteInt16At(SBufferWriter* buf, size_t pos, int16_t data);
void tbufWriteUint16( SBufferWriter* buf, uint16_t data ); void tbufWriteUint16(SBufferWriter* buf, uint16_t data);
void tbufWriteUint16At( SBufferWriter* buf, size_t pos, uint16_t data ); void tbufWriteUint16At(SBufferWriter* buf, size_t pos, uint16_t data);
void tbufWriteInt32( SBufferWriter* buf, int32_t data ); void tbufWriteInt32(SBufferWriter* buf, int32_t data);
void tbufWriteInt32At( SBufferWriter* buf, size_t pos, int32_t data ); void tbufWriteInt32At(SBufferWriter* buf, size_t pos, int32_t data);
void tbufWriteUint32( SBufferWriter* buf, uint32_t data ); void tbufWriteUint32(SBufferWriter* buf, uint32_t data);
void tbufWriteUint32At( SBufferWriter* buf, size_t pos, uint32_t data ); void tbufWriteUint32At(SBufferWriter* buf, size_t pos, uint32_t data);
void tbufWriteInt64( SBufferWriter* buf, int64_t data ); void tbufWriteInt64(SBufferWriter* buf, int64_t data);
void tbufWriteInt64At( SBufferWriter* buf, size_t pos, int64_t data ); void tbufWriteInt64At(SBufferWriter* buf, size_t pos, int64_t data);
void tbufWriteUint64( SBufferWriter* buf, uint64_t data ); void tbufWriteUint64(SBufferWriter* buf, uint64_t data);
void tbufWriteUint64At( SBufferWriter* buf, size_t pos, uint64_t data ); void tbufWriteUint64At(SBufferWriter* buf, size_t pos, uint64_t data);
void tbufWriteFloat( SBufferWriter* buf, float data ); void tbufWriteFloat(SBufferWriter* buf, float data);
void tbufWriteFloatAt( SBufferWriter* buf, size_t pos, float data ); void tbufWriteFloatAt(SBufferWriter* buf, size_t pos, float data);
void tbufWriteDouble( SBufferWriter* buf, double data ); void tbufWriteDouble(SBufferWriter* buf, double data);
void tbufWriteDoubleAt( SBufferWriter* buf, size_t pos, double data ); void tbufWriteDoubleAt(SBufferWriter* buf, size_t pos, double data);
#ifdef __cplusplus #ifdef __cplusplus
} }
......
source/util/src/tbuffer.c
浏览文件 @ 3311fec1
...@@ -13,14 +13,14 @@ ...@@ -13,14 +13,14 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "os.h"
#include "tbuffer.h" #include "tbuffer.h"
#include "exception.h" #include "exception.h"
#include "os.h"
//#include "taoserror.h" //#include "taoserror.h"
typedef union Un4B { typedef union Un4B {
uint32_t ui; uint32_t ui;
float f; float f;
} Un4B; } Un4B;
#if __STDC_VERSION__ >= 201112L #if __STDC_VERSION__ >= 201112L
static_assert(sizeof(Un4B) == sizeof(uint32_t), "sizeof(Un4B) must equal to sizeof(uint32_t)"); static_assert(sizeof(Un4B) == sizeof(uint32_t), "sizeof(Un4B) must equal to sizeof(uint32_t)");
...@@ -29,7 +29,7 @@ static_assert(sizeof(Un4B) == sizeof(float), "sizeof(Un4B) must equal to sizeof( ...@@ -29,7 +29,7 @@ static_assert(sizeof(Un4B) == sizeof(float), "sizeof(Un4B) must equal to sizeof(
typedef union Un8B { typedef union Un8B {
uint64_t ull; uint64_t ull;
double d; double d;
} Un8B; } Un8B;
#if __STDC_VERSION__ >= 201112L #if __STDC_VERSION__ >= 201112L
static_assert(sizeof(Un8B) == sizeof(uint64_t), "sizeof(Un8B) must equal to sizeof(uint64_t)"); static_assert(sizeof(Un8B) == sizeof(uint64_t), "sizeof(Un8B) must equal to sizeof(uint64_t)");
...@@ -40,172 +40,172 @@ static_assert(sizeof(Un8B) == sizeof(double), "sizeof(Un8B) must equal to sizeof ...@@ -40,172 +40,172 @@ static_assert(sizeof(Un8B) == sizeof(double), "sizeof(Un8B) must equal to sizeof
// reader functions // reader functions
size_t tbufSkip(SBufferReader* buf, size_t size) { size_t tbufSkip(SBufferReader* buf, size_t size) {
if( (buf->pos + size) > buf->size ) { if ((buf->pos + size) > buf->size) {
THROW( -1 ); THROW(-1);
} }
size_t old = buf->pos; size_t old = buf->pos;
buf->pos += size; buf->pos += size;
return old; return old;
} }
const char* tbufRead( SBufferReader* buf, size_t size ) { const char* tbufRead(SBufferReader* buf, size_t size) {
const char* ret = buf->data + buf->pos; const char* ret = buf->data + buf->pos;
tbufSkip( buf, size ); tbufSkip(buf, size);
return ret; return ret;
} }
void tbufReadToBuffer( SBufferReader* buf, void* dst, size_t size ) { void tbufReadToBuffer(SBufferReader* buf, void* dst, size_t size) {
assert( dst != NULL ); assert(dst != NULL);
// always using memcpy, leave optimization to compiler // always using memcpy, leave optimization to compiler
memcpy( dst, tbufRead(buf, size), size ); memcpy(dst, tbufRead(buf, size), size);
} }
static size_t tbufReadLength( SBufferReader* buf ) { static size_t tbufReadLength(SBufferReader* buf) {
// maximum length is 65535, if larger length is required // maximum length is 65535, if larger length is required
// this function and the corresponding write function need to be // this function and the corresponding write function need to be
// revised. // revised.
uint16_t l = tbufReadUint16( buf ); uint16_t l = tbufReadUint16(buf);
return l; return l;
} }
const char* tbufReadString( SBufferReader* buf, size_t* len ) { const char* tbufReadString(SBufferReader* buf, size_t* len) {
size_t l = tbufReadLength( buf ); size_t l = tbufReadLength(buf);
const char* ret = buf->data + buf->pos; const char* ret = buf->data + buf->pos;
tbufSkip( buf, l + 1 ); tbufSkip(buf, l + 1);
if( ret[l] != 0 ) { if (ret[l] != 0) {
THROW( -1 ); THROW(-1);
} }
if( len != NULL ) { if (len != NULL) {
*len = l; *len = l;
} }
return ret; return ret;
} }
size_t tbufReadToString( SBufferReader* buf, char* dst, size_t size ) { size_t tbufReadToString(SBufferReader* buf, char* dst, size_t size) {
assert( dst != NULL ); assert(dst != NULL);
size_t len; size_t len;
const char* str = tbufReadString( buf, &len ); const char* str = tbufReadString(buf, &len);
if (len >= size) { if (len >= size) {
len = size - 1; len = size - 1;
} }
memcpy( dst, str, len ); memcpy(dst, str, len);
dst[len] = 0; dst[len] = 0;
return len; return len;
} }
const char* tbufReadBinary( SBufferReader* buf, size_t *len ) { const char* tbufReadBinary(SBufferReader* buf, size_t* len) {
size_t l = tbufReadLength( buf ); size_t l = tbufReadLength(buf);
const char* ret = buf->data + buf->pos; const char* ret = buf->data + buf->pos;
tbufSkip( buf, l ); tbufSkip(buf, l);
if( len != NULL ) { if (len != NULL) {
*len = l; *len = l;
} }
return ret; return ret;
} }
size_t tbufReadToBinary( SBufferReader* buf, void* dst, size_t size ) { size_t tbufReadToBinary(SBufferReader* buf, void* dst, size_t size) {
assert( dst != NULL ); assert(dst != NULL);
size_t len; size_t len;
const char* data = tbufReadBinary( buf, &len ); const char* data = tbufReadBinary(buf, &len);
if( len >= size ) { if (len >= size) {
len = size; len = size;
} }
memcpy( dst, data, len ); memcpy(dst, data, len);
return len; return len;
} }
bool tbufReadBool( SBufferReader* buf ) { bool tbufReadBool(SBufferReader* buf) {
bool ret; bool ret;
tbufReadToBuffer( buf, &ret, sizeof(ret) ); tbufReadToBuffer(buf, &ret, sizeof(ret));
return ret; return ret;
} }
char tbufReadChar( SBufferReader* buf ) { char tbufReadChar(SBufferReader* buf) {
char ret; char ret;
tbufReadToBuffer( buf, &ret, sizeof(ret) ); tbufReadToBuffer(buf, &ret, sizeof(ret));
return ret; return ret;
} }
int8_t tbufReadInt8( SBufferReader* buf ) { int8_t tbufReadInt8(SBufferReader* buf) {
int8_t ret; int8_t ret;
tbufReadToBuffer( buf, &ret, sizeof(ret) ); tbufReadToBuffer(buf, &ret, sizeof(ret));
return ret; return ret;
} }
uint8_t tbufReadUint8( SBufferReader* buf ) { uint8_t tbufReadUint8(SBufferReader* buf) {
uint8_t ret; uint8_t ret;
tbufReadToBuffer( buf, &ret, sizeof(ret) ); tbufReadToBuffer(buf, &ret, sizeof(ret));
return ret; return ret;
} }
int16_t tbufReadInt16( SBufferReader* buf ) { int16_t tbufReadInt16(SBufferReader* buf) {
int16_t ret; int16_t ret;
tbufReadToBuffer( buf, &ret, sizeof(ret) ); tbufReadToBuffer(buf, &ret, sizeof(ret));
if( buf->endian ) { if (buf->endian) {
return (int16_t)ntohs( ret ); return (int16_t)ntohs(ret);
} }
return ret; return ret;
} }
uint16_t tbufReadUint16( SBufferReader* buf ) { uint16_t tbufReadUint16(SBufferReader* buf) {
uint16_t ret; uint16_t ret;
tbufReadToBuffer( buf, &ret, sizeof(ret) ); tbufReadToBuffer(buf, &ret, sizeof(ret));
if( buf->endian ) { if (buf->endian) {
return ntohs( ret ); return ntohs(ret);
} }
return ret; return ret;
} }
int32_t tbufReadInt32( SBufferReader* buf ) { int32_t tbufReadInt32(SBufferReader* buf) {
int32_t ret; int32_t ret;
tbufReadToBuffer( buf, &ret, sizeof(ret) ); tbufReadToBuffer(buf, &ret, sizeof(ret));
if( buf->endian ) { if (buf->endian) {
return (int32_t)ntohl( ret ); return (int32_t)ntohl(ret);
} }
return ret; return ret;
} }
uint32_t tbufReadUint32( SBufferReader* buf ) { uint32_t tbufReadUint32(SBufferReader* buf) {
uint32_t ret; uint32_t ret;
tbufReadToBuffer( buf, &ret, sizeof(ret) ); tbufReadToBuffer(buf, &ret, sizeof(ret));
if( buf->endian ) { if (buf->endian) {
return ntohl( ret ); return ntohl(ret);
} }
return ret; return ret;
} }
int64_t tbufReadInt64( SBufferReader* buf ) { int64_t tbufReadInt64(SBufferReader* buf) {
int64_t ret; int64_t ret;
tbufReadToBuffer( buf, &ret, sizeof(ret) ); tbufReadToBuffer(buf, &ret, sizeof(ret));
if( buf->endian ) { if (buf->endian) {
return (int64_t)htobe64( ret ); // TODO: ntohll return (int64_t)htobe64(ret); // TODO: ntohll
} }
return ret; return ret;
} }
uint64_t tbufReadUint64( SBufferReader* buf ) { uint64_t tbufReadUint64(SBufferReader* buf) {
uint64_t ret; uint64_t ret;
tbufReadToBuffer( buf, &ret, sizeof(ret) ); tbufReadToBuffer(buf, &ret, sizeof(ret));
if( buf->endian ) { if (buf->endian) {
return htobe64( ret ); // TODO: ntohll return htobe64(ret); // TODO: ntohll
} }
return ret; return ret;
} }
float tbufReadFloat( SBufferReader* buf ) { float tbufReadFloat(SBufferReader* buf) {
Un4B _un; Un4B _un;
tbufReadToBuffer( buf, &_un, sizeof(_un) ); tbufReadToBuffer(buf, &_un, sizeof(_un));
if( buf->endian ) { if (buf->endian) {
_un.ui = ntohl( _un.ui ); _un.ui = ntohl(_un.ui);
} }
return _un.f; return _un.f;
} }
double tbufReadDouble(SBufferReader* buf) { double tbufReadDouble(SBufferReader* buf) {
Un8B _un; Un8B _un;
tbufReadToBuffer( buf, &_un, sizeof(_un) ); tbufReadToBuffer(buf, &_un, sizeof(_un));
if( buf->endian ) { if (buf->endian) {
_un.ull = htobe64( _un.ull ); _un.ull = htobe64(_un.ull);
} }
return _un.d; return _un.d;
} }
...@@ -213,38 +213,38 @@ double tbufReadDouble(SBufferReader* buf) { ...@@ -213,38 +213,38 @@ double tbufReadDouble(SBufferReader* buf) {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// writer functions // writer functions
void tbufCloseWriter( SBufferWriter* buf ) { void tbufCloseWriter(SBufferWriter* buf) {
tfree(buf->data); tfree(buf->data);
// (*buf->allocator)( buf->data, 0 ); // potential memory leak. // (*buf->allocator)( buf->data, 0 ); // potential memory leak.
buf->data = NULL; buf->data = NULL;
buf->pos = 0; buf->pos = 0;
buf->size = 0; buf->size = 0;
} }
void tbufEnsureCapacity( SBufferWriter* buf, size_t size ) { void tbufEnsureCapacity(SBufferWriter* buf, size_t size) {
size += buf->pos; size += buf->pos;
if( size > buf->size ) { if (size > buf->size) {
size_t nsize = size + buf->size; size_t nsize = size + buf->size;
char* data = (*buf->allocator)( buf->data, nsize ); char* data = (*buf->allocator)(buf->data, nsize);
// TODO: the exception should be thrown by the allocator function // TODO: the exception should be thrown by the allocator function
if( data == NULL ) { if (data == NULL) {
THROW( -1 ); THROW(-1);
} }
buf->data = data; buf->data = data;
buf->size = nsize; buf->size = nsize;
} }
} }
size_t tbufReserve( SBufferWriter* buf, size_t size ) { size_t tbufReserve(SBufferWriter* buf, size_t size) {
tbufEnsureCapacity( buf, size ); tbufEnsureCapacity(buf, size);
size_t old = buf->pos; size_t old = buf->pos;
buf->pos += size; buf->pos += size;
return old; return old;
} }
char* tbufGetData( SBufferWriter* buf, bool takeOver ) { char* tbufGetData(SBufferWriter* buf, bool takeOver) {
char* ret = buf->data; char* ret = buf->data;
if( takeOver ) { if (takeOver) {
buf->pos = 0; buf->pos = 0;
buf->size = 0; buf->size = 0;
buf->data = NULL; buf->data = NULL;
...@@ -252,192 +252,174 @@ char* tbufGetData( SBufferWriter* buf, bool takeOver ) { ...@@ -252,192 +252,174 @@ char* tbufGetData( SBufferWriter* buf, bool takeOver ) {
return ret; return ret;
} }
void tbufWrite( SBufferWriter* buf, const void* data, size_t size ) { void tbufWrite(SBufferWriter* buf, const void* data, size_t size) {
assert( data != NULL ); assert(data != NULL);
tbufEnsureCapacity( buf, size ); tbufEnsureCapacity(buf, size);
memcpy( buf->data + buf->pos, data, size ); memcpy(buf->data + buf->pos, data, size);
buf->pos += size; buf->pos += size;
} }
void tbufWriteAt( SBufferWriter* buf, size_t pos, const void* data, size_t size ) { void tbufWriteAt(SBufferWriter* buf, size_t pos, const void* data, size_t size) {
assert( data != NULL ); assert(data != NULL);
// this function can only be called to fill the gap on previous writes, // this function can only be called to fill the gap on previous writes,
// so 'pos + size <= buf->pos' must be true // so 'pos + size <= buf->pos' must be true
assert( pos + size <= buf->pos ); assert(pos + size <= buf->pos);
memcpy( buf->data + pos, data, size ); memcpy(buf->data + pos, data, size);
} }
static void tbufWriteLength( SBufferWriter* buf, size_t len ) { static void tbufWriteLength(SBufferWriter* buf, size_t len) {
// maximum length is 65535, if larger length is required // maximum length is 65535, if larger length is required
// this function and the corresponding read function need to be // this function and the corresponding read function need to be
// revised. // revised.
assert( len <= 0xffff ); assert(len <= 0xffff);
tbufWriteUint16( buf, (uint16_t)len ); tbufWriteUint16(buf, (uint16_t)len);
} }
void tbufWriteStringLen( SBufferWriter* buf, const char* str, size_t len ) { void tbufWriteStringLen(SBufferWriter* buf, const char* str, size_t len) {
tbufWriteLength( buf, len ); tbufWriteLength(buf, len);
tbufWrite( buf, str, len ); tbufWrite(buf, str, len);
tbufWriteChar( buf, '\0' ); tbufWriteChar(buf, '\0');
} }
void tbufWriteString( SBufferWriter* buf, const char* str ) { void tbufWriteString(SBufferWriter* buf, const char* str) { tbufWriteStringLen(buf, str, strlen(str)); }
tbufWriteStringLen( buf, str, strlen(str) );
}
void tbufWriteBinary( SBufferWriter* buf, const void* data, size_t len ) { void tbufWriteBinary(SBufferWriter* buf, const void* data, size_t len) {
tbufWriteLength( buf, len ); tbufWriteLength(buf, len);
tbufWrite( buf, data, len ); tbufWrite(buf, data, len);
} }
void tbufWriteBool( SBufferWriter* buf, bool data ) { void tbufWriteBool(SBufferWriter* buf, bool data) { tbufWrite(buf, &data, sizeof(data)); }
tbufWrite( buf, &data, sizeof(data) );
}
void tbufWriteBoolAt( SBufferWriter* buf, size_t pos, bool data ) { void tbufWriteBoolAt(SBufferWriter* buf, size_t pos, bool data) { tbufWriteAt(buf, pos, &data, sizeof(data)); }
tbufWriteAt( buf, pos, &data, sizeof(data) );
}
void tbufWriteChar( SBufferWriter* buf, char data ) { void tbufWriteChar(SBufferWriter* buf, char data) { tbufWrite(buf, &data, sizeof(data)); }
tbufWrite( buf, &data, sizeof(data) );
}
void tbufWriteCharAt( SBufferWriter* buf, size_t pos, char data ) { void tbufWriteCharAt(SBufferWriter* buf, size_t pos, char data) { tbufWriteAt(buf, pos, &data, sizeof(data)); }
tbufWriteAt( buf, pos, &data, sizeof(data) );
}
void tbufWriteInt8( SBufferWriter* buf, int8_t data ) { void tbufWriteInt8(SBufferWriter* buf, int8_t data) { tbufWrite(buf, &data, sizeof(data)); }
tbufWrite( buf, &data, sizeof(data) );
}
void tbufWriteInt8At( SBufferWriter* buf, size_t pos, int8_t data ) { void tbufWriteInt8At(SBufferWriter* buf, size_t pos, int8_t data) { tbufWriteAt(buf, pos, &data, sizeof(data)); }
tbufWriteAt( buf, pos, &data, sizeof(data) );
}
void tbufWriteUint8( SBufferWriter* buf, uint8_t data ) { void tbufWriteUint8(SBufferWriter* buf, uint8_t data) { tbufWrite(buf, &data, sizeof(data)); }
tbufWrite( buf, &data, sizeof(data) );
}
void tbufWriteUint8At( SBufferWriter* buf, size_t pos, uint8_t data ) { void tbufWriteUint8At(SBufferWriter* buf, size_t pos, uint8_t data) { tbufWriteAt(buf, pos, &data, sizeof(data)); }
tbufWriteAt( buf, pos, &data, sizeof(data) );
}
void tbufWriteInt16( SBufferWriter* buf, int16_t data ) { void tbufWriteInt16(SBufferWriter* buf, int16_t data) {
if( buf->endian ) { if (buf->endian) {
data = (int16_t)htons( data ); data = (int16_t)htons(data);
} }
tbufWrite( buf, &data, sizeof(data) ); tbufWrite(buf, &data, sizeof(data));
} }
void tbufWriteInt16At( SBufferWriter* buf, size_t pos, int16_t data ) { void tbufWriteInt16At(SBufferWriter* buf, size_t pos, int16_t data) {
if( buf->endian ) { if (buf->endian) {
data = (int16_t)htons( data ); data = (int16_t)htons(data);
} }
tbufWriteAt( buf, pos, &data, sizeof(data) ); tbufWriteAt(buf, pos, &data, sizeof(data));
} }
void tbufWriteUint16( SBufferWriter* buf, uint16_t data ) { void tbufWriteUint16(SBufferWriter* buf, uint16_t data) {
if( buf->endian ) { if (buf->endian) {
data = htons( data ); data = htons(data);
} }
tbufWrite( buf, &data, sizeof(data) ); tbufWrite(buf, &data, sizeof(data));
} }
void tbufWriteUint16At( SBufferWriter* buf, size_t pos, uint16_t data ) { void tbufWriteUint16At(SBufferWriter* buf, size_t pos, uint16_t data) {
if( buf->endian ) { if (buf->endian) {
data = htons( data ); data = htons(data);
} }
tbufWriteAt( buf, pos, &data, sizeof(data) ); tbufWriteAt(buf, pos, &data, sizeof(data));
} }
void tbufWriteInt32( SBufferWriter* buf, int32_t data ) { void tbufWriteInt32(SBufferWriter* buf, int32_t data) {
if( buf->endian ) { if (buf->endian) {
data = (int32_t)htonl( data ); data = (int32_t)htonl(data);
} }
tbufWrite( buf, &data, sizeof(data) ); tbufWrite(buf, &data, sizeof(data));
} }
void tbufWriteInt32At( SBufferWriter* buf, size_t pos, int32_t data ) { void tbufWriteInt32At(SBufferWriter* buf, size_t pos, int32_t data) {
if( buf->endian ) { if (buf->endian) {
data = (int32_t)htonl( data ); data = (int32_t)htonl(data);
} }
tbufWriteAt( buf, pos, &data, sizeof(data) ); tbufWriteAt(buf, pos, &data, sizeof(data));
} }
void tbufWriteUint32( SBufferWriter* buf, uint32_t data ) { void tbufWriteUint32(SBufferWriter* buf, uint32_t data) {
if( buf->endian ) { if (buf->endian) {
data = htonl( data ); data = htonl(data);
} }
tbufWrite( buf, &data, sizeof(data) ); tbufWrite(buf, &data, sizeof(data));
} }
void tbufWriteUint32At( SBufferWriter* buf, size_t pos, uint32_t data ) { void tbufWriteUint32At(SBufferWriter* buf, size_t pos, uint32_t data) {
if( buf->endian ) { if (buf->endian) {
data = htonl( data ); data = htonl(data);
} }
tbufWriteAt( buf, pos, &data, sizeof(data) ); tbufWriteAt(buf, pos, &data, sizeof(data));
} }
void tbufWriteInt64( SBufferWriter* buf, int64_t data ) { void tbufWriteInt64(SBufferWriter* buf, int64_t data) {
if( buf->endian ) { if (buf->endian) {
data = (int64_t)htobe64( data ); data = (int64_t)htobe64(data);
} }
tbufWrite( buf, &data, sizeof(data) ); tbufWrite(buf, &data, sizeof(data));
} }
void tbufWriteInt64At( SBufferWriter* buf, size_t pos, int64_t data ) { void tbufWriteInt64At(SBufferWriter* buf, size_t pos, int64_t data) {
if( buf->endian ) { if (buf->endian) {
data = (int64_t)htobe64( data ); data = (int64_t)htobe64(data);
} }
tbufWriteAt( buf, pos, &data, sizeof(data) ); tbufWriteAt(buf, pos, &data, sizeof(data));
} }
void tbufWriteUint64( SBufferWriter* buf, uint64_t data ) { void tbufWriteUint64(SBufferWriter* buf, uint64_t data) {
if( buf->endian ) { if (buf->endian) {
data = htobe64( data ); data = htobe64(data);
} }
tbufWrite( buf, &data, sizeof(data) ); tbufWrite(buf, &data, sizeof(data));
} }
void tbufWriteUint64At( SBufferWriter* buf, size_t pos, uint64_t data ) { void tbufWriteUint64At(SBufferWriter* buf, size_t pos, uint64_t data) {
if( buf->endian ) { if (buf->endian) {
data = htobe64( data ); data = htobe64(data);
} }
tbufWriteAt( buf, pos, &data, sizeof(data) ); tbufWriteAt(buf, pos, &data, sizeof(data));
} }
void tbufWriteFloat( SBufferWriter* buf, float data ) { void tbufWriteFloat(SBufferWriter* buf, float data) {
Un4B _un; Un4B _un;
_un.f = data; _un.f = data;
if( buf->endian ) { if (buf->endian) {
_un.ui = htonl( _un.ui ); _un.ui = htonl(_un.ui);
} }
tbufWrite( buf, &_un, sizeof(_un) ); tbufWrite(buf, &_un, sizeof(_un));
} }
void tbufWriteFloatAt( SBufferWriter* buf, size_t pos, float data ) { void tbufWriteFloatAt(SBufferWriter* buf, size_t pos, float data) {
Un4B _un; Un4B _un;
_un.f = data; _un.f = data;
if( buf->endian ) { if (buf->endian) {
_un.ui = htonl( _un.ui ); _un.ui = htonl(_un.ui);
} }
tbufWriteAt( buf, pos, &_un, sizeof(_un) ); tbufWriteAt(buf, pos, &_un, sizeof(_un));
} }
void tbufWriteDouble( SBufferWriter* buf, double data ) { void tbufWriteDouble(SBufferWriter* buf, double data) {
Un8B _un; Un8B _un;
_un.d = data; _un.d = data;
if( buf->endian ) { if (buf->endian) {
_un.ull = htobe64( _un.ull ); _un.ull = htobe64(_un.ull);
} }
tbufWrite( buf, &_un, sizeof(_un) ); tbufWrite(buf, &_un, sizeof(_un));
} }
void tbufWriteDoubleAt( SBufferWriter* buf, size_t pos, double data ) { void tbufWriteDoubleAt(SBufferWriter* buf, size_t pos, double data) {
Un8B _un; Un8B _un;
_un.d = data; _un.d = data;
if( buf->endian ) { if (buf->endian) {
_un.ull = htobe64( _un.ull ); _un.ull = htobe64(_un.ull);
} }
tbufWriteAt( buf, pos, &_un, sizeof(_un) ); tbufWriteAt(buf, pos, &_un, sizeof(_un));
} }
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或