InfiniSQL  v0.1.2-alpha
Massive Scale Transaction Processing
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | Static Public Member Functions | Public Attributes | List of all members
SerializedMessage Class Reference

object carrying a serialized Message variant More...

#include <Message.h>

Collaboration diagram for SerializedMessage:
Collaboration graph
[legend]

Public Member Functions

 SerializedMessage (size_t sizearg)
 
 SerializedMessage (string *dataarg)
 object carrying a serialized Message variant More...
 
virtual ~SerializedMessage ()
 
payloadtype_e getpayloadtype ()
 
void ser (size_t s, void *dataptr)
 
void des (size_t s, void *dataptr)
 
void ser (int64_t d)
 
void des (int64_t *d)
 
void ser (int32_t d)
 
void des (int32_t *d)
 
void ser (int16_t d)
 
void des (int16_t *d)
 
void ser (int8_t d)
 
void des (int8_t *d)
 
void ser (const string &d)
 
void des (string &d)
 
void ser (vector< int64_t > &d)
 
void des (vector< int64_t > &d)
 
void ser (boost::unordered_map< int64_t, int64_t > &d)
 
void des (boost::unordered_map< int64_t, int64_t > &d)
 
void ser (Message::message_s &d)
 
void des (Message::message_s &d)
 
void ser (MessageSocket::socket_s &d)
 
void des (MessageSocket::socket_s &d)
 
void ser (MessageUserSchema::userschema_s &d)
 
void des (MessageUserSchema::userschema_s &d)
 
void ser (procedures_s &d)
 
void des (procedures_s &d)
 
void ser (MessageDeadlock::deadlock_s &d)
 
void des (MessageDeadlock::deadlock_s &d)
 
void ser (MessageTransaction::transaction_s &d)
 
void des (MessageTransaction::transaction_s &d)
 
void ser (MessageSubtransactionCmd::subtransaction_s &d)
 
void des (MessageSubtransactionCmd::subtransaction_s &d)
 
void ser (nonLockingIndexEntry_s &d)
 
void des (nonLockingIndexEntry_s &d)
 
void ser (MessageDispatch::dispatch_s &d)
 
void des (MessageDispatch::dispatch_s &d)
 
void ser (MessageAckDispatch::ackdispatch_s &d)
 
void des (MessageAckDispatch::ackdispatch_s &d)
 
void ser (MessageApply::apply_s &d)
 
void des (MessageApply::apply_s &d)
 
void ser (MessageAckApply::ackapply_s &d)
 
void des (MessageAckApply::ackapply_s &d)
 
void ser (boost::unordered_set< string > &d)
 
void des (boost::unordered_set< string > &d)
 
void ser (fieldValue_s &d)
 
void des (fieldValue_s &d)
 
void ser (returnRow_s &d)
 
void des (returnRow_s &d)
 
void ser (MessageDispatch::record_s &d)
 
void des (MessageDispatch::record_s &d)
 
void ser (vector< nonLockingIndexEntry_s > &d)
 
void des (vector< nonLockingIndexEntry_s > &d)
 
void ser (newDeadLockLists_s &d)
 
void des (newDeadLockLists_s &d)
 
void ser (vector< fieldValue_s > &d)
 
void des (vector< fieldValue_s > &d)
 
void ser (vector< returnRow_s > &d)
 
void des (vector< returnRow_s > &d)
 
void ser (vector< MessageDispatch::record_s > &d)
 
void des (vector< MessageDispatch::record_s > &d)
 
void ser (rowOrField_s &d)
 
void des (rowOrField_s &d)
 
void ser (MessageApply::applyindex_s &d)
 
void des (MessageApply::applyindex_s &d)
 
void ser (searchParams_s &d)
 
void des (searchParams_s &d)
 
void ser (vector< rowOrField_s > &d)
 
void des (vector< rowOrField_s > &d)
 
void ser (vector< MessageApply::applyindex_s > &d)
 
void des (vector< MessageApply::applyindex_s > &d)
 
void ser (boost::unordered_map< int64_t, vector< MessageDispatch::record_s > > &d)
 
void des (boost::unordered_map< int64_t, vector< MessageDispatch::record_s > > &d)
 

Static Public Member Functions

static size_t sersize (int64_t d)
 
static size_t sersize (int32_t d)
 
static size_t sersize (int16_t d)
 
static size_t sersize (int8_t d)
 
static size_t sersize (const string &d)
 
static size_t sersize (vector< int64_t > &d)
 
static size_t sersize (boost::unordered_map< int64_t, int64_t > &d)
 
static size_t sersize (Message::message_s &d)
 
static size_t sersize (MessageSocket::socket_s &d)
 
static size_t sersize (MessageUserSchema::userschema_s &d)
 
static size_t sersize (procedures_s &d)
 
static size_t sersize (MessageDeadlock::deadlock_s &d)
 
static size_t sersize (MessageTransaction::transaction_s &d)
 
static size_t sersize (MessageSubtransactionCmd::subtransaction_s &d)
 
static size_t sersize (nonLockingIndexEntry_s &d)
 
static size_t sersize (MessageDispatch::dispatch_s &d)
 
static size_t sersize (MessageAckDispatch::ackdispatch_s &d)
 
static size_t sersize (MessageApply::apply_s &d)
 
static size_t sersize (MessageAckApply::ackapply_s &d)
 
static size_t sersize (boost::unordered_set< string > &d)
 
static size_t sersize (fieldValue_s &d)
 
static size_t sersize (returnRow_s &d)
 
static size_t sersize (MessageDispatch::record_s &d)
 
static size_t sersize (vector< nonLockingIndexEntry_s > &d)
 
static size_t sersize (newDeadLockLists_s &d)
 
static size_t sersize (vector< fieldValue_s > &d)
 
static size_t sersize (vector< returnRow_s > &d)
 
static size_t sersize (vector< MessageDispatch::record_s > &d)
 
