If you want dumb message serialization, why don't you use the new order
classes I sent some times ago to the ml? They use a more modern/robust
serialization mechanism, that I imagined as an improvement to glob2's one.
I've reattached them to this mail.
Alternatively you could use for the order the same serialization mechanism
that is used in saved games. In addition, you get text dump of messages for
free.
Why dynamically allocating arrays to do the tcp send when you can call
SDLNet_TCP_Send several time? Is it to increase the probability the data got
send in a bock?
Steph
--
http://stephane.magnenat.net
#include "msg.h"
#include "../utils/utils.h"
#include <cassert>
#include <iostream>
#include <iomanip>
#include <map>
namespace Aseba
{
//! Static class that fills a table of known messages types in its constructor
class MessageTypesInitializer
{
public:
//! Constructor, register all known messages types
MessageTypesInitializer()
{
registerMessageType<BootloaderDescription>(ASEBA_MESSAGE_BOOTLOADER_DESCRIPTION);
registerMessageType<BootloaderDataRead>(ASEBA_MESSAGE_BOOTLOADER_PAGE_DATA_READ);
registerMessageType<BootloaderAck>(ASEBA_MESSAGE_BOOTLOADER_ACK);
registerMessageType<Presence>(ASEBA_MESSAGE_PRESENCE);
registerMessageType<Description>(ASEBA_MESSAGE_DESCRIPTION);
registerMessageType<Variables>(ASEBA_MESSAGE_VARIABLES);
registerMessageType<ExecutionState>(ASEBA_MESSAGE_EXECUTION_STATE);
registerMessageType<ArrayAccessOutOfBounds>(ASEBA_MESSAGE_ARRAY_ACCESS_OUT_OF_BOUND);
registerMessageType<DivisionByZero>(ASEBA_MESSAGE_DIVISION_BY_ZERO);
registerMessageType<BootloaderReset>(ASEBA_MESSAGE_BOOTLOADER_RESET);
registerMessageType<BootloaderReadPage>(ASEBA_MESSAGE_BOOTLOADER_READ_PAGE);
registerMessageType<BootloaderWritePage>(ASEBA_MESSAGE_BOOTLOADER_WRITE_PAGE);
registerMessageType<BootloaderPageDataWrite>(ASEBA_MESSAGE_BOOTLOADER_PAGE_DATA_WRITE);
registerMessageType<AttachDebugger>(ASEBA_MESSAGE_ATTACH_DEBUGGER);
registerMessageType<DetachDebugger>(ASEBA_MESSAGE_DETACH_DEBUGGER);
registerMessageType<SetBytecode>(ASEBA_MESSAGE_SET_BYTECODE);
registerMessageType<SetupEvent>(ASEBA_MESSAGE_SETUP_EVENT);
registerMessageType<BackgroundRun>(ASEBA_MESSAGE_BACKGROUND_RUN);
registerMessageType<Stop>(ASEBA_MESSAGE_STOP);
registerMessageType<Step>(ASEBA_MESSAGE_STEP);
registerMessageType<BreakpointSet>(ASEBA_MESSAGE_BREAKPOINT_SET);
registerMessageType<BreakpointClear>(ASEBA_MESSAGE_BREAKPOINT_CLEAR);
registerMessageType<BreakpointClearAll>(ASEBA_MESSAGE_BREAKPOINT_CLEAR_ALL);
registerMessageType<GetVariables>(ASEBA_MESSAGE_GET_VARIABLES);
}
//! Register a message type by storing a pointer to its constructor
template<typename Sub>
void registerMessageType(uint16 type)
{
messagesTypes[type] = &Creator<Sub>;
}
//! Create an instance of a registered message type
Message *createMessage(uint16 type)
{
if (messagesTypes.find(type) == messagesTypes.end())
{
std::cerr << "Message of type " << std::hex << std::showbase << std::setw(4) << type << " is unknown, aborting.\n\nKnown messages are:\n";
std::cerr << std::dec << std::noshowbase;
dumpKnownMessagesTypes(std::cerr);
std::cerr << std::endl;
assert(false);
}
return messagesTypes[type]();
}
//! Print the list of registered messages types to stream
void dumpKnownMessagesTypes(std::ostream &stream)
{
stream << std::hex << std::showbase;
for (std::map<uint16, CreatorFunc>::iterator it = messagesTypes.begin(); it != messagesTypes.end(); ++it)
stream << "\t" << std::setw(4) << it->first << "\n";
stream << std::dec << std::noshowbase;
}
protected:
//! Pointer to constructor of class Message
typedef Message* (*CreatorFunc)();
std::map<uint16, CreatorFunc> messagesTypes; //!< table of known messages types
//! Create a new message of type Sub
template<typename Sub>
static Message* Creator()
{
return new Sub();
}
} messageTypesInitializer; //!< static instance, used only to have its constructor called on startup
//
Message::Message()
{
source = 0;
type = ASEBA_MESSAGE_INVALID;
readPos = 0;
}
Message::~Message()
{
}
void Message::serialize(int fd)
{
data.resize(0);
serializeSpecific();
assert(data.size() + 2 < 65536);
uint16 len = static_cast<uint16>(data.size());
Aseba::write(fd, &len, 2);
Aseba::write(fd, &source, 2);
Aseba::write(fd, &type, 2);
Aseba::write(fd, &data[0], data.size());
}
Message *Message::receive(int fd)
{
// read header
uint16 len, source, type;
Aseba::read(fd, &len, 2);
Aseba::read(fd, &source, 2);
Aseba::read(fd, &type, 2);
// create message
Message *message = messageTypesInitializer.createMessage(type);
// preapare message
message->source = source;
message->type = type;
message->data.resize(len);
Aseba::read(fd, &message->data[0], len);
message->readPos = 0;
// deserialize it
message->deserializeSpecific();
assert(message->readPos == message->data.size());
return message;
}
void Message::dump(std::ostream &stream)
{
stream << std::hex << std::showbase << std::setw(4) << type << " ";
stream << std::dec << std::noshowbase << *this << " from ";
stream << source << " : ";
dumpSpecific(stream);
}
template<typename T>
void Message::add(const T& val)
{
size_t pos = data.size();
data.reserve(pos + sizeof(T));
const uint8 *ptr = reinterpret_cast<const uint8 *>(&val);
std::copy(ptr, ptr + sizeof(T), std::back_inserter(data));
}
template<>
void Message::add(const std::string& val)
{
assert(val.length() <= 255);
add(static_cast<uint8>(val.length()));
for (size_t i = 0; i < val.length(); i++)
add(val[i]);
}
template<typename T>
T Message::get()
{
assert(readPos + sizeof(T) <= data.size());
size_t pos = readPos;
readPos += sizeof(T);
T val;
uint8 *ptr = reinterpret_cast<uint8 *>(&val);
std::copy(data.begin() + pos, data.begin() + pos + sizeof(T), ptr);
return val;
}
template<>
std::string Message::get()
{
std::string s;
size_t len = get<uint8>();
s.resize(len);
for (size_t i = 0; i < len; i++)
s[i] = get<uint8>();
return s;
}
//
void UserMessage::dumpSpecific(std::ostream &stream)
{
stream << "user message of size " << data.size();
}
//
void BootloaderDescription::serializeSpecific()
{
add(pageSize);
add(pagesStart);
add(pagesCount);
}
void BootloaderDescription::deserializeSpecific()
{
pageSize = get<uint16>();
pagesStart = get<uint16>();
pagesCount = get<uint16>();
}
void BootloaderDescription::dumpSpecific(std::ostream &stream)
{
stream << pagesCount << " pages of size " << pageSize << " starting at page " << pagesStart;
}
//
void BootloaderDataRead::serializeSpecific()
{
for (size_t i = 0 ; i < sizeof(data); i++)
add(data[i]);
}
void BootloaderDataRead::deserializeSpecific()
{
for (size_t i = 0 ; i < sizeof(data); i++)
data[i] = get<uint8>();
}
void BootloaderDataRead::dumpSpecific(std::ostream &stream)
{
stream << std::hex << std::setfill('0');
for (size_t i = 0 ; i < sizeof(data); i++)
stream << std::setw(2) << (unsigned)data[i] << " ";
stream << std::dec << std::setfill(' ');
}
//
void BootloaderAck::serializeSpecific()
{
add(errorCode);
if (errorCode == 2)
add(errorAddress);
}
void BootloaderAck::deserializeSpecific()
{
errorCode = get<uint16>();
if (errorCode == 2)
errorAddress = get<uint16>();
}
void BootloaderAck::dumpSpecific(std::ostream &stream)
{
switch (errorCode)
{
case SUCCESS: stream << "success"; break;
case ERROR_INVALID_FRAME_SIZE: stream << "error, invalid frame size"; break;
case ERROR_PROGRAMMING_FAILED: stream << "error, programming failed at low address " << std::hex << std::showbase << errorAddress; break;
case ERROR_NOT_PROGRAMMING: stream << "error, not programming"; break;
default: stream << "unknown error"; break;
}
stream << std::dec << std::noshowbase;
}
//
void Description::serializeSpecific()
{
add(bytecodeSize);
add(stackSize);
add(variablesSize);
add(nodeName);
assert(variablesNames.size() == variablesSizes.size());
add(static_cast<uint16>(variablesNames.size()));
for (size_t i = 0; i < variablesNames.size(); i++)
{
add(variablesNames[i]);
add(variablesSizes[i]);
}
}
void Description::deserializeSpecific()
{
bytecodeSize = get<uint16>();
stackSize = get<uint16>();
variablesSize = get<uint16>();
nodeName = get<std::string>();
uint16 namedVariablesCount = get<uint16>();
variablesNames.resize(namedVariablesCount);
variablesSizes.resize(namedVariablesCount);
for (size_t i = 0; i < variablesNames.size(); i++)
{
variablesNames[i] = get<std::string>();
variablesSizes[i] = get<uint16>();
}
}
void Description::dumpSpecific(std::ostream &stream)
{
stream << "Node " << nodeName << "\n";
stream << "bytecode " << bytecodeSize << ", stack " << stackSize << ", variables " << variablesSize;
for (size_t i = 0; i < variablesNames.size(); i++)
stream << "\n\t" << variablesNames[i] << " : " << variablesSizes[i];
}
//
void Variables::serializeSpecific()
{
add(start);
for (size_t i = 0; i < variables.size(); i++)
add(variables[i]);
}
void Variables::deserializeSpecific()
{
start = get<uint16>();
variables.resize((data.size() - readPos) / 2);
for (size_t i = 0; i < variables.size(); i++)
variables[i] = get<sint16>();
}
void Variables::dumpSpecific(std::ostream &stream)
{
stream << "start " << start << ", variables vector of size " << variables.size();
}
//
void ExecutionState::serializeSpecific()
{
add(pc);
add(flags);
}
void ExecutionState::deserializeSpecific()
{
pc = get<uint16>();
flags = get<uint16>();
}
void ExecutionState::dumpSpecific(std::ostream &stream)
{
stream << "pc " << pc << ", flags ";
stream << std::hex << std::showbase << std::setw(4) << flags;
stream << std::dec << std::noshowbase;
}
//
void ArrayAccessOutOfBounds::serializeSpecific()
{
add(pc);
add(index);
}
void ArrayAccessOutOfBounds::deserializeSpecific()
{
pc = get<uint16>();
index = get<uint16>();
}
void ArrayAccessOutOfBounds::dumpSpecific(std::ostream &stream)
{
stream << "pc " << pc << ", index " << index;
}
//
void DivisionByZero::serializeSpecific()
{
add(pc);
}
void DivisionByZero::deserializeSpecific()
{
pc = get<uint16>();
}
void DivisionByZero::dumpSpecific(std::ostream &stream)
{
stream << "pc " << pc;
}
//
void CmdMessage::serializeSpecific()
{
add(dest);
}
void CmdMessage::deserializeSpecific()
{
dest = get<uint16>();
}
void CmdMessage::dumpSpecific(std::ostream &stream)
{
stream << "dest " << dest << " ";
}
//
void BootloaderReadPage::serializeSpecific()
{
CmdMessage::serializeSpecific();
add(pageNumber);
}
void BootloaderReadPage::deserializeSpecific()
{
CmdMessage::deserializeSpecific();
pageNumber = get<uint16>();
}
void BootloaderReadPage::dumpSpecific(std::ostream &stream)
{
CmdMessage::dumpSpecific(stream);
stream << "page " << pageNumber;
}
//
void BootloaderWritePage::serializeSpecific()
{
CmdMessage::serializeSpecific();
add(pageNumber);
}
void BootloaderWritePage::deserializeSpecific()
{
CmdMessage::deserializeSpecific();
pageNumber = get<uint16>();
}
void BootloaderWritePage::dumpSpecific(std::ostream &stream)
{
CmdMessage::dumpSpecific(stream);
stream << "page " << pageNumber;
}
//
void BootloaderPageDataWrite::serializeSpecific()
{
CmdMessage::serializeSpecific();
for (size_t i = 0 ; i < sizeof(data); i++)
add(data[i]);
}
void BootloaderPageDataWrite::deserializeSpecific()
{
CmdMessage::deserializeSpecific();
for (size_t i = 0 ; i < sizeof(data); i++)
data[i] = get<uint8>();
}
void BootloaderPageDataWrite::dumpSpecific(std::ostream &stream)
{
CmdMessage::dumpSpecific(stream);
stream << std::hex << std::setfill('0');
for (size_t i = 0 ; i < sizeof(data); i++)
stream << std::setw(2) << (unsigned)data[i] << " ";
stream << std::dec << std::setfill(' ');
}
//
void SetBytecode::serializeSpecific()
{
CmdMessage::serializeSpecific();
for (size_t i = 0; i < bytecode.size(); i++)
add(bytecode[i]);
}
void SetBytecode::deserializeSpecific()
{
CmdMessage::deserializeSpecific();
bytecode.resize((data.size() - readPos) / 2);
for (size_t i = 0; i < bytecode.size(); i++)
bytecode[i] = get<uint16>();
}
void SetBytecode::dumpSpecific(std::ostream &stream)
{
CmdMessage::dumpSpecific(stream);
stream << "bytecode of size " << bytecode.size();
}
//
void SetupEvent::serializeSpecific()
{
CmdMessage::serializeSpecific();
add(eventId);
for (size_t i = 0; i < arguments.size(); i++)
add(arguments[i]);
}
void SetupEvent::deserializeSpecific()
{
CmdMessage::deserializeSpecific();
eventId = get<uint16>();
arguments.resize((data.size() - readPos) / 2);
for (size_t i = 0; i < arguments.size(); i++)
arguments[i] = get<uint16>();
}
void SetupEvent::dumpSpecific(std::ostream &stream)
{
CmdMessage::dumpSpecific(stream);
stream << "event id " << eventId << ", arguments vector of size " << arguments.size();
}
//
void BreakpointSet::serializeSpecific()
{
CmdMessage::serializeSpecific();
add(pc);
}
void BreakpointSet::deserializeSpecific()
{
CmdMessage::deserializeSpecific();
pc = get<uint16>();
}
void BreakpointSet::dumpSpecific(std::ostream &stream)
{
CmdMessage::dumpSpecific(stream);
stream << "pc " << pc;
}
//
void BreakpointClear::serializeSpecific()
{
CmdMessage::serializeSpecific();
add(pc);
}
void BreakpointClear::deserializeSpecific()
{
CmdMessage::deserializeSpecific();
pc = get<uint16>();
}
void BreakpointClear::dumpSpecific(std::ostream &stream)
{
CmdMessage::dumpSpecific(stream);
stream << "pc " << pc;
}
}
#ifndef ASEBA_MSG
#define ASEBA_MSG
#include "../common/types.h"
#include "../common/consts.h"
#include <cstring>
#include <vector>
#include <valarray>
namespace Aseba
{
class Message
{
public:
uint16 source;
uint16 type;
public:
Message();
virtual ~Message();
void serialize(int fd);
static Message *receive(int fd);
void dump(std::ostream &stream);
protected:
virtual void serializeSpecific() = 0;
virtual void deserializeSpecific() = 0;
virtual void dumpSpecific(std::ostream &stream) = 0;
virtual operator const char * () const { return "message super class"; }
protected:
template<typename T> void add(const T& val);
template<typename T> T get();
protected:
std::vector<uint8> data;
size_t readPos;
};
class UserMessage : public Message
{
protected:
virtual void serializeSpecific() {}
virtual void deserializeSpecific() {}
virtual void dumpSpecific(std::ostream &stream);
virtual operator const char * () const { return "user message"; }
};
class BootloaderDescription : public Message
{
public:
uint16 pageSize;
uint16 pagesStart;
uint16 pagesCount;
public:
BootloaderDescription() { type = ASEBA_MESSAGE_BOOTLOADER_DESCRIPTION; }
protected:
virtual void serializeSpecific();
virtual void deserializeSpecific();
virtual void dumpSpecific(std::ostream &stream);
virtual operator const char * () const { return "bootloader description"; }
};
class BootloaderDataRead : public Message
{
public:
uint8 data[4];
public:
BootloaderDataRead() { type = ASEBA_MESSAGE_BOOTLOADER_PAGE_DATA_READ; }
protected:
virtual void serializeSpecific();
virtual void deserializeSpecific();
virtual void dumpSpecific(std::ostream &stream);
virtual operator const char * () const { return "bootloader page data read"; }
};
class BootloaderAck : public Message
{
public:
enum ErrorTypes
{
SUCCESS = 0,
ERROR_INVALID_FRAME_SIZE,
ERROR_PROGRAMMING_FAILED,
ERROR_NOT_PROGRAMMING
};
public:
uint16 errorCode;
uint16 errorAddress;
public:
BootloaderAck() { type = ASEBA_MESSAGE_BOOTLOADER_ACK; }
protected:
virtual void serializeSpecific();
virtual void deserializeSpecific();
virtual void dumpSpecific(std::ostream &stream);
virtual operator const char * () const { return "bootloader ack"; }
};
class Presence : public Message
{
public:
Presence() { type = ASEBA_MESSAGE_PRESENCE; }
protected:
virtual void serializeSpecific() {}
virtual void deserializeSpecific() {}
virtual void dumpSpecific(std::ostream &stream) {}
virtual operator const char * () const { return "presence message"; }
};
class Description : public Message
{
public:
uint16 bytecodeSize;
uint16 stackSize;
uint16 variablesSize;
std::string nodeName;
std::valarray<std::string> variablesNames;
std::valarray<uint16> variablesSizes;
public:
Description() { type = ASEBA_MESSAGE_DESCRIPTION; }
protected:
virtual void serializeSpecific();
virtual void deserializeSpecific();
virtual void dumpSpecific(std::ostream &stream);
virtual operator const char * () const { return "description"; }
};
class Variables : public Message
{
public:
uint16 start;
std::valarray<sint16> variables;
public:
Variables() { type = ASEBA_MESSAGE_VARIABLES; }
protected:
virtual void serializeSpecific();
virtual void deserializeSpecific();
virtual void dumpSpecific(std::ostream &stream);
virtual operator const char * () const { return "variables"; }
};
class ExecutionState : public Message
{
public:
uint16 pc;
uint16 flags;
public:
ExecutionState() { type = ASEBA_MESSAGE_EXECUTION_STATE; }
protected:
virtual void serializeSpecific();
virtual void deserializeSpecific();
virtual void dumpSpecific(std::ostream &stream);
virtual operator const char * () const { return "execution state"; }
};
class ArrayAccessOutOfBounds : public Message
{
public:
uint16 pc;
uint16 index;
public:
ArrayAccessOutOfBounds() { type = ASEBA_MESSAGE_ARRAY_ACCESS_OUT_OF_BOUND; }
protected:
virtual void serializeSpecific();
virtual void deserializeSpecific();
virtual void dumpSpecific(std::ostream &stream);
virtual operator const char * () const { return "array access out of bounds"; }
};
class DivisionByZero : public Message
{
public:
uint16 pc;
public:
DivisionByZero() { type = ASEBA_MESSAGE_DIVISION_BY_ZERO; }
protected:
virtual void serializeSpecific();
virtual void deserializeSpecific();
virtual void dumpSpecific(std::ostream &stream);
virtual operator const char * () const { return "division by zero"; }
};
//! Cammands messages talk to a specific node
class CmdMessage : public Message
{
public:
uint16 dest;
protected:
virtual void serializeSpecific();
virtual void deserializeSpecific();
virtual void dumpSpecific(std::ostream &stream);
virtual operator const char * () const { return "command message super class"; }
};
class BootloaderReset : public CmdMessage
{
public:
BootloaderReset() { type = ASEBA_MESSAGE_BOOTLOADER_RESET; }
protected:
virtual operator const char * () const { return "bootloader reset"; }
};
class BootloaderReadPage : public CmdMessage
{
public:
uint16 pageNumber;
public:
BootloaderReadPage() { type = ASEBA_MESSAGE_BOOTLOADER_READ_PAGE; }
protected:
virtual void serializeSpecific();
virtual void deserializeSpecific();
virtual void dumpSpecific(std::ostream &stream);
virtual operator const char * () const { return "bootloader read page"; }
};
class BootloaderWritePage : public CmdMessage
{
public:
uint16 pageNumber;
public:
BootloaderWritePage() { type = ASEBA_MESSAGE_BOOTLOADER_WRITE_PAGE; }
protected:
virtual void serializeSpecific();
virtual void deserializeSpecific();
virtual void dumpSpecific(std::ostream &stream);
virtual operator const char * () const { return "bootloader write page"; }
};
class BootloaderPageDataWrite : public CmdMessage
{
public:
uint8 data[4];
public:
BootloaderPageDataWrite() { type = ASEBA_MESSAGE_BOOTLOADER_PAGE_DATA_WRITE; }
protected:
virtual void serializeSpecific();
virtual void deserializeSpecific();
virtual void dumpSpecific(std::ostream &stream);
virtual operator const char * () const { return "bootloader page data write"; }
};
class AttachDebugger : public CmdMessage
{
public:
AttachDebugger() { type = ASEBA_MESSAGE_ATTACH_DEBUGGER; }
protected:
virtual operator const char * () const { return "attach debugger"; }
};
class DetachDebugger : public CmdMessage
{
public:
DetachDebugger() { type = ASEBA_MESSAGE_DETACH_DEBUGGER; }
protected:
virtual operator const char * () const { return "detach debugger"; }
};
class SetBytecode : public CmdMessage
{
public:
std::valarray<uint16> bytecode;
public:
SetBytecode() { type = ASEBA_MESSAGE_SET_BYTECODE; }
protected:
virtual void serializeSpecific();
virtual void deserializeSpecific();
virtual void dumpSpecific(std::ostream &stream);
virtual operator const char * () const { return "set bytecode"; }
};
class SetupEvent : public CmdMessage
{
public:
uint16 eventId;
std::valarray<uint16> arguments;
public:
SetupEvent() { type = ASEBA_MESSAGE_SETUP_EVENT; }
protected:
virtual void serializeSpecific();
virtual void deserializeSpecific();
virtual void dumpSpecific(std::ostream &stream);
virtual operator const char * () const { return "setup event"; }
};
class BackgroundRun : public CmdMessage
{
public:
BackgroundRun() { type = ASEBA_MESSAGE_BACKGROUND_RUN; }
protected:
virtual operator const char * () const { return "background run"; }
};
class Stop : public CmdMessage
{
public:
Stop() { type = ASEBA_MESSAGE_STOP; }
protected:
virtual operator const char * () const { return "stop"; }
};
class Step : public CmdMessage
{
public:
Step() { type = ASEBA_MESSAGE_STEP; }
protected:
virtual operator const char * () const { return "step"; }
};
class BreakpointSet : public CmdMessage
{
public:
uint16 pc;
public:
BreakpointSet() { type = ASEBA_MESSAGE_BREAKPOINT_SET; }
protected:
virtual void serializeSpecific();
virtual void deserializeSpecific();
virtual void dumpSpecific(std::ostream &stream);
virtual operator const char * () const { return "breakpoint set"; }
};
class BreakpointClear : public CmdMessage
{
public:
uint16 pc;
public:
BreakpointClear() { type = ASEBA_MESSAGE_BREAKPOINT_CLEAR; }
protected:
virtual void serializeSpecific();
virtual void deserializeSpecific();
virtual void dumpSpecific(std::ostream &stream);
virtual operator const char * () const { return "breakpoint clear"; }
};
class BreakpointClearAll : public CmdMessage
{
public:
BreakpointClearAll() { type = ASEBA_MESSAGE_BREAKPOINT_CLEAR_ALL; }
protected:
virtual operator const char * () const { return "breakpoint clear all"; }
};
class GetVariables : public CmdMessage
{
public:
GetVariables() { type = ASEBA_MESSAGE_GET_VARIABLES; }
protected:
virtual operator const char * () const { return "get variables"; }
};
}
#endif
_______________________________________________
glob2-devel mailing list
[email protected]
http://lists.nongnu.org/mailman/listinfo/glob2-devel
