(cont) Typo and minor style fixes similar to recent ones.

Author: ygoldfeld

src/flow/cfg/option_set.hpp

@@ -382,7 +382,7 @@ class Option_set_base
  *
  * ### Recommended conventions ###
  * Firstly, it is recommended to store all durations in your `Value_set` as util::Fine_duration instead of using
- * coarser units like `chrono::seconds()` or even `chrono::milliseconds()`.  This tends to lead to more consistent
+ * coarser units like `chrono::seconds` or even `chrono::milliseconds`.  This tends to lead to more consistent
  * and maintainable code, in the author's (ygoldfel) opinion, as util::Fine_duration *can* store durations expressed
  * in essentially any units, without losing precision; *does* use the same underlying storage type -- `int64_t` --
  * and hence presents no performance or overflow difficulties (usually); and changing the desired units of a duration

src/flow/error/error.cpp

@@ -27,18 +27,18 @@ Runtime_error::Runtime_error(const Error_code& err_code_or_success, util::String
   // This strange-looking dichotomy is explained in ###Rationale### in m_context_if_no_code doc header.
   boost::system::system_error(err_code_or_success,
                               err_code_or_success
-                                ? std::string(context)
-                                : std::string()),
+                                ? std::string{context}
+                                : std::string{}),
   // code() == err_code_or_success, now.
   m_context_if_no_code(code()
-                         ? std::string()
-                         : std::string(context))
+                         ? std::string{}
+                         : std::string{context})
 {
   // Nothing.
 }
 
 Runtime_error::Runtime_error(util::String_view context) :
-  Runtime_error(Error_code(), context) // Our formal contract is to be equivalent to this.
+  Runtime_error(Error_code{}, context) // Our formal contract is to be equivalent to this.
 {
   // Nothing.
 }

src/flow/error/error.hpp

@@ -37,7 +37,7 @@ namespace flow::error
  * ### Rationale ###
  * It is questionable whether Runtime_error is really necessary.  One can equally well simply throw
  * `boost::system::system_error(err_code, context)` when `bool(err_code) == true`, and
- * `std::runtime_error(context)` otherwise.  Indeed the user should feel 100% free to do that if desired.
+ * `std::runtime_error{context}` otherwise.  Indeed the user should feel 100% free to do that if desired.
  * flow::error::Runtime_error is mere syntactic sugar for code brevity, when one indeed has an `err_code` that may
  * or may not be falsy: they can just construct+throw a Runtime_error and not worry about the bifurcation.
  * In the end one likely just catches `std::exception exc` and logs/prints `exc.what()`: how precisely it was thrown

src/flow/log/buffer_logger.cpp

