Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2024-12-27 00:19:25 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

fixed compilation

Browse Source
This commit is contained in:
csoler 2017-04-05 16:53:20 +02:00
parent 48688eae3f
commit 5b3e488b42
6 changed files with 91 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
libretroshare/src/chat/rschatitems.cc
View File

@ -593,10 +593,10 @@ template<> void RsTypeSerializer::serial_process(RsItem::SerializeJob j,Serializ
TlvString tt1(info.name ,TLV_TYPE_STR_NAME) ;
TlvString tt2(info.topic,TLV_TYPE_STR_NAME) ;
RsTypeSerializer::serial_process(j,ctx,info.name,"info.name") ;
RsTypeSerializer::serial_process(j,ctx,info.topic,"info.topic") ;
RsTypeSerializer::serial_process(j,ctx,tt1,"info.name") ;
RsTypeSerializer::serial_process(j,ctx,tt2,"info.topic") ;
RsTypeSerializer::serial_process<uint32_t>(j,ctx,info.count,"info.count") ;
RsTypeSerializer::serial_process<ChatLobbyFlags>(j,ctx,info.flags,"info.flags") ;
RsTypeSerializer::serial_process(j,ctx,info.flags,"info.flags") ;
}
void RsChatLobbyListItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx)
@ -641,8 +641,8 @@ void RsChatLobbyEventItem::serial_process(RsItem::SerializeJob j,SerializeContex
RsTypeSerializer::TlvString tt(string1,TLV_TYPE_STR_NAME) ;
RsTypeSerializer::serial_process<uint8_t>(j,ctx,event_type,"event_type") ;
RsTypeSerializer::serial_process (j,ctx,string1,"string1") ;
RsTypeSerializer::serial_process<uint32_t>(j,ctx,sendTime,"sendTime") ;
RsTypeSerializer::serial_process (j,ctx,tt ,"string1") ;
RsTypeSerializer::serial_process<uint32_t>(j,ctx,sendTime ,"sendTime") ;
RsChatLobbyBouncingObject::serial_process(j,ctx,true) ;
}
@ -781,7 +781,7 @@ void RsChatLobbyInviteItem::serial_process(RsItem::SerializeJob j,SerializeConte
RsTypeSerializer::TlvString s(lobby_name,TLV_TYPE_STR_NAME) ;
RsTypeSerializer::serial_process(j,ctx,s,"lobby_name") ;
RsTypeSerializer::serial_process<ChatLobbyFlags>(j,ctx,lobby_flags,"lobby_flags") ;
RsTypeSerializer::serial_process(j,ctx,lobby_flags,"lobby_flags") ;
}
#ifdef TO_BE_REMOVED
@ -913,7 +913,7 @@ bool RsPrivateChatDistantInviteConfigItem::serialise(void *data, uint32_t& pktsi
void RsChatStatusItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx)
{
RsTypeSerializer::serial_process<uint32_t>(j,ctx,flags,"flags") ;
RsTypeSerializer::serial_process(j,ctx,flags,"flags") ;
RsTypeSerializer::TlvString tt(status_string,TLV_TYPE_STR_MSG) ;
@ -1012,7 +1012,7 @@ bool RsChatAvatarItem::serialise(void *data, uint32_t& pktsize)
void RsChatLobbyConfigItem::serial_process(RsItem::SerializeJob j,SerializeContext& ctx)
{
RsTypeSerializer::serial_process<uint64_t>(j,ctx,lobby_Id,"lobby_Id") ;
RsTypeSerializer::serial_process<uint32_t>(j,ctx,flags,"flags") ;
RsTypeSerializer::serial_process(j,ctx,flags,"flags") ;
}
#ifdef TO_BE_REMOVED

2
libretroshare/src/retroshare/rsids.h
View File

@ -120,7 +120,7 @@ template<uint32_t ID_SIZE_IN_BYTES,bool UPPER_CASE,uint32_t UNIQUE_IDENTIFIER> c
offset += SIZE_IN_BYTES ;
return true ;
}
bool deserialise(void *data,uint32_t pktsize,uint32_t& offset)
bool deserialise(const void *data,uint32_t pktsize,uint32_t& offset)
{
if(offset + SIZE_IN_BYTES > pktsize)
return false ;

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

@ -122,7 +122,7 @@ class RsItem: public RsMemoryManagement::SmallObject
*/
typedef enum { SIZE_ESTIMATE = 0x01, SERIALIZE = 0x02, DESERIALIZE = 0x03, PRINT=0x04 } SerializeJob ;
virtual void serial_process(SerializeJob j,SerializeContext& ctx)
virtual void serial_process(SerializeJob /* j */,SerializeContext& /* ctx */)
{
std::cerr << "(EE) RsItem::serial_process() called by an item using new serialization classes, but not derived! " << std::endl;
}

2
libretroshare/src/serialization/rsserializer.h
View File

@ -17,7 +17,7 @@ class RsSerializer: public RsSerialType
/*! create_item
* should be overloaded to create the correct type of item depending on the data
*/
virtual RsItem *create_item(uint16_t service, uint8_t item_sub_id)
virtual RsItem *create_item(uint16_t /* service */, uint8_t /* item_sub_id */)
{
return NULL ;
}

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

@ -1,10 +1,11 @@
#pragma once
#include <typeinfo>
#include "serialiser/rsserial.h"
#include "serialiser/rstlvbase.h"
#include "retroshare/rsflags.h"
#include "retroshare/rsids.h"
class SerializeContext
{
public:
@ -44,6 +45,10 @@ protected:
static BinaryDataBlock_ref& block_ref(unsigned char *mem,uint32_t& size) { return BinaryDataBlock_ref(mem,size).modifiable() ; }
//=================================================================================================//
// Generic types //
//=================================================================================================//
template<typename T>
static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,T& member,const std::string& member_name)
{
@ -67,7 +72,9 @@ protected:
}
}
// Arrays of stuff
//=================================================================================================//
// std::vector<T> //
//=================================================================================================//
template<typename T>
static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,std::vector<T>& v,const std::string& member_name)
@ -106,7 +113,7 @@ protected:
if(v.empty())
std::cerr << " Empty array"<< std::endl;
else
std::cerr << " Array of \"" << typeid(v[0]).name() << "\"" << " with " << v.size() << " elements:";
std::cerr << " Array of " << v.size() << " elements:" << std::endl;
for(uint32_t i=0;i<v.size();++i)
{
std::cerr << " " ;
@ -118,6 +125,39 @@ protected:
break;
}
}
//=================================================================================================//
// t_RsFlags32<> types //
//=================================================================================================//
template<int N>
static void serial_process(RsItem::SerializeJob j,SerializeContext& ctx,t_RsFlags32<N>& v,const std::string& member_name)
{
switch(j)
{
case RsItem::SIZE_ESTIMATE: ctx.mOffset += 4 ;
break ;
case RsItem::DESERIALIZE:
{
uint32_t n=0 ;
deserialize<uint32_t>(ctx.mData,ctx.mSize,ctx.mOffset,n) ;
v = t_RsFlags32<N>(n) ;
}
break ;
case RsItem::SERIALIZE:
{
uint32_t n=v.toUInt32() ;
serialize<uint32_t>(ctx.mData,ctx.mSize,ctx.mOffset,n) ;
}
break ;
case RsItem::PRINT:
std::cerr << " Flags of type " << std::hex << N << " : " << v.toUInt32() << std::endl;
break ;
}
}
protected:
template<class T> static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, const T& member);
@ -125,7 +165,36 @@ protected:
template<class T> static uint32_t serial_size(const T& /* member */);
template<class T> static void print_data(const std::string& name,const T& /* member */);
template<uint32_t ID_SIZE_IN_BYTES,bool UPPER_CASE,uint32_t UNIQUE_IDENTIFIER> static bool serialize (uint8_t data[], uint32_t size, uint32_t &offset, 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 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 void print_data(const std::string& name,const t_RsGenericIdType<ID_SIZE_IN_BYTES,UPPER_CASE,UNIQUE_IDENTIFIER>& /* member */);
};
//=================================================================================================//
// t_RsGenericId<> //
//=================================================================================================//
template<uint32_t ID_SIZE_IN_BYTES,bool UPPER_CASE,uint32_t UNIQUE_IDENTIFIER>
bool RsTypeSerializer::serialize (uint8_t data[], uint32_t size, uint32_t &offset, const t_RsGenericIdType<ID_SIZE_IN_BYTES,UPPER_CASE,UNIQUE_IDENTIFIER>& member)
{
return (*const_cast<const t_RsGenericIdType<ID_SIZE_IN_BYTES,UPPER_CASE,UNIQUE_IDENTIFIER> *>(&member)).serialise(data,size,offset) ;
}
template<uint32_t ID_SIZE_IN_BYTES,bool UPPER_CASE,uint32_t UNIQUE_IDENTIFIER>
bool RsTypeSerializer::deserialize(const uint8_t data[], uint32_t size, uint32_t &offset, t_RsGenericIdType<ID_SIZE_IN_BYTES,UPPER_CASE,UNIQUE_IDENTIFIER>& member)
{
return member.deserialise(data,size,offset) ;
}
template<uint32_t ID_SIZE_IN_BYTES,bool UPPER_CASE,uint32_t UNIQUE_IDENTIFIER>
uint32_t RsTypeSerializer::serial_size(const t_RsGenericIdType<ID_SIZE_IN_BYTES,UPPER_CASE,UNIQUE_IDENTIFIER>& member)
{
return member.serial_size();
}
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)
{
std::cerr << " [RsGenericId<" << std::hex << UNIQUE_IDENTIFIER << ">] : " << member << std::endl;
}