static size_t sersize (rowOrField_s &d)
 
static size_t sersize (MessageApply::applyindex_s &d)
 
static size_t sersize (searchParams_s &d)
 
static size_t sersize (vector< rowOrField_s > &d)
 
static size_t sersize (vector< MessageApply::applyindex_s > &d)
 
static size_t sersize (boost::unordered_map< int64_t, vector< MessageDispatch::record_s > > &d)
 

Public Attributes

size_t size
 
size_t pos
 
std::string * data
 

Detailed Description

object carrying a serialized Message variant

1) sender to obgw: SerializedMessage on stack 2) copy pointer SerializedMessage.data to new MessageSerialized.data 3) send MessageSerialized to obgw 4) obgw takes MessageSerialized.data in boost_unordered::map< int64_t, vector<string *> > for sending to remote node 5) obgw copies string *'s, deletes them, sends to remote node 6) ibgw creates new MessageSerialized for each string * gets destAddr, etc by reading 1st sizeof(Message::message_s) 7) destination copies MessageSerialized.data ptr to SerializedMessage.data 8) destination deserializes into original Message* 9) destination deletes SerializedMessage.data

source actor is the sender of this

Parameters
sizeargsize of serialized message
Returns

Definition at line 869 of file Message.h.

Constructor & Destructor Documentation

SerializedMessage::SerializedMessage ( size_t  sizearg)

Definition at line 786 of file Message.cc.

References data, and size.

786  : size(sizearg), pos(0)
787 {
788  data=new string(size, char(0));
789 }
SerializedMessage::SerializedMessage ( string *  dataarg)

object carrying a serialized Message variant

IbGateway is the sender

Parameters
dataargserialized message to populate with

Definition at line 791 of file Message.cc.

References data, and size.

791  : pos(0), data(dataarg)
792 {
793  size=data->size();
794 }
SerializedMessage::~SerializedMessage ( )
virtual

Definition at line 796 of file Message.cc.

797 {
798 }

Member Function Documentation

void SerializedMessage::des ( size_t  s,
void *  dataptr 
)

Definition at line 814 of file Message.cc.

References data, and pos.

Referenced by des(), Message::unpack(), MessageSocket::unpack(), MessageUserSchema::unpack(), MessageDeadlock::unpack(), MessageTransaction::unpack(), MessageSubtransactionCmd::unpack(), MessageCommitRollback::unpack(), MessageDispatch::unpack(), MessageAckDispatch::unpack(), MessageApply::unpack(), and MessageAckApply::unpack().

815 {
816  memcpy(dataptr, &data->at(pos), s);
817  pos += s;
818 }

Here is the caller graph for this function:

void SerializedMessage::des ( int64_t *  d)

Definition at line 832 of file Message.cc.

References data, and pos.

833 {
834  memcpy(d, &data->at(pos), sizeof(*d));
835  pos += sizeof(*d);
836 }
void SerializedMessage::des ( int32_t *  d)

Definition at line 849 of file Message.cc.

References data, and pos.

850 {
851  memcpy(d, &data->at(pos), sizeof(*d));
852  pos += sizeof(*d);
853 }
void SerializedMessage::des ( int16_t *  d)

Definition at line 866 of file Message.cc.

References data, and pos.

867 {
868  memcpy(d, &data->at(pos), sizeof(*d));
869  pos += sizeof(*d);
870 }
void SerializedMessage::des ( int8_t *  d)

Definition at line 883 of file Message.cc.

References data, and pos.

884 {
885  memcpy(d, &data->at(pos), sizeof(*d));
886  pos += sizeof(*d);
887 }
void SerializedMessage::des ( string &  d)

Definition at line 905 of file Message.cc.

References data, des(), and pos.

Referenced by des().

906 {
907  size_t s;
908  des((int64_t *)&s);
909  if (s)
910  {
911  d.assign((const char *)&data->at(pos), s);
912  pos += s;
913  }
914 }

Here is the call graph for this function:

Here is the caller graph for this function:

void SerializedMessage::des ( vector< int64_t > &  d)

Definition at line 932 of file Message.cc.

References data, des(), and pos.

933 {
934  size_t s;
935  memcpy(&s, &data->at(pos), sizeof(s));
936  pos += sizeof(s);
937  d.reserve(s);
938  for (size_t n=0; n<s; n++)
939  {
940  int64_t val;
941  des(&val);
942  d.push_back(val);
943  }
944 }

Here is the call graph for this function:

void SerializedMessage::des ( boost::unordered_map< int64_t, int64_t > &  d)

Definition at line 962 of file Message.cc.

References data, des(), and pos.

963 {
964  size_t s;
965  memcpy(&s, &data->at(pos), sizeof(s));
966  pos += sizeof(s);
967  for (size_t n=0; n<s; n++)
968  {
969  int64_t val1, val2;
970  des(&val1);
971  des(&val2);
972  d[val1]=val2;
973  }
974 }

Here is the call graph for this function:

void SerializedMessage::des ( Message::message_s &  d)

Definition at line 988 of file Message.cc.

References data, and pos.

989 {
990  memcpy(&d, &data->at(pos), sizeof(d));
991  pos += sizeof(d);
992 }
void SerializedMessage::des ( MessageSocket::socket_s &  d)

Definition at line 1006 of file Message.cc.

References data, and pos.

1007 {
1008  memcpy(&d, &data->at(pos), sizeof(d));
1009  pos += sizeof(d);
1010 }
void SerializedMessage::des ( MessageUserSchema::userschema_s &  d)

Definition at line 1023 of file Message.cc.

References data, and pos.

1024 {
1025  memcpy(&d, &data->at(pos), sizeof(d));
1026  pos += sizeof(d);
1027 }
void SerializedMessage::des ( procedures_s &  d)

Definition at line 1040 of file Message.cc.

References data, and pos.

1041 {
1042  memcpy(&d, &data->at(pos), sizeof(d));
1043  pos += sizeof(d);
1044 }
void SerializedMessage::des ( MessageDeadlock::deadlock_s &  d)

