eliminate using namespace

src/AsyncUtils.cc

@@ -7,15 +7,12 @@
 #include <phosg/Strings.hh>
 #include <string>
 
-using namespace std;
-
-AsyncEvent::AsyncEvent(asio::any_io_executor ex)
-    : executor(ex), is_set(false) {}
+AsyncEvent::AsyncEvent(asio::any_io_executor ex) : executor(ex), is_set(false) {}
 
 void AsyncEvent::set() {
   std::vector<std::unique_ptr<asio::detail::awaitable_handler<asio::any_io_executor>>> waiters_to_resume;
   {
-    lock_guard g(this->lock);
+    std::lock_guard g(this->lock);
     this->is_set = true;
     this->waiters.swap(waiters_to_resume);
   }
@@ -28,7 +25,7 @@ void AsyncEvent::set() {
 }
 
 void AsyncEvent::clear() {
-  lock_guard g(this->lock);
+  std::lock_guard g(this->lock);
   this->is_set = false;
 }
 
@@ -36,11 +33,12 @@ asio::awaitable<void> AsyncEvent::wait() {
   auto token = asio::use_awaitable_t<>{};
   co_await asio::async_initiate<asio::use_awaitable_t<>, void()>(
       [this](auto&& handler) -> void {
-        lock_guard g(this->lock);
+        std::lock_guard g(this->lock);
         if (this->is_set) {
           handler();
         } else {
-          this->waiters.emplace_back(make_unique<asio::detail::awaitable_handler<asio::any_io_executor>>(std::move(handler)));
+          this->waiters.emplace_back(
+              std::make_unique<asio::detail::awaitable_handler<asio::any_io_executor>>(std::move(handler)));
         }
       },
       token);
@@ -49,17 +47,17 @@ asio::awaitable<void> AsyncEvent::wait() {
 AsyncSocketReader::AsyncSocketReader(asio::ip::tcp::socket&& sock)
     : sock(std::move(sock)) {}
 
-asio::awaitable<string> AsyncSocketReader::read_line(const char* delimiter, size_t max_length) {
+asio::awaitable<std::string> AsyncSocketReader::read_line(const char* delimiter, size_t max_length) {
   size_t delimiter_size = strlen(delimiter);
   if (delimiter_size == 0) {
-    throw logic_error("delimiter is empty");
+    throw std::logic_error("delimiter is empty");
   }
   size_t delimiter_backup_bytes = delimiter_size - 1;
 
   size_t delimiter_pos = this->pending_data.find(delimiter);
-  while ((delimiter_pos == string::npos) && (!max_length || (this->pending_data.size() < max_length))) {
+  while ((delimiter_pos == std::string::npos) && (!max_length || (this->pending_data.size() < max_length))) {
     size_t pre_size = this->pending_data.size();
-    this->pending_data.resize(min(max_length, this->pending_data.size() + 0x400));
+    this->pending_data.resize(std::min(max_length, this->pending_data.size() + 0x400));
 
     auto buf = asio::buffer(this->pending_data.data() + pre_size, this->pending_data.size() - pre_size);
     size_t bytes_read = co_await this->sock.async_read_some(buf, asio::use_awaitable);
@@ -69,18 +67,18 @@ asio::awaitable<string> AsyncSocketReader::read_line(const char* delimiter, size
         (delimiter_backup_bytes > pre_size) ? 0 : (pre_size - delimiter_backup_bytes));
   }
 
-  if (delimiter_pos == string::npos) {
-    throw runtime_error("line exceeds max length");
+  if (delimiter_pos == std::string::npos) {
+    throw std::runtime_error("line exceeds max length");
   }
 
   // TODO: It's not great that we copy the data here. There's probably a more idiomatic and efficient way to do this.
-  string ret = this->pending_data.substr(0, delimiter_pos);
+  std::string ret = this->pending_data.substr(0, delimiter_pos);
   this->pending_data = this->pending_data.substr(delimiter_pos + delimiter_size);
   co_return ret;
 }
 
-asio::awaitable<string> AsyncSocketReader::read_data(size_t size) {
-  string ret;
+asio::awaitable<std::string> AsyncSocketReader::read_data(size_t size) {
+  std::string ret;
   if (this->pending_data.size() == size) {
     this->pending_data.swap(ret);
   } else if (this->pending_data.size() > size) {
@@ -111,7 +109,7 @@ asio::awaitable<void> AsyncSocketReader::read_data_into(void* data, size_t size)
   }
 }
 
-void AsyncWriteCollector::add(string&& data) {
+void AsyncWriteCollector::add(std::string&& data) {
   const auto& item = this->owned_data.emplace_back(std::move(data));
   bufs.emplace_back(asio::buffer(item.data(), item.size()));
 }
@@ -121,14 +119,14 @@ void AsyncWriteCollector::add_reference(const void* data, size_t size) {
 }
 
 asio::awaitable<void> AsyncWriteCollector::write(asio::ip::tcp::socket& sock) {
-  deque<string> local_owned_data;
+  std::deque<std::string> local_owned_data;
   local_owned_data.swap(this->owned_data);
-  vector<asio::const_buffer> local_bufs;
+  std::vector<asio::const_buffer> local_bufs;
   local_bufs.swap(this->bufs);
   co_await asio::async_write(sock, local_bufs, asio::use_awaitable);
 }
 
-asio::awaitable<void> async_sleep(chrono::steady_clock::duration duration) {
+asio::awaitable<void> async_sleep(std::chrono::steady_clock::duration duration) {
   asio::steady_timer timer(co_await asio::this_coro::executor, duration);
   co_await timer.async_wait(asio::use_awaitable);
 }