boost asio et serialisation
Bonjour à tous,
J'ai repris l'exemple simple fourni par le site de boost "daytime" permettant d'envoyer simplement la date et l'heure du jour.
jusque la tout ce passe très bien le code fonctionne à merveille.
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
class tcp_connection
: public boost::enable_shared_from_this<tcp_connection>
{
public:
std::string make_daytime_string()
{
using namespace std; // For time_t, time and ctime;
time_t now = time(0);
return ctime(&now);
}
typedef boost::shared_ptr<tcp_connection> pointer;
static pointer create(boost::asio::io_service& io_service)
{
return pointer(new tcp_connection(io_service));
}
tcp::socket& socket()
{
return socket_;
}
void start()
{
int i = 0;
char s[20];
std::string res = "";
while (1) {
res = itoa(i++, s, 10);
message_ = make_daytime_string() + res;
boost::asio::async_write(socket_, boost::asio::buffer( message_),
boost::bind(&tcp_connection::handle_write, shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred));
boost::this_thread::sleep(boost::posix_time::milliseconds(1000));
}
}
private:
tcp_connection(boost::asio::io_service& io_service)
: socket_(io_service)
{
}
void handle_write(const boost::system::error_code& /*error*/,
size_t /*bytes_transferred*/)
{
}
tcp::socket socket_;
std::string message_;
}; |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
class tcp_server
{
public:
tcp_server(boost::asio::io_service& io_service)
: acceptor_(io_service, tcp::endpoint(tcp::v4(), 13))
{
start_accept();
}
private:
void start_accept()
{
tcp_connection::pointer new_connection =
tcp_connection::create(acceptor_.get_io_service());
acceptor_.async_accept(new_connection->socket(),
boost::bind(&tcp_server::handle_accept, this, new_connection,
boost::asio::placeholders::error));
}
void handle_accept(tcp_connection::pointer new_connection,
const boost::system::error_code& error)
{
if (!error)
{
new_connection->start();
}
start_accept();
}
tcp::acceptor acceptor_;
}; |
et mon client:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| void main(int argc, char *argv[]) {
if (argc != 3)
{
std::cerr << "Usage: client <host>" << std::endl;
}
boost::asio::io_service io_service;
tcp::resolver resolver(io_service);
tcp::resolver::query query(argv[2], "daytime");
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
tcp::socket socket(io_service);
boost::asio::connect(socket, endpoint_iterator);
while (1)
{
boost::array<char, 128> buf;
boost::system::error_code error;
size_t len = socket.read_some(boost::asio::buffer(buf), error);
std::cout.write(buf.data(), len);
}
} |
maintenant j'aimerai passer un object un peu plus complexe qu'une string et c'est la que je bloque.
je creer une structure
Code:
1
2
3
4
5
|
struct message by[sizeof member] =
{
{ "toto", "tutu" },
}; |
et j'aimerai passer cette structure dans ma socket.
j'ai donc pensé a la serialiser mais j'ai une contrainte, celle d'etre sous visual studio 2013 qui seemble rencontrer des bugs avec la serialization de boost.
Citation:
Known Bugs with Visual Studio 2013/Visual C++ 12
Visual Studio 2013 was released quite late in the release process, so there exist several unresolved issues. These include:
- Serialization can't compile because of a missing include.
- Using has_member_function_callable_with from Boost.Container's allocator_traits causes a compile error (#9332).
- In libraries such as Unordered and MultiIndex, calling overloaded functions with initializer lists can result in a compile error, with Visual C++ claiming that the overloads are ambiguous. This is a Visual C++ bug and it isn't clear if there's a good workaround. This won't affect code that doesn't use initializer lists, or uses an initializer list that doesn't require an implicit conversion (i.e. an initializer list of the container's exact value type).
- Thread: ex_scoped_thread compile fails (#9333).
Donc on y va pour la serialisation à la main et c'est la ou j'ai besoin de vous.
si je reprend ma classe tcp_connection
j'y ajoute une fonction de serialisation:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
size_t serialize(unsigned char *dst, const struct message *object)
{
size_t i = 0;
memcpy(&dst[i], &object->id, sizeof object->id);
i += sizeof object->id;
memcpy(&dst[i], &object->content, sizeof object->content);
i += sizeof object->content;
return i;
} |
et la je bloque et ne sait plustrop quoi faire avec ca... donc si vous avez conseils et/ou idées
merci d'avance