Definition at line 1057 of file Message.cc.

References data, and pos.

1058 {
1059  memcpy(&d, &data->at(pos), sizeof(d));
1060  pos += sizeof(d);
1061 }
void SerializedMessage::des ( MessageTransaction::transaction_s &  d)

Definition at line 1074 of file Message.cc.

References data, and pos.

1075 {
1076  memcpy(&d, &data->at(pos), sizeof(d));
1077  pos += sizeof(d);
1078 }
void SerializedMessage::des ( MessageSubtransactionCmd::subtransaction_s &  d)

Definition at line 1091 of file Message.cc.

References data, and pos.

1092 {
1093  memcpy(&d, &data->at(pos), sizeof(d));
1094  pos += sizeof(d);
1095 }
void SerializedMessage::des ( nonLockingIndexEntry_s &  d)

Definition at line 1108 of file Message.cc.

References data, and pos.

1109 {
1110  memcpy(&d, &data->at(pos), sizeof(d));
1111  pos += sizeof(d);
1112 }
void SerializedMessage::des ( MessageDispatch::dispatch_s &  d)

Definition at line 1125 of file Message.cc.

References data, and pos.

1126 {
1127  memcpy(&d, &data->at(pos), sizeof(d));
1128  pos += sizeof(d);
1129 }
void SerializedMessage::des ( MessageAckDispatch::ackdispatch_s &  d)

Definition at line 1142 of file Message.cc.

References data, and pos.

1143 {
1144  memcpy(&d, &data->at(pos), sizeof(d));
1145  pos += sizeof(d);
1146 }
void SerializedMessage::des ( MessageApply::apply_s &  d)

Definition at line 1159 of file Message.cc.

References data, and pos.

1160 {
1161  memcpy(&d, &data->at(pos), sizeof(d));
1162  pos += sizeof(d);
1163 }
void SerializedMessage::des ( MessageAckApply::ackapply_s &  d)

Definition at line 1176 of file Message.cc.

References data, and pos.

1177 {
1178  memcpy(&d, &data->at(pos), sizeof(d));
1179  pos += sizeof(d);
1180 }
void SerializedMessage::des ( boost::unordered_set< string > &  d)

Definition at line 1205 of file Message.cc.

References des().

1206 {
1207  size_t s;
1208  des((int64_t *)&s);
1209  for (size_t n=0; n<s; n++)
1210  {
1211  string val;
1212  des(val);
1213  d.insert(val);
1214  }
1215 }

Here is the call graph for this function:

void SerializedMessage::des ( fieldValue_s &  d)

Definition at line 1230 of file Message.cc.

References data, des(), fieldValue_s::isnull, pos, fieldValue_s::str, and fieldValue_s::value.

1231 {
1232  memcpy(&d.value, &data->at(pos), sizeof(d.value));
1233  pos += sizeof(d.value);
1234  des(d.str);
1235  des((int8_t *)&d.isnull);
1236 }

Here is the call graph for this function:

void SerializedMessage::des ( returnRow_s &  d)

Definition at line 1252 of file Message.cc.

References des(), returnRow_s::locktype, returnRow_s::previoussubtransactionid, returnRow_s::row, and returnRow_s::rowid.

1253 {
1254  des(&d.rowid);
1255  des(&d.previoussubtransactionid);
1256  des((int8_t *)&d.locktype);
1257  des(d.row);
1258 }

Here is the call graph for this function:

void SerializedMessage::des ( MessageDispatch::record_s &  d)

Definition at line 1276 of file Message.cc.

References des(), MessageDispatch::record_s::oldrow, MessageDispatch::record_s::previoussubtransactionid, MessageDispatch::record_s::primitive, MessageDispatch::record_s::row, MessageDispatch::record_s::rowid, and MessageDispatch::record_s::tableid.

1277 {
1278  des(&d.rowid);
1279  des((int8_t *)&d.primitive);
1280  des(&d.tableid);
1281  des(&d.previoussubtransactionid);
1282  des(d.row);
1283  des(d.oldrow);
1284 }

Here is the call graph for this function:

void SerializedMessage::des ( vector< nonLockingIndexEntry_s > &  d)

Definition at line 1302 of file Message.cc.

References des().

1303 {
1304  size_t s;
1305  des((int64_t *)&s);
1306  d.reserve(s);
1307  for (size_t n=0; n<s; n++)
1308  {
1309  nonLockingIndexEntry_s val;
1310  des(val);
1311  d.push_back(val);
1312  }
1313 }

Here is the call graph for this function:

void SerializedMessage::des ( newDeadLockLists_s &  d)

Definition at line 1327 of file Message.cc.

References des(), newDeadLockLists_s::locked, and newDeadLockLists_s::waiting.

1328 {
1329  des(d.locked);
1330  des(d.waiting);
1331 }

Here is the call graph for this function:

void SerializedMessage::des ( vector< fieldValue_s > &  d)

Definition at line 1354 of file Message.cc.

References des().

1355 {
1356  size_t s;
1357  des((int64_t *)&s);
1358  d.reserve(s);
1359  for (size_t n=0; n<s; n++)
1360  {
1361  fieldValue_s val;
1362  des(val);
1363  d.push_back(val);
1364  }
1365 }

Here is the call graph for this function:

void SerializedMessage::des ( vector< returnRow_s > &  d)

Definition at line 1388 of file Message.cc.

References des().

1389 {
1390  size_t s;
1391  des((int64_t *)&s);
1392  d.reserve(s);
1393  for (size_t n=0; n<s; n++)
1394  {
1395  returnRow_s val;
1396  des(val);
1397  d.push_back(val);
1398  }
1399 }

Here is the call graph for this function:

void SerializedMessage::des ( vector< MessageDispatch::record_s > &  d)

Definition at line 1422 of file Message.cc.

References des().

