1 files changed, 67 insertions, 61 deletions

diff --git a/src/SelectEventPoll.cc b/src/SelectEventPoll.cc
index 87efee56..c709dccc 100644
--- a/src/SelectEventPoll.cc
+++ b/src/SelectEventPoll.cc
@@ -35,7 +35,7 @@
 #include "SelectEventPoll.h"
 
 #ifdef __MINGW32__
-# include <cassert>
+#include <cassert>
 #endif // __MINGW32__
 #include <cstring>
 #include <algorithm>
@@ -50,52 +50,55 @@
 
 namespace aria2 {
 
-SelectEventPoll::CommandEvent::CommandEvent(Command* command, int events):
-  command_(command), events_(events) {}
+SelectEventPoll::CommandEvent::CommandEvent(Command* command, int events)
+    : command_(command), events_(events)
+{
+}
 
 void SelectEventPoll::CommandEvent::processEvents(int events)
 {
-  if((events_&events) ||
-     ((EventPoll::EVENT_ERROR|EventPoll::EVENT_HUP)&events)) {
+  if ((events_ & events) ||
+      ((EventPoll::EVENT_ERROR | EventPoll::EVENT_HUP) & events)) {
     command_->setStatusActive();
   }
-  if(EventPoll::EVENT_READ&events) {
+  if (EventPoll::EVENT_READ & events) {
     command_->readEventReceived();
   }
-  if(EventPoll::EVENT_WRITE&events) {
+  if (EventPoll::EVENT_WRITE & events) {
     command_->writeEventReceived();
   }
-  if(EventPoll::EVENT_ERROR&events) {
+  if (EventPoll::EVENT_ERROR & events) {
     command_->errorEventReceived();
   }
-  if(EventPoll::EVENT_HUP&events) {
+  if (EventPoll::EVENT_HUP & events) {
     command_->hupEventReceived();
   }
 }
 
-SelectEventPoll::SocketEntry::SocketEntry(sock_t socket):socket_(socket) {}
+SelectEventPoll::SocketEntry::SocketEntry(sock_t socket) : socket_(socket) {}
 
-void SelectEventPoll::SocketEntry::addCommandEvent
-(Command* command, int events)
+void SelectEventPoll::SocketEntry::addCommandEvent(Command* command, int events)
 {
   CommandEvent cev(command, events);
   auto i = std::find(commandEvents_.begin(), commandEvents_.end(), cev);
-  if(i == commandEvents_.end()) {
+  if (i == commandEvents_.end()) {
     commandEvents_.push_back(cev);
-  } else {
+  }
+  else {
     (*i).addEvents(events);
   }
 }
-void SelectEventPoll::SocketEntry::removeCommandEvent
-(Command* command, int events)
+void SelectEventPoll::SocketEntry::removeCommandEvent(Command* command,
+                                                      int events)
 {
   CommandEvent cev(command, events);
   auto i = std::find(commandEvents_.begin(), commandEvents_.end(), cev);
-  if(i == commandEvents_.end()) {
+  if (i == commandEvents_.end()) {
     // not found
-  } else {
+  }
+  else {
     (*i).removeEvents(events);
-    if((*i).eventsEmpty()) {
+    if ((*i).eventsEmpty()) {
       commandEvents_.erase(i);
     }
   }
@@ -109,33 +112,34 @@ void SelectEventPoll::SocketEntry::processEvents(int events)
 
 int accumulateEvent(int events, const SelectEventPoll::CommandEvent& event)
 {
-  return events|event.getEvents();
+  return events | event.getEvents();
 }
 
 int SelectEventPoll::SocketEntry::getEvents()
 {
-  return
-    std::accumulate(commandEvents_.begin(), commandEvents_.end(), 0,
-                    accumulateEvent);
+  return std::accumulate(commandEvents_.begin(), commandEvents_.end(), 0,
+                         accumulateEvent);
 }
 
 #ifdef ENABLE_ASYNC_DNS
 
-SelectEventPoll::AsyncNameResolverEntry::AsyncNameResolverEntry
-(const std::shared_ptr<AsyncNameResolver>& nameResolver, Command* command):
-  nameResolver_(nameResolver), command_(command) {}
+SelectEventPoll::AsyncNameResolverEntry::AsyncNameResolverEntry(
+    const std::shared_ptr<AsyncNameResolver>& nameResolver, Command* command)
+    : nameResolver_(nameResolver), command_(command)
+{
+}
 
-int SelectEventPoll::AsyncNameResolverEntry::getFds
-(fd_set* rfdsPtr, fd_set* wfdsPtr)
+int SelectEventPoll::AsyncNameResolverEntry::getFds(fd_set* rfdsPtr,
+                                                    fd_set* wfdsPtr)
 {
   return nameResolver_->getFds(rfdsPtr, wfdsPtr);
 }
 
-void SelectEventPoll::AsyncNameResolverEntry::process
-(fd_set* rfdsPtr, fd_set* wfdsPtr)
+void SelectEventPoll::AsyncNameResolverEntry::process(fd_set* rfdsPtr,
+                                                      fd_set* wfdsPtr)
 {
   nameResolver_->process(rfdsPtr, wfdsPtr);
-  switch(nameResolver_->getStatus()) {
+  switch (nameResolver_->getStatus()) {
   case AsyncNameResolver::STATUS_SUCCESS:
   case AsyncNameResolver::STATUS_ERROR:
     command_->setStatusActive();
@@ -177,11 +181,11 @@ void SelectEventPoll::poll(const struct timeval& tv)
 #endif // __MINGW32__
 #ifdef ENABLE_ASYNC_DNS
 
-  for(auto& i : nameResolverEntries_) {
+  for (auto& i : nameResolverEntries_) {
     auto& entry = i.second;
     int fd = entry.getFds(&rfds, &wfds);
     // TODO force error if fd == 0
-    if(fdmax_ < fd) {
+    if (fdmax_ < fd) {
       fdmax_ = fd;
     }
   }
@@ -191,30 +195,31 @@ void SelectEventPoll::poll(const struct timeval& tv)
   do {
     struct timeval ttv = tv;
 #ifdef __MINGW32__
-    retval = select(fdmax_+1, &rfds, &wfds, &efds, &ttv);
+    retval = select(fdmax_ + 1, &rfds, &wfds, &efds, &ttv);
 #else // !__MINGW32__
-    retval = select(fdmax_+1, &rfds, &wfds, nullptr, &ttv);
+    retval = select(fdmax_ + 1, &rfds, &wfds, nullptr, &ttv);
 #endif // !__MINGW32__
-  } while(retval == -1 && errno == EINTR);
-  if(retval > 0) {
-    for(auto& i: socketEntries_) {
+  } while (retval == -1 && errno == EINTR);
+  if (retval > 0) {
+    for (auto& i : socketEntries_) {
       auto& e = i.second;
       int events = 0;
-      if(FD_ISSET(e.getSocket(), &rfds)) {
+      if (FD_ISSET(e.getSocket(), &rfds)) {
         events |= EventPoll::EVENT_READ;
       }
-      if(FD_ISSET(e.getSocket(), &wfds)) {
+      if (FD_ISSET(e.getSocket(), &wfds)) {
         events |= EventPoll::EVENT_WRITE;
       }
       e.processEvents(events);
     }
-  } else if(retval == -1) {
+  }
+  else if (retval == -1) {
     int errNum = errno;
     A2_LOG_INFO(fmt("select error: %s", util::safeStrerror(errNum).c_str()));
   }
 #ifdef ENABLE_ASYNC_DNS
 
-  for(auto& i: nameResolverEntries_) {
+  for (auto& i : nameResolverEntries_) {
     i.second.process(&rfds, &wfds);
   }
 
@@ -225,7 +230,7 @@ void SelectEventPoll::poll(const struct timeval& tv)
 namespace {
 void checkFdCountMingw(const fd_set& fdset)
 {
-  if(fdset.fd_count >= FD_SETSIZE) {
+  if (fdset.fd_count >= FD_SETSIZE) {
     A2_LOG_WARN("The number of file descriptor exceeded FD_SETSIZE. "
                 "Download may slow down or fail.");
   }
@@ -237,35 +242,35 @@ void SelectEventPoll::updateFdSet()
 {
 #ifdef __MINGW32__
   fdmax_ = dummySocket_;
-#else // !__MINGW32__
+#else  // !__MINGW32__
   fdmax_ = 0;
 #endif // !__MINGW32__
   FD_ZERO(&rfdset_);
   FD_ZERO(&wfdset_);
-  for(auto& i: socketEntries_) {
-    auto&e = i.second;
+  for (auto& i : socketEntries_) {
+    auto& e = i.second;
     sock_t fd = e.getSocket();
 #ifndef __MINGW32__
-    if(fd < 0 || FD_SETSIZE <= fd) {
+    if (fd < 0 || FD_SETSIZE <= fd) {
       A2_LOG_WARN("Detected file descriptor >= FD_SETSIZE or < 0. "
                   "Download may slow down or fail.");
       continue;
     }
 #endif // !__MINGW32__
     int events = e.getEvents();
-    if(events&EventPoll::EVENT_READ) {
+    if (events & EventPoll::EVENT_READ) {
 #ifdef __MINGW32__
       checkFdCountMingw(rfdset_);
 #endif // __MINGW32__
       FD_SET(fd, &rfdset_);
     }
-    if(events&EventPoll::EVENT_WRITE) {
+    if (events & EventPoll::EVENT_WRITE) {
 #ifdef __MINGW32__
       checkFdCountMingw(wfdset_);
 #endif // __MINGW32__
       FD_SET(fd, &wfdset_);
     }
-    if(fdmax_ < fd) {
+    if (fdmax_ < fd) {
       fdmax_ = fd;
     }
   }
@@ -275,9 +280,10 @@ bool SelectEventPoll::addEvents(sock_t socket, Command* command,
                                 EventPoll::EventType events)
 {
   auto i = socketEntries_.lower_bound(socket);
-  if(i != std::end(socketEntries_) && (*i).first == socket) {
+  if (i != std::end(socketEntries_) && (*i).first == socket) {
     (*i).second.addCommandEvent(command, events);
-  } else {
+  }
+  else {
     i = socketEntries_.insert(i, std::make_pair(socket, SocketEntry(socket)));
     (*i).second.addCommandEvent(command, events);
   }
@@ -289,14 +295,14 @@ bool SelectEventPoll::deleteEvents(sock_t socket, Command* command,
                                    EventPoll::EventType events)
 {
   auto i = socketEntries_.find(socket);
-  if(i == std::end(socketEntries_)) {
+  if (i == std::end(socketEntries_)) {
     A2_LOG_DEBUG(fmt("Socket %d is not found in SocketEntries.", socket));
     return false;
   }
 
   auto& socketEntry = (*i).second;
   socketEntry.removeCommandEvent(command, events);
-  if(socketEntry.eventEmpty()) {
+  if (socketEntry.eventEmpty()) {
     socketEntries_.erase(i);
   }
   updateFdSet();
@@ -304,23 +310,23 @@ bool SelectEventPoll::deleteEvents(sock_t socket, Command* command,
 }
 
 #ifdef ENABLE_ASYNC_DNS
-bool SelectEventPoll::addNameResolver
-(const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
+bool SelectEventPoll::addNameResolver(
+    const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
 {
   auto key = std::make_pair(resolver.get(), command);
   auto itr = nameResolverEntries_.lower_bound(key);
-  if(itr != std::end(nameResolverEntries_) && (*itr).first == key) {
+  if (itr != std::end(nameResolverEntries_) && (*itr).first == key) {
     return false;
   }
 
-  nameResolverEntries_.insert
-    (itr, std::make_pair(key, AsyncNameResolverEntry(resolver, command)));
+  nameResolverEntries_.insert(
+      itr, std::make_pair(key, AsyncNameResolverEntry(resolver, command)));
 
   return true;
 }
 
-bool SelectEventPoll::deleteNameResolver
-(const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
+bool SelectEventPoll::deleteNameResolver(
+    const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
 {
   auto key = std::make_pair(resolver.get(), command);
   return nameResolverEntries_.erase(key) == 1;