Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2025-01-28 00:07:09 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

switch BanListItem classes to new serialization system

Browse Source
This commit is contained in:
csoler 2017-04-10 22:09:56 +02:00
parent 691ed8de08
commit 731e20d0a3
6 changed files with 93 additions and 330 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

299
libretroshare/src/serialiser/rsbanlistitems.cc
View File

@ -25,7 +25,8 @@
#include "serialiser/rsbaseserial.h" #include "serialiser/rsbaseserial.h"
#include "serialiser/rsbanlistitems.h" #include "serialiser/rsbanlistitems.h"
#include "serialiser/rstlvbanlist.h"
#include "serialization/rstypeserializer.h"
/*** /***
#define RSSERIAL_DEBUG 1 #define RSSERIAL_DEBUG 1
@ -35,300 +36,36 @@
/*************************************************************************/ /*************************************************************************/
RsBanListItem::~RsBanListItem()
{
return;
}
void RsBanListItem::clear() void RsBanListItem::clear()
{ {
peerList.TlvClear(); peerList.TlvClear();
} }
std::ostream &RsBanListItem::print(std::ostream &out, uint16_t indent) void RsBanListItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx)
{ {
printRsItemBase(out, "RsBanListItem", indent); RsTypeSerializer::serial_process(j,ctx,peerList,"peerList") ;
uint16_t int_Indent = indent + 2;
peerList.print(out, int_Indent);
printRsItemEnd(out, "RsBanListItem", indent);
return out;
} }
void RsBanListConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx)
uint32_t RsBanListSerialiser::sizeList(RsBanListItem *item)
{ {
uint32_t s = 8; /* header */ RsTypeSerializer::serial_process<uint32_t>(j,ctx,type,"type") ;
s += item->peerList.TlvSize(); RsTypeSerializer::serial_process (j,ctx,peerId,"peerId") ;
RsTypeSerializer::serial_process<time_t> (j,ctx,update_time,"update_time") ;
return s; RsTypeSerializer::serial_process (j,ctx,banned_peers,"banned_peers") ;
} }
RsItem *RsBanListSerialiser::create_item(uint16_t service_id,uint8_t item_sub_id)
uint32_t RsBanListSerialiser::sizeListConfig(RsBanListConfigItem *item)
{ {
uint32_t s = 8; /* header */ if(service_id != RS_SERVICE_TYPE_BANLIST)
s += 4 ; // type return NULL ;
s += item->banned_peers.TlvSize();
s += 8 ; // update time
s += item->peerId.serial_size() ;
return s; switch(item_sub_id)
}
/* serialise the data to the buffer */
bool RsBanListSerialiser::serialiseList(RsBanListItem *item, void *data, uint32_t *pktsize)
{
uint32_t tlvsize = sizeList(item);
uint32_t offset = 0;
if (*pktsize < tlvsize)
return false; /* not enough space */
*pktsize = tlvsize;
bool ok = true;
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDsdvSerialiser::serialiseRoute() Header: " << ok << std::endl;
std::cerr << "RsDsdvSerialiser::serialiseRoute() Size: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= item->peerList.SetTlv(data, tlvsize, &offset);
if (offset != tlvsize)
{
ok = false;
#ifdef RSSERIAL_DEBUG
std::cerr << "RsDsdvSerialiser::serialiseRoute() Size Error! " << std::endl;
#endif
}
return ok;
}
/* serialise the data to the buffer */
bool RsBanListSerialiser::serialiseListConfig(RsBanListConfigItem *item, void *data, uint32_t *pktsize)
{
uint32_t tlvsize = sizeListConfig(item);
uint32_t offset = 0;
if (*pktsize < tlvsize)
return false; /* not enough space */
*pktsize = tlvsize;
bool ok = true;
ok &= setRsItemHeader(data, tlvsize, item->PacketId(), tlvsize);
#ifdef RSSERIAL_DEBUG
std::cerr << "RsBanListSerialiser::serialiseRoute() Header: " << ok << std::endl;
std::cerr << "RsBanListSerialiser::serialiseRoute() Size: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
ok &= setRawUInt32(data, tlvsize, &offset,item->type);
ok &= item->peerId.serialise(data, tlvsize, offset);
ok &= setRawTimeT(data, tlvsize, &offset,item->update_time);
/* add mandatory parts first */
ok &= item->banned_peers.SetTlv(data, tlvsize, &offset);
if (offset != tlvsize)
{ {
ok = false; case RS_PKT_SUBTYPE_BANLIST_CONFIG_ITEM: return new RsBanListConfigItem ;
#ifdef RSSERIAL_DEBUG case RS_PKT_SUBTYPE_BANLIST_ITEM: return new RsBanListItem ;
std::cerr << "RsBanListSerialiser::serialiseRoute() Size Error! " << std::endl; default:
#endif std::cerr << "(EE) unknown item subtype " << (int)item_sub_id << " in RsBanListSerialiser::create_item()" << std::endl;
} return NULL ;
return ok;
}
RsBanListItem *RsBanListSerialiser::deserialiseList(void *data, uint32_t *pktsize)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
uint32_t tlvsize = getRsItemSize(data);
uint32_t offset = 0;
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
(RS_SERVICE_TYPE_BANLIST != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_BANLIST_ITEM != getRsItemSubType(rstype)))
{
return NULL; /* wrong type */
}
if (*pktsize < tlvsize) /* check size */
return NULL; /* not enough data */
/* set the packet length */
*pktsize = tlvsize;
bool ok = true;
/* ready to load */
RsBanListItem *item = new RsBanListItem();
item->clear();
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= item->peerList.GetTlv(data, tlvsize, &offset);
if (offset != tlvsize)
{
/* error */
delete item;
return NULL;
}
if (!ok)
{
delete item;
return NULL;
}
return item;
}
RsBanListConfigItem *RsBanListSerialiser::deserialiseListConfig(void *data, uint32_t *pktsize)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
uint32_t tlvsize = getRsItemSize(data);
uint32_t offset = 0;
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
(RS_SERVICE_TYPE_BANLIST != getRsItemService(rstype)) ||
(RS_PKT_SUBTYPE_BANLIST_CONFIG_ITEM != getRsItemSubType(rstype)))
{
return NULL; /* wrong type */
}
if (*pktsize < tlvsize) /* check size */
return NULL; /* not enough data */
/* set the packet length */
*pktsize = tlvsize;
bool ok = true;
/* ready to load */
RsBanListConfigItem *item = new RsBanListConfigItem();
item->clear();
/* skip the header */
offset += 8;
ok &= getRawUInt32(data, tlvsize, &offset,&item->type);
ok &= item->peerId.deserialise(data, tlvsize, offset);
ok &= getRawTimeT(data, tlvsize, &offset,item->update_time);
/* add mandatory parts first */
ok &= item->banned_peers.GetTlv(data, tlvsize, &offset);
if (offset != tlvsize)
{
/* error */
delete item;
return NULL;
}
if (!ok)
{
delete item;
return NULL;
}
return item;
}
/*************************************************************************/
uint32_t RsBanListSerialiser::size(RsItem *i)
{
RsBanListItem *dri;
RsBanListConfigItem *drc;
if (NULL != (dri = dynamic_cast<RsBanListItem *>(i)))
{
return sizeList(dri);
}
if (NULL != (drc = dynamic_cast<RsBanListConfigItem *>(i)))
{
return sizeListConfig(drc);
}
return 0;
}
bool RsBanListSerialiser::serialise(RsItem *i, void *data, uint32_t *pktsize)
{
RsBanListItem *dri;
RsBanListConfigItem *drc;
if (NULL != (dri = dynamic_cast<RsBanListItem *>(i)))
{
return serialiseList(dri, data, pktsize);
}
if (NULL != (drc = dynamic_cast<RsBanListConfigItem *>(i)))
{
return serialiseListConfig(drc, data, pktsize);
}
return false;
}
RsItem *RsBanListSerialiser::deserialise(void *data, uint32_t *pktsize)
{
/* get the type and size */
uint32_t rstype = getRsItemId(data);
if ((RS_PKT_VERSION_SERVICE != getRsItemVersion(rstype)) ||
(RS_SERVICE_TYPE_BANLIST != getRsItemService(rstype)))
{
return NULL; /* wrong type */
}
switch(getRsItemSubType(rstype))
{
case RS_PKT_SUBTYPE_BANLIST_ITEM:
return deserialiseList(data, pktsize);
break;
case RS_PKT_SUBTYPE_BANLIST_CONFIG_ITEM:
return deserialiseListConfig(data, pktsize);
break;
default:
return NULL;
break;
} }
} }
void RsBanListConfigItem::clear()
{
banned_peers.TlvClear() ;
}
std::ostream &RsBanListConfigItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsBanListConfigItem", indent);
uint16_t int_Indent = indent + 2;
banned_peers.print(out, int_Indent);
printRsItemEnd(out, "RsBanListConfigItem", indent);
return out;
}
/*************************************************************************/