1423 {
1424  size_t s;
1425  des((int64_t *)&s);
1426  d.reserve(s);
1427  for (size_t n=0; n<s; n++)
1428  {
1429  MessageDispatch::record_s val;
1430  des(val);
1431  d.push_back(val);
1432  }
1433 }

Here is the call graph for this function:

void SerializedMessage::des ( rowOrField_s &  d)

Definition at line 1460 of file Message.cc.

References rowOrField_s::deleteindexentry, des(), rowOrField_s::engineid, rowOrField_s::fieldid, rowOrField_s::fieldVal, rowOrField_s::isnotaddunique, rowOrField_s::isreplace, rowOrField_s::isrow, rowOrField_s::newengineid, rowOrField_s::newrowid, rowOrField_s::rowid, and rowOrField_s::tableid.

1461 {
1462  des((int8_t *)&d.isrow);
1463  des(&d.tableid);
1464  des(&d.rowid);
1465  des(&d.fieldid);
1466  des(&d.engineid);
1467  des((int8_t *)&d.deleteindexentry);
1468  des((int8_t *)&d.isnotaddunique);
1469  des((int8_t *)&d.isreplace);
1470  des(&d.newrowid);
1471  des(&d.newengineid);
1472  des(d.fieldVal);
1473 }

Here is the call graph for this function:

void SerializedMessage::des ( MessageApply::applyindex_s &  d)

Definition at line 1490 of file Message.cc.

References data, des(), MessageApply::applyindex_s::entry, MessageApply::applyindex_s::fieldid, MessageApply::applyindex_s::fieldVal, MessageApply::applyindex_s::flags, pos, and MessageApply::applyindex_s::tableid.

1491 {
1492  des(d.fieldVal);
1493  des(d.entry);
1494  d.flags=data->at(pos++);
1495  des(&d.tableid);
1496  des(&d.fieldid);
1497 }

Here is the call graph for this function:

void SerializedMessage::des ( searchParams_s &  d)

Definition at line 1512 of file Message.cc.

References des(), searchParams_s::op, searchParams_s::regexString, and searchParams_s::values.

1513 {
1514  des((int8_t *)&d.op);
1515  des(d.values);
1516  des(d.regexString);
1517 }

Here is the call graph for this function:

void SerializedMessage::des ( vector< rowOrField_s > &  d)

Definition at line 1540 of file Message.cc.

References des().

1541 {
1542  size_t s;
1543  des((int64_t *)&s);
1544  d.reserve(s);
1545  for (size_t n=0; n<s; n++)
1546  {
1547  rowOrField_s val;
1548  des(val);
1549  d.push_back(val);
1550  }
1551 }

Here is the call graph for this function:

void SerializedMessage::des ( vector< MessageApply::applyindex_s > &  d)

Definition at line 1574 of file Message.cc.

References des().

1575 {
1576  size_t s;
1577  des((int64_t *)&s);
1578  d.reserve(s);
1579  for (size_t n=0; n<s; n++)
1580  {
1581  MessageApply::applyindex_s val;
1582  des(val);
1583  d.push_back(val);
1584  }
1585 }

Here is the call graph for this function:

void SerializedMessage::des ( boost::unordered_map< int64_t, vector< MessageDispatch::record_s > > &  d)

Definition at line 1606 of file Message.cc.

References data, des(), and pos.

1608 {
1609  size_t s;
1610  memcpy(&s, &data->at(pos), sizeof(s));
1611  pos += sizeof(s);
1612  for (size_t n=0; n<s; n++)
1613  {
1614  int64_t val1;
1615  des(&val1);
1616  vector<MessageDispatch::record_s> val2;
1617  des(val2);
1618  d[val1]=val2;
1619  }
1620 }

Here is the call graph for this function:

payloadtype_e SerializedMessage::getpayloadtype ( )

Definition at line 800 of file Message.cc.

References data, and Message::message_s::payloadtype.

Referenced by Message::des(), Message::ser(), MessageSocket::ser(), MessageUserSchema::ser(), MessageDeadlock::ser(), MessageTransaction::ser(), MessageSubtransactionCmd::ser(), MessageCommitRollback::ser(), MessageDispatch::ser(), MessageAckDispatch::ser(), MessageApply::ser(), and MessageAckApply::ser().

801 {
802  Message::message_s tmpheader;
803  memcpy(&tmpheader, data->c_str(), sizeof(tmpheader));
804  return tmpheader.payloadtype;
805 }

Here is the caller graph for this function:

void SerializedMessage::ser ( size_t  s,
void *  dataptr 
)

Definition at line 808 of file Message.cc.

References data, and pos.

Referenced by Message::package(), MessageSocket::package(), MessageUserSchema::package(), MessageDeadlock::package(), MessageTransaction::package(), MessageSubtransactionCmd::package(), MessageCommitRollback::package(), MessageDispatch::package(), MessageAckDispatch::package(), MessageApply::package(), MessageAckApply::package(), and ser().

809 {
810  memcpy(&data->at(pos), dataptr, s);
811  pos += s;
812 }

Here is the caller graph for this function:

void SerializedMessage::ser ( int64_t  d)

Definition at line 821 of file Message.cc.

References data, and pos.

822 {
823  memcpy(&data->at(pos), &d, sizeof(d));
824  pos += sizeof(d);
825 }
void SerializedMessage::ser ( int32_t  d)

Definition at line 838 of file Message.cc.

References data, and pos.

839 {
840  memcpy(&data->at(pos), &d, sizeof(d));
841  pos += sizeof(d);
842 }
void SerializedMessage::ser ( int16_t  d)

Definition at line 855 of file Message.cc.

References data, and pos.

856 {
857  memcpy(&data->at(pos), &d, sizeof(d));
858  pos += sizeof(d);
859 }
void SerializedMessage::ser ( int8_t  d)

Definition at line 872 of file Message.cc.

References data, and pos.

