clang-tidy modernize-.* all the things

Author: deanberris

boost/network/message/directives/remove_header.hpp

@@ -21,7 +21,7 @@ template <class T>
 struct remove_header_directive {
 
   explicit remove_header_directive(T header_name)
-      : header_name_(header_name) {};
+      : header_name_(std::move(header_name)) {};
 
   template <class MessageTag>
   void operator()(basic_message<MessageTag>& msg) const {

boost/network/protocol/http/client/async_impl.hpp

@@ -40,23 +40,23 @@ struct async_client
   async_client(bool cache_resolved, bool follow_redirect,
                bool always_verify_peer, int timeout,
                boost::shared_ptr<boost::asio::io_service> service,
-               optional<string_type> const& certificate_filename,
-               optional<string_type> const& verify_path,
-               optional<string_type> const& certificate_file,
-               optional<string_type> const& private_key_file,
-               optional<string_type> const& ciphers, long ssl_options)
+               optional<string_type>  certificate_filename,
+               optional<string_type>  verify_path,
+               optional<string_type>  certificate_file,
+               optional<string_type>  private_key_file,
+               optional<string_type>  ciphers, long ssl_options)
       : connection_base(cache_resolved, follow_redirect, timeout),
         service_ptr(service.get()
                         ? service
                         : boost::make_shared<boost::asio::io_service>()),
         service_(*service_ptr),
         resolver_(service_),
         sentinel_(new boost::asio::io_service::work(service_)),
-        certificate_filename_(certificate_filename),
-        verify_path_(verify_path),
-        certificate_file_(certificate_file),
-        private_key_file_(private_key_file),
-        ciphers_(ciphers),
+        certificate_filename_(std::move(certificate_filename)),
+        verify_path_(std::move(verify_path)),
+        certificate_file_(std::move(certificate_file)),
+        private_key_file_(std::move(private_key_file)),
+        ciphers_(std::move(ciphers)),
         ssl_options_(ssl_options),
         always_verify_peer_(always_verify_peer) {
     connection_base::resolver_strand_.reset(

boost/network/protocol/http/client/connection/async_normal.hpp

@@ -78,9 +78,9 @@ struct http_async_connection
         is_timedout_(false),
         follow_redirect_(follow_redirect),
         resolver_(resolver),
-        resolve_(resolve),
+        resolve_(std::move(resolve)),
         request_strand_(resolver.get_io_service()),
-        delegate_(delegate) {}
+        delegate_(std::move(delegate)) {}
 
   // This is the main entry point for the connection/request pipeline.
   // We're

boost/network/protocol/http/client/connection/normal_delegate.hpp

@@ -22,28 +22,29 @@ namespace impl {
 struct normal_delegate : connection_delegate {
   explicit normal_delegate(asio::io_service &service);
 
-  void connect(asio::ip::tcp::endpoint &endpoint, std::string host, boost::uint16_t source_port,
-                       function<void(system::error_code const &)> handler) override;
-  void write(
-      asio::streambuf &command_streambuf,
-      function<void(system::error_code const &, size_t)> handler) override;
-  void read_some(
-      asio::mutable_buffers_1 const &read_buffer,
-      function<void(system::error_code const &, size_t)> handler) override;
+  void connect(asio::ip::tcp::endpoint &endpoint, std::string host,
+               boost::uint16_t source_port,
+               function<void(system::error_code const &)> handler) override;
+  void write(asio::streambuf &command_streambuf,
+             function<void(system::error_code const &, size_t)> handler)
+      override;
+  void read_some(asio::mutable_buffers_1 const &read_buffer,
+                 function<void(system::error_code const &, size_t)> handler)
+      override;
   void disconnect() override;
-  ~normal_delegate() override;
+  ~normal_delegate() override = default;
+
+  normal_delegate(normal_delegate const &) = delete;
+  normal_delegate &operator=(normal_delegate) = delete;
 
  private:
   asio::io_service &service_;
   std::unique_ptr<asio::ip::tcp::socket> socket_;
-
-  normal_delegate(normal_delegate const &);     // = delete
-  normal_delegate &operator=(normal_delegate);  // = delete
 };
 
-} // namespace impl
-} // namespace http
+}  // namespace impl
+}  // namespace http
 }  // namespace network
-} // namespace boost
+}  // namespace boost
 