44
libretroshare/src/serialiser/rsbanlistitems.h
View File

@ -29,12 +29,12 @@
#include <map> #include <map>
#include "serialiser/rsserviceids.h" #include "serialiser/rsserviceids.h"
#include "serialiser/rsserial.h"
#include "serialiser/rstlvbanlist.h" #include "serialiser/rstlvbanlist.h"
#include "serialization/rsserializer.h"
#define RS_PKT_SUBTYPE_BANLIST_ITEM_deprecated 0x01 #define RS_PKT_SUBTYPE_BANLIST_ITEM_deprecated 0x01
#define RS_PKT_SUBTYPE_BANLIST_CONFIG_ITEM_deprecated 0x02 #define RS_PKT_SUBTYPE_BANLIST_CONFIG_ITEM_deprecated 0x02
#define RS_PKT_SUBTYPE_BANLIST_ITEM 0x03 #define RS_PKT_SUBTYPE_BANLIST_ITEM 0x03
#define RS_PKT_SUBTYPE_BANLIST_CONFIG_ITEM 0x04 #define RS_PKT_SUBTYPE_BANLIST_CONFIG_ITEM 0x04
/**************************************************************************/ /**************************************************************************/
@ -42,17 +42,15 @@
class RsBanListItem: public RsItem class RsBanListItem: public RsItem
{ {
public: public:
RsBanListItem() RsBanListItem() :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_BANLIST, RS_PKT_SUBTYPE_BANLIST_ITEM)
:RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_BANLIST,
RS_PKT_SUBTYPE_BANLIST_ITEM)
{ {
setPriorityLevel(QOS_PRIORITY_RS_BANLIST_ITEM); setPriorityLevel(QOS_PRIORITY_RS_BANLIST_ITEM);
return; return;
} }
virtual ~RsBanListItem(); virtual ~RsBanListItem(){}
virtual void clear(); virtual void clear();
std::ostream &print(std::ostream &out, uint16_t indent = 0); void serial_process(RsItem::SerializeJob j,SerializeContext& ctx);
RsTlvBanList peerList; RsTlvBanList peerList;
}; };
@ -64,40 +62,22 @@ public:
:RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_BANLIST, RS_PKT_SUBTYPE_BANLIST_CONFIG_ITEM) {} :RsItem(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_BANLIST, RS_PKT_SUBTYPE_BANLIST_CONFIG_ITEM) {}
virtual ~RsBanListConfigItem(){} virtual ~RsBanListConfigItem(){}
virtual void clear(); virtual void clear() { banned_peers.TlvClear() ; }
std::ostream &print(std::ostream &out, uint16_t indent = 0); void serial_process(RsItem::SerializeJob j,SerializeContext& ctx);
uint32_t type ; uint32_t type ;
RsPeerId peerId ; RsPeerId peerId ;
time_t update_time ; time_t update_time ;
RsTlvBanList banned_peers; RsTlvBanList banned_peers;
}; };
class RsBanListSerialiser: public RsSerialType class RsBanListSerialiser: public RsSerializer
{ {
public: public:
RsBanListSerialiser() RsBanListSerialiser() :RsSerializer(RS_SERVICE_TYPE_BANLIST) {}
:RsSerialType(RS_PKT_VERSION_SERVICE, RS_SERVICE_TYPE_BANLIST)
{ return; }
virtual ~RsBanListSerialiser()
{ return; }
virtual uint32_t size(RsItem *);
virtual bool serialise (RsItem *item, void *data, uint32_t *size);
virtual RsItem * deserialise(void *data, uint32_t *size);
private:
virtual uint32_t sizeList(RsBanListItem *);
virtual bool serialiseList (RsBanListItem *item, void *data, uint32_t *size);
virtual RsBanListItem *deserialiseList(void *data, uint32_t *size);
virtual uint32_t sizeListConfig(RsBanListConfigItem *);
virtual bool serialiseListConfig (RsBanListConfigItem *item, void *data, uint32_t *size);
virtual RsBanListConfigItem *deserialiseListConfig(void *data, uint32_t *size);
virtual RsItem *create_item(uint16_t service_id,uint8_t item_sub_id) ;
}; };
/**************************************************************************/ /**************************************************************************/

