restructured protocol code

common/protocol_datastructures.h

@@ -4,9 +4,7 @@
 #include <QString>
 #include <QColor>
 #include <QDateTime>
-
-class QXmlStreamReader;
-class QXmlStreamWriter;
+#include "serializable_item.h"
 
 enum ResponseCode { RespNothing, RespOk, RespInvalidCommand, RespInvalidData, RespNameNotFound, RespLoginNeeded, RespContextError, RespWrongPassword, RespSpectatorsNotAllowed };
 
@@ -20,210 +18,124 @@ enum ResponseCode { RespNothing, RespOk, RespInvalidCommand, RespInvalidData, Re
 // list index, whereas cards in any other zone are referenced by their ids.
 enum ZoneType { PrivateZone, PublicZone, HiddenZone };
 
-class ColorConverter {
+class ServerInfo_ChatChannel : public SerializableItem_Map {
 public:
-	static int colorToInt(const QColor &color)
-	{
-		return color.red() * 65536 + color.green() * 256 + color.blue();
-	}
-	static QColor colorFromInt(int colorValue)
-	{
-		return QColor(colorValue / 65536, (colorValue % 65536) / 256, colorValue % 256);
-	}
+	ServerInfo_ChatChannel(const QString &_name = QString(), const QString &_description = QString(), int _playerCount = -1, bool _autoJoin = false);
+	static SerializableItem *newItem() { return new ServerInfo_ChatChannel; }
+	QString getName() const { return static_cast<SerializableItem_String *>(itemMap.value("name"))->getData(); }
+	QString getDescription() const { return static_cast<SerializableItem_String *>(itemMap.value("description"))->getData(); }
+	int getPlayerCount() const { return static_cast<SerializableItem_Int *>(itemMap.value("player_count"))->getData(); }
+	bool getAutoJoin() const { return static_cast<SerializableItem_Bool *>(itemMap.value("auto_join"))->getData(); }
 };
 
-class SerializableItem {
-protected:
-	SerializableItem *currentItem;
+class ServerInfo_ChatUser : public SerializableItem_Map {
 public:
-	SerializableItem() : currentItem(0) { }
-	virtual bool readElement(QXmlStreamReader *xml) = 0;
-	virtual void writeElement(QXmlStreamWriter *xml) = 0;
+	ServerInfo_ChatUser(const QString &_name = QString());
+	static SerializableItem *newItem() { return new ServerInfo_ChatUser; }
+	QString getName() const { return static_cast<SerializableItem_String *>(itemMap.value("name"))->getData(); }
 };
 
-class ServerChatChannelInfo {
-private:
-	QString name;
-	QString description;
-	int playerCount;
-	bool autoJoin;
+class ServerInfo_Game : public SerializableItem_Map {
 public:
-	ServerChatChannelInfo(const QString &_name, const QString &_description, int _playerCount, bool _autoJoin)
-		: name(_name), description(_description), playerCount(_playerCount), autoJoin(_autoJoin) { }
-	QString getName() const { return name; }
-	QString getDescription() const { return description; }
-	int getPlayerCount() const { return playerCount; }
-	bool getAutoJoin() const { return autoJoin; }
+	ServerInfo_Game(int _gameId = -1, const QString &_description = QString(), bool _hasPassword = false, int _playerCount = -1, int _maxPlayers = -1, const QString &_creatorName = QString(), bool _spectatorsAllowed = false, int _spectatorCount = -1);
+	static SerializableItem *newItem() { return new ServerInfo_Game; }
+	int getGameId() const { return static_cast<SerializableItem_Int *>(itemMap.value("game_id"))->getData(); }
+	QString getDescription() const { return static_cast<SerializableItem_String *>(itemMap.value("description"))->getData(); }
+	bool getHasPassword() const { return static_cast<SerializableItem_Bool *>(itemMap.value("has_password"))->getData(); }
+	int getPlayerCount() const { return static_cast<SerializableItem_Int *>(itemMap.value("player_count"))->getData(); }
+	int getMaxPlayers() const { return static_cast<SerializableItem_Int *>(itemMap.value("max_players"))->getData(); }
+	QString getCreatorName() const { return static_cast<SerializableItem_String *>(itemMap.value("creator_name"))->getData(); }
+	bool getSpectatorsAllowed() const { return static_cast<SerializableItem_Bool *>(itemMap.value("spectators_allowed"))->getData(); }
+	int getSpectatorCount() const { return static_cast<SerializableItem_Int *>(itemMap.value("spectator_count"))->getData(); }
 };
 
-class ServerChatUserInfo {
-private:
-	QString name;
+class ServerInfo_Card : public SerializableItem_Map {
 public:
-	ServerChatUserInfo(const QString &_name)
-		: name(_name) { }
-	QString getName() const { return name; }
+	ServerInfo_Card(int _id = -1, const QString &_name = QString(), int _x = -1, int _y = -1, int _counters = -1, bool _tapped = false, bool _attacking = false, const QString &_annotation = QString());
+	static SerializableItem *newItem() { return new ServerInfo_Card; }
+	int getId() const { return static_cast<SerializableItem_Int *>(itemMap.value("id"))->getData(); }
+	QString getName() const { return static_cast<SerializableItem_String *>(itemMap.value("name"))->getData(); }
+	int getX() const { return static_cast<SerializableItem_Int *>(itemMap.value("x"))->getData(); }
+	int getY() const { return static_cast<SerializableItem_Int *>(itemMap.value("y"))->getData(); }
+	int getCounters() const { return static_cast<SerializableItem_Int *>(itemMap.value("counters"))->getData(); }
+	bool getTapped() const { return static_cast<SerializableItem_Bool *>(itemMap.value("tapped"))->getData(); }
+	bool getAttacking() const { return static_cast<SerializableItem_Bool *>(itemMap.value("attacking"))->getData(); }
+	QString getAnnotation() const { return static_cast<SerializableItem_String *>(itemMap.value("annotation"))->getData(); }
 };
 
-class ServerGameInfo {
+class ServerInfo_Zone : public SerializableItem_Map {
 private:
-	int gameId;
-	QString description;
-	bool hasPassword;
-	int playerCount;
-	int maxPlayers;
-	QString creatorName;
-	bool spectatorsAllowed;
-	int spectatorCount;
+	ZoneType typeFromString(const QString &type) const;
+	QString typeToString(ZoneType type) const;
 public:
-	ServerGameInfo(int _gameId, const QString &_description, bool _hasPassword, int _playerCount, int _maxPlayers, const QString &_creatorName, bool _spectatorsAllowed, int _spectatorCount)
-		: gameId(_gameId), description(_description), hasPassword(_hasPassword), playerCount(_playerCount), maxPlayers(_maxPlayers), creatorName(_creatorName), spectatorsAllowed(_spectatorsAllowed), spectatorCount(_spectatorCount) { }
-	int getGameId() const { return gameId; }
-	QString getDescription() const { return description; }
-	bool getHasPassword() const { return hasPassword; }
-	int getPlayerCount() const { return playerCount; }
-	int getMaxPlayers() const { return maxPlayers; }
-	QString getCreatorName() const { return creatorName; }
-	bool getSpectatorsAllowed() const { return spectatorsAllowed; }
-	int getSpectatorCount() const { return spectatorCount; }
+	ServerInfo_Zone(const QString &_name = QString(), ZoneType _type = PrivateZone, bool _hasCoords = false, int _cardCount = -1, const QList<ServerInfo_Card *> &_cardList = QList<ServerInfo_Card *>());
+	static SerializableItem *newItem() { return new ServerInfo_Zone; }
+	QString getName() const { return static_cast<SerializableItem_String *>(itemMap.value("name"))->getData(); }
+	ZoneType getType() const { return typeFromString(static_cast<SerializableItem_String *>(itemMap.value("type"))->getData()); }
+	bool getHasCoords() const { return static_cast<SerializableItem_Bool *>(itemMap.value("has_coords"))->getData(); }
+	int getCardCount() const { return static_cast<SerializableItem_Int *>(itemMap.value("card_count"))->getData(); }
+	QList<ServerInfo_Card *> getCardList() const;
 };
 
-class ServerInfo_Card : public SerializableItem {
-private:
-	int id;
-	QString name;
-	int x, y;
-	int counters;
-	bool tapped;
-	bool attacking;
-	QString annotation;
+class ServerInfo_Counter : public SerializableItem_Map {
 public:
-	ServerInfo_Card(int _id = -1, const QString &_name = QString(), int _x = -1, int _y = -1, int _counters = -1, bool _tapped = false, bool _attacking = false, const QString &_annotation = QString())
-		: id(_id), name(_name), x(_x), y(_y), counters(_counters), tapped(_tapped), attacking(_attacking), annotation(_annotation) { }
-	int getId() const { return id; }
-	QString getName() const { return name; }
-	int getX() const { return x; }
-	int getY() const { return y; }
-	int getCounters() const { return counters; }
-	bool getTapped() const { return tapped; }
-	bool getAttacking() const { return attacking; }
-	QString getAnnotation() const { return annotation; }
-	bool readElement(QXmlStreamReader *xml);
-	void writeElement(QXmlStreamWriter *xml);
+	ServerInfo_Counter(int _id = -1, const QString &_name = QString(), const QColor &_color = QColor(), int _radius = -1, int _count = -1);
+	static SerializableItem *newItem() { return new ServerInfo_Counter; }
+	int getId() const { return static_cast<SerializableItem_Int *>(itemMap.value("id"))->getData(); }
+	QString getName() const { return static_cast<SerializableItem_String *>(itemMap.value("name"))->getData(); }
+	QColor getColor() const { return static_cast<SerializableItem_Color *>(itemMap.value("color"))->getData(); }
+	int getRadius() const { return static_cast<SerializableItem_Int *>(itemMap.value("radius"))->getData(); }
+	int getCount() const { return static_cast<SerializableItem_Int *>(itemMap.value("count"))->getData(); }
 };
 
-class ServerInfo_Zone : public SerializableItem {
-private:
-	QString name;
-	ZoneType type;
-	bool hasCoords;
-	int cardCount;
-	QList<ServerInfo_Card *> cardList;
+class ServerInfo_Arrow : public SerializableItem_Map {
 public:
-	ServerInfo_Zone(const QString &_name = QString(), ZoneType _type = PrivateZone, bool _hasCoords = false, int _cardCount = -1, const QList<ServerInfo_Card *> &_cardList = QList<ServerInfo_Card *>())
-		: name(_name), type(_type), hasCoords(_hasCoords), cardCount(_cardCount), cardList(_cardList) { }
-	~ServerInfo_Zone();
-	QString getName() const { return name; }
-	ZoneType getType() const { return type; }
-	bool getHasCoords() const { return hasCoords; }
-	int getCardCount() const { return cardCount; }
-	const QList<ServerInfo_Card *> &getCardList() const { return cardList; }
-	void addCard(ServerInfo_Card *card) { cardList.append(card); ++cardCount; }
-	bool readElement(QXmlStreamReader *xml);
-	void writeElement(QXmlStreamWriter *xml);
+	ServerInfo_Arrow(int _id = -1, int _startPlayerId = -1, const QString &_startZone = QString(), int _startCardId = -1, int _targetPlayerId = -1, const QString &_targetZone = QString(), int _targetCardId = -1, const QColor &_color = QColor());
+	static SerializableItem *newItem() { return new ServerInfo_Arrow; }
+	int getId() const { return static_cast<SerializableItem_Int *>(itemMap.value("id"))->getData(); }
+	int getStartPlayerId() const { return static_cast<SerializableItem_Int *>(itemMap.value("start_player_id"))->getData(); }
+	QString getStartZone() const { return static_cast<SerializableItem_String *>(itemMap.value("start_zone"))->getData(); }
+	int getStartCardId() const { return static_cast<SerializableItem_Int *>(itemMap.value("start_card_id"))->getData(); }
+	int getTargetPlayerId() const { return static_cast<SerializableItem_Int *>(itemMap.value("target_player_id"))->getData(); }
+	QString getTargetZone() const { return static_cast<SerializableItem_String *>(itemMap.value("target_zone"))->getData(); }
+	int getTargetCardId() const { return static_cast<SerializableItem_Int *>(itemMap.value("target_card_id"))->getData(); }
+	QColor getColor() const { return static_cast<SerializableItem_Color *>(itemMap.value("color"))->getData(); }
 };
 
-class ServerInfo_Counter : public SerializableItem {
+class ServerInfo_Player : public SerializableItem_Map {
 private:
-	int id;
-	QString name;
-	QColor color;
-	int radius;
-	int count;
-public:
-	ServerInfo_Counter(int _id = -1, const QString &_name = QString(), const QColor &_color = QColor(), int _radius = -1, int _count = -1)
-		: id(_id), name(_name), color(_color), radius(_radius), count(_count) { }
-	int getId() const { return id; }
-	QString getName() const { return name; }
-	QColor getColor() const { return color; }
-	int getRadius() const { return radius; }
-	int getCount() const { return count; }
-	bool readElement(QXmlStreamReader *xml);
-	void writeElement(QXmlStreamWriter *xml);
-};
-
-class ServerInfo_Arrow : public SerializableItem {
-private:
-	int id;
-	int startPlayerId;
-	QString startZone;
-	int startCardId;
-	int targetPlayerId;
-	QString targetZone;
-	int targetCardId;
-	QColor color;
-public:
-	ServerInfo_Arrow(int _id = -1, int _startPlayerId = -1, const QString &_startZone = QString(), int _startCardId = -1, int _targetPlayerId = -1, const QString &_targetZone = QString(), int _targetCardId = -1, const QColor &_color = QColor())
-		: id(_id), startPlayerId(_startPlayerId), startZone(_startZone), startCardId(_startCardId), targetPlayerId(_targetPlayerId), targetZone(_targetZone), targetCardId(_targetCardId), color(_color) { }
-	int getId() const { return id; }
-	int getStartPlayerId() const { return startPlayerId; }
-	QString getStartZone() const { return startZone; }
-	int getStartCardId() const { return startCardId; }
-	int getTargetPlayerId() const { return targetPlayerId; }
-	QString getTargetZone() const { return targetZone; }
-	int getTargetCardId() const { return targetCardId; }
-	QColor getColor() const { return color; }
-	bool readElement(QXmlStreamReader *xml);
-	void writeElement(QXmlStreamWriter *xml);
-};
-
-class ServerInfo_Player : public SerializableItem {
-private:
-	int playerId;
-	QString name;
 	QList<ServerInfo_Zone *> zoneList;
 	QList<ServerInfo_Counter *> counterList;
 	QList<ServerInfo_Arrow *> arrowList;
+protected:
+	void extractData();
 public:
-	ServerInfo_Player(int _playerId = -1, const QString &_name = QString(), const QList<ServerInfo_Zone *> &_zoneList = QList<ServerInfo_Zone *>(), const QList<ServerInfo_Counter *> &_counterList = QList<ServerInfo_Counter *>(), const QList<ServerInfo_Arrow *> &_arrowList = QList<ServerInfo_Arrow *>())
-		: playerId(_playerId), name(_name), zoneList(_zoneList), counterList(_counterList), arrowList(_arrowList) { }
-	~ServerInfo_Player();
-	int getPlayerId() const { return playerId; }
-	QString getName() const { return name; }
+	ServerInfo_Player(int _playerId = -1, const QString &_name = QString(), const QList<ServerInfo_Zone *> &_zoneList = QList<ServerInfo_Zone *>(), const QList<ServerInfo_Counter *> &_counterList = QList<ServerInfo_Counter *>(), const QList<ServerInfo_Arrow *> &_arrowList = QList<ServerInfo_Arrow *>());
+	static SerializableItem *newItem() { return new ServerInfo_Player; }
+	int getPlayerId() const { return static_cast<SerializableItem_Int *>(itemMap.value("player_id"))->getData(); }
+	QString getName() const { return static_cast<SerializableItem_String *>(itemMap.value("name"))->getData(); }
 	const QList<ServerInfo_Zone *> &getZoneList() const { return zoneList; }
 	const QList<ServerInfo_Counter *> &getCounterList() const { return counterList; }
 	const QList<ServerInfo_Arrow *> &getArrowList() const { return arrowList; }
-	void addZone(ServerInfo_Zone *zone) { zoneList.append(zone); }
-	void addCounter(ServerInfo_Counter *counter) { counterList.append(counter); }
-	void addArrow(ServerInfo_Arrow *arrow) { arrowList.append(arrow); }
-	bool readElement(QXmlStreamReader *xml);
-	void writeElement(QXmlStreamWriter *xml);
 };
 
-class DeckList_TreeItem : public SerializableItem {
-protected:
-	QString name;
-	int id;
+class DeckList_TreeItem : public SerializableItem_Map {
 public:
-	DeckList_TreeItem(const QString &_name, int _id) : name(_name), id(_id) { }
-	QString getName() const { return name; }
-	int getId() const { return id; }
+	DeckList_TreeItem(const QString &_itemType, const QString &_name, int _id);
+	QString getName() const { return static_cast<SerializableItem_String *>(itemMap.value("name"))->getData(); }
+	int getId() const { return static_cast<SerializableItem_Int *>(itemMap.value("id"))->getData(); }
 };
 class DeckList_File : public DeckList_TreeItem {
-private:
-	QDateTime uploadTime;
 public:
-	DeckList_File(const QString &_name, int _id, QDateTime _uploadTime) : DeckList_TreeItem(_name, _id), uploadTime(_uploadTime) { }
-	bool readElement(QXmlStreamReader *xml);
-	void writeElement(QXmlStreamWriter *xml);
-	QDateTime getUploadTime() const { return uploadTime; }
+	DeckList_File(const QString &_name = QString(), int _id = -1, QDateTime _uploadTime = QDateTime());
+	static SerializableItem *newItem() { return new DeckList_File; }
+	QDateTime getUploadTime() const { return static_cast<SerializableItem_DateTime *>(itemMap.value("upload_time"))->getData(); }
 };
-class DeckList_Directory : public DeckList_TreeItem, public QList<DeckList_TreeItem *> {
+class DeckList_Directory : public DeckList_TreeItem {
 public:
-	DeckList_Directory(const QString &_name = QString(), int _id = 0) : DeckList_TreeItem(_name, _id) { }
-	~DeckList_Directory();
-	bool readElement(QXmlStreamReader *xml);
-	void writeElement(QXmlStreamWriter *xml);
+	DeckList_Directory(const QString &_name = QString(), int _id = 0);
+	static SerializableItem *newItem() { return new DeckList_Directory; }
+	QList<DeckList_TreeItem *> getTreeItems() const { return typecastItemList<DeckList_TreeItem *>(); }
 };
 
 #endif

common/protocol_items.cpp

@@ -6,378 +6,209 @@ Command_Ping::Command_Ping()
 {
 }
 Command_Login::Command_Login(const QString &_username, const QString &_password)
-	: Command("login"), username(_username), password(_password)
+	: Command("login")
 {
-	setParameter("username", username);
-	setParameter("password", password);
-}
-void Command_Login::extractParameters()
-{
-	Command::extractParameters();
-	username = parameters["username"];
-	password = parameters["password"];
+	insertItem(new SerializableItem_String("username", _username));
+	insertItem(new SerializableItem_String("password", _password));
 }
 Command_DeckList::Command_DeckList()
 	: Command("deck_list")
 {
 }
 Command_DeckNewDir::Command_DeckNewDir(const QString &_path, const QString &_dirName)
-	: Command("deck_new_dir"), path(_path), dirName(_dirName)
-{
-	setParameter("path", path);
-	setParameter("dir_name", dirName);
-}
-void Command_DeckNewDir::extractParameters()
+	: Command("deck_new_dir")
 {
-	Command::extractParameters();
-	path = parameters["path"];
-	dirName = parameters["dir_name"];
+	insertItem(new SerializableItem_String("path", _path));
+	insertItem(new SerializableItem_String("dir_name", _dirName));
 }
 Command_DeckDelDir::Command_DeckDelDir(const QString &_path)
-	: Command("deck_del_dir"), path(_path)
-{
-	setParameter("path", path);
-}
-void Command_DeckDelDir::extractParameters()
+	: Command("deck_del_dir")
 {
-	Command::extractParameters();
-	path = parameters["path"];
+	insertItem(new SerializableItem_String("path", _path));
 }
 Command_DeckDel::Command_DeckDel(int _deckId)
-	: Command("deck_del"), deckId(_deckId)
+	: Command("deck_del")
 {
-	setParameter("deck_id", deckId);
-}
-void Command_DeckDel::extractParameters()
-{
-	Command::extractParameters();
-	deckId = parameters["deck_id"].toInt();
+	insertItem(new SerializableItem_Int("deck_id", _deckId));
 }
 Command_DeckDownload::Command_DeckDownload(int _deckId)
-	: Command("deck_download"), deckId(_deckId)
+	: Command("deck_download")
 {
-	setParameter("deck_id", deckId);
-}
-void Command_DeckDownload::extractParameters()
-{
-	Command::extractParameters();
-	deckId = parameters["deck_id"].toInt();
+	insertItem(new SerializableItem_Int("deck_id", _deckId));
 }
 Command_ListChatChannels::Command_ListChatChannels()
 	: Command("list_chat_channels")
 {
 }
 Command_ChatJoinChannel::Command_ChatJoinChannel(const QString &_channel)
-	: Command("chat_join_channel"), channel(_channel)
+	: Command("chat_join_channel")
 {
-	setParameter("channel", channel);
-}
-void Command_ChatJoinChannel::extractParameters()
-{
-	Command::extractParameters();
-	channel = parameters["channel"];
+	insertItem(new SerializableItem_String("channel", _channel));
 }
 Command_ChatLeaveChannel::Command_ChatLeaveChannel(const QString &_channel)
 	: ChatCommand("chat_leave_channel", _channel)
 {
 }
 Command_ChatSay::Command_ChatSay(const QString &_channel, const QString &_message)
-	: ChatCommand("chat_say", _channel), message(_message)
-{
-	setParameter("message", message);
-}
-void Command_ChatSay::extractParameters()
+	: ChatCommand("chat_say", _channel)
 {
-	ChatCommand::extractParameters();
-	message = parameters["message"];
+	insertItem(new SerializableItem_String("message", _message));
 }
 Command_ListGames::Command_ListGames()
 	: Command("list_games")
 {
 }
 Command_CreateGame::Command_CreateGame(const QString &_description, const QString &_password, int _maxPlayers, bool _spectatorsAllowed)
-	: Command("create_game"), description(_description), password(_password), maxPlayers(_maxPlayers), spectatorsAllowed(_spectatorsAllowed)
-{
-	setParameter("description", description);
-	setParameter("password", password);
-	setParameter("max_players", maxPlayers);
-	setParameter("spectators_allowed", spectatorsAllowed);
-}
-void Command_CreateGame::extractParameters()
+	: Command("create_game")
 {
-	Command::extractParameters();
-	description = parameters["description"];
-	password = parameters["password"];
-	maxPlayers = parameters["max_players"].toInt();
-	spectatorsAllowed = (parameters["spectators_allowed"] == "1");
+	insertItem(new SerializableItem_String("description", _description));
+	insertItem(new SerializableItem_String("password", _password));
+	insertItem(new SerializableItem_Int("max_players", _maxPlayers));
+	insertItem(new SerializableItem_Bool("spectators_allowed", _spectatorsAllowed));
 }
 Command_JoinGame::Command_JoinGame(int _gameId, const QString &_password, bool _spectator)
-	: Command("join_game"), gameId(_gameId), password(_password), spectator(_spectator)
+	: Command("join_game")
 {
-	setParameter("game_id", gameId);
-	setParameter("password", password);
-	setParameter("spectator", spectator);
-}
-void Command_JoinGame::extractParameters()
-{
-	Command::extractParameters();
-	gameId = parameters["game_id"].toInt();
-	password = parameters["password"];
-	spectator = (parameters["spectator"] == "1");
+	insertItem(new SerializableItem_Int("game_id", _gameId));
+	insertItem(new SerializableItem_String("password", _password));
+	insertItem(new SerializableItem_Bool("spectator", _spectator));
 }
 Command_LeaveGame::Command_LeaveGame(int _gameId)
 	: GameCommand("leave_game", _gameId)
 {
 }
 Command_Say::Command_Say(int _gameId, const QString &_message)
-	: GameCommand("say", _gameId), message(_message)
+	: GameCommand("say", _gameId)
 {
-	setParameter("message", message);
-}
-void Command_Say::extractParameters()
-{
-	GameCommand::extractParameters();
-	message = parameters["message"];
+	insertItem(new SerializableItem_String("message", _message));
 }
 Command_Shuffle::Command_Shuffle(int _gameId)
 	: GameCommand("shuffle", _gameId)
 {
 }
 Command_RollDie::Command_RollDie(int _gameId, int _sides)
-	: GameCommand("roll_die", _gameId), sides(_sides)
-{
-	setParameter("sides", sides);
-}
-void Command_RollDie::extractParameters()
+	: GameCommand("roll_die", _gameId)
 {
-	GameCommand::extractParameters();
-	sides = parameters["sides"].toInt();
+	insertItem(new SerializableItem_Int("sides", _sides));
 }
 Command_DrawCards::Command_DrawCards(int _gameId, int _number)
-	: GameCommand("draw_cards", _gameId), number(_number)
-{
-	setParameter("number", number);
-}
-void Command_DrawCards::extractParameters()
+	: GameCommand("draw_cards", _gameId)
 {
-	GameCommand::extractParameters();
-	number = parameters["number"].toInt();
+	insertItem(new SerializableItem_Int("number", _number));
 }
 Command_MoveCard::Command_MoveCard(int _gameId, const QString &_startZone, int _cardId, const QString &_targetZone, int _x, int _y, bool _faceDown)
-	: GameCommand("move_card", _gameId), startZone(_startZone), cardId(_cardId), targetZone(_targetZone), x(_x), y(_y), faceDown(_faceDown)
+	: GameCommand("move_card", _gameId)
 {
-	setParameter("start_zone", startZone);
-	setParameter("card_id", cardId);
-	setParameter("target_zone", targetZone);
-	setParameter("x", x);
-	setParameter("y", y);
-	setParameter("face_down", faceDown);
-}
-void Command_MoveCard::extractParameters()
-{
-	GameCommand::extractParameters();
-	startZone = parameters["start_zone"];
-	cardId = parameters["card_id"].toInt();
-	targetZone = parameters["target_zone"];
-	x = parameters["x"].toInt();
-	y = parameters["y"].toInt();
-	faceDown = (parameters["face_down"] == "1");
+	insertItem(new SerializableItem_String("start_zone", _startZone));
+	insertItem(new SerializableItem_Int("card_id", _cardId));
+	insertItem(new SerializableItem_String("target_zone", _targetZone));
+	insertItem(new SerializableItem_Int("x", _x));
+	insertItem(new SerializableItem_Int("y", _y));
+	insertItem(new SerializableItem_Bool("face_down", _faceDown));
 }
 Command_CreateToken::Command_CreateToken(int _gameId, const QString &_zone, const QString &_cardName, const QString &_pt, int _x, int _y)
-	: GameCommand("create_token", _gameId), zone(_zone), cardName(_cardName), pt(_pt), x(_x), y(_y)
+	: GameCommand("create_token", _gameId)
 {
-	setParameter("zone", zone);
-	setParameter("card_name", cardName);
-	setParameter("pt", pt);
-	setParameter("x", x);
-	setParameter("y", y);
-}
-void Command_CreateToken::extractParameters()
-{
-	GameCommand::extractParameters();
-	zone = parameters["zone"];
-	cardName = parameters["card_name"];
-	pt = parameters["pt"];
-	x = parameters["x"].toInt();
-	y = parameters["y"].toInt();
+	insertItem(new SerializableItem_String("zone", _zone));
+	insertItem(new SerializableItem_String("card_name", _cardName));
+	insertItem(new SerializableItem_String("pt", _pt));
+	insertItem(new SerializableItem_Int("x", _x));
+	insertItem(new SerializableItem_Int("y", _y));
 }
 Command_CreateArrow::Command_CreateArrow(int _gameId, int _startPlayerId, const QString &_startZone, int _startCardId, int _targetPlayerId, const QString &_targetZone, int _targetCardId, const QColor &_color)
-	: GameCommand("create_arrow", _gameId), startPlayerId(_startPlayerId), startZone(_startZone), startCardId(_startCardId), targetPlayerId(_targetPlayerId), targetZone(_targetZone), targetCardId(_targetCardId), color(_color)
-{
-	setParameter("start_player_id", startPlayerId);
-	setParameter("start_zone", startZone);
-	setParameter("start_card_id", startCardId);
-	setParameter("target_player_id", targetPlayerId);
-	setParameter("target_zone", targetZone);
-	setParameter("target_card_id", targetCardId);
-	setParameter("color", color);
-}
-void Command_CreateArrow::extractParameters()
-{
-	GameCommand::extractParameters();
-	startPlayerId = parameters["start_player_id"].toInt();
-	startZone = parameters["start_zone"];
-	startCardId = parameters["start_card_id"].toInt();
-	targetPlayerId = parameters["target_player_id"].toInt();
-	targetZone = parameters["target_zone"];
-	targetCardId = parameters["target_card_id"].toInt();
-	color = ColorConverter::colorFromInt(parameters["color"].toInt());
-}
-Command_DeleteArrow::Command_DeleteArrow(int _gameId, int _arrowId)
-	: GameCommand("delete_arrow", _gameId), arrowId(_arrowId)
+	: GameCommand("create_arrow", _gameId)
 {
-	setParameter("arrow_id", arrowId);
+	insertItem(new SerializableItem_Int("start_player_id", _startPlayerId));
+	insertItem(new SerializableItem_String("start_zone", _startZone));
+	insertItem(new SerializableItem_Int("start_card_id", _startCardId));
+	insertItem(new SerializableItem_Int("target_player_id", _targetPlayerId));
+	insertItem(new SerializableItem_String("target_zone", _targetZone));
+	insertItem(new SerializableItem_Int("target_card_id", _targetCardId));
+	insertItem(new SerializableItem_Color("color", _color));
 }
-void Command_DeleteArrow::extractParameters()
+Command_DeleteArrow::Command_DeleteArrow(int _gameId, int _arrowId)
+	: GameCommand("delete_arrow", _gameId)
 {
-	GameCommand::extractParameters();
-	arrowId = parameters["arrow_id"].toInt();
+	insertItem(new SerializableItem_Int("arrow_id", _arrowId));
 }
 Command_SetCardAttr::Command_SetCardAttr(int _gameId, const QString &_zone, int _cardId, const QString &_attrName, const QString &_attrValue)
-	: GameCommand("set_card_attr", _gameId), zone(_zone), cardId(_cardId), attrName(_attrName), attrValue(_attrValue)
+	: GameCommand("set_card_attr", _gameId)
 {
-	setParameter("zone", zone);
-	setParameter("card_id", cardId);
-	setParameter("attr_name", attrName);
-	setParameter("attr_value", attrValue);
-}
-void Command_SetCardAttr::extractParameters()
-{
-	GameCommand::extractParameters();
-	zone = parameters["zone"];
-	cardId = parameters["card_id"].toInt();
-	attrName = parameters["attr_name"];
-	attrValue = parameters["attr_value"];
+	insertItem(new SerializableItem_String("zone", _zone));
+	insertItem(new SerializableItem_Int("card_id", _cardId));
+	insertItem(new SerializableItem_String("attr_name", _attrName));
+	insertItem(new SerializableItem_String("attr_value", _attrValue));
 }
 Command_ReadyStart::Command_ReadyStart(int _gameId)
 	: GameCommand("ready_start", _gameId)
 {
 }
 Command_IncCounter::Command_IncCounter(int _gameId, int _counterId, int _delta)
-	: GameCommand("inc_counter", _gameId), counterId(_counterId), delta(_delta)
-{
-	setParameter("counter_id", counterId);
-	setParameter("delta", delta);
-}
-void Command_IncCounter::extractParameters()
+	: GameCommand("inc_counter", _gameId)
 {
-	GameCommand::extractParameters();
-	counterId = parameters["counter_id"].toInt();
-	delta = parameters["delta"].toInt();
+	insertItem(new SerializableItem_Int("counter_id", _counterId));
+	insertItem(new SerializableItem_Int("delta", _delta));
 }
 Command_CreateCounter::Command_CreateCounter(int _gameId, const QString &_counterName, const QColor &_color, int _radius, int _value)
-	: GameCommand("create_counter", _gameId), counterName(_counterName), color(_color), radius(_radius), value(_value)
-{
-	setParameter("counter_name", counterName);
-	setParameter("color", color);
-	setParameter("radius", radius);
-	setParameter("value", value);
-}
-void Command_CreateCounter::extractParameters()
+	: GameCommand("create_counter", _gameId)
 {
-	GameCommand::extractParameters();
-	counterName = parameters["counter_name"];
-	color = ColorConverter::colorFromInt(parameters["color"].toInt());
-	radius = parameters["radius"].toInt();
-	value = parameters["value"].toInt();
+	insertItem(new SerializableItem_String("counter_name", _counterName));
+	insertItem(new SerializableItem_Color("color", _color));
+	insertItem(new SerializableItem_Int("radius", _radius));
+	insertItem(new SerializableItem_Int("value", _value));
 }
 Command_SetCounter::Command_SetCounter(int _gameId, int _counterId, int _value)
-	: GameCommand("set_counter", _gameId), counterId(_counterId), value(_value)
+	: GameCommand("set_counter", _gameId)
 {
-	setParameter("counter_id", counterId);
-	setParameter("value", value);
-}
-void Command_SetCounter::extractParameters()
-{
-	GameCommand::extractParameters();
-	counterId = parameters["counter_id"].toInt();
-	value = parameters["value"].toInt();
+	insertItem(new SerializableItem_Int("counter_id", _counterId));
+	insertItem(new SerializableItem_Int("value", _value));
 }
 Command_DelCounter::Command_DelCounter(int _gameId, int _counterId)
-	: GameCommand("del_counter", _gameId), counterId(_counterId)
+	: GameCommand("del_counter", _gameId)
 {
-	setParameter("counter_id", counterId);
-}
-void Command_DelCounter::extractParameters()
-{
-	GameCommand::extractParameters();
-	counterId = parameters["counter_id"].toInt();
+	insertItem(new SerializableItem_Int("counter_id", _counterId));
 }
 Command_NextTurn::Command_NextTurn(int _gameId)
 	: GameCommand("next_turn", _gameId)
 {
 }
 Command_SetActivePhase::Command_SetActivePhase(int _gameId, int _phase)
-	: GameCommand("set_active_phase", _gameId), phase(_phase)
-{
-	setParameter("phase", phase);
-}
-void Command_SetActivePhase::extractParameters()
+	: GameCommand("set_active_phase", _gameId)
 {
-	GameCommand::extractParameters();
-	phase = parameters["phase"].toInt();
+	insertItem(new SerializableItem_Int("phase", _phase));
 }
 Command_DumpZone::Command_DumpZone(int _gameId, int _playerId, const QString &_zoneName, int _numberCards)
-	: GameCommand("dump_zone", _gameId), playerId(_playerId), zoneName(_zoneName), numberCards(_numberCards)
-{
-	setParameter("player_id", playerId);
-	setParameter("zone_name", zoneName);
-	setParameter("number_cards", numberCards);
-}
-void Command_DumpZone::extractParameters()
+	: GameCommand("dump_zone", _gameId)
 {
-	GameCommand::extractParameters();
-	playerId = parameters["player_id"].toInt();
-	zoneName = parameters["zone_name"];
-	numberCards = parameters["number_cards"].toInt();
+	insertItem(new SerializableItem_Int("player_id", _playerId));
+	insertItem(new SerializableItem_String("zone_name", _zoneName));
+	insertItem(new SerializableItem_Int("number_cards", _numberCards));
 }
 Command_StopDumpZone::Command_StopDumpZone(int _gameId, int _playerId, const QString &_zoneName)
-	: GameCommand("stop_dump_zone", _gameId), playerId(_playerId), zoneName(_zoneName)
+	: GameCommand("stop_dump_zone", _gameId)
 {
-	setParameter("player_id", playerId);
-	setParameter("zone_name", zoneName);
-}
-void Command_StopDumpZone::extractParameters()
-{
-	GameCommand::extractParameters();
-	playerId = parameters["player_id"].toInt();
-	zoneName = parameters["zone_name"];
+	insertItem(new SerializableItem_Int("player_id", _playerId));
+	insertItem(new SerializableItem_String("zone_name", _zoneName));
 }
 Event_Say::Event_Say(int _gameId, int _playerId, const QString &_message)
-	: GameEvent("say", _gameId, _playerId), message(_message)
+	: GameEvent("say", _gameId, _playerId)
 {
-	setParameter("message", message);
-}
-void Event_Say::extractParameters()
-{
-	GameEvent::extractParameters();
-	message = parameters["message"];
+	insertItem(new SerializableItem_String("message", _message));
 }
 Event_Join::Event_Join(int _gameId, int _playerId, const QString &_playerName, bool _spectator)
-	: GameEvent("join", _gameId, _playerId), playerName(_playerName), spectator(_spectator)
-{
-	setParameter("player_name", playerName);
-	setParameter("spectator", spectator);
-}
-void Event_Join::extractParameters()
+	: GameEvent("join", _gameId, _playerId)
 {
-	GameEvent::extractParameters();
-	playerName = parameters["player_name"];
-	spectator = (parameters["spectator"] == "1");
+	insertItem(new SerializableItem_String("player_name", _playerName));
+	insertItem(new SerializableItem_Bool("spectator", _spectator));
 }
 Event_Leave::Event_Leave(int _gameId, int _playerId)
 	: GameEvent("leave", _gameId, _playerId)
 {
 }
 Event_DeckSelect::Event_DeckSelect(int _gameId, int _playerId, int _deckId)
-	: GameEvent("deck_select", _gameId, _playerId), deckId(_deckId)
-{
-	setParameter("deck_id", deckId);
-}
-void Event_DeckSelect::extractParameters()
+	: GameEvent("deck_select", _gameId, _playerId)
 {
-	GameEvent::extractParameters();
-	deckId = parameters["deck_id"].toInt();
+	insertItem(new SerializableItem_Int("deck_id", _deckId));
 }
 Event_GameClosed::Event_GameClosed(int _gameId, int _playerId)
 	: GameEvent("game_closed", _gameId, _playerId)
@@ -396,210 +227,107 @@ Event_Shuffle::Event_Shuffle(int _gameId, int _playerId)
 {
 }
 Event_RollDie::Event_RollDie(int _gameId, int _playerId, int _sides, int _value)
-	: GameEvent("roll_die", _gameId, _playerId), sides(_sides), value(_value)
+	: GameEvent("roll_die", _gameId, _playerId)
 {
-	setParameter("sides", sides);
-	setParameter("value", value);
-}
-void Event_RollDie::extractParameters()
-{
-	GameEvent::extractParameters();
-	sides = parameters["sides"].toInt();
-	value = parameters["value"].toInt();
+	insertItem(new SerializableItem_Int("sides", _sides));
+	insertItem(new SerializableItem_Int("value", _value));
 }
 Event_MoveCard::Event_MoveCard(int _gameId, int _playerId, int _cardId, const QString &_cardName, const QString &_startZone, int _position, const QString &_targetZone, int _x, int _y, bool _faceDown)
-	: GameEvent("move_card", _gameId, _playerId), cardId(_cardId), cardName(_cardName), startZone(_startZone), position(_position), targetZone(_targetZone), x(_x), y(_y), faceDown(_faceDown)
-{
-	setParameter("card_id", cardId);
-	setParameter("card_name", cardName);
-	setParameter("start_zone", startZone);
-	setParameter("position", position);
-	setParameter("target_zone", targetZone);
-	setParameter("x", x);
-	setParameter("y", y);
-	setParameter("face_down", faceDown);
-}
-void Event_MoveCard::extractParameters()
-{
-	GameEvent::extractParameters();
-	cardId = parameters["card_id"].toInt();
-	cardName = parameters["card_name"];
-	startZone = parameters["start_zone"];
-	position = parameters["position"].toInt();
-	targetZone = parameters["target_zone"];
-	x = parameters["x"].toInt();
-	y = parameters["y"].toInt();
-	faceDown = (parameters["face_down"] == "1");
-}
-Event_CreateToken::Event_CreateToken(int _gameId, int _playerId, const QString &_zone, int _cardId, const QString &_cardName, const QString &_pt, int _x, int _y)
-	: GameEvent("create_token", _gameId, _playerId), zone(_zone), cardId(_cardId), cardName(_cardName), pt(_pt), x(_x), y(_y)
+	: GameEvent("move_card", _gameId, _playerId)
 {
-	setParameter("zone", zone);
-	setParameter("card_id", cardId);
-	setParameter("card_name", cardName);
-	setParameter("pt", pt);
-	setParameter("x", x);
-	setParameter("y", y);
+	insertItem(new SerializableItem_Int("card_id", _cardId));
+	insertItem(new SerializableItem_String("card_name", _cardName));
+	insertItem(new SerializableItem_String("start_zone", _startZone));
+	insertItem(new SerializableItem_Int("position", _position));
+	insertItem(new SerializableItem_String("target_zone", _targetZone));
+	insertItem(new SerializableItem_Int("x", _x));
+	insertItem(new SerializableItem_Int("y", _y));
+	insertItem(new SerializableItem_Bool("face_down", _faceDown));
 }
-void Event_CreateToken::extractParameters()
+Event_CreateToken::Event_CreateToken(int _gameId, int _playerId, const QString &_zone, int _cardId, const QString &_cardName, const QString &_pt, int _x, int _y)
+	: GameEvent("create_token", _gameId, _playerId)
 {
-	GameEvent::extractParameters();
-	zone = parameters["zone"];
-	cardId = parameters["card_id"].toInt();
-	cardName = parameters["card_name"];
-	pt = parameters["pt"];
-	x = parameters["x"].toInt();
-	y = parameters["y"].toInt();
+	insertItem(new SerializableItem_String("zone", _zone));
+	insertItem(new SerializableItem_Int("card_id", _cardId));
+	insertItem(new SerializableItem_String("card_name", _cardName));
+	insertItem(new SerializableItem_String("pt", _pt));
+	insertItem(new SerializableItem_Int("x", _x));
+	insertItem(new SerializableItem_Int("y", _y));
 }
 Event_DeleteArrow::Event_DeleteArrow(int _gameId, int _playerId, int _arrowId)
-	: GameEvent("delete_arrow", _gameId, _playerId), arrowId(_arrowId)
+	: GameEvent("delete_arrow", _gameId, _playerId)
 {
-	setParameter("arrow_id", arrowId);
-}
-void Event_DeleteArrow::extractParameters()
-{
-	GameEvent::extractParameters();
-	arrowId = parameters["arrow_id"].toInt();
+	insertItem(new SerializableItem_Int("arrow_id", _arrowId));
 }
 Event_SetCardAttr::Event_SetCardAttr(int _gameId, int _playerId, const QString &_zone, int _cardId, const QString &_attrName, const QString &_attrValue)
-	: GameEvent("set_card_attr", _gameId, _playerId), zone(_zone), cardId(_cardId), attrName(_attrName), attrValue(_attrValue)
+	: GameEvent("set_card_attr", _gameId, _playerId)
 {
-	setParameter("zone", zone);
-	setParameter("card_id", cardId);
-	setParameter("attr_name", attrName);
-	setParameter("attr_value", attrValue);
-}
-void Event_SetCardAttr::extractParameters()
-{
-	GameEvent::extractParameters();
-	zone = parameters["zone"];
-	cardId = parameters["card_id"].toInt();
-	attrName = parameters["attr_name"];
-	attrValue = parameters["attr_value"];
+	insertItem(new SerializableItem_String("zone", _zone));
+	insertItem(new SerializableItem_Int("card_id", _cardId));
+	insertItem(new SerializableItem_String("attr_name", _attrName));
+	insertItem(new SerializableItem_String("attr_value", _attrValue));
 }
 Event_SetCounter::Event_SetCounter(int _gameId, int _playerId, int _counterId, int _value)
-	: GameEvent("set_counter", _gameId, _playerId), counterId(_counterId), value(_value)
-{
-	setParameter("counter_id", counterId);
-	setParameter("value", value);
-}
-void Event_SetCounter::extractParameters()
+	: GameEvent("set_counter", _gameId, _playerId)
 {
-	GameEvent::extractParameters();
-	counterId = parameters["counter_id"].toInt();
-	value = parameters["value"].toInt();
+	insertItem(new SerializableItem_Int("counter_id", _counterId));
+	insertItem(new SerializableItem_Int("value", _value));
 }
 Event_DelCounter::Event_DelCounter(int _gameId, int _playerId, int _counterId)
-	: GameEvent("del_counter", _gameId, _playerId), counterId(_counterId)
-{
-	setParameter("counter_id", counterId);
-}
-void Event_DelCounter::extractParameters()
+	: GameEvent("del_counter", _gameId, _playerId)
 {
-	GameEvent::extractParameters();
-	counterId = parameters["counter_id"].toInt();
+	insertItem(new SerializableItem_Int("counter_id", _counterId));
 }
 Event_SetActivePlayer::Event_SetActivePlayer(int _gameId, int _playerId, int _activePlayerId)
-	: GameEvent("set_active_player", _gameId, _playerId), activePlayerId(_activePlayerId)
+	: GameEvent("set_active_player", _gameId, _playerId)
 {
-	setParameter("active_player_id", activePlayerId);
-}
-void Event_SetActivePlayer::extractParameters()
-{
-	GameEvent::extractParameters();
-	activePlayerId = parameters["active_player_id"].toInt();
+	insertItem(new SerializableItem_Int("active_player_id", _activePlayerId));
 }
 Event_SetActivePhase::Event_SetActivePhase(int _gameId, int _playerId, int _phase)
-	: GameEvent("set_active_phase", _gameId, _playerId), phase(_phase)
+	: GameEvent("set_active_phase", _gameId, _playerId)
 {
-	setParameter("phase", phase);
-}
-void Event_SetActivePhase::extractParameters()
-{
-	GameEvent::extractParameters();
-	phase = parameters["phase"].toInt();
+	insertItem(new SerializableItem_Int("phase", _phase));
 }
 Event_DumpZone::Event_DumpZone(int _gameId, int _playerId, int _zoneOwnerId, const QString &_zone, int _numberCards)
-	: GameEvent("dump_zone", _gameId, _playerId), zoneOwnerId(_zoneOwnerId), zone(_zone), numberCards(_numberCards)
-{
-	setParameter("zone_owner_id", zoneOwnerId);
-	setParameter("zone", zone);
-	setParameter("number_cards", numberCards);
-}
-void Event_DumpZone::extractParameters()
+	: GameEvent("dump_zone", _gameId, _playerId)
 {
-	GameEvent::extractParameters();
-	zoneOwnerId = parameters["zone_owner_id"].toInt();
-	zone = parameters["zone"];
-	numberCards = parameters["number_cards"].toInt();
+	insertItem(new SerializableItem_Int("zone_owner_id", _zoneOwnerId));
+	insertItem(new SerializableItem_String("zone", _zone));
+	insertItem(new SerializableItem_Int("number_cards", _numberCards));
 }
 Event_StopDumpZone::Event_StopDumpZone(int _gameId, int _playerId, int _zoneOwnerId, const QString &_zone)
-	: GameEvent("stop_dump_zone", _gameId, _playerId), zoneOwnerId(_zoneOwnerId), zone(_zone)
-{
-	setParameter("zone_owner_id", zoneOwnerId);
-	setParameter("zone", zone);
-}
-void Event_StopDumpZone::extractParameters()
+	: GameEvent("stop_dump_zone", _gameId, _playerId)
 {
-	GameEvent::extractParameters();
-	zoneOwnerId = parameters["zone_owner_id"].toInt();
-	zone = parameters["zone"];
+	insertItem(new SerializableItem_Int("zone_owner_id", _zoneOwnerId));
+	insertItem(new SerializableItem_String("zone", _zone));
 }
 Event_ServerMessage::Event_ServerMessage(const QString &_message)
-	: GenericEvent("server_message"), message(_message)
+	: GenericEvent("server_message")
 {
-	setParameter("message", message);
-}
-void Event_ServerMessage::extractParameters()
-{
-	GenericEvent::extractParameters();
-	message = parameters["message"];
+	insertItem(new SerializableItem_String("message", _message));
 }
 Event_GameJoined::Event_GameJoined(int _gameId, int _playerId, bool _spectator)
-	: GenericEvent("game_joined"), gameId(_gameId), playerId(_playerId), spectator(_spectator)
+	: GenericEvent("game_joined")
 {
-	setParameter("game_id", gameId);
-	setParameter("player_id", playerId);
-	setParameter("spectator", spectator);
-}
-void Event_GameJoined::extractParameters()
-{
-	GenericEvent::extractParameters();
-	gameId = parameters["game_id"].toInt();
-	playerId = parameters["player_id"].toInt();
-	spectator = (parameters["spectator"] == "1");
+	insertItem(new SerializableItem_Int("game_id", _gameId));
+	insertItem(new SerializableItem_Int("player_id", _playerId));
+	insertItem(new SerializableItem_Bool("spectator", _spectator));
 }
 Event_ChatJoinChannel::Event_ChatJoinChannel(const QString &_channel, const QString &_playerName)
-	: ChatEvent("chat_join_channel", _channel), playerName(_playerName)
-{
-	setParameter("player_name", playerName);
-}
-void Event_ChatJoinChannel::extractParameters()
+	: ChatEvent("chat_join_channel", _channel)
 {
-	ChatEvent::extractParameters();
-	playerName = parameters["player_name"];
+	insertItem(new SerializableItem_String("player_name", _playerName));
 }
 Event_ChatLeaveChannel::Event_ChatLeaveChannel(const QString &_channel, const QString &_playerName)
-	: ChatEvent("chat_leave_channel", _channel), playerName(_playerName)
-{
-	setParameter("player_name", playerName);
-}
-void Event_ChatLeaveChannel::extractParameters()
+	: ChatEvent("chat_leave_channel", _channel)
 {
-	ChatEvent::extractParameters();
-	playerName = parameters["player_name"];
+	insertItem(new SerializableItem_String("player_name", _playerName));
 }
 Event_ChatSay::Event_ChatSay(const QString &_channel, const QString &_playerName, const QString &_message)
-	: ChatEvent("chat_say", _channel), playerName(_playerName), message(_message)
-{
-	setParameter("player_name", playerName);
-	setParameter("message", message);
-}
-void Event_ChatSay::extractParameters()
+	: ChatEvent("chat_say", _channel)
 {
-	ChatEvent::extractParameters();
-	playerName = parameters["player_name"];
-	message = parameters["message"];
+	insertItem(new SerializableItem_String("player_name", _playerName));
+	insertItem(new SerializableItem_String("message", _message));
 }
 void ProtocolItem::initializeHashAuto()
 {

common/protocol_items.h

@@ -5,745 +5,502 @@
 
 class Command_Ping : public Command {
 	Q_OBJECT
-private:
 public:
 	Command_Ping();
-	static ProtocolItem *newItem() { return new Command_Ping; }
+	static SerializableItem *newItem() { return new Command_Ping; }
 	int getItemId() const { return ItemId_Command_Ping; }
 };
 class Command_Login : public Command {
 	Q_OBJECT
-private:
-	QString username;
-	QString password;
 public:
 	Command_Login(const QString &_username = QString(), const QString &_password = QString());
-	QString getUsername() const { return username; }
-	QString getPassword() const { return password; }
-	static ProtocolItem *newItem() { return new Command_Login; }
+	QString getUsername() const { return static_cast<SerializableItem_String *>(itemMap.value("username"))->getData(); };
+	QString getPassword() const { return static_cast<SerializableItem_String *>(itemMap.value("password"))->getData(); };
+	static SerializableItem *newItem() { return new Command_Login; }
 	int getItemId() const { return ItemId_Command_Login; }
-protected:
-	void extractParameters();
 };
 class Command_DeckList : public Command {
 	Q_OBJECT
-private:
 public:
 	Command_DeckList();
-	static ProtocolItem *newItem() { return new Command_DeckList; }
+	static SerializableItem *newItem() { return new Command_DeckList; }
 	int getItemId() const { return ItemId_Command_DeckList; }
 };
 class Command_DeckNewDir : public Command {
 	Q_OBJECT
-private:
-	QString path;
-	QString dirName;
 public:
 	Command_DeckNewDir(const QString &_path = QString(), const QString &_dirName = QString());
-	QString getPath() const { return path; }
-	QString getDirName() const { return dirName; }
-	static ProtocolItem *newItem() { return new Command_DeckNewDir; }
+	QString getPath() const { return static_cast<SerializableItem_String *>(itemMap.value("path"))->getData(); };
+	QString getDirName() const { return static_cast<SerializableItem_String *>(itemMap.value("dir_name"))->getData(); };
+	static SerializableItem *newItem() { return new Command_DeckNewDir; }
 	int getItemId() const { return ItemId_Command_DeckNewDir; }
-protected:
-	void extractParameters();
 };
 class Command_DeckDelDir : public Command {
 	Q_OBJECT
-private:
-	QString path;
 public:
 	Command_DeckDelDir(const QString &_path = QString());
-	QString getPath() const { return path; }
-	static ProtocolItem *newItem() { return new Command_DeckDelDir; }
+	QString getPath() const { return static_cast<SerializableItem_String *>(itemMap.value("path"))->getData(); };
+	static SerializableItem *newItem() { return new Command_DeckDelDir; }
 	int getItemId() const { return ItemId_Command_DeckDelDir; }
-protected:
-	void extractParameters();
 };
 class Command_DeckDel : public Command {
 	Q_OBJECT
-private:
-	int deckId;
 public:
 	Command_DeckDel(int _deckId = -1);
-	int getDeckId() const { return deckId; }
-	static ProtocolItem *newItem() { return new Command_DeckDel; }
+	int getDeckId() const { return static_cast<SerializableItem_Int *>(itemMap.value("deck_id"))->getData(); };
+	static SerializableItem *newItem() { return new Command_DeckDel; }
 	int getItemId() const { return ItemId_Command_DeckDel; }
-protected:
-	void extractParameters();
 };
 class Command_DeckDownload : public Command {
 	Q_OBJECT
-private:
-	int deckId;
 public:
 	Command_DeckDownload(int _deckId = -1);
-	int getDeckId() const { return deckId; }
-	static ProtocolItem *newItem() { return new Command_DeckDownload; }
+	int getDeckId() const { return static_cast<SerializableItem_Int *>(itemMap.value("deck_id"))->getData(); };
+	static SerializableItem *newItem() { return new Command_DeckDownload; }
 	int getItemId() const { return ItemId_Command_DeckDownload; }
-protected:
-	void extractParameters();
 };
 class Command_ListChatChannels : public Command {
 	Q_OBJECT
-private:
 public:
 	Command_ListChatChannels();
-	static ProtocolItem *newItem() { return new Command_ListChatChannels; }
+	static SerializableItem *newItem() { return new Command_ListChatChannels; }
 	int getItemId() const { return ItemId_Command_ListChatChannels; }
 };
 class Command_ChatJoinChannel : public Command {
 	Q_OBJECT
-private:
-	QString channel;
 public:
 	Command_ChatJoinChannel(const QString &_channel = QString());
-	QString getChannel() const { return channel; }
-	static ProtocolItem *newItem() { return new Command_ChatJoinChannel; }
+	QString getChannel() const { return static_cast<SerializableItem_String *>(itemMap.value("channel"))->getData(); };
+	static SerializableItem *newItem() { return new Command_ChatJoinChannel; }
 	int getItemId() const { return ItemId_Command_ChatJoinChannel; }
-protected:
-	void extractParameters();
 };
 class Command_ChatLeaveChannel : public ChatCommand {
 	Q_OBJECT
-private:
 public:
 	Command_ChatLeaveChannel(const QString &_channel = QString());
-	static ProtocolItem *newItem() { return new Command_ChatLeaveChannel; }
+	static SerializableItem *newItem() { return new Command_ChatLeaveChannel; }
 	int getItemId() const { return ItemId_Command_ChatLeaveChannel; }
 };
 class Command_ChatSay : public ChatCommand {
 	Q_OBJECT
-private:
-	QString message;
 public:
 	Command_ChatSay(const QString &_channel = QString(), const QString &_message = QString());
-	QString getMessage() const { return message; }
-	static ProtocolItem *newItem() { return new Command_ChatSay; }
+	QString getMessage() const { return static_cast<SerializableItem_String *>(itemMap.value("message"))->getData(); };
+	static SerializableItem *newItem() { return new Command_ChatSay; }
 	int getItemId() const { return ItemId_Command_ChatSay; }
-protected:
-	void extractParameters();
 };
 class Command_ListGames : public Command {
 	Q_OBJECT
-private:
 public:
 	Command_ListGames();
-	static ProtocolItem *newItem() { return new Command_ListGames; }
+	static SerializableItem *newItem() { return new Command_ListGames; }
 	int getItemId() const { return ItemId_Command_ListGames; }
 };
 class Command_CreateGame : public Command {
 	Q_OBJECT
-private:
-	QString description;
-	QString password;
-	int maxPlayers;
-	bool spectatorsAllowed;
 public:
 	Command_CreateGame(const QString &_description = QString(), const QString &_password = QString(), int _maxPlayers = -1, bool _spectatorsAllowed = false);
-	QString getDescription() const { return description; }
-	QString getPassword() const { return password; }
-	int getMaxPlayers() const { return maxPlayers; }
-	bool getSpectatorsAllowed() const { return spectatorsAllowed; }
-	static ProtocolItem *newItem() { return new Command_CreateGame; }
+	QString getDescription() const { return static_cast<SerializableItem_String *>(itemMap.value("description"))->getData(); };
+	QString getPassword() const { return static_cast<SerializableItem_String *>(itemMap.value("password"))->getData(); };
+	int getMaxPlayers() const { return static_cast<SerializableItem_Int *>(itemMap.value("max_players"))->getData(); };
+	bool getSpectatorsAllowed() const { return static_cast<SerializableItem_Bool *>(itemMap.value("spectators_allowed"))->getData(); };
+	static SerializableItem *newItem() { return new Command_CreateGame; }
 	int getItemId() const { return ItemId_Command_CreateGame; }
-protected:
-	void extractParameters();
 };
 class Command_JoinGame : public Command {
 	Q_OBJECT
-private:
-	int gameId;
-	QString password;
-	bool spectator;
 public:
 	Command_JoinGame(int _gameId = -1, const QString &_password = QString(), bool _spectator = false);
-	int getGameId() const { return gameId; }
-	QString getPassword() const { return password; }
-	bool getSpectator() const { return spectator; }
-	static ProtocolItem *newItem() { return new Command_JoinGame; }
+	int getGameId() const { return static_cast<SerializableItem_Int *>(itemMap.value("game_id"))->getData(); };
+	QString getPassword() const { return static_cast<SerializableItem_String *>(itemMap.value("password"))->getData(); };
+	bool getSpectator() const { return static_cast<SerializableItem_Bool *>(itemMap.value("spectator"))->getData(); };
+	static SerializableItem *newItem() { return new Command_JoinGame; }
 	int getItemId() const { return ItemId_Command_JoinGame; }
-protected:
-	void extractParameters();
 };
 class Command_LeaveGame : public GameCommand {
 	Q_OBJECT
-private:
 public:
 	Command_LeaveGame(int _gameId = -1);
-	static ProtocolItem *newItem() { return new Command_LeaveGame; }
+	static SerializableItem *newItem() { return new Command_LeaveGame; }
 	int getItemId() const { return ItemId_Command_LeaveGame; }
 };
 class Command_Say : public GameCommand {
 	Q_OBJECT
-private:
-	QString message;
 public:
 	Command_Say(int _gameId = -1, const QString &_message = QString());
-	QString getMessage() const { return message; }
-	static ProtocolItem *newItem() { return new Command_Say; }
+	QString getMessage() const { return static_cast<SerializableItem_String *>(itemMap.value("message"))->getData(); };
+	static SerializableItem *newItem() { return new Command_Say; }
 	int getItemId() const { return ItemId_Command_Say; }
-protected:
-	void extractParameters();
 };
 class Command_Shuffle : public GameCommand {
 	Q_OBJECT
-private:
 public:
 	Command_Shuffle(int _gameId = -1);
-	static ProtocolItem *newItem() { return new Command_Shuffle; }
+	static SerializableItem *newItem() { return new Command_Shuffle; }
 	int getItemId() const { return ItemId_Command_Shuffle; }
 };
 class Command_RollDie : public GameCommand {
 	Q_OBJECT
-private:
-	int sides;
 public:
 	Command_RollDie(int _gameId = -1, int _sides = -1);
-	int getSides() const { return sides; }
-	static ProtocolItem *newItem() { return new Command_RollDie; }
+	int getSides() const { return static_cast<SerializableItem_Int *>(itemMap.value("sides"))->getData(); };
+	static SerializableItem *newItem() { return new Command_RollDie; }
 	int getItemId() const { return ItemId_Command_RollDie; }
-protected:
-	void extractParameters();
 };
 class Command_DrawCards : public GameCommand {
 	Q_OBJECT
-private:
-	int number;
 public:
 	Command_DrawCards(int _gameId = -1, int _number = -1);
-	int getNumber() const { return number; }
-	static ProtocolItem *newItem() { return new Command_DrawCards; }
+	int getNumber() const { return static_cast<SerializableItem_Int *>(itemMap.value("number"))->getData(); };
+	static SerializableItem *newItem() { return new Command_DrawCards; }
 	int getItemId() const { return ItemId_Command_DrawCards; }
-protected:
-	void extractParameters();
 };
 class Command_MoveCard : public GameCommand {
 	Q_OBJECT
-private:
-	QString startZone;
-	int cardId;
-	QString targetZone;
-	int x;
-	int y;
-	bool faceDown;
 public:
 	Command_MoveCard(int _gameId = -1, const QString &_startZone = QString(), int _cardId = -1, const QString &_targetZone = QString(), int _x = -1, int _y = -1, bool _faceDown = false);
-	QString getStartZone() const { return startZone; }
-	int getCardId() const { return cardId; }
-	QString getTargetZone() const { return targetZone; }
-	int getX() const { return x; }
-	int getY() const { return y; }
-	bool getFaceDown() const { return faceDown; }
-	static ProtocolItem *newItem() { return new Command_MoveCard; }
+	QString getStartZone() const { return static_cast<SerializableItem_String *>(itemMap.value("start_zone"))->getData(); };
+	int getCardId() const { return static_cast<SerializableItem_Int *>(itemMap.value("card_id"))->getData(); };
+	QString getTargetZone() const { return static_cast<SerializableItem_String *>(itemMap.value("target_zone"))->getData(); };
+	int getX() const { return static_cast<SerializableItem_Int *>(itemMap.value("x"))->getData(); };
+	int getY() const { return static_cast<SerializableItem_Int *>(itemMap.value("y"))->getData(); };
+	bool getFaceDown() const { return static_cast<SerializableItem_Bool *>(itemMap.value("face_down"))->getData(); };
+	static SerializableItem *newItem() { return new Command_MoveCard; }
 	int getItemId() const { return ItemId_Command_MoveCard; }
-protected:
-	void extractParameters();
 };
 class Command_CreateToken : public GameCommand {
 	Q_OBJECT
-private:
-	QString zone;
-	QString cardName;
-	QString pt;
-	int x;
-	int y;
 public:
 	Command_CreateToken(int _gameId = -1, const QString &_zone = QString(), const QString &_cardName = QString(), const QString &_pt = QString(), int _x = -1, int _y = -1);
-	QString getZone() const { return zone; }
-	QString getCardName() const { return cardName; }
-	QString getPt() const { return pt; }
-	int getX() const { return x; }
-	int getY() const { return y; }
-	static ProtocolItem *newItem() { return new Command_CreateToken; }
+	QString getZone() const { return static_cast<SerializableItem_String *>(itemMap.value("zone"))->getData(); };
+	QString getCardName() const { return static_cast<SerializableItem_String *>(itemMap.value("card_name"))->getData(); };
+	QString getPt() const { return static_cast<SerializableItem_String *>(itemMap.value("pt"))->getData(); };
+	int getX() const { return static_cast<SerializableItem_Int *>(itemMap.value("x"))->getData(); };
+	int getY() const { return static_cast<SerializableItem_Int *>(itemMap.value("y"))->getData(); };
+	static SerializableItem *newItem() { return new Command_CreateToken; }
 	int getItemId() const { return ItemId_Command_CreateToken; }
-protected:
-	void extractParameters();
 };
 class Command_CreateArrow : public GameCommand {
 	Q_OBJECT
-private:
-	int startPlayerId;
-	QString startZone;
-	int startCardId;
-	int targetPlayerId;
-	QString targetZone;
-	int targetCardId;
-	QColor color;
 public:
 	Command_CreateArrow(int _gameId = -1, int _startPlayerId = -1, const QString &_startZone = QString(), int _startCardId = -1, int _targetPlayerId = -1, const QString &_targetZone = QString(), int _targetCardId = -1, const QColor &_color = QColor());
-	int getStartPlayerId() const { return startPlayerId; }
-	QString getStartZone() const { return startZone; }
-	int getStartCardId() const { return startCardId; }
-	int getTargetPlayerId() const { return targetPlayerId; }
-	QString getTargetZone() const { return targetZone; }
-	int getTargetCardId() const { return targetCardId; }
-	QColor getColor() const { return color; }
-	static ProtocolItem *newItem() { return new Command_CreateArrow; }
+	int getStartPlayerId() const { return static_cast<SerializableItem_Int *>(itemMap.value("start_player_id"))->getData(); };
+	QString getStartZone() const { return static_cast<SerializableItem_String *>(itemMap.value("start_zone"))->getData(); };
+	int getStartCardId() const { return static_cast<SerializableItem_Int *>(itemMap.value("start_card_id"))->getData(); };
+	int getTargetPlayerId() const { return static_cast<SerializableItem_Int *>(itemMap.value("target_player_id"))->getData(); };
+	QString getTargetZone() const { return static_cast<SerializableItem_String *>(itemMap.value("target_zone"))->getData(); };
+	int getTargetCardId() const { return static_cast<SerializableItem_Int *>(itemMap.value("target_card_id"))->getData(); };
+	QColor getColor() const { return static_cast<SerializableItem_Color *>(itemMap.value("color"))->getData(); };
+	static SerializableItem *newItem() { return new Command_CreateArrow; }
 	int getItemId() const { return ItemId_Command_CreateArrow; }
-protected:
-	void extractParameters();
 };
 class Command_DeleteArrow : public GameCommand {
 	Q_OBJECT
-private:
-	int arrowId;
 public:
 	Command_DeleteArrow(int _gameId = -1, int _arrowId = -1);
-	int getArrowId() const { return arrowId; }
-	static ProtocolItem *newItem() { return new Command_DeleteArrow; }
+	int getArrowId() const { return static_cast<SerializableItem_Int *>(itemMap.value("arrow_id"))->getData(); };
+	static SerializableItem *newItem() { return new Command_DeleteArrow; }
 	int getItemId() const { return ItemId_Command_DeleteArrow; }
-protected:
-	void extractParameters();
 };
 class Command_SetCardAttr : public GameCommand {
 	Q_OBJECT
-private:
-	QString zone;
-	int cardId;
-	QString attrName;
-	QString attrValue;
 public:
 	Command_SetCardAttr(int _gameId = -1, const QString &_zone = QString(), int _cardId = -1, const QString &_attrName = QString(), const QString &_attrValue = QString());
-	QString getZone() const { return zone; }
-	int getCardId() const { return cardId; }
-	QString getAttrName() const { return attrName; }
-	QString getAttrValue() const { return attrValue; }
-	static ProtocolItem *newItem() { return new Command_SetCardAttr; }
+	QString getZone() const { return static_cast<SerializableItem_String *>(itemMap.value("zone"))->getData(); };
+	int getCardId() const { return static_cast<SerializableItem_Int *>(itemMap.value("card_id"))->getData(); };
+	QString getAttrName() const { return static_cast<SerializableItem_String *>(itemMap.value("attr_name"))->getData(); };
+	QString getAttrValue() const { return static_cast<SerializableItem_String *>(itemMap.value("attr_value"))->getData(); };
+	static SerializableItem *newItem() { return new Command_SetCardAttr; }
 	int getItemId() const { return ItemId_Command_SetCardAttr; }
-protected:
-	void extractParameters();
 };
 class Command_ReadyStart : public GameCommand {
 	Q_OBJECT
-private:
 public:
 	Command_ReadyStart(int _gameId = -1);
-	static ProtocolItem *newItem() { return new Command_ReadyStart; }
+	static SerializableItem *newItem() { return new Command_ReadyStart; }
 	int getItemId() const { return ItemId_Command_ReadyStart; }
 };
 class Command_IncCounter : public GameCommand {
 	Q_OBJECT
-private:
-	int counterId;
-	int delta;
 public:
 	Command_IncCounter(int _gameId = -1, int _counterId = -1, int _delta = -1);
-	int getCounterId() const { return counterId; }
-	int getDelta() const { return delta; }
-	static ProtocolItem *newItem() { return new Command_IncCounter; }
+	int getCounterId() const { return static_cast<SerializableItem_Int *>(itemMap.value("counter_id"))->getData(); };
+	int getDelta() const { return static_cast<SerializableItem_Int *>(itemMap.value("delta"))->getData(); };
+	static SerializableItem *newItem() { return new Command_IncCounter; }
 	int getItemId() const { return ItemId_Command_IncCounter; }
-protected:
-	void extractParameters();
 };
 class Command_CreateCounter : public GameCommand {
 	Q_OBJECT
-private:
-	QString counterName;
-	QColor color;
-	int radius;
-	int value;
 public:
 	Command_CreateCounter(int _gameId = -1, const QString &_counterName = QString(), const QColor &_color = QColor(), int _radius = -1, int _value = -1);
-	QString getCounterName() const { return counterName; }
-	QColor getColor() const { return color; }
-	int getRadius() const { return radius; }
-	int getValue() const { return value; }
-	static ProtocolItem *newItem() { return new Command_CreateCounter; }
+	QString getCounterName() const { return static_cast<SerializableItem_String *>(itemMap.value("counter_name"))->getData(); };
+	QColor getColor() const { return static_cast<SerializableItem_Color *>(itemMap.value("color"))->getData(); };
+	int getRadius() const { return static_cast<SerializableItem_Int *>(itemMap.value("radius"))->getData(); };
+	int getValue() const { return static_cast<SerializableItem_Int *>(itemMap.value("value"))->getData(); };
+	static SerializableItem *newItem() { return new Command_CreateCounter; }
 	int getItemId() const { return ItemId_Command_CreateCounter; }
-protected:
-	void extractParameters();
 };
 class Command_SetCounter : public GameCommand {
 	Q_OBJECT
-private:
-	int counterId;
-	int value;
 public:
 	Command_SetCounter(int _gameId = -1, int _counterId = -1, int _value = -1);
-	int getCounterId() const { return counterId; }
-	int getValue() const { return value; }
-	static ProtocolItem *newItem() { return new Command_SetCounter; }
+	int getCounterId() const { return static_cast<SerializableItem_Int *>(itemMap.value("counter_id"))->getData(); };
+	int getValue() const { return static_cast<SerializableItem_Int *>(itemMap.value("value"))->getData(); };
+	static SerializableItem *newItem() { return new Command_SetCounter; }
 	int getItemId() const { return ItemId_Command_SetCounter; }
-protected:
-	void extractParameters();
 };
 class Command_DelCounter : public GameCommand {
 	Q_OBJECT
-private:
-	int counterId;
 public:
 	Command_DelCounter(int _gameId = -1, int _counterId = -1);
-	int getCounterId() const { return counterId; }
-	static ProtocolItem *newItem() { return new Command_DelCounter; }
+	int getCounterId() const { return static_cast<SerializableItem_Int *>(itemMap.value("counter_id"))->getData(); };
+	static SerializableItem *newItem() { return new Command_DelCounter; }
 	int getItemId() const { return ItemId_Command_DelCounter; }
-protected:
-	void extractParameters();
 };
 class Command_NextTurn : public GameCommand {
 	Q_OBJECT
-private:
 public:
 	Command_NextTurn(int _gameId = -1);
-	static ProtocolItem *newItem() { return new Command_NextTurn; }
+	static SerializableItem *newItem() { return new Command_NextTurn; }
 	int getItemId() const { return ItemId_Command_NextTurn; }
 };
 class Command_SetActivePhase : public GameCommand {
 	Q_OBJECT
-private:
-	int phase;
 public:
 	Command_SetActivePhase(int _gameId = -1, int _phase = -1);
-	int getPhase() const { return phase; }
-	static ProtocolItem *newItem() { return new Command_SetActivePhase; }
+	int getPhase() const { return static_cast<SerializableItem_Int *>(itemMap.value("phase"))->getData(); };
+	static SerializableItem *newItem() { return new Command_SetActivePhase; }
 	int getItemId() const { return ItemId_Command_SetActivePhase; }
-protected:
-	void extractParameters();
 };
 class Command_DumpZone : public GameCommand {
 	Q_OBJECT
-private:
-	int playerId;
-	QString zoneName;
-	int numberCards;
 public:
 	Command_DumpZone(int _gameId = -1, int _playerId = -1, const QString &_zoneName = QString(), int _numberCards = -1);
-	int getPlayerId() const { return playerId; }
-	QString getZoneName() const { return zoneName; }
-	int getNumberCards() const { return numberCards; }
-	static ProtocolItem *newItem() { return new Command_DumpZone; }
+	int getPlayerId() const { return static_cast<SerializableItem_Int *>(itemMap.value("player_id"))->getData(); };
+	QString getZoneName() const { return static_cast<SerializableItem_String *>(itemMap.value("zone_name"))->getData(); };
+	int getNumberCards() const { return static_cast<SerializableItem_Int *>(itemMap.value("number_cards"))->getData(); };
+	static SerializableItem *newItem() { return new Command_DumpZone; }
 	int getItemId() const { return ItemId_Command_DumpZone; }
-protected:
-	void extractParameters();
 };
 class Command_StopDumpZone : public GameCommand {
 	Q_OBJECT
-private:
-	int playerId;
-	QString zoneName;
 public:
 	Command_StopDumpZone(int _gameId = -1, int _playerId = -1, const QString &_zoneName = QString());
-	int getPlayerId() const { return playerId; }
-	QString getZoneName() const { return zoneName; }
-	static ProtocolItem *newItem() { return new Command_StopDumpZone; }
+	int getPlayerId() const { return static_cast<SerializableItem_Int *>(itemMap.value("player_id"))->getData(); };
+	QString getZoneName() const { return static_cast<SerializableItem_String *>(itemMap.value("zone_name"))->getData(); };
+	static SerializableItem *newItem() { return new Command_StopDumpZone; }
 	int getItemId() const { return ItemId_Command_StopDumpZone; }
-protected:
-	void extractParameters();
 };
 class Event_Say : public GameEvent {
 	Q_OBJECT
-private:
-	QString message;
 public:
 	Event_Say(int _gameId = -1, int _playerId = -1, const QString &_message = QString());
-	QString getMessage() const { return message; }
-	static ProtocolItem *newItem() { return new Event_Say; }
+	QString getMessage() const { return static_cast<SerializableItem_String *>(itemMap.value("message"))->getData(); };
+	static SerializableItem *newItem() { return new Event_Say; }
 	int getItemId() const { return ItemId_Event_Say; }
-protected:
-	void extractParameters();
 };
 class Event_Join : public GameEvent {
 	Q_OBJECT
-private:
-	QString playerName;
-	bool spectator;
 public:
 	Event_Join(int _gameId = -1, int _playerId = -1, const QString &_playerName = QString(), bool _spectator = false);
-	QString getPlayerName() const { return playerName; }
-	bool getSpectator() const { return spectator; }
-	static ProtocolItem *newItem() { return new Event_Join; }
+	QString getPlayerName() const { return static_cast<SerializableItem_String *>(itemMap.value("player_name"))->getData(); };
+	bool getSpectator() const { return static_cast<SerializableItem_Bool *>(itemMap.value("spectator"))->getData(); };
+	static SerializableItem *newItem() { return new Event_Join; }
 	int getItemId() const { return ItemId_Event_Join; }
-protected:
-	void extractParameters();
 };
 class Event_Leave : public GameEvent {
 	Q_OBJECT
-private:
 public:
 	Event_Leave(int _gameId = -1, int _playerId = -1);
-	static ProtocolItem *newItem() { return new Event_Leave; }
+	static SerializableItem *newItem() { return new Event_Leave; }
 	int getItemId() const { return ItemId_Event_Leave; }
 };
 class Event_DeckSelect : public GameEvent {
 	Q_OBJECT
-private:
-	int deckId;
 public:
 	Event_DeckSelect(int _gameId = -1, int _playerId = -1, int _deckId = -1);
-	int getDeckId() const { return deckId; }
-	static ProtocolItem *newItem() { return new Event_DeckSelect; }
+	int getDeckId() const { return static_cast<SerializableItem_Int *>(itemMap.value("deck_id"))->getData(); };
+	static SerializableItem *newItem() { return new Event_DeckSelect; }
 	int getItemId() const { return ItemId_Event_DeckSelect; }
-protected:
-	void extractParameters();
 };
 class Event_GameClosed : public GameEvent {
 	Q_OBJECT
-private:
 public:
 	Event_GameClosed(int _gameId = -1, int _playerId = -1);
-	static ProtocolItem *newItem() { return new Event_GameClosed; }
+	static SerializableItem *newItem() { return new Event_GameClosed; }
 	int getItemId() const { return ItemId_Event_GameClosed; }
 };
 class Event_ReadyStart : public GameEvent {
 	Q_OBJECT
-private:
 public:
 	Event_ReadyStart(int _gameId = -1, int _playerId = -1);
-	static ProtocolItem *newItem() { return new Event_ReadyStart; }
+	static SerializableItem *newItem() { return new Event_ReadyStart; }
 	int getItemId() const { return ItemId_Event_ReadyStart; }
 };
 class Event_GameStart : public GameEvent {
 	Q_OBJECT
-private:
 public:
 	Event_GameStart(int _gameId = -1, int _playerId = -1);
-	static ProtocolItem *newItem() { return new Event_GameStart; }
+	static SerializableItem *newItem() { return new Event_GameStart; }
 	int getItemId() const { return ItemId_Event_GameStart; }
 };
 class Event_Shuffle : public GameEvent {
 	Q_OBJECT
-private:
 public:
 	Event_Shuffle(int _gameId = -1, int _playerId = -1);
-	static ProtocolItem *newItem() { return new Event_Shuffle; }
+	static SerializableItem *newItem() { return new Event_Shuffle; }
 	int getItemId() const { return ItemId_Event_Shuffle; }
 };
 class Event_RollDie : public GameEvent {
 	Q_OBJECT
-private:
-	int sides;
-	int value;
 public:
 	Event_RollDie(int _gameId = -1, int _playerId = -1, int _sides = -1, int _value = -1);
-	int getSides() const { return sides; }
-	int getValue() const { return value; }
-	static ProtocolItem *newItem() { return new Event_RollDie; }
+	int getSides() const { return static_cast<SerializableItem_Int *>(itemMap.value("sides"))->getData(); };
+	int getValue() const { return static_cast<SerializableItem_Int *>(itemMap.value("value"))->getData(); };
+	static SerializableItem *newItem() { return new Event_RollDie; }
 	int getItemId() const { return ItemId_Event_RollDie; }
-protected:
-	void extractParameters();
 };
 class Event_MoveCard : public GameEvent {
 	Q_OBJECT
-private:
-	int cardId;
-	QString cardName;
-	QString startZone;
-	int position;
-	QString targetZone;
-	int x;
-	int y;
-	bool faceDown;
 public:
 	Event_MoveCard(int _gameId = -1, int _playerId = -1, int _cardId = -1, const QString &_cardName = QString(), const QString &_startZone = QString(), int _position = -1, const QString &_targetZone = QString(), int _x = -1, int _y = -1, bool _faceDown = false);
-	int getCardId() const { return cardId; }
-	QString getCardName() const { return cardName; }
-	QString getStartZone() const { return startZone; }
-	int getPosition() const { return position; }
-	QString getTargetZone() const { return targetZone; }
-	int getX() const { return x; }
-	int getY() const { return y; }
-	bool getFaceDown() const { return faceDown; }
-	static ProtocolItem *newItem() { return new Event_MoveCard; }
+	int getCardId() const { return static_cast<SerializableItem_Int *>(itemMap.value("card_id"))->getData(); };
+	QString getCardName() const { return static_cast<SerializableItem_String *>(itemMap.value("card_name"))->getData(); };
+	QString getStartZone() const { return static_cast<SerializableItem_String *>(itemMap.value("start_zone"))->getData(); };
+	int getPosition() const { return static_cast<SerializableItem_Int *>(itemMap.value("position"))->getData(); };
+	QString getTargetZone() const { return static_cast<SerializableItem_String *>(itemMap.value("target_zone"))->getData(); };
+	int getX() const { return static_cast<SerializableItem_Int *>(itemMap.value("x"))->getData(); };
+	int getY() const { return static_cast<SerializableItem_Int *>(itemMap.value("y"))->getData(); };
+	bool getFaceDown() const { return static_cast<SerializableItem_Bool *>(itemMap.value("face_down"))->getData(); };
+	static SerializableItem *newItem() { return new Event_MoveCard; }
 	int getItemId() const { return ItemId_Event_MoveCard; }
-protected:
-	void extractParameters();
 };
 class Event_CreateToken : public GameEvent {
 	Q_OBJECT
-private:
-	QString zone;
-	int cardId;
-	QString cardName;
-	QString pt;
-	int x;
-	int y;
 public:
 	Event_CreateToken(int _gameId = -1, int _playerId = -1, const QString &_zone = QString(), int _cardId = -1, const QString &_cardName = QString(), const QString &_pt = QString(), int _x = -1, int _y = -1);
-	QString getZone() const { return zone; }
-	int getCardId() const { return cardId; }
-	QString getCardName() const { return cardName; }
-	QString getPt() const { return pt; }
-	int getX() const { return x; }
-	int getY() const { return y; }
-	static ProtocolItem *newItem() { return new Event_CreateToken; }
+	QString getZone() const { return static_cast<SerializableItem_String *>(itemMap.value("zone"))->getData(); };
+	int getCardId() const { return static_cast<SerializableItem_Int *>(itemMap.value("card_id"))->getData(); };
+	QString getCardName() const { return static_cast<SerializableItem_String *>(itemMap.value("card_name"))->getData(); };
+	QString getPt() const { return static_cast<SerializableItem_String *>(itemMap.value("pt"))->getData(); };
+	int getX() const { return static_cast<SerializableItem_Int *>(itemMap.value("x"))->getData(); };
+	int getY() const { return static_cast<SerializableItem_Int *>(itemMap.value("y"))->getData(); };
+	static SerializableItem *newItem() { return new Event_CreateToken; }
 	int getItemId() const { return ItemId_Event_CreateToken; }
-protected:
-	void extractParameters();
 };
 class Event_DeleteArrow : public GameEvent {
 	Q_OBJECT
-private:
-	int arrowId;
 public:
 	Event_DeleteArrow(int _gameId = -1, int _playerId = -1, int _arrowId = -1);
-	int getArrowId() const { return arrowId; }
-	static ProtocolItem *newItem() { return new Event_DeleteArrow; }
+	int getArrowId() const { return static_cast<SerializableItem_Int *>(itemMap.value("arrow_id"))->getData(); };
+	static SerializableItem *newItem() { return new Event_DeleteArrow; }
 	int getItemId() const { return ItemId_Event_DeleteArrow; }
-protected:
-	void extractParameters();
 };
 class Event_SetCardAttr : public GameEvent {
 	Q_OBJECT
-private:
-	QString zone;
-	int cardId;
-	QString attrName;
-	QString attrValue;
 public:
 	Event_SetCardAttr(int _gameId = -1, int _playerId = -1, const QString &_zone = QString(), int _cardId = -1, const QString &_attrName = QString(), const QString &_attrValue = QString());
-	QString getZone() const { return zone; }
-	int getCardId() const { return cardId; }
-	QString getAttrName() const { return attrName; }
-	QString getAttrValue() const { return attrValue; }
-	static ProtocolItem *newItem() { return new Event_SetCardAttr; }
+	QString getZone() const { return static_cast<SerializableItem_String *>(itemMap.value("zone"))->getData(); };
+	int getCardId() const { return static_cast<SerializableItem_Int *>(itemMap.value("card_id"))->getData(); };
+	QString getAttrName() const { return static_cast<SerializableItem_String *>(itemMap.value("attr_name"))->getData(); };
+	QString getAttrValue() const { return static_cast<SerializableItem_String *>(itemMap.value("attr_value"))->getData(); };
+	static SerializableItem *newItem() { return new Event_SetCardAttr; }
 	int getItemId() const { return ItemId_Event_SetCardAttr; }
-protected:
-	void extractParameters();
 };
 class Event_SetCounter : public GameEvent {
 	Q_OBJECT
-private:
-	int counterId;
-	int value;
 public:
 	Event_SetCounter(int _gameId = -1, int _playerId = -1, int _counterId = -1, int _value = -1);
-	int getCounterId() const { return counterId; }
-	int getValue() const { return value; }
-	static ProtocolItem *newItem() { return new Event_SetCounter; }
+	int getCounterId() const { return static_cast<SerializableItem_Int *>(itemMap.value("counter_id"))->getData(); };
+	int getValue() const { return static_cast<SerializableItem_Int *>(itemMap.value("value"))->getData(); };
+	static SerializableItem *newItem() { return new Event_SetCounter; }
 	int getItemId() const { return ItemId_Event_SetCounter; }
-protected:
-	void extractParameters();
 };
 class Event_DelCounter : public GameEvent {
 	Q_OBJECT
-private:
-	int counterId;
 public:
 	Event_DelCounter(int _gameId = -1, int _playerId = -1, int _counterId = -1);
-	int getCounterId() const { return counterId; }
-	static ProtocolItem *newItem() { return new Event_DelCounter; }
+	int getCounterId() const { return static_cast<SerializableItem_Int *>(itemMap.value("counter_id"))->getData(); };
+	static SerializableItem *newItem() { return new Event_DelCounter; }
 	int getItemId() const { return ItemId_Event_DelCounter; }
-protected:
-	void extractParameters();
 };
 class Event_SetActivePlayer : public GameEvent {
 	Q_OBJECT
-private:
-	int activePlayerId;
 public:
 	Event_SetActivePlayer(int _gameId = -1, int _playerId = -1, int _activePlayerId = -1);
-	int getActivePlayerId() const { return activePlayerId; }
-	static ProtocolItem *newItem() { return new Event_SetActivePlayer; }
+	int getActivePlayerId() const { return static_cast<SerializableItem_Int *>(itemMap.value("active_player_id"))->getData(); };
+	static SerializableItem *newItem() { return new Event_SetActivePlayer; }
 	int getItemId() const { return ItemId_Event_SetActivePlayer; }
-protected:
-	void extractParameters();
 };
 class Event_SetActivePhase : public GameEvent {
 	Q_OBJECT
-private:
-	int phase;
 public:
 	Event_SetActivePhase(int _gameId = -1, int _playerId = -1, int _phase = -1);
-	int getPhase() const { return phase; }
-	static ProtocolItem *newItem() { return new Event_SetActivePhase; }
+	int getPhase() const { return static_cast<SerializableItem_Int *>(itemMap.value("phase"))->getData(); };
+	static SerializableItem *newItem() { return new Event_SetActivePhase; }
 	int getItemId() const { return ItemId_Event_SetActivePhase; }
-protected:
-	void extractParameters();
 };
 class Event_DumpZone : public GameEvent {
 	Q_OBJECT
-private:
-	int zoneOwnerId;
-	QString zone;
-	int numberCards;
 public:
 	Event_DumpZone(int _gameId = -1, int _playerId = -1, int _zoneOwnerId = -1, const QString &_zone = QString(), int _numberCards = -1);
-	int getZoneOwnerId() const { return zoneOwnerId; }
-	QString getZone() const { return zone; }
-	int getNumberCards() const { return numberCards; }
-	static ProtocolItem *newItem() { return new Event_DumpZone; }
+	int getZoneOwnerId() const { return static_cast<SerializableItem_Int *>(itemMap.value("zone_owner_id"))->getData(); };
+	QString getZone() const { return static_cast<SerializableItem_String *>(itemMap.value("zone"))->getData(); };
+	int getNumberCards() const { return static_cast<SerializableItem_Int *>(itemMap.value("number_cards"))->getData(); };
+	static SerializableItem *newItem() { return new Event_DumpZone; }
 	int getItemId() const { return ItemId_Event_DumpZone; }
-protected:
-	void extractParameters();
 };
 class Event_StopDumpZone : public GameEvent {
 	Q_OBJECT
-private:
-	int zoneOwnerId;
-	QString zone;
 public:
 	Event_StopDumpZone(int _gameId = -1, int _playerId = -1, int _zoneOwnerId = -1, const QString &_zone = QString());
-	int getZoneOwnerId() const { return zoneOwnerId; }
-	QString getZone() const { return zone; }
-	static ProtocolItem *newItem() { return new Event_StopDumpZone; }
+	int getZoneOwnerId() const { return static_cast<SerializableItem_Int *>(itemMap.value("zone_owner_id"))->getData(); };
+	QString getZone() const { return static_cast<SerializableItem_String *>(itemMap.value("zone"))->getData(); };
+	static SerializableItem *newItem() { return new Event_StopDumpZone; }
 	int getItemId() const { return ItemId_Event_StopDumpZone; }
-protected:
-	void extractParameters();
 };
 class Event_ServerMessage : public GenericEvent {
 	Q_OBJECT
-private:
-	QString message;
 public:
 	Event_ServerMessage(const QString &_message = QString());
-	QString getMessage() const { return message; }
-	static ProtocolItem *newItem() { return new Event_ServerMessage; }
+	QString getMessage() const { return static_cast<SerializableItem_String *>(itemMap.value("message"))->getData(); };
+	static SerializableItem *newItem() { return new Event_ServerMessage; }
 	int getItemId() const { return ItemId_Event_ServerMessage; }
-protected:
-	void extractParameters();
 };
 class Event_GameJoined : public GenericEvent {
 	Q_OBJECT
-private:
-	int gameId;
-	int playerId;
-	bool spectator;
 public:
 	Event_GameJoined(int _gameId = -1, int _playerId = -1, bool _spectator = false);
-	int getGameId() const { return gameId; }
-	int getPlayerId() const { return playerId; }
-	bool getSpectator() const { return spectator; }
-	static ProtocolItem *newItem() { return new Event_GameJoined; }
+	int getGameId() const { return static_cast<SerializableItem_Int *>(itemMap.value("game_id"))->getData(); };
+	int getPlayerId() const { return static_cast<SerializableItem_Int *>(itemMap.value("player_id"))->getData(); };
+	bool getSpectator() const { return static_cast<SerializableItem_Bool *>(itemMap.value("spectator"))->getData(); };
+	static SerializableItem *newItem() { return new Event_GameJoined; }
 	int getItemId() const { return ItemId_Event_GameJoined; }
-protected:
-	void extractParameters();
 };
 class Event_ChatJoinChannel : public ChatEvent {
 	Q_OBJECT
-private:
-	QString playerName;
 public:
 	Event_ChatJoinChannel(const QString &_channel = QString(), const QString &_playerName = QString());
-	QString getPlayerName() const { return playerName; }
-	static ProtocolItem *newItem() { return new Event_ChatJoinChannel; }
+	QString getPlayerName() const { return static_cast<SerializableItem_String *>(itemMap.value("player_name"))->getData(); };
+	static SerializableItem *newItem() { return new Event_ChatJoinChannel; }
 	int getItemId() const { return ItemId_Event_ChatJoinChannel; }
-protected:
-	void extractParameters();
 };
 class Event_ChatLeaveChannel : public ChatEvent {
 	Q_OBJECT
-private:
-	QString playerName;
 public:
 	Event_ChatLeaveChannel(const QString &_channel = QString(), const QString &_playerName = QString());
-	QString getPlayerName() const { return playerName; }
-	static ProtocolItem *newItem() { return new Event_ChatLeaveChannel; }
+	QString getPlayerName() const { return static_cast<SerializableItem_String *>(itemMap.value("player_name"))->getData(); };
+	static SerializableItem *newItem() { return new Event_ChatLeaveChannel; }
 	int getItemId() const { return ItemId_Event_ChatLeaveChannel; }
-protected:
-	void extractParameters();
 };
 class Event_ChatSay : public ChatEvent {
 	Q_OBJECT
-private:
-	QString playerName;
-	QString message;
 public:
 	Event_ChatSay(const QString &_channel = QString(), const QString &_playerName = QString(), const QString &_message = QString());
-	QString getPlayerName() const { return playerName; }
-	QString getMessage() const { return message; }
-	static ProtocolItem *newItem() { return new Event_ChatSay; }
+	QString getPlayerName() const { return static_cast<SerializableItem_String *>(itemMap.value("player_name"))->getData(); };
+	QString getMessage() const { return static_cast<SerializableItem_String *>(itemMap.value("message"))->getData(); };
+	static SerializableItem *newItem() { return new Event_ChatSay; }
 	int getItemId() const { return ItemId_Event_ChatSay; }
-protected:
-	void extractParameters();
 };
 
 #endif

common/protocol_mc.pl

@@ -70,12 +70,9 @@ while (<file>) {
 	$className = $namePrefix . '_' . $name2;
 	$itemEnum .= "ItemId_$className = " . ++$itemId . ",\n";
 	$headerfileBuffer .= "class $className : public $baseClass {\n"
-		. "\tQ_OBJECT\n"
-		. "private:\n";
-	$paramStr2 = '';
-	$paramStr3 = '';
-	$paramStr4 = '';
-	$paramStr5 = '';
+		. "\tQ_OBJECT\n";
+	$constructorCode = '';
+	$getFunctionCode = '';
 	while ($param = shift(@line)) {
 		($key, $value) = split(/,/, $param);
 		($prettyVarName = $value) =~ s/_(.)/\U$1\E/g;
@@ -85,52 +82,44 @@ while (<file>) {
 		if (!($constructorParamsCpp eq '')) {
 			$constructorParamsCpp .= ', ';
 		}
-		$paramStr2 .= ", $prettyVarName(_$prettyVarName)";
-		$paramStr3 .= "\tsetParameter(\"$value\", $prettyVarName);\n";
+		($prettyVarName2 = $prettyVarName) =~ s/^(.)/\U$1\E/;
 		if ($key eq 'b') {
 			$dataType = 'bool';
 			$constructorParamsH .= "bool _$prettyVarName = false";
 			$constructorParamsCpp .= "bool _$prettyVarName";
-			$paramStr5 .= "\t$prettyVarName = (parameters[\"$value\"] == \"1\");\n";
+			$constructorCode .= "\tinsertItem(new SerializableItem_Bool(\"$value\", _$prettyVarName));\n";
+			$getFunctionCode .= "\t$dataType get$prettyVarName2() const { return static_cast<SerializableItem_Bool *>(itemMap.value(\"$value\"))->getData(); };\n";
 		} elsif ($key eq 's') {
 			$dataType = 'QString';
 			$constructorParamsH .= "const QString &_$prettyVarName = QString()";
 			$constructorParamsCpp .= "const QString &_$prettyVarName";
-			$paramStr5 .= "\t$prettyVarName = parameters[\"$value\"];\n";
+			$constructorCode .= "\tinsertItem(new SerializableItem_String(\"$value\", _$prettyVarName));\n";
+			$getFunctionCode .= "\t$dataType get$prettyVarName2() const { return static_cast<SerializableItem_String *>(itemMap.value(\"$value\"))->getData(); };\n";
 		} elsif ($key eq 'i') {
 			$dataType = 'int';
 			$constructorParamsH .= "int _$prettyVarName = -1";
 			$constructorParamsCpp .= "int _$prettyVarName";
-			$paramStr5 .= "\t$prettyVarName = parameters[\"$value\"].toInt();\n";
+			$constructorCode .= "\tinsertItem(new SerializableItem_Int(\"$value\", _$prettyVarName));\n";
+			$getFunctionCode .= "\t$dataType get$prettyVarName2() const { return static_cast<SerializableItem_Int *>(itemMap.value(\"$value\"))->getData(); };\n";
 		} elsif ($key eq 'c') {
 			$dataType = 'QColor';
 			$constructorParamsH .= "const QColor &_$prettyVarName = QColor()";
 			$constructorParamsCpp .= "const QColor &_$prettyVarName";
-			$paramStr5 .= "\t$prettyVarName = ColorConverter::colorFromInt(parameters[\"$value\"].toInt());\n";
+			$constructorCode .= "\tinsertItem(new SerializableItem_Color(\"$value\", _$prettyVarName));\n";
+			$getFunctionCode .= "\t$dataType get$prettyVarName2() const { return static_cast<SerializableItem_Color *>(itemMap.value(\"$value\"))->getData(); };\n";
 		}
-		($prettyVarName2 = $prettyVarName) =~ s/^(.)/\U$1\E/;
-		$paramStr4 .= "\t$dataType get$prettyVarName2() const { return $prettyVarName; }\n";
-		$headerfileBuffer .= "\t$dataType $prettyVarName;\n";
 	}
 	$headerfileBuffer .= "public:\n"
 		. "\t$className($constructorParamsH);\n"
-		. $paramStr4
-		. "\tstatic ProtocolItem *newItem() { return new $className; }\n"
+		. $getFunctionCode
+		. "\tstatic SerializableItem *newItem() { return new $className; }\n"
 		. "\tint getItemId() const { return ItemId_$className; }\n"
-		. ($paramStr5 eq '' ? '' : "protected:\n\tvoid extractParameters();\n")
 		. "};\n";
 	print cppfile $className . "::$className($constructorParamsCpp)\n"
-		. "\t: $parentConstructorCall$paramStr2\n"
+		. "\t: $parentConstructorCall\n"
 		. "{\n"
-		. $paramStr3
+		. $constructorCode
 		. "}\n";
-	if (!($paramStr5 eq '')) {
-		print cppfile "void $className" . "::extractParameters()\n"
-			. "{\n"
-			. "\t$baseClass" . "::extractParameters();\n"
-			. $paramStr5
-			. "}\n";
-	}
 	$initializeHash .= "\titemNameHash.insert(\"$type$name1\", $className" . "::newItem);\n";
 }
 close(file);

common/serializable_item.cpp

+#include "serializable_item.h"
+#include <QXmlStreamReader>
+#include <QXmlStreamWriter>
+#include <QDebug>
+
+QHash<QString, SerializableItem::NewItemFunction> SerializableItem::itemNameHash;
+
+SerializableItem *SerializableItem::getNewItem(const QString &name)
+{
+	if (!itemNameHash.contains(name))
+		return 0;
+	return itemNameHash.value(name)();
+}
+
+void SerializableItem::registerSerializableItem(const QString &name, NewItemFunction func)
+{
+	itemNameHash.insert(name, func);
+}
+
+bool SerializableItem::read(QXmlStreamReader *xml)
+{
+	while (!xml->atEnd()) {
+		xml->readNext();
+		readElement(xml);
+		if (xml->isEndElement() && (xml->name() == itemType))
+			return true;
+	}
+	return false;
+}
+
+void SerializableItem::write(QXmlStreamWriter *xml)
+{
+	xml->writeStartElement(itemType);
+	if (!itemSubType.isEmpty())
+		xml->writeAttribute("type", itemSubType);
+	writeElement(xml);
+	xml->writeEndElement();
+}
+
+SerializableItem_Map::~SerializableItem_Map()
+{
+	QMapIterator<QString, SerializableItem *> mapIterator(itemMap);
+	while (mapIterator.hasNext())
+		delete mapIterator.next().value();
+	for (int i = 0; i < itemList.size(); ++i)
+		delete itemList[i];
+}
+
+void SerializableItem_Map::readElement(QXmlStreamReader *xml)
+{
+	if (currentItem) {
+		if (currentItem->read(xml))
+			currentItem = 0;
+	} else if (xml->isEndElement() && (xml->name() == itemType))
+		extractData();
+	else if (xml->isStartElement()) {
+		QString childName = xml->name().toString();
+		QString childSubType = xml->attributes().value("type").toString();
+		qDebug() << "Map: started new item, name=" << childName << "subtype=" << childSubType;
+		currentItem = itemMap.value(childName);
+		if (!currentItem) {
+			qDebug() << "Item not found in map";
+			currentItem = getNewItem(childName + childSubType);
+			itemList.append(currentItem);
+			if (!currentItem) {
+				qDebug() << "Item still not found";
+				currentItem = new SerializableItem_Invalid(childName);
+			}
+		}
+		if (currentItem->read(xml))
+			currentItem = 0;
+	}
+}
+
+void SerializableItem_Map::writeElement(QXmlStreamWriter *xml)
+{
+	QMapIterator<QString, SerializableItem *> mapIterator(itemMap);
+	while (mapIterator.hasNext())
+		mapIterator.next().value()->write(xml);
+	for (int i = 0; i < itemList.size(); ++i)
+		itemList[i]->write(xml);
+}
+
+void SerializableItem_String::readElement(QXmlStreamReader *xml)
+{
+	if (xml->isCharacters() && !xml->isWhitespace())
+		data = xml->text().toString();
+}
+
+void SerializableItem_String::writeElement(QXmlStreamWriter *xml)
+{
+	xml->writeCharacters(data);
+}
+
+void SerializableItem_Int::readElement(QXmlStreamReader *xml)
+{
+	if (xml->isCharacters() && !xml->isWhitespace()) {
+		bool ok;
+		data = xml->text().toString().toInt(&ok);
+		if (!ok)
+			data = -1;
+	}
+}
+
+void SerializableItem_Int::writeElement(QXmlStreamWriter *xml)
+{
+	xml->writeCharacters(QString::number(data));
+}
+
+void SerializableItem_Bool::readElement(QXmlStreamReader *xml)
+{
+	if (xml->isCharacters() && !xml->isWhitespace())
+		data = xml->text().toString() == "1";
+}
+
+void SerializableItem_Bool::writeElement(QXmlStreamWriter *xml)
+{
+	xml->writeCharacters(data ? "1" : "0");
+}
+
+int SerializableItem_Color::colorToInt(const QColor &color) const
+{
+	return color.red() * 65536 + color.green() * 256 + color.blue();
+}
+
+QColor SerializableItem_Color::colorFromInt(int colorValue) const
+{
+	return QColor(colorValue / 65536, (colorValue % 65536) / 256, colorValue % 256);
+}
+
+void SerializableItem_Color::readElement(QXmlStreamReader *xml)
+{
+	if (xml->isCharacters() && !xml->isWhitespace()) {
+		bool ok;
+		int colorValue = xml->text().toString().toInt(&ok);
+		data = ok ? colorFromInt(colorValue) : Qt::black;
+	}
+}
+
+void SerializableItem_Color::writeElement(QXmlStreamWriter *xml)
+{
+	xml->writeCharacters(QString::number(colorToInt(data)));
+}
+
+void SerializableItem_DateTime::readElement(QXmlStreamReader *xml)
+{
+	if (xml->isCharacters() && !xml->isWhitespace()) {
+		bool ok;
+		unsigned int dateTimeValue = xml->text().toString().toUInt(&ok);
+		data = ok ? QDateTime::fromTime_t(dateTimeValue) : QDateTime();
+	}
+}
+
+void SerializableItem_DateTime::writeElement(QXmlStreamWriter *xml)
+{
+	xml->writeCharacters(QString::number(data.toTime_t()));
+}

common/serializable_item.h

+#ifndef SERIALIZABLE_ITEM_H
+#define SERIALIZABLE_ITEM_H
+
+#include <QObject>
+#include <QMap>
+#include <QList>
+#include <QHash>
+#include <QColor>
+#include <QDateTime>
+
+class QXmlStreamReader;
+class QXmlStreamWriter;
+
+class SerializableItem : public QObject {
+	Q_OBJECT
+protected:
+	typedef SerializableItem *(*NewItemFunction)();
+	static QHash<QString, NewItemFunction> itemNameHash;
+	
+	QString itemType, itemSubType;
+public:
+	SerializableItem(const QString &_itemType, const QString &_itemSubType = QString())
+		: QObject(), itemType(_itemType), itemSubType(_itemSubType) { }
+	static void registerSerializableItem(const QString &name, NewItemFunction func);
+	static SerializableItem *getNewItem(const QString &name);
+	const QString &getItemType() const { return itemType; }
+	const QString &getItemSubType() const { return itemSubType; }
+	virtual void readElement(QXmlStreamReader *xml) = 0;
+	virtual void writeElement(QXmlStreamWriter *xml) = 0;
+	bool read(QXmlStreamReader *xml);
+	void write(QXmlStreamWriter *xml);
+};
+
+class SerializableItem_Invalid : public SerializableItem {
+public:
+	SerializableItem_Invalid(const QString &_itemType) : SerializableItem(_itemType) { }
+	void readElement(QXmlStreamReader * /*xml*/) { }
+	void writeElement(QXmlStreamWriter * /*xml*/) { }
+};
+
+class SerializableItem_Map : public SerializableItem {
+private:
+	SerializableItem *currentItem;
+protected:
+	QMap<QString, SerializableItem *> itemMap;
+	QList<SerializableItem *> itemList;
+	virtual void extractData() { }
+	void insertItem(SerializableItem *item)
+	{
+		itemMap.insert(item->getItemType(), item);
+	}
+	template<class T> QList<T> typecastItemList() const
+	{
+		QList<T> result;
+		for (int i = 0; i < itemList.size(); ++i) {
+			T item = dynamic_cast<T>(itemList[i]);
+			if (item)
+				result.append(item);
+		}
+		return result;
+	}
+public:
+	SerializableItem_Map(const QString &_itemType, const QString &_itemSubType = QString())
+		: SerializableItem(_itemType, _itemSubType), currentItem(0)
+	{
+	}
+	~SerializableItem_Map();
+	void readElement(QXmlStreamReader *xml);
+	void writeElement(QXmlStreamWriter *xml);
+	void appendItem(SerializableItem *item) { itemList.append(item); }
+};
+
+class SerializableItem_String : public SerializableItem {
+private:
+	QString data;
+protected:
+	void readElement(QXmlStreamReader *xml);
+	void writeElement(QXmlStreamWriter *xml);
+public:
+	SerializableItem_String(const QString &_itemType, const QString &_data)
+		: SerializableItem(_itemType), data(_data) { }
+	const QString &getData() { return data; }
+	void setData(const QString &_data) { data = _data; }
+};
+
+class SerializableItem_Int : public SerializableItem {
+private:
+	int data;
+protected:
+	void readElement(QXmlStreamReader *xml);
+	void writeElement(QXmlStreamWriter *xml);
+public:
+	SerializableItem_Int(const QString &_itemType, int _data)
+		: SerializableItem(_itemType), data(_data) { }
+	int getData() { return data; }
+	void setData(int _data) { data = _data; }
+};
+
+class SerializableItem_Bool : public SerializableItem {
+private:
+	bool data;
+protected:
+	void readElement(QXmlStreamReader *xml);
+	void writeElement(QXmlStreamWriter *xml);
+public:
+	SerializableItem_Bool(const QString &_itemType, bool _data)
+		: SerializableItem(_itemType), data(_data) { }
+	bool getData() { return data; }
+	void setData(bool _data) { data = _data; }
+};
+
+class SerializableItem_Color : public SerializableItem {
+private:
+	QColor data;
+	int colorToInt(const QColor &color) const;
+	QColor colorFromInt(int colorValue) const;
+protected:
+	void readElement(QXmlStreamReader *xml);
+	void writeElement(QXmlStreamWriter *xml);
+public:
+	SerializableItem_Color(const QString &_itemType, const QColor &_data)
+		: SerializableItem(_itemType), data(_data) { }
+	const QColor &getData() { return data; }
+	void setData(const QColor &_data) { data = _data; }
+};
+ 
+class SerializableItem_DateTime : public SerializableItem {
+private:
+	QDateTime data;
+protected:
+	void readElement(QXmlStreamReader *xml);
+	void writeElement(QXmlStreamWriter *xml);
+public:
+	SerializableItem_DateTime(const QString &_itemType, const QDateTime &_data)
+		: SerializableItem(_itemType), data(_data) { }
+	const QDateTime &getData() { return data; }
+	void setData(const QDateTime &_data) { data = _data; }
+};
+
+#endif

common/server.cpp

@@ -61,10 +61,10 @@ Server_Game *Server::getGame(int gameId) const
 
 void Server::broadcastGameListUpdate(Server_Game *game)
 {
-	Event_ListGames *event = new Event_ListGames;
+	QList<ServerInfo_Game *> eventGameList;
 	if (game->getPlayerCount())
 		// Game is open
-		event->addGame(
+		eventGameList.append(new ServerInfo_Game(
 			game->getGameId(),
 			game->getDescription(),
 			!game->getPassword().isEmpty(),
@@ -73,10 +73,11 @@ void Server::broadcastGameListUpdate(Server_Game *game)
 			game->getCreatorName(),
 			game->getSpectatorsAllowed(),
 			game->getSpectatorCount()
-		);
+		));
 	else
 		// Game is closing
-		event->addGame(game->getGameId(), QString(), false, 0, game->getMaxPlayers(), QString(), false, 0);
+		eventGameList.append(new ServerInfo_Game(game->getGameId(), QString(), false, 0, game->getMaxPlayers(), QString(), false, 0));
+	Event_ListGames *event = new Event_ListGames(eventGameList);
 	
 	for (int i = 0; i < clients.size(); i++)
 		if (clients[i]->getAcceptsGameListChanges())
@@ -87,8 +88,9 @@ void Server::broadcastGameListUpdate(Server_Game *game)
 void Server::broadcastChannelUpdate()
 {
 	Server_ChatChannel *channel = static_cast<Server_ChatChannel *>(sender());
-	Event_ListChatChannels *event = new Event_ListChatChannels;
-	event->addChannel(channel->getName(), channel->getDescription(), channel->size(), channel->getAutoJoin());
+	QList<ServerInfo_ChatChannel *> eventChannelList;
+	eventChannelList.append(new ServerInfo_ChatChannel(channel->getName(), channel->getDescription(), channel->size(), channel->getAutoJoin()));
+	Event_ListChatChannels *event = new Event_ListChatChannels(eventChannelList);
 
 	for (int i = 0; i < clients.size(); ++i)
 	  	if (clients[i]->getAcceptsChatChannelListChanges())

common/server_chatchannel.cpp

@@ -11,9 +11,10 @@ void Server_ChatChannel::addClient(Server_ProtocolHandler *client)
 	sendChatEvent(new Event_ChatJoinChannel(name, client->getPlayerName()));
 	append(client);
 	
-	Event_ChatListPlayers *eventCLP = new Event_ChatListPlayers(name);
+	QList<ServerInfo_ChatUser *> eventUserList;
 	for (int i = 0; i < size(); ++i)
-		eventCLP->addPlayer(at(i)->getPlayerName());
+		eventUserList.append(new ServerInfo_ChatUser(at(i)->getPlayerName()));
+	Event_ChatListPlayers *eventCLP = new Event_ChatListPlayers(name, eventUserList);
 	client->enqueueProtocolItem(eventCLP);
 	
 	client->enqueueProtocolItem(new Event_ChatSay(name, QString(), joinMessage));

common/server_protocolhandler.cpp

@@ -10,6 +10,7 @@
 #include "server_counter.h"
 #include "server_game.h"
 #include "server_player.h"
+#include "decklist.h"
 
 Server_ProtocolHandler::Server_ProtocolHandler(Server *_server, QObject *parent)
 	: QObject(parent), server(_server), authState(PasswordWrong), acceptsGameListChanges(false)
@@ -148,13 +149,13 @@ ResponseCode Server_ProtocolHandler::cmdListChatChannels(Command_ListChatChannel
 	if (authState == PasswordWrong)
 		return RespLoginNeeded;
 	
-	Event_ListChatChannels *event = new Event_ListChatChannels;
+	QList<ServerInfo_ChatChannel *> eventChannelList;
 	QMapIterator<QString, Server_ChatChannel *> channelIterator(server->getChatChannels());
 	while (channelIterator.hasNext()) {
 		Server_ChatChannel *c = channelIterator.next().value();
-		event->addChannel(c->getName(), c->getDescription(), c->size(), c->getAutoJoin());
+		eventChannelList.append(new ServerInfo_ChatChannel(c->getName(), c->getDescription(), c->size(), c->getAutoJoin()));
 	}
-	sendProtocolItem(event);
+	sendProtocolItem(new Event_ListChatChannels(eventChannelList));
 	
 	acceptsChatChannelListChanges = true;
 	return RespOk;
@@ -193,11 +194,11 @@ ResponseCode Server_ProtocolHandler::cmdChatSay(Command_ChatSay *cmd, Server_Cha
 
 ResponseCode Server_ProtocolHandler::cmdListGames(Command_ListGames * /*cmd*/)
 {
-	Event_ListGames *event = new Event_ListGames;
 	const QList<Server_Game *> &gameList = server->getGames();
+	QList<ServerInfo_Game *> eventGameList;
 	for (int i = 0; i < gameList.size(); ++i) {
 		Server_Game *g = gameList[i];
-		event->addGame(
+		eventGameList.append(new ServerInfo_Game(
 			g->getGameId(),
 			g->getDescription(),
 			!g->getPassword().isEmpty(),
@@ -206,9 +207,9 @@ ResponseCode Server_ProtocolHandler::cmdListGames(Command_ListGames * /*cmd*/)
 			g->getCreatorName(),
 			g->getSpectatorsAllowed(),
 			g->getSpectatorCount()
-		);
+		));
 	}
-	sendProtocolItem(event);
+	sendProtocolItem(new Event_ListGames(eventGameList));
 	
 	acceptsGameListChanges = true;
 	return RespOk;
@@ -253,7 +254,7 @@ ResponseCode Server_ProtocolHandler::cmdDeckSelect(Command_DeckSelect *cmd, Serv
 	if (cmd->getDeckId() == -1) {
 		if (!cmd->getDeck())
 			return RespInvalidData;
-		deck = cmd->getDeck();
+		deck = new DeckList(cmd->getDeck());
 	} else {
 		try {
 			deck = getDeckFromDatabase(cmd->getDeckId());
@@ -265,7 +266,7 @@ ResponseCode Server_ProtocolHandler::cmdDeckSelect(Command_DeckSelect *cmd, Serv
 	
 	game->sendGameEvent(new Event_DeckSelect(-1, player->getPlayerId(), cmd->getDeckId()));
 	
-	sendProtocolItem(new Response_DeckDownload(cmd->getCmdId(), RespOk, deck));
+	sendProtocolItem(new Response_DeckDownload(cmd->getCmdId(), RespOk, new DeckList(deck)));
 	return RespNothing;
 }
 
@@ -427,7 +428,7 @@ ResponseCode Server_ProtocolHandler::cmdCreateArrow(Command_CreateArrow *cmd, Se
 
 	Server_Arrow *arrow = new Server_Arrow(player->newArrowId(), startCard, targetCard, cmd->getColor());
 	player->addArrow(arrow);
-	game->sendGameEvent(new Event_CreateArrow(-1, player->getPlayerId(), new ServerInfo_Arrow(
+	game->sendGameEvent(new Event_CreateArrows(-1, player->getPlayerId(), QList<ServerInfo_Arrow *>() << new ServerInfo_Arrow(
 		arrow->getId(),
 		startPlayer->getPlayerId(),
 		startZone->getName(),
@@ -500,7 +501,7 @@ ResponseCode Server_ProtocolHandler::cmdCreateCounter(Command_CreateCounter *cmd
 {
 	Server_Counter *c = new Server_Counter(player->newCounterId(), cmd->getCounterName(), cmd->getColor(), cmd->getRadius(), cmd->getValue());
 	player->addCounter(c);
-	game->sendGameEvent(new Event_CreateCounter(-1, player->getPlayerId(), new ServerInfo_Counter(c->getId(), c->getName(), c->getColor(), c->getRadius(), c->getCount())));
+	game->sendGameEvent(new Event_CreateCounters(-1, player->getPlayerId(), QList<ServerInfo_Counter *>() << new ServerInfo_Counter(c->getId(), c->getName(), c->getColor(), c->getRadius(), c->getCount())));
 	
 	return RespOk;
 }

servatrice/servatrice.pro

@@ -14,6 +14,7 @@ QT += network sql
 
 HEADERS += src/servatrice.h \
 	src/serversocketinterface.h \
+	../common/serializable_item.h \
 	../common/decklist.h \
 	../common/protocol.h \
 	../common/protocol_items.h \
@@ -33,6 +34,7 @@ HEADERS += src/servatrice.h \
 SOURCES += src/main.cpp \
 	src/servatrice.cpp \
 	src/serversocketinterface.cpp \
+	../common/serializable_item.cpp \
 	../common/decklist.cpp \
 	../common/protocol.cpp \
 	../common/protocol_items.cpp \

servatrice/src/serversocketinterface.cpp

@@ -29,7 +29,7 @@
 #include "server_player.h"
 
 ServerSocketInterface::ServerSocketInterface(Servatrice *_server, QTcpSocket *_socket, QObject *parent)
-	: Server_ProtocolHandler(_server, parent), servatrice(_server), socket(_socket), currentItem(0)
+	: Server_ProtocolHandler(_server, parent), servatrice(_server), socket(_socket), topLevelItem(0)
 {
 	xmlWriter = new QXmlStreamWriter;
 	xmlWriter->setDevice(socket);
@@ -57,41 +57,31 @@ ServerSocketInterface::~ServerSocketInterface()
 	delete socket;
 }
 
-void ServerSocketInterface::itemFinishedReading()
+void ServerSocketInterface::processProtocolItem(ProtocolItem *item)
 {
-	Command *command = qobject_cast<Command *>(currentItem);
-	if (qobject_cast<InvalidCommand *>(command))
+	Command *command = qobject_cast<Command *>(item);
+	if (!command)
 		sendProtocolItem(new ProtocolResponse(command->getCmdId(), RespInvalidCommand));
 	else
 		processCommand(command);
-	currentItem = 0;
 }
 
 void ServerSocketInterface::readClient()
 {
 	xmlReader->addData(socket->readAll());
 	
-	if (currentItem) {
-		if (!currentItem->read(xmlReader))
-			return;
-		itemFinishedReading();
-	}
-	while (!xmlReader->atEnd()) {
-		xmlReader->readNext();
-		if (xmlReader->isStartElement()) {
-			QString itemType = xmlReader->name().toString();
-			if (itemType == "cockatrice_client_stream")
-				continue;
-			QString itemName = xmlReader->attributes().value("name").toString();
-			qDebug() << "parseXml: startElement: " << "type =" << itemType << ", name =" << itemName;
-			currentItem = ProtocolItem::getNewItem(itemType + itemName);
-			if (!currentItem)
-				currentItem = new InvalidCommand;
-			if (!currentItem->read(xmlReader))
-				return;
-			itemFinishedReading();
+	if (topLevelItem)
+		topLevelItem->read(xmlReader);
+	else
+		while (!xmlReader->atEnd()) {
+			xmlReader->readNext();
+			if (xmlReader->isStartElement() && (xmlReader->name().toString() == "cockatrice_client_stream")) {
+				topLevelItem = new TopLevelProtocolItem;
+				connect(topLevelItem, SIGNAL(protocolItemReceived(ProtocolItem *)), this, SLOT(processProtocolItem(ProtocolItem *)));
+				
+				topLevelItem->read(xmlReader);
+			}
 		}
-	}
 }
 
 void ServerSocketInterface::catchSocketError(QAbstractSocket::SocketError socketError)
@@ -147,7 +137,7 @@ bool ServerSocketInterface::deckListHelper(DeckList_Directory *folder)
 	
 	while (query.next()) {
 		DeckList_Directory *newFolder = new DeckList_Directory(query.value(1).toString(), query.value(0).toInt());
-		folder->append(newFolder);
+		folder->appendItem(newFolder);
 		if (!deckListHelper(newFolder))
 			return false;
 	}
@@ -160,7 +150,7 @@ bool ServerSocketInterface::deckListHelper(DeckList_Directory *folder)
 	
 	while (query.next()) {
 		DeckList_File *newFile = new DeckList_File(query.value(1).toString(), query.value(0).toInt(), query.value(2).toDateTime());
-		folder->append(newFile);
+		folder->appendItem(newFile);
 	}
 	
 	return true;
@@ -266,7 +256,7 @@ ResponseCode ServerSocketInterface::cmdDeckUpload(Command_DeckUpload *cmd)
 	QString deckContents;
 	QXmlStreamWriter deckWriter(&deckContents);
 	deckWriter.writeStartDocument();
-	cmd->getDeck()->writeElement(&deckWriter);
+	cmd->getDeck()->write(&deckWriter);
 	deckWriter.writeEndDocument();
 	
 	QString deckName = cmd->getDeck()->getName();
@@ -281,8 +271,6 @@ ResponseCode ServerSocketInterface::cmdDeckUpload(Command_DeckUpload *cmd)
 	query.bindValue(":content", deckContents);
 	servatrice->execSqlQuery(query);
 	
-	delete cmd->getDeck();
-	
 	sendProtocolItem(new Response_DeckUpload(cmd->getCmdId(), RespOk, new DeckList_File(deckName, query.lastInsertId().toInt(), QDateTime::currentDateTime())));
 	return RespNothing;
 }
@@ -302,8 +290,7 @@ DeckList *ServerSocketInterface::getDeckFromDatabase(int deckId)
 	
 	QXmlStreamReader deckReader(query.value(0).toString());
 	DeckList *deck = new DeckList;
-	if (!deck->loadFromXml(&deckReader))
-		throw RespInvalidData;
+	deck->loadFromXml(&deckReader);
 	
 	return deck;
 }
@@ -317,6 +304,5 @@ ResponseCode ServerSocketInterface::cmdDeckDownload(Command_DeckDownload *cmd)
 		return r;
 	}
 	sendProtocolItem(new Response_DeckDownload(cmd->getCmdId(), RespOk, deck));
-	delete deck;
 	return RespNothing;
 }

servatrice/src/serversocketinterface.h

@@ -28,6 +28,7 @@ class Servatrice;
 class QXmlStreamReader;
 class QXmlStreamWriter;
 class DeckList;
+class TopLevelProtocolItem;
 
 class ServerSocketInterface : public Server_ProtocolHandler
 {
@@ -35,12 +36,13 @@ class ServerSocketInterface : public Server_ProtocolHandler
 private slots:
 	void readClient();
 	void catchSocketError(QAbstractSocket::SocketError socketError);
+	void processProtocolItem(ProtocolItem *item);
 private:
 	Servatrice *servatrice;
 	QTcpSocket *socket;
 	QXmlStreamWriter *xmlWriter;
 	QXmlStreamReader *xmlReader;
-	ProtocolItem *currentItem;
+	TopLevelProtocolItem *topLevelItem;
 
 	int getDeckPathId(int basePathId, QStringList path);
 	int getDeckPathId(const QString &path);
@@ -53,8 +55,6 @@ private:
 	ResponseCode cmdDeckUpload(Command_DeckUpload *cmd);
 	DeckList *getDeckFromDatabase(int deckId);
 	ResponseCode cmdDeckDownload(Command_DeckDownload *cmd);
-	
-	void itemFinishedReading();
 public:
 	ServerSocketInterface(Servatrice *_server, QTcpSocket *_socket, QObject *parent = 0);
 	~ServerSocketInterface();