split SBuffer to Reader & Writer

src/util/inc/tbuffer.h

@@ -23,160 +23,102 @@
 extern "C" {
 #endif
 
-/*
-// SBuffer can be used to read or write a buffer, but cannot be used for both
-// read & write at a same time. Below is an example:
-#include <stdio.h>
-#include <stdlib.h>
-#include "exception.h"
-#include "tbuffer.h"
-
-int foo() {
-  SBuffer wbuf, rbuf;
-  tbufSetup(&wbuf, NULL, false);
-  tbufSetup(&rbuf, NULL, false);
-
-  TRY {
-    //--------------------- write ------------------------
-    tbufBeginWrite(&wbuf);
-    // reserve 1024 bytes for the buffer to improve performance
-    tbufEnsureCapacity(&wbuf, 1024);
-    // write 5 integers to the buffer
-    for (int i = 0; i < 5; i++) {
-      tbufWriteInt32(&wbuf, i);
-    }
-    // write a string to the buffer
-    tbufWriteString(&wbuf, "this is a string.\n");
-    // acquire the result and close the write buffer
-    size_t size = tbufTell(&wbuf);
-    char*  data = tbufGetData(&wbuf, true);
-
-    //------------------------ read -----------------------
-    tbufBeginRead(&rbuf, data, size);
-    // read & print out 5 integers
-    for (int i = 0; i < 5; i++) {
-      printf("%d\n", tbufReadInt32(&rbuf));
-    }
-    // read & print out a string
-    puts(tbufReadString(&rbuf, NULL));
-    // try read another integer, this result in an error as there no this integer
-    tbufReadInt32(&rbuf);
-    printf("you should not see this message.\n");
-  } CATCH( code ) {
-    printf("exception code is: %d, you will see this message after print out 5 integers and a string.\n", code);
-    THROW( code );
-  } END_CATCH
-
-  tbufClose(&wbuf, true);
-  tbufClose(&rbuf, false);
-  return 0;
-}
-
-int main(int argc, char** argv) {
-    TRY {
-        printf("in main: you will see this line\n");
-        foo();
-        printf("in main: you will not see this line\n");
-    } CATCH( code ) {
-        printf("foo raise an exception with code %d\n", code);
-    } END_CATCH
-
-    return 0;
-}
-*/
+typedef struct {
+  bool endian;
+  const char* data;
+  size_t pos;
+  size_t size;
+} SBufferReader;
 
 typedef struct {
-  void*   (*allocator)(void*, size_t);
-  bool    endian;
-  char*   data;
-  size_t  pos;
-  size_t  size;
-} SBuffer;
-
-// common functions can be used in both read & write
-
-// tbufSetup setup the buffer, should be called before tbufBeginRead / tbufBeginWrite
-// *allocator*, function to allocate memory, will use 'realloc' if NULL
-// *endian*, if true, read/write functions of primitive types will do 'ntoh' or 'hton' automatically
-void   tbufSetup(SBuffer* buf, void* (*allocator)(void*, size_t), bool endian);
-size_t tbufTell(SBuffer* buf);
-size_t tbufSeekTo(SBuffer* buf, size_t pos);
-void   tbufClose(SBuffer* buf, bool keepData);
-
-// basic read functions
-void        tbufBeginRead(SBuffer* buf, void* data, size_t len);
-size_t      tbufSkip(SBuffer* buf, size_t size);
-char*       tbufRead(SBuffer* buf, size_t size);
-void        tbufReadToBuffer(SBuffer* buf, void* dst, size_t size);
-const char* tbufReadString(SBuffer* buf, size_t* len);
-size_t      tbufReadToString(SBuffer* buf, char* dst, size_t size);
-const char* tbufReadBinary(SBuffer* buf, size_t *len);
-size_t      tbufReadToBinary(SBuffer* buf, void* dst, size_t size);
-
-// basic write functions
-void        tbufBeginWrite(SBuffer* buf);
-void        tbufEnsureCapacity(SBuffer* buf, size_t size);
-size_t      tbufReserve(SBuffer* buf, size_t size);
-char*       tbufGetData(SBuffer* buf, bool takeOver);
-void        tbufWrite(SBuffer* buf, const void* data, size_t size);
-void        tbufWriteAt(SBuffer* buf, size_t pos, const void* data, size_t size);
-void        tbufWriteStringLen(SBuffer* buf, const char* str, size_t len);
-void        tbufWriteString(SBuffer* buf, const char* str);
-// the prototype of WriteBinary and Write is identical
-// the difference is: WriteBinary writes the length of the data to the buffer
+  bool endian;
+  char* data;
+  size_t pos;
+  size_t size;
+  void* (*allocator)( void*, size_t );
+} SBufferWriter;
+
+////////////////////////////////////////////////////////////////////////////////
+// common functions & macros for both reader & writer
+#define tbufTell( buf ) ((buf)->pos)
+
+
+////////////////////////////////////////////////////////////////////////////////
+// reader functions & macros
+
+// *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))}
+
+size_t      tbufSkip( SBufferReader* buf, size_t size );
+
+char*       tbufRead( SBufferReader* buf, size_t size );
+void        tbufReadToBuffer( SBufferReader* buf, void* dst, size_t size );
+const char* tbufReadString( SBufferReader* buf, size_t* len );
+size_t      tbufReadToString( SBufferReader* buf, char* 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 );
+int8_t   tbufReadInt8( SBufferReader* buf );
+uint8_t  tbufReadUint8( SBufferReader* buf );
+int16_t  tbufReadInt16( SBufferReader* buf );
+uint16_t tbufReadUint16( SBufferReader* buf );
+int32_t  tbufReadInt32( SBufferReader* buf );
+uint32_t tbufReadUint32( SBufferReader* buf );
+int64_t  tbufReadInt64( SBufferReader* buf );
+uint64_t tbufReadUint64( SBufferReader* buf );
+float    tbufReadFloat( SBufferReader* buf );
+double   tbufReadDouble( SBufferReader* buf );
+
+
+////////////////////////////////////////////////////////////////////////////////
+// writer functions & macros
+
+// *Allocator*, function to allocate memory, will use 'realloc' if NULL
+// *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))}
+void   tbufCloseWriter( SBufferWriter* buf );
+
+void   tbufEnsureCapacity( SBufferWriter* buf, size_t size );
+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   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 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
 // size before read. Write only write the data itself, which means the reader
 // need to know data size before read.