10
libretroshare/src/serialization/serial_test.cc
View File

@ -3,6 +3,7 @@
//
#include <set>
#include <vector>
#include "util/rsmemory.h"
#include "util/rsprint.h"
@ -90,9 +91,9 @@ class RsTestItem: public RsItem
str = "test string";
ts = time(NULL) ;
int_set.insert(lrand48()) ;
int_set.insert(lrand48()) ;
int_set.insert(lrand48()) ;
int_set.push_back(lrand48()) ;
int_set.push_back(lrand48()) ;
int_set.push_back(lrand48()) ;
}
// Derived from RsItem
@ -114,7 +115,7 @@ class RsTestItem: public RsItem
private:
std::string str ;
uint64_t ts ;
std::set<uint32_t> int_set ;
std::vector<uint32_t> int_set ;
friend int main(int argc,char *argv[]);
};
@ -148,6 +149,7 @@ class RsTestSerializer: public RsSerializer
void check(const std::string& s1,const std::string& s2) { assert(s1 == s2) ; }
void check(const uint64_t& s1,const uint64_t& s2) { assert(s1 == s2) ; }
void check(const std::set<uint32_t>& s1,const std::set<uint32_t>& s2) { assert(s1 == s2) ; }
void check(const std::vector<uint32_t>& s1,const std::vector<uint32_t>& s2) { assert(s1 == s2) ; }
int main(int argc,char *argv[])
{