add more functions

include/common/tmsg.h

@@ -57,8 +57,14 @@ extern int   tMsgDict[];
 typedef uint16_t tmsg_t;
 
 /* ------------------------ ENCODE/DECODE FUNCTIONS AND MACROS ------------------------ */
+struct SMEListNode {
+  TD_SLIST_NODE(SMEListNode);
+  SEncoder coder;
+};
+
 typedef struct SMsgEncoder {
   SEncoder coder;
+  TD_SLIST(SMEListNode) eStack;  // encode stack
 } SMsgEncoder;
 
 struct SMDFreeListNode {
@@ -66,8 +72,14 @@ struct SMDFreeListNode {
   char payload[];
 };
 
+struct SMDListNode {
+  TD_SLIST_NODE(SMDListNode);
+  SDecoder coder;
+};
+
 typedef struct SMsgDecoder {
   SDecoder coder;
+  TD_SLIST(SMDListNode) dStack;
   TD_SLIST(SMDFreeListNode) freeList;
 } SMsgDecoder;
 

include/util/encode.h

@@ -26,8 +26,8 @@ extern "C" {
 typedef struct {
   td_endian_t endian;
   uint8_t*    data;
-  int64_t     size;
-  int64_t     pos;
+  int32_t     size;
+  int32_t     pos;
 } SEncoder, SDecoder;
 
 #define tPut(TYPE, BUF, VAL) ((TYPE*)(BUF))[0] = (VAL)
@@ -62,7 +62,7 @@ typedef struct {
 #define TD_CHECK_CODER_CAPACITY_FAILED(CODER, EXPSIZE) (((CODER)->size - (CODER)->pos) < (EXPSIZE))
 
 /* ------------------------ FOR ENCODER ------------------------ */
-static FORCE_INLINE void tInitEncoder(SEncoder* pEncoder, td_endian_t endian, uint8_t* data, int64_t size) {
+static FORCE_INLINE void tInitEncoder(SEncoder* pEncoder, td_endian_t endian, uint8_t* data, int32_t size) {
   pEncoder->endian = endian;
   pEncoder->data = data;
   pEncoder->size = (data) ? size : 0;
@@ -266,7 +266,7 @@ static FORCE_INLINE int tEncodeCStr(SEncoder* pEncoder, const char* val) {
 }
 
 /* ------------------------ FOR DECODER ------------------------ */
-static FORCE_INLINE void tInitDecoder(SDecoder* pDecoder, td_endian_t endian, uint8_t* data, int64_t size) {
+static FORCE_INLINE void tInitDecoder(SDecoder* pDecoder, td_endian_t endian, uint8_t* data, int32_t size) {
   ASSERT(!TD_IS_NULL(data));
   pDecoder->endian = endian;
   pDecoder->data = data;

source/common/src/tmsg.c

@@ -27,9 +27,30 @@
 #undef TD_MSG_SEG_CODE_
 #include "tmsgdef.h"
 
+static int  tmsgStartEncode(SMsgEncoder *pME);
+static void tmsgEndEncode(SMsgEncoder *pME);
+static int  tmsgStartDecode(SMsgDecoder *pMD);
+static void tmsgEndDecode(SMsgDecoder *pMD);
+
 /* ------------------------ ENCODE/DECODE FUNCTIONS ------------------------ */
+void tmsgInitMsgEncoder(SMsgEncoder *pME, td_endian_t endian, uint8_t *data, int64_t size) {
+  tInitEncoder(&(pME->coder), endian, data, size);
+  TD_SLIST_INIT(&(pME->eStack));
+}
+
+void tmsgClearMsgEncoder(SMsgEncoder *pME) {
+  struct SMEListNode *pNode;
+  for (;;) {
+    pNode = TD_SLIST_HEAD(&(pME->eStack));
+    if (TD_IS_NULL(pNode)) break;
+    TD_SLIST_POP(&(pME->eStack));
+    free(pNode);
+  }
+}
+
 void tmsgInitMsgDecoder(SMsgDecoder *pMD, td_endian_t endian, uint8_t *data, int64_t size) {
   tInitDecoder(&pMD->coder, endian, data, size);
+  TD_SLIST_INIT(&(pMD->dStack));
   TD_SLIST_INIT(&(pMD->freeList));
 }
 
@@ -45,12 +66,24 @@ void tmsgClearMsgDecoder(SMsgDecoder *pMD) {
 
 /* ------------------------ MESSAGE ENCODE/DECODE ------------------------ */
 int tmsgSVCreateTbReqEncode(SMsgEncoder *pCoder, SVCreateTbReq *pReq) {
+  tmsgStartEncode(pCoder);
   // TODO
+
+  tmsgEndEncode(pCoder);
   return 0;
 }
 
 int tmsgSVCreateTbReqDecode(SMsgDecoder *pCoder, SVCreateTbReq *pReq) {
-  // TODO
+  tmsgStartDecode(pCoder);
+
+  // TODO: decode
+
+  // Decode is not end
+  if (pCoder->coder.pos != pCoder->coder.size) {
+    // Continue decode
+  }
+
+  tmsgEndDecode(pCoder);
   return 0;
 }
 
@@ -147,4 +180,64 @@ void *tDeserializeSVCreateTbReq(void *buf, SVCreateTbReq *pReq) {
   }
 
   return buf;
+}
+
+/* ------------------------ STATIC METHODS ------------------------ */
+static int tmsgStartEncode(SMsgEncoder *pME) {
+  struct SMEListNode *pNode = (struct SMEListNode *)malloc(sizeof(*pNode));
+  if (TD_IS_NULL(pNode)) return -1;
+
+  pNode->coder = pME->coder;
+  TD_SLIST_PUSH(&(pME->eStack), pNode);
+  TD_CODER_MOVE_POS(&(pME->coder), sizeof(int32_t));
+
+  return 0;
+}
+
+static void tmsgEndEncode(SMsgEncoder *pME) {
+  int32_t             size;
+  struct SMEListNode *pNode;
+
+  pNode = TD_SLIST_HEAD(&(pME->eStack));
+  ASSERT(pNode);
+  TD_SLIST_POP(&(pME->eStack));
+
+  size = pME->coder.pos - pNode->coder.pos;
+  tEncodeI32(&(pNode->coder), size);
+
+  free(pNode);
+}
+
+static int tmsgStartDecode(SMsgDecoder *pMD) {
+  struct SMDListNode *pNode;
+  int32_t             size;
+
+  pNode = (struct SMDListNode *)malloc(sizeof(*pNode));
+  if (pNode == NULL) return -1;
+
+  tDecodeI32(&(pMD->coder), &size);
+
+  pNode->coder = pMD->coder;
+  TD_SLIST_PUSH(&(pMD->dStack), pNode);
+
+  pMD->coder.pos = 0;
+  pMD->coder.size = size - sizeof(int32_t);
+  pMD->coder.data = TD_CODER_CURRENT(&(pNode->coder));
+
+  return 0;
+}
+
+static void tmsgEndDecode(SMsgDecoder *pMD) {
+  ASSERT(pMD->coder.pos == pMD->coder.size);
+  struct SMDListNode *pNode;
+
+  pNode = TD_SLIST_HEAD(&(pMD->dStack));
+  ASSERT(pNode);
+  TD_SLIST_POP(&(pMD->dStack));
+
+  pNode->coder.pos += pMD->coder.size;
+
+  pMD->coder = pNode->coder;
+
+  free(pNode);
 }