-void        tbufWriteBinary(SBuffer* buf, const void* data, size_t len);
-
-// read / write functions for primitive types
-bool tbufReadBool(SBuffer* buf);
-void tbufWriteBool(SBuffer* buf, bool data);
-void tbufWriteBoolAt(SBuffer* buf, size_t pos, bool data);
-
-char tbufReadChar(SBuffer* buf);
-void tbufWriteChar(SBuffer* buf, char data);
-void tbufWriteCharAt(SBuffer* buf, size_t pos, char data);
-
-int8_t tbufReadInt8(SBuffer* buf);
-void tbufWriteInt8(SBuffer* buf, int8_t data);
-void tbufWriteInt8At(SBuffer* buf, size_t pos, int8_t data);
-
-uint8_t tbufReadUint8(SBuffer* buf);
-void tbufWriteUint8(SBuffer* buf, uint8_t data);
-void tbufWriteUint8At(SBuffer* buf, size_t pos, uint8_t data);
-
-int16_t tbufReadInt16(SBuffer* buf);
-void tbufWriteInt16(SBuffer* buf, int16_t data);
-void tbufWriteInt16At(SBuffer* buf, size_t pos, int16_t data);
-
-uint16_t tbufReadUint16(SBuffer* buf);
-void tbufWriteUint16(SBuffer* buf, uint16_t data);
-void tbufWriteUint16At(SBuffer* buf, size_t pos, uint16_t data);
-
-int32_t tbufReadInt32(SBuffer* buf);
-void tbufWriteInt32(SBuffer* buf, int32_t data);
-void tbufWriteInt32At(SBuffer* buf, size_t pos, int32_t data);
-
-uint32_t tbufReadUint32(SBuffer* buf);
-void tbufWriteUint32(SBuffer* buf, uint32_t data);
-void tbufWriteUint32At(SBuffer* buf, size_t pos, uint32_t data);
-
-int64_t tbufReadInt64(SBuffer* buf);
-void tbufWriteInt64(SBuffer* buf, int64_t data);
-void tbufWriteInt64At(SBuffer* buf, size_t pos, int64_t data);
-
-uint64_t tbufReadUint64(SBuffer* buf);
-void tbufWriteUint64(SBuffer* buf, uint64_t data);
-void tbufWriteUint64At(SBuffer* buf, size_t pos, uint64_t data);
-
-float tbufReadFloat(SBuffer* buf);
-void tbufWriteFloat(SBuffer* buf, float data);
-void tbufWriteFloatAt(SBuffer* buf, size_t pos, float data);
-
-double tbufReadDouble(SBuffer* buf);
-void tbufWriteDouble(SBuffer* buf, double data);
-void tbufWriteDoubleAt(SBuffer* buf, size_t pos, double data);
+void   tbufWriteBinary( SBufferWriter* buf, const void* data, size_t len );
+
+void tbufWriteBool( SBufferWriter* buf, bool data );
+void tbufWriteBoolAt( SBufferWriter* buf, size_t pos, bool data );
+void tbufWriteChar( SBufferWriter* buf, char data );
+void tbufWriteCharAt( SBufferWriter* buf, size_t pos, char data );
+void tbufWriteInt8( SBufferWriter* buf, int8_t data );
+void tbufWriteInt8At( SBufferWriter* buf, size_t pos, int8_t data );
+void tbufWriteUint8( SBufferWriter* buf, uint8_t data );
+void tbufWriteUint8At( SBufferWriter* buf, size_t pos, uint8_t data );
+void tbufWriteInt16( SBufferWriter* buf, int16_t data );
+void tbufWriteInt16At( SBufferWriter* buf, size_t pos, int16_t data );
+void tbufWriteUint16( SBufferWriter* buf, uint16_t data );
+void tbufWriteUint16At( SBufferWriter* buf, size_t pos, uint16_t data );
+void tbufWriteInt32( SBufferWriter* buf, int32_t data );
+void tbufWriteInt32At( SBufferWriter* buf, size_t pos, int32_t data );
+void tbufWriteUint32( SBufferWriter* buf, uint32_t data );
+void tbufWriteUint32At( SBufferWriter* buf, size_t pos, uint32_t data );
+void tbufWriteInt64( SBufferWriter* buf, int64_t data );
+void tbufWriteInt64At( SBufferWriter* buf, size_t pos, int64_t data );
+void tbufWriteUint64( SBufferWriter* buf, uint64_t data );
+void tbufWriteUint64At( SBufferWriter* buf, size_t pos, uint64_t data );
+void tbufWriteFloat( SBufferWriter* buf, float data );
+void tbufWriteFloatAt( SBufferWriter* buf, size_t pos, float data );
+void tbufWriteDouble( SBufferWriter* buf, double data );
+void tbufWriteDoubleAt( SBufferWriter* buf, size_t pos, double data );
 
 #ifdef __cplusplus
 }

