FM / detail

/usr/include/boost/beast/core/detail

Name	Size	Mode	Actions
impl/	-	0755	rm
allocator.hpp	945	0644	edit dl rm
async_base.hpp	901	0644	edit dl rm
base64.hpp	1942	0644	edit dl rm
base64.ipp	6170	0644	edit dl rm
bind_continuation.hpp	3504	0644	edit dl rm
bind_default_executor.hpp	3243	0644	edit dl rm
bind_handler.hpp	10959	0644	edit dl rm
buffer.hpp	1825	0644	edit dl rm
buffers_pair.hpp	2636	0644	edit dl rm
buffers_range_adaptor.hpp	2651	0644	edit dl rm
buffers_ref.hpp	1648	0644	edit dl rm
buffer_traits.hpp	2095	0644	edit dl rm
chacha.hpp	4167	0644	edit dl rm
char_buffer.hpp	1407	0644	edit dl rm
clamp.hpp	1229	0644	edit dl rm
config.hpp	2884	0644	edit dl rm
cpu_info.hpp	1787	0644	edit dl rm
flat_stream.hpp	1919	0644	edit dl rm
get_io_context.hpp	2338	0644	edit dl rm
is_invocable.hpp	1888	0644	edit dl rm
ostream.hpp	7004	0644	edit dl rm
pcg.hpp	1464	0644	edit dl rm
read.hpp	9217	0644	edit dl rm
remap_post_to_defer.hpp	2152	0644	edit dl rm
service_base.hpp	850	0644	edit dl rm
sha1.hpp	1624	0644	edit dl rm
sha1.ipp	7998	0644	edit dl rm
static_const.hpp	1154	0644	edit dl rm
static_ostream.hpp	3030	0644	edit dl rm
static_string.hpp	3030	0644	edit dl rm
stream_base.hpp	2685	0644	edit dl rm
stream_traits.hpp	2796	0644	edit dl rm
string.hpp	898	0644	edit dl rm
temporary_buffer.hpp	1611	0644	edit dl rm
tuple.hpp	2194	0644	edit dl rm
type_traits.hpp	2779	0644	edit dl rm
variant.hpp	4889	0644	edit dl rm
varint.hpp	1712	0644	edit dl rm
win32_unicode_path.hpp	2148	0644	edit dl rm
work_guard.hpp	1851	0644	edit dl rm

Edit: /usr/include/boost/beast/core/detail/stream_base.hpp (2685B)

#ifndef BOOST_BEAST_CORE_DETAIL_STREAM_BASE_HPP
#define BOOST_BEAST_CORE_DETAIL_STREAM_BASE_HPP

#include <boost/asio/steady_timer.hpp>
#include <boost/assert.hpp>
#include <boost/core/exchange.hpp>
#include <chrono>
#include <cstdint>
#include <utility>

namespace boost {
namespace beast {
namespace detail {

struct any_endpoint
{
    template<class Error, class Endpoint>
    bool
    operator()(
        Error const&, Endpoint const&) const noexcept
    {
        return true;
    }
};

struct stream_base
{
    using clock_type = std::chrono::steady_clock;
    using time_point = typename
        std::chrono::steady_clock::time_point;
    using tick_type = std::uint64_t;

struct op_state
    {
        net::steady_timer timer;    // for timing out
        tick_type tick = 0;         // counts waits
        bool pending = false;       // if op is pending
        bool timeout = false;       // if timed out

template<class... Args>
        explicit
        op_state(Args&&... args)
            : timer(std::forward<Args>(args)...)
        {
        }
    };

class pending_guard
    {
        bool& b_;
        bool clear_ = true;

public:
        ~pending_guard()
        {
            if(clear_)
                b_ = false;
        }

explicit
        pending_guard(bool& b)
            : b_(b)
        {
            // If this assert goes off, it means you are attempting
            // to issue two of the same asynchronous I/O operation
            // at the same time, without waiting for the first one
            // to complete. For example, attempting two simultaneous
            // calls to async_read_some. Only one pending call of
            // each I/O type (read and write) is permitted.
            //
            BOOST_ASSERT(! b_);
            b_ = true;
        }

pending_guard(
            pending_guard&& other) noexcept
            : b_(other.b_)
            , clear_(boost::exchange(
                other.clear_, false))
        {
        }

void
        reset()
        {
            BOOST_ASSERT(clear_);
            b_ = false;
            clear_ = false;
        }
    };

static time_point never() noexcept
    {
        return (time_point::max)();
    }

static std::size_t constexpr no_limit =
        (std::numeric_limits<std::size_t>::max)();
};

} // detail
} // beast
} // boost

#endif

// // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // 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) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_DETAIL_STREAM_BASE_HPP #define BOOST_BEAST_CORE_DETAIL_STREAM_BASE_HPP #include #include #include #include #include #include namespace boost { namespace beast { namespace detail { struct any_endpoint { template bool operator()( Error const&, Endpoint const&) const noexcept { return true; } }; struct stream_base { using clock_type = std::chrono::steady_clock; using time_point = typename std::chrono::steady_clock::time_point; using tick_type = std::uint64_t; struct op_state { net::steady_timer timer; // for timing out tick_type tick = 0; // counts waits bool pending = false; // if op is pending bool timeout = false; // if timed out template explicit op_state(Args&&... args) : timer(std::forward(args)...) { } }; class pending_guard { bool& b_; bool clear_ = true; public: ~pending_guard() { if(clear_) b_ = false; } explicit pending_guard(bool& b) : b_(b) { // If this assert goes off, it means you are attempting // to issue two of the same asynchronous I/O operation // at the same time, without waiting for the first one // to complete. For example, attempting two simultaneous // calls to async_read_some. Only one pending call of // each I/O type (read and write) is permitted. // BOOST_ASSERT(! b_); b_ = true; } pending_guard( pending_guard&& other) noexcept : b_(other.b_) , clear_(boost::exchange( other.clear_, false)) { } void reset() { BOOST_ASSERT(clear_); b_ = false; clear_ = false; } }; static time_point never() noexcept { return (time_point::max)(); } static std::size_t constexpr no_limit = (std::numeric_limits::max)(); }; } // detail } // beast } // boost #endif