@@ -44,7 +44,7 @@ bool Buffer_logger::logs_asynchronously() const // Virtual.
 void Buffer_logger::do_log(Msg_metadata* metadata, util::String_view msg) // Virtual.
 {
   // Prevent simultaneous logging, reading-by-copy.
-  util::Lock_guard<decltype(m_log_mutex)> lock(m_log_mutex);
+  util::Lock_guard<decltype(m_log_mutex)> lock{m_log_mutex};
 
   // m_os_writer wraps (as of this writing) String_ostream, which wraps std::string.  Write msg+metadata to std::string.
   m_os_writer.log(*metadata, msg);
@@ -58,7 +58,7 @@ const std::string& Buffer_logger::buffer_str() const
 const std::string Buffer_logger::buffer_str_copy() const
 {
   // Prevent simultaneous logging, reading.
-  util::Lock_guard<decltype(m_log_mutex)> lock(m_log_mutex);
+  util::Lock_guard<decltype(m_log_mutex)> lock{m_log_mutex};
 
   return buffer_str(); // Copy occurs here; then mutex is unlocked.
 }

src/flow/log/simple_ostream_logger.cpp

@@ -66,7 +66,7 @@ void Simple_ostream_logger::do_log(Msg_metadata* metadata, util::String_view msg
    * line, for example.  So it still seems best to avoid any interleaving even when it's further away from our control,
    * as in that latter situation.  So just don't mess with it and always use one mutex to avoid as much interleaving
    * as we can. */
-  util::Lock_guard<decltype(m_log_mutex)> lock(m_log_mutex);
+  util::Lock_guard<decltype(m_log_mutex)> lock{m_log_mutex};
 
   /* This next part will block calling thread for however long the writing takes.
    * This is likely not an issue with cout/cerr but can be a significant issue with ofstream.  Hence why

src/flow/net_flow/asio/server_socket.hpp

@@ -275,7 +275,7 @@ void Server_socket::async_accept(const Handler& on_result)
 template<typename Handler>
 void Server_socket::async_accept(bool reactor_pattern, const Handler& on_result)
 {
-  async_accept_impl(Handler_func(on_result), Fine_time_pt{}, reactor_pattern);
+  async_accept_impl(Handler_func{on_result}, Fine_time_pt{}, reactor_pattern);
 }
 
 template<typename Rep, typename Period, typename Handler>

src/flow/net_flow/detail/cong_ctl/cong_ctl_classic_bw.cpp

@@ -24,7 +24,7 @@ namespace flow::net_flow
 
 // Use conservative start value which will be overridden with the next ACK.  (Value taken from Linux tcp_westwood.c.)
 const Send_bandwidth_estimator::Time_unit Congestion_control_classic_with_bandwidth_est::S_INIT_RTT_MIN
-  = boost::chrono::seconds(20);
+  = boost::chrono::seconds{20};
 
 // Implementations.
 

src/flow/net_flow/event_set.cpp

@@ -456,8 +456,7 @@ bool Event_set::sync_wait_impl(const Fine_duration& max_wait, Error_code* err_co
 
 bool Event_set::sync_wait(Error_code* err_code)
 {
-  using boost::chrono::microseconds;
-  return sync_wait(microseconds(microseconds::max()), err_code); // Wait indefinitely.  May throw.
+  return sync_wait(boost::chrono::microseconds::max(), err_code); // Wait indefinitely.  May throw.
 }
 
 void Event_set::close(Error_code* err_code)
@@ -736,9 +735,9 @@ Event_set::Ev_type_to_socks_map Event_set::empty_ev_type_to_socks_map() // Stati
   return Ev_type_to_socks_map
          {{
             // Linked_hash_map order is significant.  Iteration will occur in this canonical order in logs, etc.
-            { Event_type::S_PEER_SOCKET_READABLE, Sockets() },
-            { Event_type::S_PEER_SOCKET_WRITABLE, Sockets() },
-            { Event_type::S_SERVER_SOCKET_ACCEPTABLE, Sockets() }
+            { Event_type::S_PEER_SOCKET_READABLE, Sockets{} },
+            { Event_type::S_PEER_SOCKET_WRITABLE, Sockets{} },
+            { Event_type::S_SERVER_SOCKET_ACCEPTABLE, Sockets{} }
           }};
 }
 
@@ -1425,7 +1424,7 @@ void Node::interrupt_all_waits_worker()
   for (Event_set::Ptr event_set : m_event_sets)
   {
     // Work on one Event_set at a time.  Lock it.
-    Event_set::Lock_guard lock(event_set->m_mutex);
+    Event_set::Lock_guard lock{event_set->m_mutex};
 
     if (event_set->m_state == Event_set::State::S_WAITING)
     {

src/flow/net_flow/event_set.hpp

@@ -1022,7 +1022,7 @@ bool Event_set::add_wanted_socket(typename Socket::Ptr sock, Event_type ev_type,
   // We are in thread U != W.
 
   // Accessing m_state, socket sets, etc. which may be written by other threads at any time.  Must lock.
-  Lock_guard lock(m_mutex);
+  Lock_guard lock{m_mutex};
 
   FLOW_LOG_TRACE("Object [" << sock << "] wanted for event type [" << ev_type << "] in Event_set [" << this << "].");
 
@@ -1059,7 +1059,7 @@ bool Event_set::remove_wanted_socket(typename Socket::Ptr sock, Event_type ev_ty
   // We are in thread U != W.
 
   // Accessing m_state, the sets, etc. which may be written by other threads at any time.  Must lock.
-  Lock_guard lock(m_mutex);
+  Lock_guard lock{m_mutex};
 
   FLOW_LOG_TRACE("Object [" << sock << "] no longer wanted for event type [" << ev_type << "] in "
                  "Event_set [" << this << "].");

src/flow/net_flow/node.cpp

@@ -42,7 +42,7 @@ Node::Node(log::Logger* logger_ptr, const util::Udp_endpoint& low_lvl_endpoint,
   log::Log_context(this_thread_init_logger_setup("", logger_ptr),
                    Flow_log_component::S_NET_FLOW),
   /* Take the given Node_options set and copy it into our stored global options.  (Note the default
-   * is Node_options().)  The default is safe, but if they actually are providing a custom set of
+   * is Node_options{}.)  The default is safe, but if they actually are providing a custom set of
    * options, then we must validate before accepting.  This may result in a validation error.
    * If !err_code, then it'll throw exception right here.  If err_code, then it will set *err_code,
    * so we check for it inside the constructor body and exit. */
@@ -339,7 +339,7 @@ void Node::worker_run(const util::Udp_endpoint low_lvl_endpoint)
     while (!m_event_sets.empty()) // As above.
     {
       const Event_set::Ptr event_set = *m_event_sets.begin();
-      Event_set::Lock_guard lock(event_set->m_mutex); // Pre-condition for event_set_close_worker().
+      Event_set::Lock_guard lock{event_set->m_mutex}; // Pre-condition for event_set_close_worker().
       event_set_close_worker(event_set);
     }