I am trying to make a http call using boost beast and want to write it before writing to socket; i tried to use ostringstream to get the value of request to get it in printed log and getting the below error message:
string verb = "POST";
using http::field;
http::request<http::string_body> request;
request.method_string(verb);
request.target(server_endpoint);
request.version(11);
request.set(field::host, hostname);
request.set(field::accept, "*/*");
request.set(field::authorization, authorization_token);
request.set(field::user_agent, client_name);
request.set(field::content_length, req_str.length());
request.set(field::content_type, "application/x-www-form-urlencoded");
request.set(field::connection, field::close);
request.body() = req_str;
request.prepare_payload();
fast_ostringstream oss;
oss <<"Request message" << request;
PBLOG_INFO(oss.str());
oss.clear();
HttpTracRequestHandler.cpp:78:26: error: invalid operands to binary expression ('framework::string_::fast_ostringstream' and
'http::request<http::string_body>' (aka 'boost::beast::http::message<true, boost::beast::http::basic_string_body<char,
std::char_traits<char>, std::allocator<char> >, boost::beast::http::basic_fields<std::allocator<char> > >'))
oss <<"Request message" << request;
~~~~~~~~~~~~~~~~~~~~~~~ ^ ~~~~~~~
/BARXPBViewstore/GIT_Workspace/barx_rel/mq8_barx/barx-server/appl/include/FoxException/GenericException.h:133:19: note: candidate function
[with TData = boost::beast::http::message<true, boost::beast::http::basic_string_body<char, std::char_traits<char>,
std::allocator<char> >, boost::beast::http::basic_fields<std::allocator<char> > >] not viable: no known conversion from
'framework::string_::fast_ostringstream' to 'GenericException &' for 1st argument
GenericException& operator<<(GenericException &e, const TData& data)
^
/BARXPBViewstore/GIT_Workspace/boost/boost_1_70_0/boost/beast/http/impl/write.hpp:921:1: note: candidate function [with isRequest = true,
Body = boost::beast::http::basic_string_body<char, std::char_traits<char>, std::allocator<char> >, Fields =
boost::beast::http::basic_fields<std::allocator<char> >] not viable: no known conversion from 'framework::string_::fast_ostringstream'
to 'std::ostream &' (aka 'basic_ostream<char> &') for 1st argument
operator<<(std::ostream& os,
^
/BARXPBViewstore/GIT_Workspace/boost/boost_1_70_0/boost/beast/http/write.hpp:721:1: note: candidate function [with isRequest = true, Fields
= boost::beast::http::basic_fields<std::allocator<char> >] not viable: no known conversion from
'framework::string_::fast_ostringstream' to 'std::ostream &' (aka 'basic_ostream<char> &') for 1st argument
operator<<(std::ostream& os,
^
/BARXPBViewstore/GIT_Workspace/boost/boost_1_70_0/boost/beast/http/impl/write.hpp:901:1: note: candidate function [with Fields =
boost::beast::http::basic_fields<std::allocator<char> >] not viable: no known conversion from 'framework::string_::fast_ostringstream'
to 'std::ostream &' (aka 'basic_ostream<char> &') for 1st argument
Your code looks normal. In fact it works with standard string streams:
#include <boost/beast/http.hpp>
#include <iostream>
#include <sstream>
namespace http = boost::beast::http;
#define PBLOG_INFO(a) do { std::clog << (a) << std::endl; } while(0);
int main() {
std::string verb = "POST", req_str = "payload";
using http::field;
http::request<http::string_body> request;
request.method_string(verb);
request.target("server_endpoint");
request.version(11);
request.set(field::host, "hostname");
request.set(field::accept, "*/*");
request.set(field::authorization, "authorization_token");
request.set(field::user_agent, "client_name");
request.set(field::content_length, req_str.length());
request.set(field::content_type, "application/x-www-form-urlencoded");
request.set(field::connection, field::close);
request.body() = req_str;
request.prepare_payload();
{
std::ostringstream oss;
oss <<"Request message " << request;
PBLOG_INFO(oss.str());
oss.clear();
}
}
Prints
Request message POST server_endpoint HTTP/1.1
Host: hostname
Accept: */*
Authorization: authorization_token
User-Agent: client_name
Content-Type: application/x-www-form-urlencoded
Connection: Close
Content-Length: 7
payload
The problem appears to be that Beast's streaming operators overloads do not apply to whatever type fast_ostringstream is. That's by design:
no known conversion from 'framework::string_::fast_ostringstream'
to 'std::ostream &' (aka 'basic_ostream<char> &')
The authors fast_ostringstream apparently cheated in the sense that it might be fast, but it definitely isn't an ostream& :).
I tried to get a similar error by creating my own cheating stream:
struct my_cheat_stream {
using Device = boost::iostreams::back_insert_device<std::string>;
using Stream = boost::iostreams::stream<Device>;
std::string buf;
Stream _impl { buf };
template <typename T> my_cheat_stream& operator<<(T&& rhs) {
_impl << std::forward<T>(rhs);
return *this;
}
std::string&& str()&& { _impl.flush(); return std::move(buf); }
std::string_view str()& { _impl.flush(); return buf; }
void clear() {
buf.clear();
_impl.clear(std::ios::failbit|std::ios::badbit);
}
};
However, it simply compiles, because, obviously, operator<< <T>() just applies. Perhaps you can fix your fast_ostringstream accordingly, or use something else.
You could use the above counter-example as leverage:
template <typename Stream> struct wrap_non_std_stream {
Stream& _wrapped;
explicit wrap_non_std_stream(Stream& ref) : _wrapped(ref) {}
template <typename T> auto& operator<<(T const& rhs) {
_wrapped << rhs;
return *this;
}
auto& operator<<(std::ostream&(*manip)(std::ostream&)) {
_wrapped << manip;
return *this;
}
};
Now you should be able to
fast_ostringstream oss;
wrap_non_std_stream woss{oss};
woss << "Request message " << request;
If the underlying stream does, it will also support manipulators:
woss << std::endl << std::fixed << std::boolalpha << std::flush;