ich hab da mal ne Frage:

Beim Umstellen einer Funktionalität von nativen socket-funktionen auf boost::asio stehe ich vor dem Problem, dass die normale socket write_to funktion in einem integer die Anzahl geschriebener bytes zurückgibt, womit es einfach ist, Fehler abzufangen.

Die asio::write funktion tut auch genau das, nicht aber die async_write funktion, was ja klar ist, da sie sofort zurückkehrt, bevor was geschrieben wurde.

Aber in dieser registriert man ja eine handler-funktion die aufgerufen wird, wenn der Krempel tatsächlich geschrieben wurde.

Die übernimmt einen errorcode und eine size_t, wobei ich messerscharf folgere, das diese size_t die geschriebenen bytes sind.

Mein Ansatz ist daher folgender:

void meine_klasse::handle_sento(size_t correct_size, const boost::system::error_code& error, size_t bytes_written)
{
    if (error)
        Logger::log() << "Async send failed with: " << error.message();
    if (bytes_written != correct_size)
        Logger::log() << "Async send returned wrong number of bytes written, this indicates network problems";
}

void meine_klasse::async_write(const void* data, size_t sz)
{
    m_socket.async_send_to( boost::asio::buffer((const char*)data, sz),
                            m_endpoint,
                            boost::bind(&meine_klasse::handle_send_to,
                                        this, sz,
                                        boost::asio::placeholders::error, 
                                        boost::asio::placeholders::bytes_transferred()));
}

Dieses placeholders::bytes_transferred() ist ein Schuß ins blaue, aber es _scheint_ zu funktionieren.

Vielleicht kann mir eine asio-Guru kurz sagen, ob ich auf dem richtigen Weg bin.

Zweite Frage: Ihr seht dass ich einen const void* übernehme. Die socket send_to lässt sich nämlich einfach einen void* und eine länge geben und dann schreibt sie so viele bytes wie angebene die an dieser Adresse stehen raus. Das ist für meine Anwendung sehr angenehm und funktioniert (getestet).

Wie verhält es sich mit der async_send_to funktion? Kann ich der auch rohe Daten zu fressen geben? Meine jetzige Lösung (siehe oben) scheint erstmal implizit in einen std::string zu konvertieren.
Wenn nein, wie implementiere ich ohne möglichst große chirurgische Eingriffe eine serialisierung?

Gruß,
Phil

Dieses placeholders::bytes_transferred() ist ein Schuß ins blaue, aber es _scheint_ zu funktionieren.

Vielleicht kann mir eine asio-Guru kurz sagen, ob ich auf dem richtigen Weg bin.

Wieso liest du nicht einfach die Dokumentation?
placeholders::error
placeholders::bytes_transferred

PhilippM schrieb:

Zweite Frage: Ihr seht dass ich einen const void* übernehme. Die socket send_to lässt sich nämlich einfach einen void* und eine länge geben und dann schreibt sie so viele bytes wie angebene die an dieser Adresse stehen raus. Das ist für meine Anwendung sehr angenehm und funktioniert (getestet).

Wie verhält es sich mit der async_send_to funktion? Kann ich der auch rohe Daten zu fressen geben?

Wieso liest du nicht einfach die Dokumentation?
buffer (5 of 22 overloads)

Grüssli