23
libretroshare/src/serialiser/rsbaseserial.cc
View File

@ -35,7 +35,7 @@
/* UInt8 get/set */ /* UInt8 get/set */
bool getRawUInt8(void *data, uint32_t size, uint32_t *offset, uint8_t *out) bool getRawUInt8(const void *data, uint32_t size, uint32_t *offset, uint8_t *out)
{ {
/* first check there is space */ /* first check there is space */
if (size < *offset + 1) if (size < *offset + 1)
@ -71,7 +71,7 @@ bool setRawUInt8(void *data, uint32_t size, uint32_t *offset, uint8_t in)
} }
/* UInt16 get/set */ /* UInt16 get/set */
bool getRawUInt16(void *data, uint32_t size, uint32_t *offset, uint16_t *out) bool getRawUInt16(const void *data, uint32_t size, uint32_t *offset, uint16_t *out)
{ {
/* first check there is space */ /* first check there is space */
if (size < *offset + 2) if (size < *offset + 2)
@ -113,7 +113,7 @@ bool setRawUInt16(void *data, uint32_t size, uint32_t *offset, uint16_t in)
/* UInt32 get/set */ /* UInt32 get/set */
bool getRawUInt32(void *data, uint32_t size, uint32_t *offset, uint32_t *out) bool getRawUInt32(const void *data, uint32_t size, uint32_t *offset, uint32_t *out)
{ {
/* first check there is space */ /* first check there is space */
if (size < *offset + 4) if (size < *offset + 4)
@ -155,7 +155,7 @@ bool setRawUInt32(void *data, uint32_t size, uint32_t *offset, uint32_t in)
/* UInt64 get/set */ /* UInt64 get/set */
bool getRawUInt64(void *data, uint32_t size, uint32_t *offset, uint64_t *out) bool getRawUInt64(const void *data, uint32_t size, uint32_t *offset, uint64_t *out)
{ {
/* first check there is space */ /* first check there is space */
if (size < *offset + 8) if (size < *offset + 8)
@ -195,7 +195,7 @@ bool setRawUInt64(void *data, uint32_t size, uint32_t *offset, uint64_t in)
return true; return true;
} }
bool getRawUFloat32(void *data,uint32_t size,uint32_t *offset,float& f) bool getRawUFloat32(const void *data, uint32_t size, uint32_t *offset, float& f)
{ {
uint32_t n ; uint32_t n ;
if(!getRawUInt32(data, size, offset, &n) ) if(!getRawUInt32(data, size, offset, &n) )
@ -208,6 +208,13 @@ bool getRawUFloat32(void *data,uint32_t size,uint32_t *offset,float& f)
bool setRawUFloat32(void *data,uint32_t size,uint32_t *offset,float f) bool setRawUFloat32(void *data,uint32_t size,uint32_t *offset,float f)
{ {
uint32_t sz = 4;
if ( !data || size <= *offset || size < sz + *offset )
{
std::cerr << "(EE) not enough room. SIZE+offset=" << sz+*offset << " and size is only " << size << std::endl;
return false;
}
if(f < 0.0f) if(f < 0.0f)
{ {
std::cerr << "(EE) Cannot serialise invalid negative float value " << f << " in " << __PRETTY_FUNCTION__ << std::endl; std::cerr << "(EE) Cannot serialise invalid negative float value " << f << " in " << __PRETTY_FUNCTION__ << std::endl;
@ -229,7 +236,7 @@ uint32_t getRawStringSize(const std::string &outStr)
return outStr.length() + 4; return outStr.length() + 4;
} }
bool getRawString(void *data, uint32_t size, uint32_t *offset, std::string &outStr) bool getRawString(const void *data, uint32_t size, uint32_t *offset, std::string &outStr)
{ {
#warning Gio: "I had to change this. It seems like a bug to not clear the string. Should make sure it's not introducing any side effect." #warning Gio: "I had to change this. It seems like a bug to not clear the string. Should make sure it's not introducing any side effect."
outStr.clear(); outStr.clear();
@ -284,7 +291,7 @@ bool setRawString(void *data, uint32_t size, uint32_t *offset, const std::string
return true; return true;
} }
bool getRawTimeT(void *data,uint32_t size,uint32_t *offset,time_t& t) bool getRawTimeT(const void *data,uint32_t size,uint32_t *offset,time_t& t)
{ {
uint64_t T ; uint64_t T ;
bool res = getRawUInt64(data,size,offset,&T) ; bool res = getRawUInt64(data,size,offset,&T) ;
@ -292,7 +299,7 @@ bool getRawTimeT(void *data,uint32_t size,uint32_t *offset,time_t& t)
return res ; return res ;
} }
bool setRawTimeT(void *data,uint32_t size,uint32_t *offset,const time_t& t) bool setRawTimeT(void *data, uint32_t size, uint32_t *offset, const time_t& t)
{ {
return setRawUInt64(data,size,offset,t) ; return setRawUInt64(data,size,offset,t) ;
} }

14
libretroshare/src/serialiser/rsbaseserial.h
View File

@ -48,27 +48,27 @@
* *
******************************************************************/ ******************************************************************/
bool getRawUInt8(void *data, uint32_t size, uint32_t *offset, uint8_t *out); bool getRawUInt8(const void *data, uint32_t size, uint32_t *offset, uint8_t *out);
bool setRawUInt8(void *data, uint32_t size, uint32_t *offset, uint8_t in); bool setRawUInt8(void *data, uint32_t size, uint32_t *offset, uint8_t in);
bool getRawUInt16(void *data, uint32_t size, uint32_t *offset, uint16_t *out); bool getRawUInt16(const void *data, uint32_t size, uint32_t *offset, uint16_t *out);
bool setRawUInt16(void *data, uint32_t size, uint32_t *offset, uint16_t in); bool setRawUInt16(void *data, uint32_t size, uint32_t *offset, uint16_t in);
bool getRawUInt32(void *data, uint32_t size, uint32_t *offset, uint32_t *out); bool getRawUInt32(const void *data, uint32_t size, uint32_t *offset, uint32_t *out);
bool setRawUInt32(void *data, uint32_t size, uint32_t *offset, uint32_t in); bool setRawUInt32(void *data, uint32_t size, uint32_t *offset, uint32_t in);
bool getRawUInt64(void *data, uint32_t size, uint32_t *offset, uint64_t *out); bool getRawUInt64(const void *data, uint32_t size, uint32_t *offset, uint64_t *out);
bool setRawUInt64(void *data, uint32_t size, uint32_t *offset, uint64_t in); bool setRawUInt64(void *data, uint32_t size, uint32_t *offset, uint64_t in);
bool getRawUFloat32(void *data, uint32_t size, uint32_t *offset, float& out); bool getRawUFloat32(const void *data, uint32_t size, uint32_t *offset, float& out);
bool setRawUFloat32(void *data, uint32_t size, uint32_t *offset, float in); bool setRawUFloat32(void *data, uint32_t size, uint32_t *offset, float in);
uint32_t getRawStringSize(const std::string &outStr); uint32_t getRawStringSize(const std::string &outStr);
bool getRawString(void *data, uint32_t size, uint32_t *offset, std::string &outStr); bool getRawString(const void *data, uint32_t size, uint32_t *offset, std::string &outStr);
bool setRawString(void *data, uint32_t size, uint32_t *offset, const std::string &inStr); bool setRawString(void *data, uint32_t size, uint32_t *offset, const std::string &inStr);
bool getRawTimeT(const void *data, uint32_t size, uint32_t *offset, time_t& outStr);
bool setRawTimeT(void *data, uint32_t size, uint32_t *offset, const time_t& inStr); bool setRawTimeT(void *data, uint32_t size, uint32_t *offset, const time_t& inStr);
bool getRawTimeT(void *data, uint32_t size, uint32_t *offset, time_t& outStr);
#endif #endif

7
libretroshare/src/serialiser/rsserial.h
View File

@ -84,7 +84,12 @@ class RsItem: public RsMemoryManagement::SmallObject
virtual ~RsItem(); virtual ~RsItem();
virtual void clear() = 0; virtual void clear() = 0;
virtual std::ostream &print(std::ostream &out, uint16_t indent = 0) = 0; virtual std::ostream &print(std::ostream &out, uint16_t indent = 0)
{
std::cerr << "(EE) RsItem::print() called by an item using new serialization classes, but not derived! " << std::endl;
#warning This method should normally call serial_process(PRINT,ctx)
return out;
}
void print_string(std::string &out, uint16_t indent = 0); void print_string(std::string &out, uint16_t indent = 0);
/* source / destination id */ /* source / destination id */

36
libretroshare/src/serialization/rstypeserializer.h
View File

@ -2,6 +2,7 @@
#include "serialiser/rsserial.h" #include "serialiser/rsserial.h"
#include "serialiser/rstlvbase.h" #include "serialiser/rstlvbase.h"
#include "serialiser/rstlvlist.h"
#include "retroshare/rsflags.h" #include "retroshare/rsflags.h"
#include "retroshare/rsids.h" #include "retroshare/rsids.h"
@ -183,6 +184,11 @@ class RsTypeSerializer
template<uint32_t ID_SIZE_IN_BYTES,bool UPPER_CASE,uint32_t UNIQUE_IDENTIFIER> static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, t_RsGenericIdType<ID_SIZE_IN_BYTES,UPPER_CASE,UNIQUE_IDENTIFIER>& member); template<uint32_t ID_SIZE_IN_BYTES,bool UPPER_CASE,uint32_t UNIQUE_IDENTIFIER> static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, t_RsGenericIdType<ID_SIZE_IN_BYTES,UPPER_CASE,UNIQUE_IDENTIFIER>& member);
template<uint32_t ID_SIZE_IN_BYTES,bool UPPER_CASE,uint32_t UNIQUE_IDENTIFIER> static uint32_t serial_size(const t_RsGenericIdType<ID_SIZE_IN_BYTES,UPPER_CASE,UNIQUE_IDENTIFIER>& /* member */); template<uint32_t ID_SIZE_IN_BYTES,bool UPPER_CASE,uint32_t UNIQUE_IDENTIFIER> static uint32_t serial_size(const t_RsGenericIdType<ID_SIZE_IN_BYTES,UPPER_CASE,UNIQUE_IDENTIFIER>& /* member */);
template<uint32_t ID_SIZE_IN_BYTES,bool UPPER_CASE,uint32_t UNIQUE_IDENTIFIER> static void print_data(const std::string& name,const t_RsGenericIdType<ID_SIZE_IN_BYTES,UPPER_CASE,UNIQUE_IDENTIFIER>& /* member */); template<uint32_t ID_SIZE_IN_BYTES,bool UPPER_CASE,uint32_t UNIQUE_IDENTIFIER> static void print_data(const std::string& name,const t_RsGenericIdType<ID_SIZE_IN_BYTES,UPPER_CASE,UNIQUE_IDENTIFIER>& /* member */);
template<class TLV_CLASS,uint32_t TLV_TYPE> static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, const t_RsTlvList<TLV_CLASS,TLV_TYPE>& member);
template<class TLV_CLASS,uint32_t TLV_TYPE> static bool deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, t_RsTlvList<TLV_CLASS,TLV_TYPE>& member);
template<class TLV_CLASS,uint32_t TLV_TYPE> static uint32_t serial_size(const t_RsTlvList<TLV_CLASS,TLV_TYPE>& /* member */);
template<class TLV_CLASS,uint32_t TLV_TYPE> static void print_data(const std::string& name,const t_RsTlvList<TLV_CLASS,TLV_TYPE>& /* member */);
}; };
//=================================================================================================// //=================================================================================================//
@ -208,7 +214,35 @@ uint32_t RsTypeSerializer::serial_size(const t_RsGenericIdType<ID_SIZE_IN_BYTES,
} }
template<uint32_t ID_SIZE_IN_BYTES,bool UPPER_CASE,uint32_t UNIQUE_IDENTIFIER> template<uint32_t ID_SIZE_IN_BYTES,bool UPPER_CASE,uint32_t UNIQUE_IDENTIFIER>
void RsTypeSerializer::print_data(const std::string& name,const t_RsGenericIdType<ID_SIZE_IN_BYTES,UPPER_CASE,UNIQUE_IDENTIFIER>& member) void RsTypeSerializer::print_data(const std::string& /* name */,const t_RsGenericIdType<ID_SIZE_IN_BYTES,UPPER_CASE,UNIQUE_IDENTIFIER>& member)
{ {
std::cerr << " [RsGenericId<" << std::hex << UNIQUE_IDENTIFIER << ">] : " << member << std::endl; std::cerr << " [RsGenericId<" << std::hex << UNIQUE_IDENTIFIER << ">] : " << member << std::endl;
} }
//=================================================================================================//
// t_RsTlvList<> //
//=================================================================================================//
template<class TLV_CLASS,uint32_t TLV_TYPE>
bool RsTypeSerializer::serialize (uint8_t data[], uint32_t size, uint32_t &offset, const t_RsTlvList<TLV_CLASS,TLV_TYPE>& member)
{
return (*const_cast<const t_RsTlvList<TLV_CLASS,TLV_TYPE> *>(&member)).SetTlv(data,size,&offset) ;
}
template<class TLV_CLASS,uint32_t TLV_TYPE>
bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, t_RsTlvList<TLV_CLASS,TLV_TYPE>& member)
{
return member.GetTlv(const_cast<uint8_t*>(data),size,&offset) ;
}
template<class TLV_CLASS,uint32_t TLV_TYPE>
uint32_t RsTypeSerializer::serial_size(const t_RsTlvList<TLV_CLASS,TLV_TYPE>& member)
{
return member.TlvSize();
}
template<class TLV_CLASS,uint32_t TLV_TYPE>
void RsTypeSerializer::print_data(const std::string& /* name */,const t_RsTlvList<TLV_CLASS,TLV_TYPE>& member)
{
std::cerr << " [t_RsTlvString<" << std::hex << TLV_TYPE << ">] : size=" << member.mList.size() << std::endl;
}