873 {
874  memcpy(&data->at(pos), &d, sizeof(d));
875  pos += sizeof(d);
876 }
void SerializedMessage::ser ( const string &  d)

Definition at line 890 of file Message.cc.

References data, pos, and ser().

891 {
892  ser((int64_t)d.size());
893  if (d.size())
894  {
895  memcpy(&data->at(pos), d.c_str(), d.size());
896  pos += d.size();
897  }
898 }

Here is the call graph for this function:

void SerializedMessage::ser ( vector< int64_t > &  d)

Definition at line 916 of file Message.cc.

References data, pos, and ser().

917 {
918  size_t s=d.size();
919  memcpy(&data->at(pos), &s, sizeof(s));
920  pos += sizeof(s);
921  for (size_t n=0; n<s; n++)
922  {
923  ser(d[n]);
924  }
925 }

Here is the call graph for this function:

void SerializedMessage::ser ( boost::unordered_map< int64_t, int64_t > &  d)

Definition at line 946 of file Message.cc.

References ser().

947 {
948  ser((int64_t)d.size());
949  boost::unordered_map<int64_t, int64_t>::const_iterator it;
950  for (it=d.begin(); it != d.end(); ++it)
951  {
952  ser(it->first);
953  ser(it->second);
954  }
955 }

Here is the call graph for this function:

void SerializedMessage::ser ( Message::message_s &  d)

Definition at line 977 of file Message.cc.

References data, and pos.

978 {
979  memcpy(&data->at(pos), &d, sizeof(d));
980  pos += sizeof(d);
981 }
void SerializedMessage::ser ( MessageSocket::socket_s &  d)

Definition at line 995 of file Message.cc.

References data, and pos.

996 {
997  memcpy(&data->at(pos), &d, sizeof(d));
998  pos += sizeof(d);
999 }
void SerializedMessage::ser ( MessageUserSchema::userschema_s &  d)

Definition at line 1012 of file Message.cc.

References data, and pos.

1013 {
1014  memcpy(&data->at(pos), &d, sizeof(d));
1015  pos += sizeof(d);
1016 }
void SerializedMessage::ser ( procedures_s &  d)

Definition at line 1029 of file Message.cc.

References data, and pos.

1030 {
1031  memcpy(&data->at(pos), &d, sizeof(d));
1032  pos += sizeof(d);
1033 }
void SerializedMessage::ser ( MessageDeadlock::deadlock_s &  d)

Definition at line 1046 of file Message.cc.

References data, and pos.

1047 {
1048  memcpy(&data->at(pos), &d, sizeof(d));
1049  pos += sizeof(d);
1050 }
void SerializedMessage::ser ( MessageTransaction::transaction_s &  d)

Definition at line 1063 of file Message.cc.

References data, and pos.

1064 {
1065  memcpy(&data->at(pos), &d, sizeof(d));
1066  pos += sizeof(d);
1067 }
void SerializedMessage::ser ( MessageSubtransactionCmd::subtransaction_s &  d)

Definition at line 1080 of file Message.cc.

References data, and pos.

1081 {
1082  memcpy(&data->at(pos), &d, sizeof(d));
1083  pos += sizeof(d);
1084 }
void SerializedMessage::ser ( nonLockingIndexEntry_s &  d)

Definition at line 1097 of file Message.cc.

References data, and pos.

1098 {
1099  memcpy(&data->at(pos), &d, sizeof(d));
1100  pos += sizeof(d);
1101 }
void SerializedMessage::ser ( MessageDispatch::dispatch_s &  d)

Definition at line 1114 of file Message.cc.

References data, and pos.

1115 {
1116  memcpy(&data->at(pos), &d, sizeof(d));
1117  pos += sizeof(d);
1118 }
void SerializedMessage::ser ( MessageAckDispatch::ackdispatch_s &  d)

Definition at line 1131 of file Message.cc.

References data, and pos.

1132 {
1133  memcpy(&data->at(pos), &d, sizeof(d));
1134  pos += sizeof(d);
1135 }
void SerializedMessage::ser ( MessageApply::apply_s &  d)

Definition at line 1148 of file Message.cc.

References data, and pos.

1149 {
1150  memcpy(&data->at(pos), &d, sizeof(d));
1151  pos += sizeof(d);
1152 }
void SerializedMessage::ser ( MessageAckApply::ackapply_s &  d)

Definition at line 1165 of file Message.cc.

References data, and pos.

1166 {
1167  memcpy(&data->at(pos), &d, sizeof(d));
1168  pos += sizeof(d);
1169 }
void SerializedMessage::ser ( boost::unordered_set< string > &  d)

Definition at line 1183 of file Message.cc.

References ser().

1184 {
1185  size_t s=d.size();
1186  ser((int64_t)s);
1187  boost::unordered_set<string>::const_iterator it;
1188  for (it=d.begin(); it != d.end(); ++it)
1189  {
1190  ser(*it);
1191  }
1192 }

Here is the call graph for this function:

void SerializedMessage::ser ( fieldValue_s &  d)

Definition at line 1217 of file Message.cc.

References data, fieldValue_s::isnull, pos, ser(), fieldValue_s::str, and fieldValue_s::value.

1218 {
1219  memcpy(&data->at(pos), &d.value, sizeof(d.value));
1220  pos += sizeof(d.value);
1221  ser(d.str);
1222  ser((int8_t)d.isnull);
1223 }

Here is the call graph for this function:

void SerializedMessage::ser ( returnRow_s &  d)

Definition at line 1238 of file Message.cc.

References returnRow_s::locktype, returnRow_s::previoussubtransactionid, returnRow_s::row, returnRow_s::rowid, and ser().

1239 {
1240  ser(d.rowid);
1241  ser(d.previoussubtransactionid);
1242  ser((int8_t)d.locktype);
1243  ser(d.row);
1244 }

Here is the call graph for this function:

void SerializedMessage::ser ( MessageDispatch::record_s &  d)

Definition at line 1260 of file Message.cc.

