diff options
author | 2021-11-15 04:15:13 +1100 | |
---|---|---|
committer | 2021-11-15 04:15:13 +1100 | |
commit | 44ec6d2e0ee569202b75b73eea40972595866779 (patch) | |
tree | b286443c264704198789514e0594dc24b3ca9f96 /3rdparty/asio/src/examples/cpp11/timers/time_t_timer.cpp | |
parent | 137f254b918f1f1ebee43dfbed86793b0dae73eb (diff) |
3rdparty: Updated ASIO to version 1.20.0.
The doc folder isn't included as it's pretty big.
This required include/asio/detail/win_iocp_socket_accept_op.hpp due to
mismatched order in the member declarations and initialiser list for the
win_iocp_socket_accept_op class. I reversed the declaration order so it
matches win_iocp_socket_move_accept_op.
Diffstat (limited to '3rdparty/asio/src/examples/cpp11/timers/time_t_timer.cpp')
-rw-r--r-- | 3rdparty/asio/src/examples/cpp11/timers/time_t_timer.cpp | 106 |
1 files changed, 106 insertions, 0 deletions
diff --git a/3rdparty/asio/src/examples/cpp11/timers/time_t_timer.cpp b/3rdparty/asio/src/examples/cpp11/timers/time_t_timer.cpp new file mode 100644 index 00000000000..764ca586d1b --- /dev/null +++ b/3rdparty/asio/src/examples/cpp11/timers/time_t_timer.cpp @@ -0,0 +1,106 @@ +// +// time_t_timer.cpp +// ~~~~~~~~~~~~~~~~ +// +// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff 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) +// + +#include <asio.hpp> +#include <ctime> +#include <chrono> +#include <iostream> + +// A custom implementation of the Clock concept from the standard C++ library. +struct time_t_clock +{ + // The duration type. + typedef std::chrono::steady_clock::duration duration; + + // The duration's underlying arithmetic representation. + typedef duration::rep rep; + + // The ratio representing the duration's tick period. + typedef duration::period period; + + // An absolute time point represented using the clock. + typedef std::chrono::time_point<time_t_clock> time_point; + + // The clock is not monotonically increasing. + static constexpr bool is_steady = false; + + // Get the current time. + static time_point now() noexcept + { + return time_point() + std::chrono::seconds(std::time(0)); + } +}; + +// The asio::basic_waitable_timer template accepts an optional WaitTraits +// template parameter. The underlying time_t clock has one-second granularity, +// so these traits may be customised to reduce the latency between the clock +// ticking over and a wait operation's completion. When the timeout is near +// (less than one second away) we poll the clock more frequently to detect the +// time change closer to when it occurs. The user can select the appropriate +// trade off between accuracy and the increased CPU cost of polling. In extreme +// cases, a zero duration may be returned to make the timers as accurate as +// possible, albeit with 100% CPU usage. +struct time_t_wait_traits +{ + // Determine how long until the clock should be next polled to determine + // whether the duration has elapsed. + static time_t_clock::duration to_wait_duration( + const time_t_clock::duration& d) + { + if (d > std::chrono::seconds(1)) + return d - std::chrono::seconds(1); + else if (d > std::chrono::seconds(0)) + return std::chrono::milliseconds(10); + else + return std::chrono::seconds(0); + } + + // Determine how long until the clock should be next polled to determine + // whether the absoluate time has been reached. + static time_t_clock::duration to_wait_duration( + const time_t_clock::time_point& t) + { + return to_wait_duration(t - time_t_clock::now()); + } +}; + +typedef asio::basic_waitable_timer< + time_t_clock, time_t_wait_traits> time_t_timer; + +int main() +{ + try + { + asio::io_context io_context; + + time_t_timer timer(io_context); + + timer.expires_after(std::chrono::seconds(5)); + std::cout << "Starting synchronous wait\n"; + timer.wait(); + std::cout << "Finished synchronous wait\n"; + + timer.expires_after(std::chrono::seconds(5)); + std::cout << "Starting asynchronous wait\n"; + timer.async_wait( + [](const std::error_code& /*error*/) + { + std::cout << "timeout\n"; + }); + io_context.run(); + std::cout << "Finished asynchronous wait\n"; + } + catch (std::exception& e) + { + std::cout << "Exception: " << e.what() << "\n"; + } + + return 0; +} |