src/util/src/tbuffer.c

@@ -22,417 +22,378 @@
 #include <taoserror.h>
 
 ////////////////////////////////////////////////////////////////////////////////
-// common functions
-
-void tbufSetup(
-  SBuffer* buf,
-  void* (*allocator)(void*, size_t),
-  bool endian
-) {
-  if (allocator != NULL) {
-    buf->allocator = allocator;
-  } else {
-    buf->allocator = realloc;
-  }
-
-  buf->endian = endian;
-}
-
-size_t tbufTell(SBuffer* buf) {
-  return buf->pos;
-}
+// reader functions
 
-size_t tbufSeekTo(SBuffer* buf, size_t pos) {
-  if (pos > buf->size) {
+size_t tbufSkip(SBufferReader* buf, size_t size) {
+  if( (buf->pos + size) > buf->size ) {
     THROW( TSDB_CODE_MEMORY_CORRUPTED );
   }
   size_t old = buf->pos;
-  buf->pos = pos;
+  buf->pos += size;
   return old;
 }
 
-void tbufClose(SBuffer* buf, bool keepData) {
-  if (!keepData) {
-    (*buf->allocator)(buf->data, 0);
-  }
-  buf->data = NULL;
-  buf->pos = 0;
-  buf->size = 0;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// read functions
-
-void tbufBeginRead(SBuffer* buf, void* data, size_t len) {
-  buf->data = data;
-  buf->pos = 0;
-  buf->size = (data == NULL) ? 0 : len;
-}
-
-size_t tbufSkip(SBuffer* buf, size_t size) {
-  return tbufSeekTo(buf, buf->pos + size);
-}
-
-char* tbufRead(SBuffer* buf, size_t size) {
+char* tbufRead( SBufferReader* buf, size_t size ) {
   char* ret = buf->data + buf->pos;
-  tbufSkip(buf, size);
+  tbufSkip( buf, size );
   return ret;
 }
 
-void tbufReadToBuffer(SBuffer* buf, void* dst, size_t size) {
-  assert(dst != NULL);
+void tbufReadToBuffer( SBufferReader* buf, void* dst, size_t size ) {
+  assert( dst != NULL );
   // always using memcpy, leave optimization to compiler
-  memcpy(dst, tbufRead(buf, size), size);
+  memcpy( dst, tbufRead(buf, size), size );
 }
 
-static size_t tbufReadLength(SBuffer* buf) {
+static size_t tbufReadLength( SBufferReader* buf ) {
   // maximum length is 65535, if larger length is required
   // this function and the corresponding write function need to be
   // revised.
-  uint16_t l = tbufReadUint16(buf);
+  uint16_t l = tbufReadUint16( buf );
   return l;
 }
 
-const char* tbufReadString(SBuffer* buf, size_t* len) {
-  size_t l = tbufReadLength(buf);
-  char*    ret = buf->data + buf->pos;
-  tbufSkip(buf, l + 1);
-  ret[l] = 0;  // ensure the string end with '\0'
-  if (len != NULL) {
+const char* tbufReadString( SBufferReader* buf, size_t* len ) {
+  size_t l = tbufReadLength( buf );
+  char* ret = buf->data + buf->pos;
+  tbufSkip( buf, l + 1 );
+  if( ret[l] != 0 ) {
+    THROW( TSDB_CODE_MEMORY_CORRUPTED );
+  }
+  if( len != NULL ) {
     *len = l;
   }
   return ret;
 }
 
-size_t tbufReadToString(SBuffer* buf, char* dst, size_t size) {
-  assert(dst != NULL);
-  size_t      len;
-  const char* str = tbufReadString(buf, &len);
+size_t tbufReadToString( SBufferReader* buf, char* dst, size_t size ) {
+  assert( dst != NULL );
+  size_t len;
+  const char* str = tbufReadString( buf, &len );
   if (len >= size) {
     len = size - 1;
   }
-  memcpy(dst, str, len);
+  memcpy( dst, str, len );
   dst[len] = 0;
   return len;
 }
 
-const char* tbufReadBinary(SBuffer* buf, size_t *len) {
-  size_t l = tbufReadLength(buf);
+const char* tbufReadBinary( SBufferReader* buf, size_t *len ) {
+  size_t l = tbufReadLength( buf );
   char* ret = buf->data + buf->pos;
-  tbufSkip(buf, l);
-  if (len != NULL) {
+  tbufSkip( buf, l );
+  if( len != NULL ) {
     *len = l;
   }
   return ret;
 }
 
-size_t tbufReadToBinary(SBuffer* buf, void* dst, size_t size) {
-  assert(dst != NULL);
-  size_t      len;
-  const char* data = tbufReadBinary(buf, &len);
-  if (len >= size) {
+size_t tbufReadToBinary( SBufferReader* buf, void* dst, size_t size ) {
+  assert( dst != NULL );
+  size_t len;
+  const char* data = tbufReadBinary( buf, &len );
+  if( len >= size ) {
     len = size;
   }
-  memcpy(dst, data, len);
+  memcpy( dst, data, len );
   return len;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// write functions
+bool tbufReadBool( SBufferReader* buf ) {
+  bool ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  return ret;
+}
 
-void  tbufBeginWrite(SBuffer* buf) {
-  buf->data = NULL;
-  buf->pos = 0;
-  buf->size = 0;
+char tbufReadChar( SBufferReader* buf ) {
+  char ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  return ret;
 }
 
-void tbufEnsureCapacity(SBuffer* buf, size_t size) {
-  size += buf->pos;
-  if (size > buf->size) {
-    size_t nsize = size + buf->size;
-    char* data = (*buf->allocator)(buf->data, nsize);
-    if (data == NULL) {
-      // TODO: handle client out of memory
-      THROW( TSDB_CODE_SERV_OUT_OF_MEMORY );
-    }
-    buf->data = data;
-    buf->size = nsize;
-  }
+int8_t tbufReadInt8( SBufferReader* buf ) {
+  int8_t ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  return ret;
 }
 
-size_t tbufReserve(SBuffer* buf, size_t size) {
-  tbufEnsureCapacity(buf, size);
-  return tbufSeekTo(buf, buf->pos + size);
+uint8_t tbufReadUint8( SBufferReader* buf ) {
+  uint8_t ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  return ret;
 }
 
-char* tbufGetData(SBuffer* buf, bool takeOver) {
-  char* ret = buf->data;
-  if (takeOver) {
-    buf->pos = 0;
-    buf->size = 0;
-    buf->data = NULL;
+int16_t tbufReadInt16( SBufferReader* buf ) {
+  int16_t ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  if( buf->endian ) {
+    return (int16_t)ntohs( ret );
   }
+  return ret;
+}
 
+uint16_t tbufReadUint16( SBufferReader* buf ) {
+  uint16_t ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  if( buf->endian ) {
+    return ntohs( ret );
+  }
   return ret;
 }
 
-void tbufWrite(SBuffer* buf, const void* data, size_t size) {
-  assert(data != NULL);
-  tbufEnsureCapacity(buf, size);
-  memcpy(buf->data + buf->pos, data, size);
-  buf->pos += size;
+int32_t tbufReadInt32( SBufferReader* buf ) {
+  int32_t ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  if( buf->endian ) {
+    return (int32_t)ntohl( ret );
+  }
+  return ret;
 }
 
-void tbufWriteAt(SBuffer* buf, size_t pos, const void* data, size_t size) {
-  assert(data != NULL);
-  // this function can only be called to fill the gap on previous writes,
-  // so 'pos + size <= buf->pos' must be true
-  assert(pos + size <= buf->pos);
-  memcpy(buf->data + pos, data, size);
+uint32_t tbufReadUint32( SBufferReader* buf ) {
+  uint32_t ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  if( buf->endian ) {
+    return ntohl( ret );
+  }
+  return ret;
 }
 
-static void tbufWriteLength(SBuffer* buf, size_t len) {
-  // maximum length is 65535, if larger length is required
-  // this function and the corresponding read function need to be
-  // revised.
-  assert(len <= 0xffff);
-  tbufWriteUint16(buf, (uint16_t)len);
+int64_t tbufReadInt64( SBufferReader* buf ) {
+  int64_t ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  if( buf->endian ) {
+    return (int64_t)htobe64( ret ); // TODO: ntohll
+  }
+  return ret;
 }
 
-void tbufWriteStringLen(SBuffer* buf, const char* str, size_t len) {
-  tbufWriteLength(buf, len);
-  tbufWrite(buf, str, len);
-  tbufWriteChar(buf, '\0');
+uint64_t tbufReadUint64( SBufferReader* buf ) {
+  uint64_t ret;
+  tbufReadToBuffer( buf, &ret, sizeof(ret) );
+  if( buf->endian ) {
+    return htobe64( ret ); // TODO: ntohll
+  }
+  return ret;
 }
 
-void tbufWriteString(SBuffer* buf, const char* str) {
-  tbufWriteStringLen(buf, str, strlen(str));
+float tbufReadFloat( SBufferReader* buf ) {
+  uint32_t ret = tbufReadUint32( buf );
+  return *(float*)( &ret );
 }
 
-void tbufWriteBinary(SBuffer* buf, const void* data, size_t len) {
-  tbufWriteLength(buf, len);
-  tbufWrite(buf, data, len);
+double tbufReadDouble(SBufferReader* buf) {
+  uint64_t ret = tbufReadUint64( buf );
+  return *(double*)( &ret );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// read / write functions for primitive types
+// writer functions
 
-bool tbufReadBool(SBuffer* buf) {
-  bool ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  return ret;
+void tbufCloseWriter( SBufferWriter* buf ) {
+  (*buf->allocator)( buf->data, 0 );
+  buf->data = NULL;
+  buf->pos = 0;
+  buf->size = 0;
 }
 
-void tbufWriteBool(SBuffer* buf, bool data) {
-  tbufWrite(buf, &data, sizeof(data));
+void tbufEnsureCapacity( SBufferWriter* buf, size_t size ) {
+  size += buf->pos;
+  if( size > buf->size ) {
+    size_t nsize = size + buf->size;
+    char* data = (*buf->allocator)( buf->data, nsize );
+    // TODO: the exception should be thrown by the allocator function
+    if( data == NULL ) {
+      THROW( TSDB_CODE_SERV_OUT_OF_MEMORY );
+    }
+    buf->data = data;
+    buf->size = nsize;
+  }
 }
 
-void tbufWriteBoolAt(SBuffer* buf, size_t pos, bool data) {
-  tbufWriteAt(buf, pos, &data, sizeof(data));
+size_t tbufReserve( SBufferWriter* buf, size_t size ) {
+  tbufEnsureCapacity( buf, size );
+  size_t old = buf->pos;
+  buf->pos += size;
+  return old;
 }
 
-char tbufReadChar(SBuffer* buf) {
-  char ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
+char* tbufGetData( SBufferWriter* buf, bool takeOver ) {
+  char* ret = buf->data;
+  if( takeOver ) {
+    buf->pos = 0;
+    buf->size = 0;
+    buf->data = NULL;
+  }
   return ret;
 }
 
-void tbufWriteChar(SBuffer* buf, char data) {
-  tbufWrite(buf, &data, sizeof(data));
+void tbufWrite( SBufferWriter* buf, const void* data, size_t size ) {
+  assert( data != NULL );
+  tbufEnsureCapacity( buf, size );
+  memcpy( buf->data + buf->pos, data, size );
+  buf->pos += size;
 }
 
-void tbufWriteCharAt(SBuffer* buf, size_t pos, char data) {
-  tbufWriteAt(buf, pos, &data, sizeof(data));
+void tbufWriteAt( SBufferWriter* buf, size_t pos, const void* data, size_t size ) {
+  assert( data != NULL );
+  // this function can only be called to fill the gap on previous writes,
+  // so 'pos + size <= buf->pos' must be true
+  assert( pos + size <= buf->pos );
+  memcpy( buf->data + pos, data, size );
 }
 
-int8_t tbufReadInt8(SBuffer* buf) {
-  int8_t ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  return ret;
+static void tbufWriteLength( SBufferWriter* buf, size_t len ) {
+  // maximum length is 65535, if larger length is required
+  // this function and the corresponding read function need to be
+  // revised.
+  assert( len <= 0xffff );
+  tbufWriteUint16( buf, (uint16_t)len );
 }
 
-void tbufWriteInt8(SBuffer* buf, int8_t data) {
-  tbufWrite(buf, &data, sizeof(data));
+void tbufWriteStringLen( SBufferWriter* buf, const char* str, size_t len ) {
+  tbufWriteLength( buf, len );
+  tbufWrite( buf, str, len );
+  tbufWriteChar( buf, '\0' );
 }
 
-void tbufWriteInt8At(SBuffer* buf, size_t pos, int8_t data) {
-  tbufWriteAt(buf, pos, &data, sizeof(data));
+void tbufWriteString( SBufferWriter* buf, const char* str ) {
+  tbufWriteStringLen( buf, str, strlen(str) );
 }
 
-uint8_t tbufReadUint8(SBuffer* buf) {
-  uint8_t ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  return ret;
+void tbufWriteBinary( SBufferWriter* buf, const void* data, size_t len ) {
+  tbufWriteLength( buf, len );
+  tbufWrite( buf, data, len );
 }
 
-void tbufWriteUint8(SBuffer* buf, uint8_t data) {
-  tbufWrite(buf, &data, sizeof(data));
+void tbufWriteBool( SBufferWriter* buf, bool data ) {
+  tbufWrite( buf, &data, sizeof(data) );
 }
 
-void tbufWriteUint8At(SBuffer* buf, size_t pos, uint8_t data) {
-  tbufWriteAt(buf, pos, &data, sizeof(data));
+void tbufWriteBoolAt( SBufferWriter* buf, size_t pos, bool data ) {
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
 }
 
-int16_t tbufReadInt16(SBuffer* buf) {
-  int16_t ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if (buf->endian) {
-    return (int16_t)ntohs(ret);
-  }
-  return ret;
+void tbufWriteChar( SBufferWriter* buf, char data ) {
+  tbufWrite( buf, &data, sizeof(data) );
 }
 
-void tbufWriteInt16(SBuffer* buf, int16_t data) {
-  if (buf->endian) {
-    data = (int16_t)htons(data);
-  }
-  tbufWrite(buf, &data, sizeof(data));
+void tbufWriteCharAt( SBufferWriter* buf, size_t pos, char data ) {
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
 }
 
-void tbufWriteInt16At(SBuffer* buf, size_t pos, int16_t data) {
-  if (buf->endian) {
-    data = (int16_t)htons(data);
-  }
-  tbufWriteAt(buf, pos, &data, sizeof(data));
+void tbufWriteInt8( SBufferWriter* buf, int8_t data ) {
+  tbufWrite( buf, &data, sizeof(data) );
 }
 
-uint16_t tbufReadUint16(SBuffer* buf) {
-  uint16_t ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if (buf->endian) {
-    return ntohs(ret);
-  }
-  return ret;
+void tbufWriteInt8At( SBufferWriter* buf, size_t pos, int8_t data ) {
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
 }
 
-void tbufWriteUint16(SBuffer* buf, uint16_t data) {
-  if (buf->endian) {
-    data = htons(data);
-  }
-  tbufWrite(buf, &data, sizeof(data));
+void tbufWriteUint8( SBufferWriter* buf, uint8_t data ) {
+  tbufWrite( buf, &data, sizeof(data) );
 }
 
-void tbufWriteUint16At(SBuffer* buf, size_t pos, uint16_t data) {
-  if (buf->endian) {
-    data = htons(data);
-  }
-  tbufWriteAt(buf, pos, &data, sizeof(data));
+void tbufWriteUint8At( SBufferWriter* buf, size_t pos, uint8_t data ) {
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
 }
 
-int32_t tbufReadInt32(SBuffer* buf) {
-  int32_t ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if (buf->endian) {
-    return (int32_t)ntohl(ret);
+void tbufWriteInt16( SBufferWriter* buf, int16_t data ) {
+  if( buf->endian ) {
+    data = (int16_t)htons( data );
   }
-  return ret;
+  tbufWrite( buf, &data, sizeof(data) );
 }
 
-void tbufWriteInt32(SBuffer* buf, int32_t data) {
-  if (buf->endian) {
-    data = (int32_t)htonl(data);
+void tbufWriteInt16At( SBufferWriter* buf, size_t pos, int16_t data ) {
+  if( buf->endian ) {
+    data = (int16_t)htons( data );
   }
-  tbufWrite(buf, &data, sizeof(data));
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
 }
 
-void tbufWriteInt32At(SBuffer* buf, size_t pos, int32_t data) {
-  if (buf->endian) {
-    data = (int32_t)htonl(data);
+void tbufWriteUint16( SBufferWriter* buf, uint16_t data ) {
+  if( buf->endian ) {
+    data = htons( data );
   }
-  tbufWriteAt(buf, pos, &data, sizeof(data));
+  tbufWrite( buf, &data, sizeof(data) );
 }
 
-uint32_t tbufReadUint32(SBuffer* buf) {
-  uint32_t ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if (buf->endian) {
-    return ntohl(ret);
+void tbufWriteUint16At( SBufferWriter* buf, size_t pos, uint16_t data ) {
+  if( buf->endian ) {
+    data = htons( data );
   }
-  return ret;
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
 }
 
-void tbufWriteUint32(SBuffer* buf, uint32_t data) {
-  if (buf->endian) {
-    data = htonl(data);
+void tbufWriteInt32( SBufferWriter* buf, int32_t data ) {
+  if( buf->endian ) {
+    data = (int32_t)htonl( data );
   }
-  tbufWrite(buf, &data, sizeof(data));
+  tbufWrite( buf, &data, sizeof(data) );
 }
 
-void tbufWriteUint32At(SBuffer* buf, size_t pos, uint32_t data) {
-  if (buf->endian) {
-    data = htonl(data);
+void tbufWriteInt32At( SBufferWriter* buf, size_t pos, int32_t data ) {
+  if( buf->endian ) {
+    data = (int32_t)htonl( data );
   }
-  tbufWriteAt(buf, pos, &data, sizeof(data));
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
 }
 
-int64_t tbufReadInt64(SBuffer* buf) {
-  int64_t ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if (buf->endian) {
-    return (int64_t)htobe64(ret); // TODO: ntohll
+void tbufWriteUint32( SBufferWriter* buf, uint32_t data ) {
+  if( buf->endian ) {
+    data = htonl( data );
   }
-  return ret;
+  tbufWrite( buf, &data, sizeof(data) );
 }
 
-void tbufWriteInt64(SBuffer* buf, int64_t data) {
-  if (buf->endian) {
-    data = (int64_t)htobe64(data);
+void tbufWriteUint32At( SBufferWriter* buf, size_t pos, uint32_t data ) {
+  if( buf->endian ) {
+    data = htonl( data );
   }
-  tbufWrite(buf, &data, sizeof(data));
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
 }
 
-void tbufWriteInt64At(SBuffer* buf, size_t pos, int64_t data) {
-  if (buf->endian) {
-    data = (int64_t)htobe64(data);
+void tbufWriteInt64( SBufferWriter* buf, int64_t data ) {
+  if( buf->endian ) {
+    data = (int64_t)htobe64( data );
   }
-  tbufWriteAt(buf, pos, &data, sizeof(data));
+  tbufWrite( buf, &data, sizeof(data) );
 }
 
-uint64_t tbufReadUint64(SBuffer* buf) {
-  uint64_t ret;
-  tbufReadToBuffer(buf, &ret, sizeof(ret));
-  if (buf->endian) {
-    return htobe64(ret); // TODO: ntohll
+void tbufWriteInt64At( SBufferWriter* buf, size_t pos, int64_t data ) {
+  if( buf->endian ) {
+    data = (int64_t)htobe64( data );
   }
-  return ret;
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
 }
 
-void tbufWriteUint64(SBuffer* buf, uint64_t data) {
-  if (buf->endian) {
-    data = htobe64(data);
+void tbufWriteUint64( SBufferWriter* buf, uint64_t data ) {
+  if( buf->endian ) {
+    data = htobe64( data );
   }
-  tbufWrite(buf, &data, sizeof(data));
+  tbufWrite( buf, &data, sizeof(data) );
 }
 
-void tbufWriteUint64At(SBuffer* buf, size_t pos, uint64_t data) {
-  if (buf->endian) {
-    data = htobe64(data);
+void tbufWriteUint64At( SBufferWriter* buf, size_t pos, uint64_t data ) {
+  if( buf->endian ) {
+    data = htobe64( data );
   }
-  tbufWriteAt(buf, pos, &data, sizeof(data));
-}
-
-float tbufReadFloat(SBuffer* buf) {
-  uint32_t ret = tbufReadUint32(buf);
-  return *(float*)(&ret);
-}
-
-void tbufWriteFloat(SBuffer* buf, float data) {
-  tbufWriteUint32(buf, *(uint32_t*)(&data));
+  tbufWriteAt( buf, pos, &data, sizeof(data) );
 }
 
-void tbufWriteFloatAt(SBuffer* buf, size_t pos, float data) {
-  tbufWriteUint32At(buf, pos, *(uint32_t*)(&data));
+void tbufWriteFloat( SBufferWriter* buf, float data ) {
+  tbufWriteUint32( buf, *(uint32_t*)(&data) );
 }
 
-double tbufReadDouble(SBuffer* buf) {
-  uint64_t ret = tbufReadUint64(buf);
-  return *(double*)(&ret);
+void tbufWriteFloatAt( SBufferWriter* buf, size_t pos, float data ) {
+  tbufWriteUint32At( buf, pos, *(uint32_t*)(&data) );
 }
 
-void tbufWriteDouble(SBuffer* buf, double data) {
-  tbufWriteUint64(buf, *(uint64_t*)(&data));
+void tbufWriteDouble( SBufferWriter* buf, double data ) {
+  tbufWriteUint64( buf, *(uint64_t*)(&data) );
 }
 
-void tbufWriteDoubleAt(SBuffer* buf, size_t pos, double data) {
-  tbufWriteUint64At(buf, pos, *(uint64_t*)(&data));
+void tbufWriteDoubleAt( SBufferWriter* buf, size_t pos, double data ) {
+  tbufWriteUint64At( buf, pos, *(uint64_t*)(&data) );
 }