-#endif // BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_NORMAL_DELEGATE_20110819
+#endif  // BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_NORMAL_DELEGATE_20110819

boost/network/protocol/http/client/connection/normal_delegate.ipp

@@ -54,6 +54,4 @@ void boost::network::http::impl::normal_delegate::disconnect() {
   }
 }
 
-boost::network::http::impl::normal_delegate::~normal_delegate() {}
-
 #endif  // BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_NORMAL_DELEGATE_IPP_20110819

boost/network/protocol/http/client/connection/ssl_delegate.ipp

@@ -20,11 +20,11 @@ boost::network::http::impl::ssl_delegate::ssl_delegate(
     optional<std::string> ciphers,
     long ssl_options)
     : service_(service),
-      certificate_filename_(certificate_filename),
-      verify_path_(verify_path),
-      certificate_file_(certificate_file),
-      private_key_file_(private_key_file),
-      ciphers_(ciphers),
+      certificate_filename_(std::move(certificate_filename)),
+      verify_path_(std::move(verify_path)),
+      certificate_file_(std::move(certificate_file)),
+      private_key_file_(std::move(private_key_file)),
+      ciphers_(std::move(ciphers)),
       ssl_options_(ssl_options),
       always_verify_peer_(always_verify_peer) {}
 

boost/network/protocol/http/client/connection/sync_normal.hpp

@@ -47,7 +47,7 @@ struct http_sync_connection
         timeout_(timeout),
         timer_(resolver.get_io_service()),
         resolver_(resolver),
