[FOLD]

Author: vinniefalco

include/boost/http_io/server/workers.hpp

@@ -100,15 +100,15 @@ class workers
         endpoint const& ep,
         bool reuse_addr = true)
     {
-        ve_.emplace_back(concurrency_, ex_, ep, reuse_addr);
+        va_.emplace_back(concurrency_, ex_, ep, reuse_addr);
     }
 
 private:
-    struct entry
+    struct acceptor
     {
         template<class... Args>
         explicit
-        entry(
+        acceptor(
             unsigned concurrency,
             Args&&... args)
             : sock(std::forward<Args>(args)...)
@@ -140,13 +140,13 @@ class workers
     void stop() override;
     void do_idle(void*) override;
     void do_accepts();
-    void on_accept(entry* e, worker* w,
-        system::error_code const& ec);
+    void on_accept(acceptor*, worker*,
+        system::error_code const&);
     void do_stop();
 
     Executor ex_;
     fixed_array<worker> vw_;
-    std::vector<entry> ve_;
+    std::vector<acceptor> va_;
     worker* idle_ = nullptr;
 
     std::size_t n_idle_ = 0;
@@ -178,13 +178,13 @@ workers(
 template<class Executor, class Worker>
 void
 workers<Executor, Worker>::
-do_idle(void* p)
+do_idle(void* pw)
 {
     asio::dispatch(ex_,
-        [this, p]()
+        [this, pw]()
         {
             worker* w = vw_.data() +
-                reinterpret_cast<std::uintptr_t>(p) /
+                reinterpret_cast<std::uintptr_t>(pw) /
                 reinterpret_cast<std::uintptr_t>(vw_.data());
             // push
             w->next = idle_;
@@ -217,19 +217,19 @@ do_accepts()
     BOOST_ASSERT(ex_.running_in_this_thread());
     if(idle_)
     {
-        for(auto& e : ve_)
+        for(auto& a : va_)
         {
-            while(e.need > 0)
+            while(a.need > 0)
             {
-                --e.need;
-                LOG_TRC(sect_, "need=", e.need);
+                --a.need;
+                LOG_TRC(sect_, "need=", a.need);
                 // pop
-                auto w = idle_;
+                auto pw = idle_;
                 idle_ = idle_->next;
                 --n_idle_;
                 LOG_TRC(sect_, "n_idle=", n_idle_);
-                e.sock.async_accept(w->w.socket(), w->w.endpoint(),
-                    asio::prepend(call_mf(&workers::on_accept, this), &e, w));
+                a.sock.async_accept(pw->w.socket(), pw->w.endpoint(),
+                    asio::prepend(call_mf(&workers::on_accept, this), &a, pw));
                 if(! idle_)
                     goto busy;
             }
@@ -246,25 +246,25 @@ template<class Executor, class Worker>
 void
 workers<Executor, Worker>::
 on_accept(
-    entry* e,
-    worker* w,
+    acceptor* pa,
+    worker* pw,
     system::error_code const& ec)
 {
-    ++e->need;
-    LOG_TRC(sect_, "need=", e->need);
+    ++pa->need;
+    LOG_TRC(sect_, "need=", pa->need);
     if(ec.failed())
     {
         // push
-        w->next = idle_;
-        idle_ = w;
+        pw->next = idle_;
+        idle_ = pw;
         ++n_idle_;
         LOG_TRC(sect_, "n_idle=", n_idle_);
         LOG_DBG(sect_, "async_accept: ", ec.message());
         return do_accepts();
     }
     do_accepts();
-    asio::dispatch(w->w.socket().get_executor(),
-        call_mf(&Worker::on_accept, &w->w));
+    asio::dispatch(pw->w.socket().get_executor(),
+        call_mf(&Worker::on_accept, &pw->w));
 }
 
 template<class Executor, class Worker>
@@ -274,10 +274,10 @@ do_stop()
 {
     for(auto& w : vw_)
         w.w.cancel();
-    for(auto& e : ve_)
+    for(auto& a : va_)
     {
         system::error_code ec;
-        e.sock.cancel(ec); // error ignored
+        a.sock.cancel(ec); // error ignored
     }
 }