References MessageDispatch::record_s::oldrow, MessageDispatch::record_s::previoussubtransactionid, MessageDispatch::record_s::primitive, MessageDispatch::record_s::row, MessageDispatch::record_s::rowid, ser(), and MessageDispatch::record_s::tableid.

1261 {
1262  ser(d.rowid);
1263  ser((int8_t)d.primitive);
1264  ser(d.tableid);
1265  ser(d.previoussubtransactionid);
1266  ser(d.row);
1267  ser(d.oldrow);
1268 }

Here is the call graph for this function:

void SerializedMessage::ser ( vector< nonLockingIndexEntry_s > &  d)

Definition at line 1286 of file Message.cc.

References ser().

1287 {
1288  ser((int64_t)d.size());
1289  vector<nonLockingIndexEntry_s>::iterator it;
1290  for (it=d.begin(); it != d.end(); ++it)
1291  {
1292  ser(*it);
1293  }
1294 }

Here is the call graph for this function:

void SerializedMessage::ser ( newDeadLockLists_s &  d)

Definition at line 1316 of file Message.cc.

References newDeadLockLists_s::locked, ser(), and newDeadLockLists_s::waiting.

1317 {
1318  ser(d.locked);
1319  ser(d.waiting);
1320 }

Here is the call graph for this function:

void SerializedMessage::ser ( vector< fieldValue_s > &  d)

Definition at line 1333 of file Message.cc.

References ser().

1334 {
1335  ser((int64_t)d.size());
1336  vector<fieldValue_s>::iterator it;
1337  for (it=d.begin(); it != d.end(); ++it)
1338  {
1339  ser(*it);
1340  }
1341 }

Here is the call graph for this function:

void SerializedMessage::ser ( vector< returnRow_s > &  d)

Definition at line 1367 of file Message.cc.

References ser().

1368 {
1369  ser((int64_t)d.size());
1370  vector<returnRow_s>::iterator it;
1371  for (it=d.begin(); it != d.end(); ++it)
1372  {
1373  ser(*it);
1374  }
1375 }

Here is the call graph for this function:

void SerializedMessage::ser ( vector< MessageDispatch::record_s > &  d)

Definition at line 1401 of file Message.cc.

References ser().

1402 {
1403  ser((int64_t)d.size());
1404  vector<MessageDispatch::record_s>::iterator it;
1405  for (it=d.begin(); it != d.end(); ++it)
1406  {
1407  ser(*it);
1408  }
1409 }

Here is the call graph for this function:

void SerializedMessage::ser ( rowOrField_s &  d)

Definition at line 1435 of file Message.cc.

References rowOrField_s::deleteindexentry, rowOrField_s::engineid, rowOrField_s::fieldid, rowOrField_s::fieldVal, rowOrField_s::isnotaddunique, rowOrField_s::isreplace, rowOrField_s::isrow, rowOrField_s::newengineid, rowOrField_s::newrowid, rowOrField_s::rowid, ser(), and rowOrField_s::tableid.

1436 {
1437  ser((int8_t)d.isrow);
1438  ser(d.tableid);
1439  ser(d.rowid);
1440  ser(d.fieldid);
1441  ser(d.engineid);
1442  ser((int8_t)d.deleteindexentry);
1443  ser((int8_t)d.isnotaddunique);
1444  ser((int8_t)d.isreplace);
1445  ser(d.newrowid);
1446  ser(d.newengineid);
1447  ser(d.fieldVal);
1448 }

Here is the call graph for this function:

void SerializedMessage::ser ( MessageApply::applyindex_s &  d)

Definition at line 1475 of file Message.cc.

References data, MessageApply::applyindex_s::entry, MessageApply::applyindex_s::fieldid, MessageApply::applyindex_s::fieldVal, MessageApply::applyindex_s::flags, pos, ser(), and MessageApply::applyindex_s::tableid.

1476 {
1477  ser(d.fieldVal);
1478  ser(d.entry);
1479  data[pos++]=d.flags;
1480  ser(d.tableid);
1481  ser(d.fieldid);
1482 }

Here is the call graph for this function:

void SerializedMessage::ser ( searchParams_s &  d)

Definition at line 1500 of file Message.cc.

References searchParams_s::op, searchParams_s::regexString, ser(), and searchParams_s::values.

1501 {
1502  ser((int8_t)d.op);
1503  ser(d.values);
1504  ser(d.regexString);
1505 }

Here is the call graph for this function:

void SerializedMessage::ser ( vector< rowOrField_s > &  d)

Definition at line 1519 of file Message.cc.

References ser().

1520 {
1521  ser((int64_t)d.size());
1522  vector<rowOrField_s>::iterator it;
1523  for (it=d.begin(); it != d.end(); ++it)
1524  {
1525  ser(*it);
1526  }
1527 }

Here is the call graph for this function:

void SerializedMessage::ser ( vector< MessageApply::applyindex_s > &  d)

Definition at line 1553 of file Message.cc.

References ser().

1554 {
1555  ser((int64_t)d.size());
1556  vector<MessageApply::applyindex_s>::iterator it;
1557  for (it=d.begin(); it != d.end(); ++it)
1558  {
1559  ser(*it);
1560  }
1561 }

Here is the call graph for this function:

void SerializedMessage::ser ( boost::unordered_map< int64_t, vector< MessageDispatch::record_s > > &  d)

Definition at line 1587 of file Message.cc.

References ser().

1589 {
1590  ser((int64_t)d.size());
1591  boost::unordered_map< int64_t,
1592  vector<MessageDispatch::record_s> >::iterator it;
1593  for (it=d.begin(); it != d.end(); ++it)
1594  {
1595  ser(it->first);
1596  ser(it->second);
1597  }
1598 }

Here is the call graph for this function:

size_t SerializedMessage::sersize ( int64_t  d)
static

Definition at line 827 of file Message.cc.

