feedc0de/boost_beast
1
0
Fork 0
forked from boostorg/beast
Code Pull Requests Activity
Files
2cfe3ba1b80c3db219b8712cb1559de8f57239fc
boost_beast/include/boost/beast/core/ostream.hpp

91 lines
2.6 KiB
C++
Raw Normal View History

New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
//
Check BOOST_NO_CXX11_THREAD_LOCAL
2019-02-21 07:00:31 -08:00
// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
Boost prep
2017-07-20 13:40:34 -07:00
// Official repository: https://github.com/boostorg/beast
//
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
Boost prep
2017-07-20 13:40:34 -07:00
#ifndef BOOST_BEAST_WRITE_OSTREAM_HPP
#define BOOST_BEAST_WRITE_OSTREAM_HPP
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
config.hpp is not a public header
2017-10-10 07:49:03 -07:00
#include <boost/beast/core/detail/config.hpp>
Boost prep
2017-07-20 13:40:34 -07:00
#include <boost/beast/core/detail/ostream.hpp>
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
#include <type_traits>
#include <streambuf>
#include <utility>
make_printable replaces buffers rename (API Change): * The function buffers is deprecated, use the new function make_printable as the replacement. Actions Required: * Replace call sites to use make_printable instead of buffers, and also include make_printable.hpp instead of ostream.hpp.
2018-12-16 14:36:17 -08:00
#ifdef BOOST_BEAST_ALLOW_DEPRECATED
#include <boost/beast/core/make_printable.hpp>
#endif
Boost prep
2017-07-20 13:40:34 -07:00
namespace boost {
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
namespace beast {
Tidy up docs
2019-03-05 12:05:00 -08:00
/** Return an output stream that formats values into a <em>DynamicBuffer</em>.
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
Tidy up docs
2019-03-05 12:05:00 -08:00
This function wraps the caller provided <em>DynamicBuffer</em> into
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
a `std::ostream` derived class, to allow `operator<<` stream style
formatting operations.
@par Example
@code
ostream(buffer) << "Hello, world!" << std::endl;
@endcode
@note Calling members of the underlying buffer before the output
stream is destroyed results in undefined behavior.
Tidy up docs
2019-03-05 12:05:00 -08:00
@param buffer An object meeting the requirements of <em>DynamicBuffer</em>
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
into which the formatted output will be placed.
Concept revision and documentation (API Change): The concept type traits are renamed for consistency, and consolidated into a single header file <beast/core/type_traits.hpp> A new section, Core Concepts, is added to the documentation describing all of the core utility classes and functions. This also includes a complete explanation and sample program describing how to write asynchronous initiation functions and their associated composed operations.
2017-05-10 12:03:00 -07:00
@return An object derived from `std::ostream` which redirects output
The wrapped dynamic buffer is not modified, a copy is made instead.
Ownership of the underlying memory is not transferred, the application
is still responsible for managing its lifetime. The caller is
responsible for ensuring the dynamic buffer is not destroyed for the
lifetime of the output stream.
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
*/
template<class DynamicBuffer>
Boost prep
2017-07-20 13:40:34 -07:00
#if BOOST_BEAST_DOXYGEN
Squashed 'doc/docca/' changes from 1bfc5ede..df9bd956 df9bd956 Add deduced alias 220ded9a Add see-below alias git-subtree-dir: doc/docca git-subtree-split: df9bd956e2480467447c80ffae3b44b3c0b0756a
2018-11-11 21:53:13 -08:00
__implementation_defined__
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
#else
detail::ostream_helper<
DynamicBuffer, char, std::char_traits<char>,
ostream workaround for gcc 4.8.4
2017-05-08 19:02:58 -07:00
detail::basic_streambuf_movable::value>
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
#endif
ostream(DynamicBuffer& buffer)
{
Update for Net-TS Asio (API Change): fix #769 The following classes are removed: * handler_type * async_result * async_completion * is_dynamic_buffer * is_const_buffer_sequence * is_mutable_buffer_sequence * handler_alloc Actions Required: * Use BOOST_ASIO_HANDLER_TYPE instead of handler_type * Use BOOST_ASIO_INITFN_RESULT_TYPE instead of async_result * Use boost::asio::async_completion * Use boost::asio::is_dynamic_buffer * Use boost::asio::is_const_buffer_sequence * Use boost::asio::is_mutable_buffer_sequence * boost::asio::associated_allocator_t replaces handler_alloc
2017-09-07 07:39:52 -07:00
static_assert(
net is a namespace alias for boost::asio: The namespace alias beast::net replaces boost::asio in all code and documentation.
2018-11-30 14:58:38 -08:00
net::is_dynamic_buffer<DynamicBuffer>::value,
Concept check tidying
2019-02-20 19:19:59 -08:00
"DynamicBuffer type requirements not met");
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
return detail::ostream_helper<
DynamicBuffer, char, std::char_traits<char>,
ostream workaround for gcc 4.8.4
2017-05-08 19:02:58 -07:00
detail::basic_streambuf_movable::value>{buffer};
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
}
make_printable replaces buffers rename (API Change): * The function buffers is deprecated, use the new function make_printable as the replacement. Actions Required: * Replace call sites to use make_printable instead of buffers, and also include make_printable.hpp instead of ostream.hpp.
2018-12-16 14:36:17 -08:00
//------------------------------------------------------------------------------
#ifdef BOOST_BEAST_ALLOW_DEPRECATED
template<class T>
detail::make_printable_adaptor<T>
buffers(T const& t)
{
return make_printable(t);
}
#else
template<class T>
void buffers(T const&)
{
static_assert(sizeof(T) == 0,
"The function buffers() is deprecated, use make_printable() instead, "
"or define BOOST_BEAST_ALLOW_DEPRECATED to silence this error.");
}
#endif
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
} // beast
Boost prep
2017-07-20 13:40:34 -07:00
} // boost
New ostream() returns dynamic buffer output stream (API Change): This eliminates beast::write output for dynamic buffers and replaces it with the function ostream() that wraps a caller provided dynamic buffer and returns the result as a std::ostream derived object. Callers may now produce formatted output into any object meeting the requirements of DynamicBuffer using operator<< and the standard stream modifiers such as std::endl. This new technique is more efficient, as implementations of operator<< can now write directly into the output using std::ostream::write and std::ostream::put. Example of use: beast::streambuf sb; beast::ostream(sb) << "Hello, world!" << std::endl;
2017-05-03 15:29:23 -07:00
#endif
Copy Permalink