-        resolve_(resolve),
+        resolve_(std::move(resolve)),
         socket_(resolver.get_io_service()) {}
 
   void init_socket(string_type  /*unused*/const& hostname, string_type const& port) {

boost/network/protocol/http/client/connection/sync_ssl.hpp

@@ -63,7 +63,7 @@ struct https_sync_connection
         timeout_(timeout),
         timer_(resolver.get_io_service()),
         resolver_(resolver),
-        resolve_(resolve),
+        resolve_(std::move(resolve)),
         context_(resolver.get_io_service(),
                  boost::asio::ssl::context::sslv23_client),
         socket_(resolver.get_io_service(), context_) {

boost/network/protocol/http/client/sync_impl.hpp

@@ -52,23 +52,23 @@ struct sync_client
   sync_client(
       bool cache_resolved, bool follow_redirect, bool always_verify_peer,
       int timeout, boost::shared_ptr<boost::asio::io_service> service,
-      optional<string_type> const& certificate_filename =
+      optional<string_type>  certificate_filename =
           optional<string_type>(),
-      optional<string_type> const& verify_path = optional<string_type>(),
-      optional<string_type> const& certificate_file = optional<string_type>(),
-      optional<string_type> const& private_key_file = optional<string_type>(),
-      optional<string_type> const& ciphers = optional<string_type>(),
+      optional<string_type>  verify_path = optional<string_type>(),
+      optional<string_type>  certificate_file = optional<string_type>(),
+      optional<string_type>  private_key_file = optional<string_type>(),
+      optional<string_type>  ciphers = optional<string_type>(),
       long ssl_options = 0)
       : connection_base(cache_resolved, follow_redirect, timeout),
         service_ptr(service.get() ? service
                                   : make_shared<boost::asio::io_service>()),
         service_(*service_ptr),
         resolver_(service_),
-        certificate_filename_(certificate_filename),
-        verify_path_(verify_path),
-        certificate_file_(certificate_file),
-        private_key_file_(private_key_file),
-        ciphers_(ciphers),
+        certificate_filename_(std::move(certificate_filename)),
+        verify_path_(std::move(verify_path)),
+        certificate_file_(std::move(certificate_file)),
+        private_key_file_(std::move(private_key_file)),
+        ciphers_(std::move(ciphers)),
         ssl_options_(ssl_options),
         always_verify_peer_(always_verify_peer) {}
 

boost/network/protocol/http/impl/response.ipp

@@ -108,8 +108,7 @@ struct basic_response<tags::http_server> {
     static const char crlf[] = {'\r', '\n'};
     std::vector<const_buffer> buffers;
     buffers.push_back(to_buffer(status));
-    for (std::size_t i = 0; i < headers.size(); ++i) {
-      header_type &h = headers[i];
+    for (auto & h : headers) {
       buffers.push_back(buffer(h.name));
       buffers.push_back(buffer(name_value_separator));
       buffers.push_back(buffer(h.value));

boost/network/protocol/http/policies/pooled_connection.hpp

@@ -65,7 +65,7 @@ struct pooled_connection_policy : resolver_policy<Tag>::type {
                                    ssl_options)),
           resolver_(resolver),
           connection_follow_redirect_(follow_redirect),
-          get_connection_(get_connection),
+          get_connection_(std::move(get_connection)),
           certificate_filename_(certificate_filename),
           verify_path_(verify_path),
           certificate_file_(certificate_file),

boost/network/protocol/http/server/async_connection.hpp

@@ -559,7 +559,7 @@ struct async_connection
       headers_buffer.consume(headers_buffer.size());
       headers_already_sent = true;
       thread_pool().post(callback);
-      pending_actions_list::iterator start = pending_actions.begin(),
+      auto start = pending_actions.begin(),
                                      end = pending_actions.end();
       while (start != end) {
         thread_pool().post(*start++);

boost/network/protocol/http/server/sync_connection.hpp

@@ -84,7 +84,7 @@ struct sync_connection
       if (done) {
         if (request_.method[0] == 'P') {
           // look for the content-length header
-          typename std::vector<typename request_header<Tag>::type>::iterator
+          auto
               it = std::find_if(request_.headers.begin(),
                                 request_.headers.end(), is_content_length());
           if (it == request_.headers.end()) {

boost/network/protocol/stream_handler.hpp

@@ -10,22 +10,23 @@
 #pragma once
 #endif  // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
-#include <cstddef>
-#include <boost/asio/detail/throw_error.hpp>
-#include <boost/asio/error.hpp>
 #include <boost/asio.hpp>
-#ifdef BOOST_NETWORK_ENABLE_HTTPS
-#include <boost/asio/ssl.hpp>
-#endif
-#include <boost/asio/detail/push_options.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/async_result.hpp>
+#include <boost/asio/basic_socket.hpp>
+#include <boost/asio/detail/config.hpp>
 #include <boost/asio/detail/config.hpp>
 #include <boost/asio/detail/handler_type_requirements.hpp>
+#include <boost/asio/detail/push_options.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/error.hpp>
 #include <boost/asio/stream_socket_service.hpp>
-#include <boost/asio/async_result.hpp>
 #include <boost/make_shared.hpp>
-#include <boost/asio/detail/config.hpp>
-#include <boost/asio/async_result.hpp>
-#include <boost/asio/basic_socket.hpp>
+#include <cstddef>
+
+#ifdef BOOST_NETWORK_ENABLE_HTTPS
+#include <boost/asio/ssl.hpp>
+#endif
 
 namespace boost {
 namespace network {
@@ -43,12 +44,12 @@ typedef boost::asio::ssl::context ssl_context;
 struct stream_handler {
  public:
   stream_handler(boost::shared_ptr<tcp_socket> socket)
-      : tcp_sock_(socket), ssl_enabled(false) {}
+      : tcp_sock_(std::move(socket)), ssl_enabled(false) {}
 
-  ~stream_handler() {}
+  ~stream_handler() = default;
 
   stream_handler(boost::shared_ptr<ssl_socket> socket)
-      : ssl_sock_(socket), ssl_enabled(true) {}
+      : ssl_sock_(std::move(socket)), ssl_enabled(true) {}
 
   stream_handler(boost::asio::io_service& io,
                  boost::shared_ptr<ssl_context> ctx =

boost/network/uri/directives/authority.hpp

@@ -14,8 +14,8 @@ namespace uri {
 
 struct authority_directive {
 
-  explicit authority_directive(const std::string &authority)
-      : authority_(authority) {}
+  explicit authority_directive(std::string authority)
+      : authority_(std::move(authority)) {}
 
   template <class Uri>
   void operator()(Uri &uri) const {

boost/network/uri/directives/fragment.hpp

@@ -16,8 +16,8 @@ namespace network {
 namespace uri {
 struct fragment_directive {
 
-  explicit fragment_directive(const std::string &fragment)
-      : fragment_(fragment) {}
+  explicit fragment_directive(std::string fragment)
+      : fragment_(std::move(fragment)) {}
 
   template <class Uri>
   void operator()(Uri &uri) const {

boost/network/uri/directives/host.hpp

@@ -15,7 +15,7 @@ namespace network {
 namespace uri {
 struct host_directive {
 
-  explicit host_directive(const std::string & host) : host_(host) {}
+  explicit host_directive(std::string  host) : host_(std::move(host)) {}
 
   template <class Uri>
   void operator()(Uri &uri) const {

boost/network/uri/directives/path.hpp

@@ -16,7 +16,7 @@ namespace network {
 namespace uri {
 struct path_directive {
 
-  explicit path_directive(const std::string &path) : path_(path) {}
+  explicit path_directive(std::string path) : path_(std::move(path)) {}
 
   template <class Uri>
   void operator()(Uri &uri) const {
@@ -28,7 +28,7 @@ struct path_directive {
 
 struct encoded_path_directive {
 
-  explicit encoded_path_directive(const std::string & path) : path_(path) {}
+  explicit encoded_path_directive(std::string  path) : path_(std::move(path)) {}
 
   void operator()(uri &uri_) const {
     std::string encoded_path;

boost/network/uri/directives/port.hpp

@@ -16,7 +16,7 @@ namespace network {
 namespace uri {
 struct port_directive {
 
-  explicit port_directive(const std::string &port) : port_(port) {}
+  explicit port_directive(std::string port) : port_(std::move(port)) {}
 
   explicit port_directive(boost::uint16_t port)
       : port_(boost::lexical_cast<std::string>(port)) {}

boost/network/uri/directives/query.hpp

@@ -17,7 +17,7 @@ namespace network {
 namespace uri {
 struct query_directive {
 
-  explicit query_directive(const std::string & query) : query_(query) {}
+  explicit query_directive(std::string  query) : query_(std::move(query)) {}
 
   template <class Uri>
   void operator()(Uri &uri) const {
@@ -34,8 +34,8 @@ inline query_directive query(const std::string &query) {
 
 struct query_key_query_directive {
 
-  query_key_query_directive(const std::string & key, const std::string & query)
-      : key_(key), query_(query) {}
+  query_key_query_directive(std::string  key, std::string  query)
+      : key_(std::move(key)), query_(std::move(query)) {}
 
   template <class Uri>
   void operator()(Uri &uri) const {

boost/network/uri/directives/scheme.hpp

@@ -16,7 +16,7 @@ namespace network {
 namespace uri {
 struct scheme_directive {
 
-  explicit scheme_directive(const std::string &scheme) : scheme(scheme) {}
+  explicit scheme_directive(std::string scheme) : scheme(std::move(scheme)) {}
 
   template <class Uri>
   void operator()(Uri &uri) const {

boost/network/uri/directives/user_info.hpp

@@ -15,8 +15,8 @@ namespace network {
 namespace uri {
 struct user_info_directive {
 
-  explicit user_info_directive(const std::string &user_info)
-      : user_info_(user_info) {}
+  explicit user_info_directive(std::string user_info)
+      : user_info_(std::move(user_info)) {}
 
   template <class Uri>
   void operator()(Uri &uri) const {

boost/network/uri/uri.hpp

@@ -46,7 +46,7 @@ class BOOST_URI_DECL uri {
   //    parse();
   //}
 
-  uri(const string_type &str) : uri_(str), is_valid_(false) { parse(); }
+  uri(string_type str) : uri_(std::move(str)), is_valid_(false) { parse(); }
 
   template <class FwdIter>
   uri(const FwdIter &first, const FwdIter &last)

boost/network/utils/thread_pool.hpp

@@ -35,8 +35,8 @@ struct basic_thread_pool {
                     io_service_ptr io_service = io_service_ptr(),
                     worker_threads_ptr worker_threads = worker_threads_ptr())
       : threads_(threads),
-        io_service_(io_service),
-        worker_threads_(worker_threads),
+        io_service_(std::move(io_service)),
+        worker_threads_(std::move(worker_threads)),
         sentinel_() {
     bool commit = false;
     BOOST_SCOPE_EXIT_TPL(

libs/mime/test/mime-roundtrip.cpp

@@ -107,7 +107,7 @@ test_suite *init_unit_test_suite(int, char **)
 #ifdef BOOST_TEST_DYN_LINK
       true;
 #else
-      0;
+      nullptr;
 #endif
 }