Referenced by sersize(), Message::size(), MessageSocket::size(), MessageUserSchema::size(), MessageDeadlock::size(), MessageTransaction::size(), MessageSubtransactionCmd::size(), MessageCommitRollback::size(), MessageDispatch::size(), MessageAckDispatch::size(), MessageApply::size(), and MessageAckApply::size().

828 {
829  return sizeof(d);
830 }

Here is the caller graph for this function:

size_t SerializedMessage::sersize ( int32_t  d)
static

Definition at line 844 of file Message.cc.

845 {
846  return sizeof(d);
847 }
size_t SerializedMessage::sersize ( int16_t  d)
static

Definition at line 861 of file Message.cc.

862 {
863  return sizeof(d);
864 }
size_t SerializedMessage::sersize ( int8_t  d)
static

Definition at line 878 of file Message.cc.

879 {
880  return sizeof(d);
881 }
size_t SerializedMessage::sersize ( const string &  d)
static

Definition at line 900 of file Message.cc.

901 {
902  return sizeof(int64_t)+d.size();
903 }
size_t SerializedMessage::sersize ( vector< int64_t > &  d)
static

Definition at line 927 of file Message.cc.

928 {
929  return sizeof(size_t) + (d.size() * sizeof(int64_t));
930 }
size_t SerializedMessage::sersize ( boost::unordered_map< int64_t, int64_t > &  d)
static

Definition at line 957 of file Message.cc.

958 {
959  return d.size() + (d.size() * 2 * sizeof(int64_t));
960 }
size_t SerializedMessage::sersize ( Message::message_s &  d)
static

Definition at line 983 of file Message.cc.

984 {
985  return sizeof(d);
986 }
size_t SerializedMessage::sersize ( MessageSocket::socket_s &  d)
static

Definition at line 1001 of file Message.cc.

1002 {
1003  return sizeof(d);
1004 }
size_t SerializedMessage::sersize ( MessageUserSchema::userschema_s &  d)
static

Definition at line 1018 of file Message.cc.

1019 {
1020  return sizeof(d);
1021 }
size_t SerializedMessage::sersize ( procedures_s &  d)
static

Definition at line 1035 of file Message.cc.

1036 {
1037  return sizeof(d);
1038 }
size_t SerializedMessage::sersize ( MessageDeadlock::deadlock_s &  d)
static

Definition at line 1052 of file Message.cc.

1053 {
1054  return sizeof(d);
1055 }
size_t SerializedMessage::sersize ( MessageTransaction::transaction_s &  d)
static

Definition at line 1069 of file Message.cc.

1070 {
1071  return sizeof(d);
1072 }
size_t SerializedMessage::sersize ( MessageSubtransactionCmd::subtransaction_s &  d)
static

Definition at line 1086 of file Message.cc.

1087 {
1088  return sizeof(d);
1089 }
size_t SerializedMessage::sersize ( nonLockingIndexEntry_s &  d)
static

Definition at line 1103 of file Message.cc.

1104 {
1105  return sizeof(d);
1106 }
size_t SerializedMessage::sersize ( MessageDispatch::dispatch_s &  d)
static

Definition at line 1120 of file Message.cc.

1121 {
1122  return sizeof(d);
1123 }
size_t SerializedMessage::sersize ( MessageAckDispatch::ackdispatch_s &  d)
static

Definition at line 1137 of file Message.cc.

1138 {
1139  return sizeof(d);
1140 }
size_t SerializedMessage::sersize ( MessageApply::apply_s &  d)
static

Definition at line 1154 of file Message.cc.

1155 {
1156  return sizeof(d);
1157 }
size_t SerializedMessage::sersize ( MessageAckApply::ackapply_s &  d)
static

Definition at line 1171 of file Message.cc.

1172 {
1173  return sizeof(d);
1174 }
size_t SerializedMessage::sersize ( boost::unordered_set< string > &  d)
static

Definition at line 1194 of file Message.cc.

References sersize().

1195 {
1196  size_t retval=sizeof(size_t);
1197  boost::unordered_set<string>::const_iterator it;
1198  for (it=d.begin(); it != d.end(); ++it)
1199  {
1200  retval += sersize(*it);
1201  }
1202  return retval;
1203 }

Here is the call graph for this function:

size_t SerializedMessage::sersize ( fieldValue_s &  d)
static

Definition at line 1225 of file Message.cc.

References fieldValue_s::isnull, sersize(), fieldValue_s::str, and fieldValue_s::value.

1226 {
1227  return sizeof(d.value)+sersize(d.str)+sersize((int8_t)d.isnull);
1228 }

Here is the call graph for this function:

size_t SerializedMessage::sersize ( returnRow_s &  d)
static

Definition at line 1246 of file Message.cc.

References returnRow_s::locktype, returnRow_s::previoussubtransactionid, returnRow_s::row, returnRow_s::rowid, and sersize().

1247 {
1248  return sersize(d.rowid)+sersize(d.previoussubtransactionid)+
1249  sersize((int8_t)d.locktype)+sersize(d.row);
1250 }

Here is the call graph for this function:

size_t SerializedMessage::sersize ( MessageDispatch::record_s &  d)
static

Definition at line 1270 of file Message.cc.

References MessageDispatch::record_s::oldrow, MessageDispatch::record_s::previoussubtransactionid, MessageDispatch::record_s::primitive, MessageDispatch::record_s::row, MessageDispatch::record_s::rowid, sersize(), and MessageDispatch::record_s::tableid.

1271 {
1272  return sersize(d.rowid)+sersize((int8_t)d.primitive)+sersize(d.tableid)+
1273  sersize(d.previoussubtransactionid)+sersize(d.row)+sersize(d.oldrow);
1274 }

Here is the call graph for this function:

size_t SerializedMessage::sersize ( vector< nonLockingIndexEntry_s > &  d)
static

Definition at line 1296 of file Message.cc.

1297 {
1298  size_t s=d.size();
1299  return sizeof(int64_t) + (s *sizeof(nonLockingIndexEntry_s));
1300 }
size_t SerializedMessage::sersize ( newDeadLockLists_s &  d)
static

Definition at line 1322 of file Message.cc.

References newDeadLockLists_s::locked, sersize(), and newDeadLockLists_s::waiting.

1323 {
1324  return sersize(d.locked)+sersize(d.waiting);
1325 }

Here is the call graph for this function:

size_t SerializedMessage::sersize ( vector< fieldValue_s > &  d)
static

Definition at line 1343 of file Message.cc.

References sersize().

1344 {
1345  size_t retval=sizeof(int64_t);
1346  vector<fieldValue_s>::iterator it;
1347  for (it = d.begin(); it != d.end(); ++it)
1348  {
1349  retval += sersize(*it);
1350  }
1351  return retval;
1352 }

Here is the call graph for this function:

size_t SerializedMessage::sersize ( vector< returnRow_s > &  d)
static

Definition at line 1377 of file Message.cc.

References sersize().

1378 {
1379  size_t retval=sizeof(int64_t);
1380  vector<returnRow_s>::iterator it;
1381  for (it = d.begin(); it != d.end(); ++it)
1382  {
1383  retval += sersize(*it);
1384  }
1385  return retval;
1386 }

Here is the call graph for this function:

size_t SerializedMessage::sersize ( vector< MessageDispatch::record_s > &  d)
static

Definition at line 1411 of file Message.cc.

References sersize().

1412 {
1413  size_t retval=sizeof(int64_t);
1414  vector<MessageDispatch::record_s>::iterator it;
1415  for (it = d.begin(); it != d.end(); ++it)
1416  {
1417  retval += sersize(*it);
1418  }
1419  return retval;
1420 }

Here is the call graph for this function:

size_t SerializedMessage::sersize ( rowOrField_s &  d)
static

Definition at line 1450 of file Message.cc.

References rowOrField_s::deleteindexentry, rowOrField_s::engineid, rowOrField_s::fieldid, rowOrField_s::fieldVal, rowOrField_s::isnotaddunique, rowOrField_s::isreplace, rowOrField_s::isrow, rowOrField_s::newengineid, rowOrField_s::newrowid, rowOrField_s::rowid, sersize(), and rowOrField_s::tableid.

1451 {
1452  return sersize((int8_t)d.isrow)+sersize(d.tableid)+sersize(d.rowid)+
1453  sersize(d.fieldid)+sersize(d.engineid)+
1454  sersize((int8_t)d.deleteindexentry)+
1455  sersize((int8_t)d.isnotaddunique)+
1456  sersize((int8_t)d.isreplace)+sersize(d.newrowid)+
1457  sersize(d.newengineid)+sersize(d.fieldVal);
1458 }

Here is the call graph for this function:

size_t SerializedMessage::sersize ( MessageApply::applyindex_s &  d)
static

Definition at line 1484 of file Message.cc.

References MessageApply::applyindex_s::entry, MessageApply::applyindex_s::fieldid, MessageApply::applyindex_s::fieldVal, sersize(), and MessageApply::applyindex_s::tableid.

1485 {
1486  return sersize(d.fieldVal)+sersize(d.entry)+1+sersize(d.tableid)+
1487  sersize(d.fieldid);
1488 }

Here is the call graph for this function:

size_t SerializedMessage::sersize ( searchParams_s &  d)
static

Definition at line 1507 of file Message.cc.

References searchParams_s::op, searchParams_s::regexString, sersize(), and searchParams_s::values.

1508 {
1509  return sersize((int8_t)d.op)+sersize(d.values)+sersize(d.regexString);
1510 }

Here is the call graph for this function:

size_t SerializedMessage::sersize ( vector< rowOrField_s > &  d)
static

Definition at line 1529 of file Message.cc.

References sersize().

1530 {
1531  size_t retval=sizeof(int64_t);
1532  vector<rowOrField_s>::iterator it;
1533  for (it = d.begin(); it != d.end(); ++it)
1534  {
1535  retval += sersize(*it);
1536  }
1537  return retval;
1538 }

Here is the call graph for this function:

size_t SerializedMessage::sersize ( vector< MessageApply::applyindex_s > &  d)
static

Definition at line 1563 of file Message.cc.

References sersize().

1564 {
1565  size_t retval=sizeof(int64_t);
1566  vector<MessageApply::applyindex_s>::iterator it;
1567  for (it = d.begin(); it != d.end(); ++it)
1568  {
1569  retval += sersize(*it);
1570  }
1571  return retval;
1572 }

Here is the call graph for this function:

size_t SerializedMessage::sersize ( boost::unordered_map< int64_t, vector< MessageDispatch::record_s > > &  d)
static

Definition at line 1600 of file Message.cc.

1602 {
1603  return d.size() + (d.size() * 2 * sizeof(int64_t));
1604 }

Member Data Documentation

std::string* SerializedMessage::data

Definition at line 886 of file Message.h.

Referenced by des(), getpayloadtype(), Message::ser(), MessageSocket::ser(), MessageUserSchema::ser(), MessageDeadlock::ser(), MessageTransaction::ser(), MessageSubtransactionCmd::ser(), MessageCommitRollback::ser(), MessageDispatch::ser(), MessageAckDispatch::ser(), MessageApply::ser(), MessageAckApply::ser(), ser(), and SerializedMessage().

size_t SerializedMessage::pos

Definition at line 885 of file Message.h.

Referenced by des(), Message::ser(), MessageSocket::ser(), MessageUserSchema::ser(), MessageDeadlock::ser(), MessageTransaction::ser(), MessageSubtransactionCmd::ser(), MessageCommitRollback::ser(), MessageDispatch::ser(), MessageAckDispatch::ser(), MessageApply::ser(), MessageAckApply::ser(), and ser().

size_t SerializedMessage::size

Definition at line 884 of file Message.h.

Referenced by SerializedMessage().

The documentation for this class was generated from the following files: