make clang-format using clang-format-3.6

examples/libaria2ex.cc

@@ -55,7 +55,8 @@ int downloadEventCallback(aria2::Session* session, aria2::DownloadEvent event,
   }
   std::cerr << " [" << aria2::gidToHex(gid) << "] ";
   aria2::DownloadHandle* dh = aria2::getDownloadHandle(session, gid);
-  if(!dh) return 0;
+  if (!dh)
+    return 0;
   if (dh->getNumFiles() > 0) {
     aria2::FileData f = dh->getFile(1);
     // Path may be empty if the file name has not been determined yet.
@@ -63,7 +64,8 @@ int downloadEventCallback(aria2::Session* session, aria2::DownloadEvent event,
       if (!f.uris.empty()) {
         std::cerr << f.uris[0].uri;
       }
-    } else {
+    }
+    else {
       std::cerr << f.path;
     }
   }
@@ -109,8 +111,8 @@ int main(int argc, char** argv)
     // the application can call aria2 API to add URI or query progress
     // here
     auto now = std::chrono::steady_clock::now();
-    auto count = std::chrono::duration_cast<std::chrono::milliseconds>
+    auto count = std::chrono::duration_cast<std::chrono::milliseconds>(
-      (now - start).count();
+                     now - start).count();
     // Print progress information once per 500ms
     if (count >= 500) {
       start = now;
@@ -124,14 +126,13 @@ int main(int argc, char** argv)
         aria2::DownloadHandle* dh = aria2::getDownloadHandle(session, gid);
         if (dh) {
           std::cerr << "    [" << aria2::gidToHex(gid) << "] "
-                    << dh->getCompletedLength() << "/"
+                    << dh->getCompletedLength() << "/" << dh->getTotalLength()
-                    << dh->getTotalLength() << "("
+                    << "(" << (dh->getTotalLength() > 0
-                    << (dh->getTotalLength() > 0 ?
+                                   ? (100 * dh->getCompletedLength() /
-                        (100*dh->getCompletedLength()/dh->getTotalLength())
+                                      dh->getTotalLength())
                                    : 0) << "%)"
-                    << " D:"
+                    << " D:" << dh->getDownloadSpeed() / 1024
-                    << dh->getDownloadSpeed()/1024 << "KiB/s, U:"
+                    << "KiB/s, U:" << dh->getUploadSpeed() / 1024 << "KiB/s"
-                    << dh->getUploadSpeed()/1024 << "KiB/s"
                     << std::endl;
           aria2::deleteDownloadHandle(dh);
         }

examples/libaria2wx.cc

@@ -38,7 +38,8 @@
 // the main window.
 //
 // Compile and link like this:
-// $ g++ -O2 -Wall -g -std=c++11 `wx-config --cflags` -o libaria2wx libaria2wx.cc `wx-config --libs` -laria2 -pthread
+// $ g++ -O2 -Wall -g -std=c++11 `wx-config --cflags` -o libaria2wx
+// libaria2wx.cc `wx-config --libs` -laria2 -pthread
 #include <iostream>
 #include <chrono>
 #include <thread>
@@ -66,8 +67,7 @@ struct Notification {
 // std::queue<T> wrapper synchronized by mutex. In this example
 // program, only one thread consumes from the queue, so separating
 // empty() and pop() is not a problem.
-template<typename T>
+template <typename T> class SynchronizedQueue {
-class SynchronizedQueue {
 public:
   SynchronizedQueue() {}
   ~SynchronizedQueue() {}
@@ -88,6 +88,7 @@ public:
     std::lock_guard<std::mutex> l(m_);
     return q_.empty();
   }
+
 private:
   std::queue<std::unique_ptr<T>> q_;
   std::mutex m_;
@@ -110,7 +111,8 @@ struct ShutdownJob : public Job {
 struct AddUriJob : public Job {
   AddUriJob(std::vector<std::string>&& uris, aria2::KeyVals&& options)
       : uris(uris), options(options)
-  {}
+  {
+  }
   virtual void execute(aria2::Session* session)
   {
     // TODO check return value
@@ -148,6 +150,7 @@ public:
   void OnTimer(wxTimerEvent& event);
   void OnAddUri(wxCommandEvent& event);
   void UpdateActiveStatus(const std::vector<DownloadStatus>& v);
+
 private:
   wxTextCtrl* text_;
   wxTimer timer_;
@@ -157,13 +160,9 @@ private:
   DECLARE_EVENT_TABLE()
 };
 
-enum {
+enum { TIMER_ID = 1 };
-  TIMER_ID = 1
-};
 
-enum {
+enum { MI_ADD_URI = 1 };
-  MI_ADD_URI = 1
-};
 
 BEGIN_EVENT_TABLE(MainFrame, wxFrame)
 EVT_CLOSE(MainFrame::OnCloseWindow)
@@ -177,6 +176,7 @@ public:
   void OnButton(wxCommandEvent& event);
   wxString GetUri();
   wxString GetOption();
+
 private:
   wxTextCtrl* uriText_;
   wxTextCtrl* optionText_;
@@ -193,7 +193,8 @@ IMPLEMENT_APP(Aria2App)
 
 bool Aria2App::OnInit()
 {
-  if(!wxApp::OnInit()) return false;
+  if (!wxApp::OnInit())
+    return false;
   aria2::libraryInit();
   MainFrame* frame = new MainFrame(wxT("libaria2 GUI example"));
   frame->Show(true);
@@ -207,14 +208,12 @@ int Aria2App::OnExit()
 }
 
 MainFrame::MainFrame(const wxString& title)
-  : wxFrame(nullptr, wxID_ANY, title, wxDefaultPosition,
+    : wxFrame(nullptr, wxID_ANY, title, wxDefaultPosition, wxSize(640, 400)),
-            wxSize(640, 400)),
       timer_(this, TIMER_ID),
       downloaderThread_(downloaderJob, std::ref(jobq_), std::ref(notifyq_))
 {
   wxMenu* downloadMenu = new wxMenu;
-  downloadMenu->Append(MI_ADD_URI, wxT("&Add URI"),
+  downloadMenu->Append(MI_ADD_URI, wxT("&Add URI"), wxT("Add URI to download"));
-                       wxT("Add URI to download"));
 
   wxMenuBar* menuBar = new wxMenuBar();
   menuBar->Append(downloadMenu, wxT("&Download"));
@@ -248,7 +247,8 @@ void MainFrame::OnAddUri(wxCommandEvent& WXUNUSED(event))
     for (int i = 0; i < (int)optstr.size(); ++i) {
       if (optstr[i] == '\n') {
         keyfirst = i + 1;
-      } else if(optstr[i] == '=') {
+      }
+      else if (optstr[i] == '=') {
         int j;
         for (j = i + 1; j < (int)optstr.size(); ++j) {
           if (optstr[j] == '\n') {
@@ -256,16 +256,16 @@ void MainFrame::OnAddUri(wxCommandEvent& WXUNUSED(event))
           }
         }
         if (i - keyfirst > 0) {
-          options.push_back
+          options.push_back(
-            (std::make_pair(optstr.substr(keyfirst, i - keyfirst),
+              std::make_pair(optstr.substr(keyfirst, i - keyfirst),
                              optstr.substr(i + 1, j - i - 1)));
         }
         keyfirst = j + 1;
         i = j;
       }
     }
-    jobq_.push(std::unique_ptr<Job>(new AddUriJob(std::move(uris),
+    jobq_.push(std::unique_ptr<Job>(
-                                                  std::move(options))));
+        new AddUriJob(std::move(uris), std::move(options))));
   }
 }
 
@@ -287,43 +287,34 @@ void MainFrame::OnTimer(wxTimerEvent& event)
   }
 }
 
-template<typename T>
+template <typename T> std::string abbrevsize(T size)
-std::string abbrevsize(T size)
 {
   if (size >= 1024 * 1024 * 1024) {
     return std::to_string(size / 1024 / 1024 / 1024) + "G";
-  } else if(size >= 1024*1024) {
+  }
+  else if (size >= 1024 * 1024) {
     return std::to_string(size / 1024 / 1024) + "M";
-  } else if(size >= 1024) {
+  }
+  else if (size >= 1024) {
     return std::to_string(size / 1024) + "K";
-  } else {
+  }
+  else {
     return std::to_string(size);
   }
 }
 
-wxString towxs(const std::string& s)
+wxString towxs(const std::string& s) { return wxString(s.c_str(), wxConvUTF8); }
-{
-  return wxString(s.c_str(), wxConvUTF8);
-}
 
 void MainFrame::UpdateActiveStatus(const std::vector<DownloadStatus>& v)
 {
   text_->Clear();
   for (auto& a : v) {
-    *text_ << wxT("[")
+    *text_ << wxT("[") << towxs(aria2::gidToHex(a.gid)) << wxT("] ")
-           << towxs(aria2::gidToHex(a.gid))
+           << towxs(abbrevsize(a.completedLength)) << wxT("/")
-           << wxT("] ")
+           << towxs(abbrevsize(a.totalLength)) << wxT("(")
-           << towxs(abbrevsize(a.completedLength))
-           << wxT("/")
-           << towxs(abbrevsize(a.totalLength))
-           << wxT("(")
            << (a.totalLength != 0 ? a.completedLength * 100 / a.totalLength : 0)
-           << wxT("%)")
+           << wxT("%)") << wxT(" D:") << towxs(abbrevsize(a.downloadSpeed))
-           << wxT(" D:")
+           << wxT(" U:") << towxs(abbrevsize(a.uploadSpeed)) << wxT("\n")
-           << towxs(abbrevsize(a.downloadSpeed))
-           << wxT(" U:")
-           << towxs(abbrevsize(a.uploadSpeed))
-           << wxT("\n")
            << wxT("File:") << towxs(a.filename) << wxT("\n");
   }
 }
@@ -339,9 +330,8 @@ AddUriDialog::AddUriDialog(wxWindow* parent)
   uriText_ = new wxTextCtrl(panel, wxID_ANY);
   box->Add(uriText_, wxSizerFlags().Align(wxGROW));
   // Option multi text input
-  box->Add(new wxStaticText
+  box->Add(new wxStaticText(
-           (panel, wxID_ANY,
+      panel, wxID_ANY, wxT("Options (key=value pair per line, e.g. dir=/tmp")));
-            wxT("Options (key=value pair per line, e.g. dir=/tmp")));
   optionText_ = new wxTextCtrl(panel, wxID_ANY, wxT(""), wxDefaultPosition,
                                wxDefaultSize, wxTE_MULTILINE);
   box->Add(optionText_, wxSizerFlags().Align(wxGROW));
@@ -369,32 +359,19 @@ void AddUriDialog::OnButton(wxCommandEvent& event)
   EndModal(ret);
 }
 
-wxString AddUriDialog::GetUri()
+wxString AddUriDialog::GetUri() { return uriText_->GetValue(); }
-{
-  return uriText_->GetValue();
-}
 
-wxString AddUriDialog::GetOption()
+wxString AddUriDialog::GetOption() { return optionText_->GetValue(); }
-{
-  return optionText_->GetValue();
-}
 
 struct DownloadStatusNotification : public Notification {
-  DownloadStatusNotification(std::vector<DownloadStatus>&& v)
+  DownloadStatusNotification(std::vector<DownloadStatus>&& v) : v(v) {}
-    : v(v) {}
+  virtual void notify(MainFrame* frame) { frame->UpdateActiveStatus(v); }
-  virtual void notify(MainFrame* frame)
-  {
-    frame->UpdateActiveStatus(v);
-  }
   std::vector<DownloadStatus> v;
 };
 
 struct ShutdownNotification : public Notification {
   ShutdownNotification() {}
-  virtual void notify(MainFrame* frame)
+  virtual void notify(MainFrame* frame) { frame->Close(); }
-  {
-    frame->Close();
-  }
 };
 
 int downloaderJob(JobQueue& jobq, NotifyQueue& notifyq)
@@ -412,8 +389,8 @@ int downloaderJob(JobQueue& jobq, NotifyQueue& notifyq)
       break;
     }
     auto now = std::chrono::steady_clock::now();
-    auto count = std::chrono::duration_cast<std::chrono::milliseconds>
+    auto count = std::chrono::duration_cast<std::chrono::milliseconds>(
-      (now - start).count();
+                     now - start).count();
     while (!jobq.empty()) {
       std::unique_ptr<Job> job = jobq.pop();
       job->execute(session);
@@ -439,8 +416,8 @@ int downloaderJob(JobQueue& jobq, NotifyQueue& notifyq)
           aria2::deleteDownloadHandle(dh);
         }
       }
-      notifyq.push(std::unique_ptr<Notification>
+      notifyq.push(std::unique_ptr<Notification>(
-                   (new DownloadStatusNotification(std::move(v))));
+          new DownloadStatusNotification(std::move(v))));
     }
   }
   int rv = aria2::sessionFinal(session);
@@ -449,4 +426,3 @@ int downloaderJob(JobQueue& jobq, NotifyQueue& notifyq)
   notifyq.push(std::unique_ptr<Notification>(new ShutdownNotification()));
   return rv;
 }
-

src/AbstractAuthResolver.cc

@@ -42,8 +42,8 @@ AbstractAuthResolver::AbstractAuthResolver() {}
 
 AbstractAuthResolver::~AbstractAuthResolver() {}
 
-void AbstractAuthResolver::setUserDefinedCred
+void AbstractAuthResolver::setUserDefinedCred(std::string user,
-(std::string user, std::string password)
+                                              std::string password)
 {
   userDefinedUser_ = std::move(user);
   userDefinedPassword_ = std::move(password);
@@ -55,8 +55,8 @@ AbstractAuthResolver::getUserDefinedAuthConfig() const
   return AuthConfig::create(userDefinedUser_, userDefinedPassword_);
 }
 
-void AbstractAuthResolver::setDefaultCred
+void AbstractAuthResolver::setDefaultCred(std::string user,
-(std::string user, std::string password)
+                                          std::string password)
 {
   defaultUser_ = std::move(user);
   defaultPassword_ = std::move(password);

src/AbstractAuthResolver.h

@@ -52,6 +52,7 @@ public:
   void setDefaultCred(std::string user, std::string password);
 
   std::unique_ptr<AuthConfig> getDefaultAuthConfig() const;
+
 private:
   std::string userDefinedUser_;
   std::string userDefinedPassword_;

src/AbstractBtMessage.cc

@@ -51,7 +51,8 @@ AbstractBtMessage::AbstractBtMessage(uint8_t id, const char* name)
       requestFactory_(nullptr),
       peerConnection_(nullptr),
       metadataGetMode_(false)
-{}
+{
+}
 
 AbstractBtMessage::~AbstractBtMessage() {}
 
@@ -67,9 +68,8 @@ void AbstractBtMessage::validate()
   }
 }
 
-void
+void AbstractBtMessage::setBtMessageValidator(
-AbstractBtMessage::setBtMessageValidator
+    std::unique_ptr<BtMessageValidator> validator)
-(std::unique_ptr<BtMessageValidator> validator)
 {
   validator_ = std::move(validator);
 }

src/AbstractBtMessage.h

@@ -71,69 +71,38 @@ private:
   std::unique_ptr<BtMessageValidator> validator_;
 
   bool metadataGetMode_;
+
 protected:
-  PieceStorage* getPieceStorage() const
+  PieceStorage* getPieceStorage() const { return pieceStorage_; }
-  {
-    return pieceStorage_;
-  }
 
-  PeerConnection* getPeerConnection() const
+  PeerConnection* getPeerConnection() const { return peerConnection_; }
-  {
-    return peerConnection_;
-  }
 
-  BtMessageDispatcher* getBtMessageDispatcher() const
+  BtMessageDispatcher* getBtMessageDispatcher() const { return dispatcher_; }
-  {
-    return dispatcher_;
-  }
 
-  BtRequestFactory* getBtRequestFactory() const
+  BtRequestFactory* getBtRequestFactory() const { return requestFactory_; }
-  {
-    return requestFactory_;
-  }
 
-  BtMessageFactory* getBtMessageFactory() const
+  BtMessageFactory* getBtMessageFactory() const { return messageFactory_; }
-  {
+
-    return messageFactory_;
+  bool isMetadataGetMode() const { return metadataGetMode_; }
-  }
 
-  bool isMetadataGetMode() const
-  {
-    return metadataGetMode_;
-  }
 public:
   AbstractBtMessage(uint8_t id, const char* name);
 
   virtual ~AbstractBtMessage();
 
-  virtual bool isInvalidate() CXX11_OVERRIDE {
+  virtual bool isInvalidate() CXX11_OVERRIDE { return invalidate_; }
-    return invalidate_;
-  }
 
-  void setInvalidate(bool invalidate) {
+  void setInvalidate(bool invalidate) { invalidate_ = invalidate; }
-    invalidate_ = invalidate;
-  }
 
-  virtual bool isUploading() CXX11_OVERRIDE {
+  virtual bool isUploading() CXX11_OVERRIDE { return uploading_; }
-    return uploading_;
-  }
 
-  void setUploading(bool uploading) {
+  void setUploading(bool uploading) { uploading_ = uploading; }
-    uploading_ = uploading;
-  }
 
-  cuid_t getCuid() const {
+  cuid_t getCuid() const { return cuid_; }
-    return cuid_;
-  }
 
-  void setCuid(cuid_t cuid) {
+  void setCuid(cuid_t cuid) { cuid_ = cuid; }
-    cuid_ = cuid;
-  }
 
-  const std::shared_ptr<Peer>& getPeer() const
+  const std::shared_ptr<Peer>& getPeer() const { return peer_; }
-  {
-    return peer_;
-  }
 
   void setPeer(const std::shared_ptr<Peer>& peer);
 
@@ -143,11 +112,15 @@ public:
 
   virtual void onQueued() CXX11_OVERRIDE {}
 
-  virtual void onAbortOutstandingRequestEvent
+  virtual void onAbortOutstandingRequestEvent(
-  (const BtAbortOutstandingRequestEvent& event) CXX11_OVERRIDE {}
+      const BtAbortOutstandingRequestEvent& event) CXX11_OVERRIDE
+  {
+  }
 
-  virtual void onCancelSendingPieceEvent
+  virtual void onCancelSendingPieceEvent(const BtCancelSendingPieceEvent& event)
-  (const BtCancelSendingPieceEvent& event) CXX11_OVERRIDE {}
+      CXX11_OVERRIDE
+  {
+  }
 
   virtual void onChokingEvent(const BtChokingEvent& event) CXX11_OVERRIDE {}
 
@@ -163,15 +136,9 @@ public:
 
   void setBtRequestFactory(BtRequestFactory* factory);
 
-  const char* getName() const
+  const char* getName() const { return name_; }
-  {
-    return name_;
-  }
 
-  void enableMetadataGetMode()
+  void enableMetadataGetMode() { metadataGetMode_ = true; }
-  {
-    metadataGetMode_ = true;
-  }
 };
 
 } // namespace aria2

src/AbstractCommand.cc

@@ -74,13 +74,10 @@
 
 namespace aria2 {
 
-AbstractCommand::AbstractCommand
+AbstractCommand::AbstractCommand(
-(cuid_t cuid,
+    cuid_t cuid, const std::shared_ptr<Request>& req,
- const std::shared_ptr<Request>& req,
+    const std::shared_ptr<FileEntry>& fileEntry, RequestGroup* requestGroup,
- const std::shared_ptr<FileEntry>& fileEntry,
+    DownloadEngine* e, const std::shared_ptr<SocketCore>& s,
- RequestGroup* requestGroup,
- DownloadEngine* e,
- const std::shared_ptr<SocketCore>& s,
     const std::shared_ptr<SocketRecvBuffer>& socketRecvBuffer,
     bool incNumConnection)
     : Command(cuid),
@@ -127,19 +124,18 @@ AbstractCommand::~AbstractCommand()
   }
 }
 
-void
+void AbstractCommand::useFasterRequest(
-AbstractCommand::useFasterRequest(const std::shared_ptr<Request>& fasterRequest)
+    const std::shared_ptr<Request>& fasterRequest)
 {
   A2_LOG_INFO(fmt("CUID#%" PRId64 " - Use faster Request hostname=%s, port=%u",
-                  getCuid(),
+                  getCuid(), fasterRequest->getHost().c_str(),
-                  fasterRequest->getHost().c_str(),
                   fasterRequest->getPort()));
   // Cancel current Request object and use faster one.
   fileEntry_->removeRequest(req_);
   e_->setNoWait(true);
-  e_->addCommand
+  e_->addCommand(
-    (InitiateConnectionCommandFactory::createInitiateConnectionCommand
+      InitiateConnectionCommandFactory::createInitiateConnectionCommand(
-     (getCuid(), fasterRequest, fileEntry_, requestGroup_, e_));
+          getCuid(), fasterRequest, fileEntry_, requestGroup_, e_));
 }
 
 bool AbstractCommand::shouldProcess() const
@@ -180,11 +176,8 @@ bool AbstractCommand::execute()
 {
   A2_LOG_DEBUG(fmt("CUID#%" PRId64
                    " - socket: read:%d, write:%d, hup:%d, err:%d",
-                   getCuid(),
+                   getCuid(), readEventEnabled(), writeEventEnabled(),
-                   readEventEnabled(),
+                   hupEventEnabled(), errorEventEnabled()));
-                   writeEventEnabled(),
-                   hupEventEnabled(),
-                   errorEventEnabled()));
   try {
     if (requestGroup_->downloadFinished() || requestGroup_->isHaltRequested()) {
       return true;
@@ -194,8 +187,7 @@ bool AbstractCommand::execute()
       A2_LOG_DEBUG(fmt("CUID#%" PRId64
                        " - Discard original URI=%s because it is"
                        " requested.",
-                       getCuid(),
+                       getCuid(), req_->getUri().c_str()));
-                       req_->getUri().c_str()));
       return prepareForRetry(0);
     }
 
@@ -243,8 +235,8 @@ bool AbstractCommand::execute()
         if (getOption()->getAsBool(PREF_SELECT_LEAST_USED_HOST)) {
           getDownloadEngine()->getRequestGroupMan()->getUsedHosts(usedHosts);
         }
-        auto fasterRequest = fileEntry_->findFasterRequest
+        auto fasterRequest = fileEntry_->findFasterRequest(
-          (req_, usedHosts, e_->getRequestGroupMan()->getServerStatMan());
+            req_, usedHosts, e_->getRequestGroupMan()->getServerStatMan());
         if (fasterRequest) {
           useFasterRequest(fasterRequest);
           return true;
@@ -296,8 +288,8 @@ bool AbstractCommand::execute()
         size_t minSplitSize = calculateMinSplitSize();
         size_t maxSegments = req_->getMaxPipelinedRequest();
         if (segments_.size() < maxSegments) {
-          sm->getSegment
+          sm->getSegment(segments_, getCuid(), minSplitSize, fileEntry_,
-            (segments_, getCuid(), minSplitSize, fileEntry_, maxSegments);
+                         maxSegments);
         }
         if (segments_.empty()) {
           return prepareForRetry(0);
@@ -308,22 +300,21 @@ bool AbstractCommand::execute()
     }
 
     if (errorEventEnabled()) {
-      throw DL_RETRY_EX
+      throw DL_RETRY_EX(
-        (fmt(MSG_NETWORK_PROBLEM, socket_->getSocketError().c_str()));
+          fmt(MSG_NETWORK_PROBLEM, socket_->getSocketError().c_str()));
     }
 
     if (checkPoint_.difference(global::wallclock()) >= timeout_) {
       // timeout triggers ServerStat error state.
-      auto ss = e_->getRequestGroupMan()->getOrCreateServerStat
+      auto ss = e_->getRequestGroupMan()->getOrCreateServerStat(
-        (req_->getHost(), req_->getProtocol());
+          req_->getHost(), req_->getProtocol());
       ss->setError();
       // When DNS query was timeout, req_->getConnectedAddr() is
       // empty.
       if (!req_->getConnectedAddr().empty()) {
         // Purging IP address cache to renew IP address.
         A2_LOG_DEBUG(fmt("CUID#%" PRId64 " - Marking IP address %s as bad",
-                         getCuid(),
+                         getCuid(), req_->getConnectedAddr().c_str()));
-                         req_->getConnectedAddr().c_str()));
         e_->markBadIPAddress(req_->getConnectedHostname(),
                              req_->getConnectedAddr(),
                              req_->getConnectedPort());
@@ -345,8 +336,8 @@ bool AbstractCommand::execute()
   catch (DlAbortEx& err) {
     requestGroup_->setLastErrorCode(err.getErrorCode(), err.what());
     if (req_) {
-      A2_LOG_ERROR_EX
+      A2_LOG_ERROR_EX(
-        (fmt(MSG_DOWNLOAD_ABORTED, getCuid(), req_->getUri().c_str()),
+          fmt(MSG_DOWNLOAD_ABORTED, getCuid(), req_->getUri().c_str()),
           DL_ABORT_EX2(fmt("URI=%s", req_->getCurrentUri().c_str()), err));
       fileEntry_->addURIResult(req_->getUri(), err.getErrorCode());
       if (err.getErrorCode() == error_code::CANNOT_RESUME) {
@@ -362,8 +353,8 @@ bool AbstractCommand::execute()
   }
   catch (DlRetryEx& err) {
     assert(req_);
-    A2_LOG_INFO_EX
+    A2_LOG_INFO_EX(
-      (fmt(MSG_RESTARTING_DOWNLOAD, getCuid(), req_->getUri().c_str()),
+        fmt(MSG_RESTARTING_DOWNLOAD, getCuid(), req_->getUri().c_str()),
         DL_RETRY_EX2(fmt("URI=%s", req_->getCurrentUri().c_str()), err));
     req_->addTryCount();
     req_->resetRedirectCount();
@@ -373,8 +364,8 @@ bool AbstractCommand::execute()
     bool isAbort = maxTries != 0 && req_->getTryCount() >= maxTries;
     if (isAbort) {
       A2_LOG_INFO(fmt(MSG_MAX_TRY, getCuid(), req_->getTryCount()));
-      A2_LOG_ERROR_EX
+      A2_LOG_ERROR_EX(
-        (fmt(MSG_DOWNLOAD_ABORTED, getCuid(), req_->getUri().c_str()), err);
+          fmt(MSG_DOWNLOAD_ABORTED, getCuid(), req_->getUri().c_str()), err);
       fileEntry_->addURIResult(req_->getUri(), err.getErrorCode());
       requestGroup_->setLastErrorCode(err.getErrorCode(), err.what());
       if (err.getErrorCode() == error_code::CANNOT_RESUME) {
@@ -394,11 +385,12 @@ bool AbstractCommand::execute()
   catch (DownloadFailureException& err) {
     requestGroup_->setLastErrorCode(err.getErrorCode(), err.what());
     if (req_) {
-      A2_LOG_ERROR_EX
+      A2_LOG_ERROR_EX(
-        (fmt(MSG_DOWNLOAD_ABORTED, getCuid(), req_->getUri().c_str()),
+          fmt(MSG_DOWNLOAD_ABORTED, getCuid(), req_->getUri().c_str()),
           DL_ABORT_EX2(fmt("URI=%s", req_->getCurrentUri().c_str()), err));
       fileEntry_->addURIResult(req_->getUri(), err.getErrorCode());
-    } else {
+    }
+    else {
       A2_LOG_ERROR_EX(EX_EXCEPTION_CAUGHT, err);
     }
     requestGroup_->setHaltRequested(true);
@@ -422,8 +414,8 @@ void AbstractCommand::tryReserved()
       return;
     }
   }
-  A2_LOG_DEBUG
+  A2_LOG_DEBUG(
-    (fmt("CUID#%" PRId64 " - Trying reserved/pooled request.", getCuid()));
+      fmt("CUID#%" PRId64 " - Trying reserved/pooled request.", getCuid()));
   std::vector<std::unique_ptr<Command>> commands;
   requestGroup_->createNextCommand(commands, e_, 1);
   e_->setNoWait(true);
@@ -443,8 +435,7 @@ bool AbstractCommand::prepareForRetry(time_t wait)
     req_->setMaxPipelinedRequest(1);
 
     fileEntry_->poolRequest(req_);
-    A2_LOG_DEBUG(fmt("CUID#%" PRId64 " - Pooling request URI=%s",
+    A2_LOG_DEBUG(fmt("CUID#%" PRId64 " - Pooling request URI=%s", getCuid(),
-                     getCuid(),
                      req_->getUri().c_str()));
     if (getSegmentMan()) {
       getSegmentMan()->recognizeSegmentFor(fileEntry_);
@@ -518,8 +509,7 @@ void AbstractCommand::onAbort()
   uris.reserve(res.size());
   std::transform(std::begin(res), std::end(res), std::back_inserter(uris),
                  std::mem_fn(&URIResult::getURI));
-  A2_LOG_DEBUG(fmt("CUID#%" PRId64 " - %lu URIs found.",
+  A2_LOG_DEBUG(fmt("CUID#%" PRId64 " - %lu URIs found.", getCuid(),
-                   getCuid(),
                    static_cast<unsigned long int>(uris.size())));
   fileEntry_->addUris(std::begin(uris), std::end(uris));
   getSegmentMan()->recognizeSegmentFor(fileEntry_);
@@ -536,8 +526,8 @@ void AbstractCommand::disableReadCheckSocket()
   readCheckTarget_.reset();
 }
 
-void
+void AbstractCommand::setReadCheckSocket(
-AbstractCommand::setReadCheckSocket(const std::shared_ptr<SocketCore>& socket)
+    const std::shared_ptr<SocketCore>& socket)
 {
   if (!socket->isOpen()) {
     disableReadCheckSocket();
@@ -558,9 +548,8 @@ AbstractCommand::setReadCheckSocket(const std::shared_ptr<SocketCore>& socket)
   readCheckTarget_ = socket;
 }
 
-void
+void AbstractCommand::setReadCheckSocketIf(
-AbstractCommand::setReadCheckSocketIf(const std::shared_ptr<SocketCore>& socket,
+    const std::shared_ptr<SocketCore>& socket, bool pred)
-                                      bool pred)
 {
   if (pred) {
     setReadCheckSocket(socket);
@@ -580,8 +569,8 @@ void AbstractCommand::disableWriteCheckSocket()
   writeCheckTarget_.reset();
 }
 
-void
+void AbstractCommand::setWriteCheckSocket(
-AbstractCommand::setWriteCheckSocket(const std::shared_ptr<SocketCore>& socket)
+    const std::shared_ptr<SocketCore>& socket)
 {
   if (!socket->isOpen()) {
     disableWriteCheckSocket();
@@ -602,8 +591,8 @@ AbstractCommand::setWriteCheckSocket(const std::shared_ptr<SocketCore>& socket)
   writeCheckTarget_ = socket;
 }
 
-void AbstractCommand::setWriteCheckSocketIf
+void AbstractCommand::setWriteCheckSocketIf(
-(const std::shared_ptr<SocketCore>& socket, bool pred)
+    const std::shared_ptr<SocketCore>& socket, bool pred)
 {
   if (pred) {
     setWriteCheckSocket(socket);
@@ -623,10 +612,8 @@ void AbstractCommand::swapSocket(std::shared_ptr<SocketCore>& socket)
 namespace {
 // Constructs proxy URI, merging username and password if they are
 // defined.
-std::string makeProxyUri(PrefPtr proxyPref,
+std::string makeProxyUri(PrefPtr proxyPref, PrefPtr proxyUser,
-                         PrefPtr proxyUser,
+                         PrefPtr proxyPasswd, const Option* option)
-                         PrefPtr proxyPasswd,
-                         const Option* option)
 {
   uri::UriStruct us;
   if (!uri::parse(us, option->get(proxyPref))) {
@@ -645,15 +632,13 @@ std::string makeProxyUri(PrefPtr proxyPref,
 
 namespace {
 // Returns proxy option value for the given protocol.
-std::string getProxyOptionFor(PrefPtr proxyPref,
+std::string getProxyOptionFor(PrefPtr proxyPref, PrefPtr proxyUser,
-                              PrefPtr proxyUser,
+                              PrefPtr proxyPasswd, const Option* option)
-                              PrefPtr proxyPasswd,
-                              const Option* option)
 {
   std::string uri = makeProxyUri(proxyPref, proxyUser, proxyPasswd, option);
   if (uri.empty()) {
-    return makeProxyUri
+    return makeProxyUri(PREF_ALL_PROXY, PREF_ALL_PROXY_USER,
-      (PREF_ALL_PROXY, PREF_ALL_PROXY_USER, PREF_ALL_PROXY_PASSWD, option);
+                        PREF_ALL_PROXY_PASSWD, option);
   }
 
   return uri;
@@ -665,20 +650,18 @@ std::string getProxyOptionFor(PrefPtr proxyPref,
 std::string getProxyUri(const std::string& protocol, const Option* option)
 {
   if (protocol == "http") {
-    return getProxyOptionFor
+    return getProxyOptionFor(PREF_HTTP_PROXY, PREF_HTTP_PROXY_USER,
-      (PREF_HTTP_PROXY, PREF_HTTP_PROXY_USER, PREF_HTTP_PROXY_PASSWD, option);
+                             PREF_HTTP_PROXY_PASSWD, option);
   }
 
   if (protocol == "https") {
-    return getProxyOptionFor(PREF_HTTPS_PROXY,
+    return getProxyOptionFor(PREF_HTTPS_PROXY, PREF_HTTPS_PROXY_USER,
-                             PREF_HTTPS_PROXY_USER,
+                             PREF_HTTPS_PROXY_PASSWD, option);
-                             PREF_HTTPS_PROXY_PASSWD,
-                             option);
   }
 
   if (protocol == "ftp" || protocol == "sftp") {
-    return getProxyOptionFor
+    return getProxyOptionFor(PREF_FTP_PROXY, PREF_FTP_PROXY_USER,
-      (PREF_FTP_PROXY, PREF_FTP_PROXY_USER, PREF_FTP_PROXY_PASSWD, option);
+                             PREF_FTP_PROXY_PASSWD, option);
   }
 
   return A2STR::NIL;
@@ -752,8 +735,8 @@ std::shared_ptr<Request> AbstractCommand::createProxyRequest() const
       A2_LOG_DEBUG(fmt("CUID#%" PRId64 " - Using proxy", getCuid()));
     }
     else {
-      A2_LOG_DEBUG
+      A2_LOG_DEBUG(
-        (fmt("CUID#%" PRId64 " - Failed to parse proxy string", getCuid()));
+          fmt("CUID#%" PRId64 " - Failed to parse proxy string", getCuid()));
       proxyRequest.reset();
     }
   }
@@ -790,8 +773,7 @@ std::string AbstractCommand::resolveHostname(std::vector<std::string>& addrs,
             ->getOrCreateServerStat(req_->getHost(), req_->getProtocol())
             ->setError();
       }
-      throw DL_ABORT_EX2(fmt(MSG_NAME_RESOLUTION_FAILED,
+      throw DL_ABORT_EX2(fmt(MSG_NAME_RESOLUTION_FAILED, getCuid(),
-                             getCuid(),
                              hostname.c_str(),
                              asyncNameResolverMan_->getLastError().c_str()),
                          error_code::NAME_RESOLVE_ERROR);
@@ -801,10 +783,8 @@ std::string AbstractCommand::resolveHostname(std::vector<std::string>& addrs,
     case 1:
       asyncNameResolverMan_->getResolvedAddress(addrs);
       if (addrs.empty()) {
-        throw DL_ABORT_EX2(fmt(MSG_NAME_RESOLUTION_FAILED,
+        throw DL_ABORT_EX2(fmt(MSG_NAME_RESOLUTION_FAILED, getCuid(),
-                               getCuid(),
+                               hostname.c_str(), "No address returned"),
-                               hostname.c_str(),
-                               "No address returned"),
                            error_code::NAME_RESOLVE_ERROR);
       }
       break;
@@ -829,20 +809,19 @@ std::string AbstractCommand::resolveHostname(std::vector<std::string>& addrs,
   return ipaddr;
 }
 
-void AbstractCommand::prepareForNextAction
+void AbstractCommand::prepareForNextAction(
-(std::unique_ptr<CheckIntegrityEntry> checkEntry)
+    std::unique_ptr<CheckIntegrityEntry> checkEntry)
 {
   std::vector<std::unique_ptr<Command>> commands;
-  requestGroup_->processCheckIntegrityEntry
+  requestGroup_->processCheckIntegrityEntry(commands, std::move(checkEntry),
-    (commands, std::move(checkEntry), e_);
+                                            e_);
   e_->addCommand(std::move(commands));
   e_->setNoWait(true);
 }
 
-bool AbstractCommand::checkIfConnectionEstablished
+bool AbstractCommand::checkIfConnectionEstablished(
-(const std::shared_ptr<SocketCore>& socket,
+    const std::shared_ptr<SocketCore>& socket,
- const std::string& connectedHostname,
+    const std::string& connectedHostname, const std::string& connectedAddr,
- const std::string& connectedAddr,
     uint16_t connectedPort)
 {
   std::string error = socket->getSocketError();
@@ -864,14 +843,12 @@ bool AbstractCommand::checkIfConnectionEstablished
     throw DL_RETRY_EX(fmt(MSG_ESTABLISHING_CONNECTION_FAILED, error.c_str()));
   }
 
-  A2_LOG_INFO(fmt(MSG_CONNECT_FAILED_AND_RETRY,
+  A2_LOG_INFO(fmt(MSG_CONNECT_FAILED_AND_RETRY, getCuid(),
-                  getCuid(),
+                  connectedAddr.c_str(), connectedPort));
-                  connectedAddr.c_str(),
-                  connectedPort));
   e_->setNoWait(true);
-  e_->addCommand
+  e_->addCommand(
-    (InitiateConnectionCommandFactory::createInitiateConnectionCommand
+      InitiateConnectionCommandFactory::createInitiateConnectionCommand(
-     (getCuid(), req_, fileEntry_, requestGroup_, e_));
+          getCuid(), req_, fileEntry_, requestGroup_, e_));
   return false;
 }
 
@@ -909,10 +886,7 @@ void AbstractCommand::setRequest(const std::shared_ptr<Request>& request)
   req_ = request;
 }
 
-void AbstractCommand::resetRequest()
+void AbstractCommand::resetRequest() { req_.reset(); }
-{
-  req_.reset();
-}
 
 void AbstractCommand::setFileEntry(const std::shared_ptr<FileEntry>& fileEntry)
 {

src/AbstractCommand.h

@@ -62,8 +62,7 @@ class AsyncNameResolver;
 class AsyncNameResolverMan;
 #endif // ENABLE_ASYNC_DNS
 
-class AbstractCommand : public Command
+class AbstractCommand : public Command {
-{
 private:
   std::shared_ptr<Request> req_;
   std::shared_ptr<FileEntry> fileEntry_;
@@ -97,15 +96,9 @@ private:
   bool shouldProcess() const;
 
 public:
-  RequestGroup* getRequestGroup() const
+  RequestGroup* getRequestGroup() const { return requestGroup_; }
-  {
-    return requestGroup_;
-  }
 
-  const std::shared_ptr<Request>& getRequest() const
+  const std::shared_ptr<Request>& getRequest() const { return req_; }
-  {
-    return req_;
-  }
 
   void setRequest(const std::shared_ptr<Request>& request);
 
@@ -113,27 +106,15 @@ public:
   // setRequest(std::shared_ptr<Request>());
   void resetRequest();
 
-  const std::shared_ptr<FileEntry>& getFileEntry() const
+  const std::shared_ptr<FileEntry>& getFileEntry() const { return fileEntry_; }
-  {
-    return fileEntry_;
-  }
 
   void setFileEntry(const std::shared_ptr<FileEntry>& fileEntry);
 
-  DownloadEngine* getDownloadEngine() const
+  DownloadEngine* getDownloadEngine() const { return e_; }
-  {
-    return e_;
-  }
 
-  const std::shared_ptr<SocketCore>& getSocket() const
+  const std::shared_ptr<SocketCore>& getSocket() const { return socket_; }
-  {
-    return socket_;
-  }
 
-  std::shared_ptr<SocketCore>& getSocket()
+  std::shared_ptr<SocketCore>& getSocket() { return socket_; }
-  {
-    return socket_;
-  }
 
   void setSocket(const std::shared_ptr<SocketCore>& s);
 
@@ -155,8 +136,7 @@ public:
   // arguments until resolved address is returned.  Exception is
   // thrown on error. port is used for retrieving cached addresses.
   std::string resolveHostname(std::vector<std::string>& addrs,
-                              const std::string& hostname,
+                              const std::string& hostname, uint16_t port);
-                              uint16_t port);
 
   void tryReserved();
 
@@ -185,10 +165,7 @@ public:
   // check.
   void swapSocket(std::shared_ptr<SocketCore>& socket);
 
-  std::chrono::seconds getTimeout() const
+  std::chrono::seconds getTimeout() const { return timeout_; }
-  {
-    return timeout_;
-  }
 
   void setTimeout(std::chrono::seconds timeout)
   {
@@ -229,10 +206,7 @@ public:
   const std::shared_ptr<SegmentMan>& getSegmentMan() const;
   const std::shared_ptr<PieceStorage>& getPieceStorage() const;
 
-  Timer& getCheckPoint()
+  Timer& getCheckPoint() { return checkPoint_; }
-  {
-    return checkPoint_;
-  }
 
   void checkSocketRecvBuffer();
 
@@ -247,20 +221,14 @@ protected:
 
   // Returns true if the derived class wants to execute
   // executeInternal() unconditionally
-  virtual bool noCheck() const
+  virtual bool noCheck() const { return false; }
-  {
-    return false;
-  }
 
 public:
-  AbstractCommand(cuid_t cuid,
+  AbstractCommand(
-                  const std::shared_ptr<Request>& req,
+      cuid_t cuid, const std::shared_ptr<Request>& req,
-                  const std::shared_ptr<FileEntry>& fileEntry,
+      const std::shared_ptr<FileEntry>& fileEntry, RequestGroup* requestGroup,
-                  RequestGroup* requestGroup,
+      DownloadEngine* e, const std::shared_ptr<SocketCore>& s = nullptr,
-                  DownloadEngine* e,
+      const std::shared_ptr<SocketRecvBuffer>& socketRecvBuffer = nullptr,
-                  const std::shared_ptr<SocketCore>& s = nullptr,
-                  const std::shared_ptr<SocketRecvBuffer>& socketRecvBuffer =
-                      nullptr,
       bool incNumConnection = true);
 
   virtual ~AbstractCommand();

src/AbstractDiskWriter.cc

@@ -68,13 +68,11 @@ AbstractDiskWriter::AbstractDiskWriter(const std::string& filename)
       mapaddr_(nullptr),
       maplen_(0)
 
-{}
-
-AbstractDiskWriter::~AbstractDiskWriter()
 {
-  closeFile();
 }
 
+AbstractDiskWriter::~AbstractDiskWriter() { closeFile(); }
+
 namespace {
 // Returns error code depending on the platform. For MinGW32, return
 // the value of GetLastError(). Otherwise, return errno.
@@ -97,13 +95,10 @@ std::string fileStrerror(int errNum)
 #ifdef __MINGW32__
   static char buf[256];
   if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-                   0,
+                    0, errNum,
-                   errNum,
                     // Default language
-                   MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
+                    MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), (LPTSTR)&buf,
-                   (LPTSTR) &buf,
+                    sizeof(buf), 0) == 0) {
-                   sizeof(buf),
-                   0) == 0) {
     snprintf(buf, sizeof(buf), "File I/O error %x", errNum);
   }
   return buf;
@@ -117,7 +112,8 @@ void AbstractDiskWriter::openFile(int64_t totalLength)
 {
   try {
     openExistingFile(totalLength);
-  } catch(RecoverableException& e) {
+  }
+  catch (RecoverableException& e) {
     if (
 #ifdef __MINGW32__
         e.getErrNum() == ERROR_FILE_NOT_FOUND ||
@@ -127,7 +123,8 @@ void AbstractDiskWriter::openFile(int64_t totalLength)
 #endif // !__MINGW32__
         ) {
       initAndOpenFile(totalLength);
-    } else {
+    }
+    else {
       throw;
     }
   }
@@ -151,9 +148,10 @@ void AbstractDiskWriter::closeFile()
 #endif // !__MINGW32__
     if (errNum != 0) {
       int errNum = fileError();
-      A2_LOG_ERROR(fmt("Unmapping file %s failed: %s",
+      A2_LOG_ERROR(fmt("Unmapping file %s failed: %s", filename_.c_str(),
-                       filename_.c_str(), fileStrerror(errNum).c_str()));
+                       fileStrerror(errNum).c_str()));
-    } else {
+    }
+    else {
       A2_LOG_INFO(fmt("Unmapping file %s succeeded", filename_.c_str()));
     }
     mapaddr_ = nullptr;
@@ -182,18 +180,22 @@ HANDLE openFileWithFlags(const std::string& filename, int flags,
 
   if (flags & O_RDWR) {
     desiredAccess = GENERIC_READ | GENERIC_WRITE;
-  } else if(flags & O_WRONLY) {
+  }
+  else if (flags & O_WRONLY) {
     desiredAccess = GENERIC_WRITE;
-  } else {
+  }
+  else {
     desiredAccess = GENERIC_READ;
   }
   if (flags & O_CREAT) {
     if (flags & O_TRUNC) {
       creationDisp |= CREATE_ALWAYS;
-    } else {
+    }
+    else {
       creationDisp |= CREATE_NEW;
     }
-  } else {
+  }
+  else {
     creationDisp |= OPEN_EXISTING;
   }
   hn = CreateFileW(utf8ToWChar(filename).c_str(), desiredAccess, sharedMode,
@@ -201,8 +203,7 @@ HANDLE openFileWithFlags(const std::string& filename, int flags,
                    FILE_ATTRIBUTE_NORMAL, /* hTemplateFile */ 0);
   if (hn == INVALID_HANDLE_VALUE) {
     int errNum = GetLastError();
-    throw DL_ABORT_EX3(errNum, fmt(EX_FILE_OPEN,
+    throw DL_ABORT_EX3(errNum, fmt(EX_FILE_OPEN, filename.c_str(),
-                                   filename.c_str(),
                                    fileStrerror(errNum).c_str()),
                        errCode);
   }
@@ -213,8 +214,9 @@ int openFileWithFlags(const std::string& filename, int flags,
                       error_code::Value errCode)
 {
   int fd;
-  while((fd = a2open(utf8ToWChar(filename).c_str(), flags, OPEN_MODE)) == -1
+  while ((fd = a2open(utf8ToWChar(filename).c_str(), flags, OPEN_MODE)) == -1 &&
-        && errno == EINTR);
+         errno == EINTR)
+    ;
   if (fd < 0) {
     int errNum = errno;
     throw DL_ABORT_EX3(errNum, fmt(EX_FILE_OPEN, filename.c_str(),
@@ -235,7 +237,8 @@ void AbstractDiskWriter::openExistingFile(int64_t totalLength)
   int flags = O_BINARY;
   if (readOnly_) {
     flags |= O_RDONLY;
-  } else {
+  }
+  else {
     flags |= O_RDWR;
   }
   fd_ = openFileWithFlags(filename_, flags, error_code::FILE_OPEN_ERROR);
@@ -245,7 +248,8 @@ void AbstractDiskWriter::createFile(int addFlags)
 {
   assert(!filename_.empty());
   util::mkdirs(File(filename_).getDirname());
-  fd_ = openFileWithFlags(filename_, O_CREAT|O_RDWR|O_TRUNC|O_BINARY|addFlags,
+  fd_ = openFileWithFlags(filename_,
+                          O_CREAT | O_RDWR | O_TRUNC | O_BINARY | addFlags,
                           error_code::FILE_CREATE_ERROR);
 }
 
@@ -255,21 +259,26 @@ ssize_t AbstractDiskWriter::writeDataInternal(const unsigned char* data,
   if (mapaddr_) {
     memcpy(mapaddr_ + offset, data, len);
     return len;
-  } else {
+  }
+  else {
     ssize_t writtenLength = 0;
     seek(offset);
     while ((size_t)writtenLength < len) {
 #ifdef __MINGW32__
       DWORD nwrite;
-      if(WriteFile(fd_, data+writtenLength, len-writtenLength, &nwrite, 0)) {
+      if (WriteFile(fd_, data + writtenLength, len - writtenLength, &nwrite,
+                    0)) {
         writtenLength += nwrite;
-      } else {
+      }
+      else {
         return -1;
       }
 #else  // !__MINGW32__
       ssize_t ret = 0;
-      while((ret = write(fd_, data+writtenLength, len-writtenLength)) == -1 &&
+      while ((ret = write(fd_, data + writtenLength, len - writtenLength)) ==
-            errno == EINTR);
+                 -1 &&
+             errno == EINTR)
+        ;
       if (ret == -1) {
         return -1;
       }
@@ -290,18 +299,21 @@ ssize_t AbstractDiskWriter::readDataInternal(unsigned char* data, size_t len,
     auto readlen = std::min(maplen_ - offset, static_cast<int64_t>(len));
     memcpy(data, mapaddr_ + offset, readlen);
     return readlen;
-  } else {
+  }
+  else {
     seek(offset);
 #ifdef __MINGW32__
     DWORD nread;
     if (ReadFile(fd_, data, len, &nread, 0)) {
       return nread;
-    } else {
+    }
+    else {
       return -1;
     }
 #else  // !__MINGW32__
     ssize_t ret = 0;
-    while((ret = read(fd_, data, len)) == -1 && errno == EINTR);
+    while ((ret = read(fd_, data, len)) == -1 && errno == EINTR)
+      ;
     return ret;
 #endif // !__MINGW32__
   }
@@ -319,8 +331,8 @@ void AbstractDiskWriter::seek(int64_t offset)
 #endif // !__MINGW32__
   {
     int errNum = fileError();
-      throw DL_ABORT_EX2(fmt(EX_FILE_SEEK, filename_.c_str(),
+    throw DL_ABORT_EX2(
-                             fileStrerror(errNum).c_str()),
+        fmt(EX_FILE_SEEK, filename_.c_str(), fileStrerror(errNum).c_str()),
         error_code::FILE_IO_ERROR);
   }
 }
@@ -344,14 +356,15 @@ void AbstractDiskWriter::ensureMmapWrite(size_t len, int64_t offset)
         }
 #endif // !__MINGW32__
         if (errNum != 0) {
-          A2_LOG_ERROR(fmt("Unmapping file %s failed: %s",
+          A2_LOG_ERROR(fmt("Unmapping file %s failed: %s", filename_.c_str(),
-                           filename_.c_str(), fileStrerror(errNum).c_str()));
+                           fileStrerror(errNum).c_str()));
         }
         mapaddr_ = nullptr;
         maplen_ = 0;
         enableMmap_ = false;
       }
-    } else {
+    }
+    else {
       int64_t filesize = size();
 
       if (filesize == 0) {
@@ -364,35 +377,35 @@ void AbstractDiskWriter::ensureMmapWrite(size_t len, int64_t offset)
       int errNum = 0;
       if (static_cast<int64_t>(len + offset) <= filesize) {
 #ifdef __MINGW32__
-        mapView_ = CreateFileMapping(fd_, 0, PAGE_READWRITE,
+        mapView_ = CreateFileMapping(fd_, 0, PAGE_READWRITE, filesize >> 32,
-                                     filesize >> 32, filesize & 0xffffffffu,
+                                     filesize & 0xffffffffu, 0);
-                                     0);
         if (mapView_) {
-          mapaddr_ = reinterpret_cast<unsigned char*>
+          mapaddr_ = reinterpret_cast<unsigned char*>(
-            (MapViewOfFile(mapView_, FILE_MAP_WRITE, 0, 0, 0));
+              MapViewOfFile(mapView_, FILE_MAP_WRITE, 0, 0, 0));
           if (!mapaddr_) {
             errNum = GetLastError();
             CloseHandle(mapView_);
             mapView_ = INVALID_HANDLE_VALUE;
           }
-        } else {
+        }
+        else {
           errNum = GetLastError();
         }
 #else  // !__MINGW32__
-        mapaddr_ = reinterpret_cast<unsigned char*>
+        mapaddr_ = reinterpret_cast<unsigned char*>(mmap(
-          (mmap(nullptr, filesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd_, 0));
+            nullptr, filesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd_, 0));
         if (!mapaddr_) {
           errNum = errno;
         }
 #endif // !__MINGW32__
         if (mapaddr_) {
           A2_LOG_DEBUG(fmt("Mapping file %s succeeded, length=%" PRId64 "",
-                           filename_.c_str(),
+                           filename_.c_str(), static_cast<uint64_t>(filesize)));
-                           static_cast<uint64_t>(filesize)));
           maplen_ = filesize;
-        } else {
+        }
-          A2_LOG_WARN(fmt("Mapping file %s failed: %s",
+        else {
-                          filename_.c_str(), fileStrerror(errNum).c_str()));
+          A2_LOG_WARN(fmt("Mapping file %s failed: %s", filename_.c_str(),
+                          fileStrerror(errNum).c_str()));
           enableMmap_ = false;
         }
       }
@@ -401,7 +414,8 @@ void AbstractDiskWriter::ensureMmapWrite(size_t len, int64_t offset)
 #endif // HAVE_MMAP || __MINGW32__
 }
 
-void AbstractDiskWriter::writeData(const unsigned char* data, size_t len, int64_t offset)
+void AbstractDiskWriter::writeData(const unsigned char* data, size_t len,
+                                   int64_t offset)
 {
   ensureMmapWrite(len, offset);
   if (writeDataInternal(data, len, offset) < 0) {
@@ -415,26 +429,26 @@ void AbstractDiskWriter::writeData(const unsigned char* data, size_t len, int64_
         errNum == ENOSPC
 #endif // !__MINGW32__
         ) {
-      throw DOWNLOAD_FAILURE_EXCEPTION3
+      throw DOWNLOAD_FAILURE_EXCEPTION3(
-        (errNum, fmt(EX_FILE_WRITE, filename_.c_str(),
+          errNum,
-                     fileStrerror(errNum).c_str()),
+          fmt(EX_FILE_WRITE, filename_.c_str(), fileStrerror(errNum).c_str()),
           error_code::NOT_ENOUGH_DISK_SPACE);
-    } else {
+    }
-      throw DL_ABORT_EX3
+    else {
-        (errNum, fmt(EX_FILE_WRITE, filename_.c_str(),
+      throw DL_ABORT_EX3(errNum, fmt(EX_FILE_WRITE, filename_.c_str(),
                                      fileStrerror(errNum).c_str()),
                          error_code::FILE_IO_ERROR);
     }
   }
 }
 
-ssize_t AbstractDiskWriter::readData(unsigned char* data, size_t len, int64_t offset)
+ssize_t AbstractDiskWriter::readData(unsigned char* data, size_t len,
+                                     int64_t offset)
 {
   ssize_t ret;
   if ((ret = readDataInternal(data, len, offset)) < 0) {
     int errNum = fileError();
-    throw DL_ABORT_EX3
+    throw DL_ABORT_EX3(errNum, fmt(EX_FILE_READ, filename_.c_str(),
-      (errNum, fmt(EX_FILE_READ, filename_.c_str(),
                                    fileStrerror(errNum).c_str()),
                        error_code::FILE_IO_ERROR);
   }
@@ -456,8 +470,8 @@ void AbstractDiskWriter::truncate(int64_t length)
 #endif // !__MINGW32__
   {
     int errNum = fileError();
-      throw DL_ABORT_EX2(fmt("File truncation failed. cause: %s",
+    throw DL_ABORT_EX2(
-                             fileStrerror(errNum).c_str()),
+        fmt("File truncation failed. cause: %s", fileStrerror(errNum).c_str()),
         error_code::FILE_IO_ERROR);
   }
 }
@@ -470,8 +484,8 @@ void AbstractDiskWriter::allocate(int64_t offset, int64_t length, bool sparse)
   if (sparse) {
 #ifdef __MINGW32__
     DWORD bytesReturned;
-    if(!DeviceIoControl(fd_, FSCTL_SET_SPARSE, 0, 0, 0, 0,
+    if (!DeviceIoControl(fd_, FSCTL_SET_SPARSE, 0, 0, 0, 0, &bytesReturned,
-                        &bytesReturned, 0)) {
+                         0)) {
       A2_LOG_WARN(fmt("Making file sparse failed or pending: %s",
                       fileStrerror(GetLastError()).c_str()));
     }
@@ -486,20 +500,16 @@ void AbstractDiskWriter::allocate(int64_t offset, int64_t length, bool sparse)
   auto toalloc = offset + length - size();
   while (toalloc > 0) {
     fstore_t fstore = {
-      F_ALLOCATECONTIG | F_ALLOCATEALL,
+        F_ALLOCATECONTIG | F_ALLOCATEALL, F_PEOFPOSMODE, 0,
-      F_PEOFPOSMODE,
-      0,
         // Allocate in 1GB chunks or else some OSX versions may choke.
-      std::min(toalloc, (int64_t)1<<30),
+        std::min(toalloc, (int64_t)1 << 30), 0};
-      0
-    };
     if (fcntl(fd_, F_PREALLOCATE, &fstore) == -1) {
       // Retry non-contig.
       fstore.fst_flags = F_ALLOCATEALL;
       if (fcntl(fd_, F_PREALLOCATE, &fstore) == -1) {
         int err = errno;
-        throw DL_ABORT_EX3(err,
+        throw DL_ABORT_EX3(
-                          fmt("fcntl(F_PREALLOCATE) of %" PRId64 " failed. cause: %s",
+            err, fmt("fcntl(F_PREALLOCATE) of %" PRId64 " failed. cause: %s",
                      fstore.fst_length, util::safeStrerror(err).c_str()),
             error_code::FILE_IO_ERROR);
       }
@@ -512,19 +522,18 @@ void AbstractDiskWriter::allocate(int64_t offset, int64_t length, bool sparse)
   // For linux, we use fallocate to detect file system supports
   // fallocate or not.
   int r;
-  while((r = fallocate(fd_, 0, offset, length)) == -1 && errno == EINTR);
+  while ((r = fallocate(fd_, 0, offset, length)) == -1 && errno == EINTR)
+    ;
   int errNum = errno;
   if (r == -1) {
-    throw DL_ABORT_EX3(errNum,
+    throw DL_ABORT_EX3(errNum, fmt("fallocate failed. cause: %s",
-                       fmt("fallocate failed. cause: %s",
                                    util::safeStrerror(errNum).c_str()),
                        error_code::FILE_IO_ERROR);
   }
 #elif HAVE_POSIX_FALLOCATE
   int r = posix_fallocate(fd_, offset, length);
   if (r != 0) {
-    throw DL_ABORT_EX3(r,
+    throw DL_ABORT_EX3(r, fmt("posix_fallocate failed. cause: %s",
-                       fmt("posix_fallocate failed. cause: %s",
                               util::safeStrerror(r).c_str()),
                        error_code::FILE_IO_ERROR);
   }
@@ -534,25 +543,13 @@ void AbstractDiskWriter::allocate(int64_t offset, int64_t length, bool sparse)
 #endif // HAVE_SOME_FALLOCATE
 }
 
-int64_t AbstractDiskWriter::size()
+int64_t AbstractDiskWriter::size() { return File(filename_).size(); }
-{
-  return File(filename_).size();
-}
 
-void AbstractDiskWriter::enableReadOnly()
+void AbstractDiskWriter::enableReadOnly() { readOnly_ = true; }
-{
-  readOnly_ = true;
-}
 
-void AbstractDiskWriter::disableReadOnly()
+void AbstractDiskWriter::disableReadOnly() { readOnly_ = false; }
-{
-  readOnly_ = false;
-}
 
-void AbstractDiskWriter::enableMmap()
+void AbstractDiskWriter::enableMmap() { enableMmap_ = true; }
-{
-  enableMmap_ = true;
-}
 
 void AbstractDiskWriter::dropCache(int64_t len, int64_t offset)
 {

src/AbstractDiskWriter.h

@@ -65,8 +65,10 @@ private:
   void seek(int64_t offset);
 
   void ensureMmapWrite(size_t len, int64_t offset);
+
 protected:
   void createFile(int addFlags = 0);
+
 public:
   AbstractDiskWriter(const std::string& filename);
   virtual ~AbstractDiskWriter();
@@ -77,17 +79,17 @@ public:
 
   virtual void openExistingFile(int64_t totalLength = 0) CXX11_OVERRIDE;
 
-  virtual void writeData(const unsigned char* data, size_t len, int64_t offset)
+  virtual void writeData(const unsigned char* data, size_t len,
-    CXX11_OVERRIDE;
+                         int64_t offset) CXX11_OVERRIDE;
 
-  virtual ssize_t readData(unsigned char* data, size_t len, int64_t offset)
+  virtual ssize_t readData(unsigned char* data, size_t len,
-    CXX11_OVERRIDE;
+                           int64_t offset) CXX11_OVERRIDE;
 
   virtual void truncate(int64_t length) CXX11_OVERRIDE;
 
   // File must be opened before calling this function.
-  virtual void allocate(int64_t offset, int64_t length, bool sparse)
+  virtual void allocate(int64_t offset, int64_t length,
-     CXX11_OVERRIDE;
+                        bool sparse) CXX11_OVERRIDE;
 
   virtual int64_t size() CXX11_OVERRIDE;
 

src/AbstractHttpServerResponseCommand.cc

@@ -47,11 +47,9 @@
 
 namespace aria2 {
 
-AbstractHttpServerResponseCommand::AbstractHttpServerResponseCommand
+AbstractHttpServerResponseCommand::AbstractHttpServerResponseCommand(
-(cuid_t cuid,
+    cuid_t cuid, const std::shared_ptr<HttpServer>& httpServer,
- const std::shared_ptr<HttpServer>& httpServer,
+    DownloadEngine* e, const std::shared_ptr<SocketCore>& socket)
- DownloadEngine* e,
- const std::shared_ptr<SocketCore>& socket)
     : Command(cuid),
       e_(e),
       socket_(socket),
@@ -80,7 +78,8 @@ void AbstractHttpServerResponseCommand::updateReadWriteCheck()
       readCheck_ = true;
       e_->addSocketForReadCheck(socket_, this);
     }
-  } else if(readCheck_) {
+  }
+  else if (readCheck_) {
     readCheck_ = false;
     e_->deleteSocketForReadCheck(socket_, this);
   }
@@ -89,7 +88,8 @@ void AbstractHttpServerResponseCommand::updateReadWriteCheck()
       writeCheck_ = true;
       e_->addSocketForWriteCheck(socket_, this);
     }
-  } else if(writeCheck_) {
+  }
+  else if (writeCheck_) {
     writeCheck_ = false;
     e_->deleteSocketForWriteCheck(socket_, this);
   }
@@ -105,9 +105,9 @@ bool AbstractHttpServerResponseCommand::execute()
     if (len > 0) {
       timeoutTimer_ = global::wallclock();
     }
-  } catch(RecoverableException& e) {
+  }
-    A2_LOG_INFO_EX
+  catch (RecoverableException& e) {
-      (fmt("CUID#%" PRId64
+    A2_LOG_INFO_EX(fmt("CUID#%" PRId64
                        " - Error occurred while transmitting response body.",
                        getCuid()),
                    e);
@@ -118,13 +118,15 @@ bool AbstractHttpServerResponseCommand::execute()
                     getCuid()));
     afterSend(httpServer_, e_);
     return true;
-  } else {
+  }
+  else {
     if (timeoutTimer_.difference(global::wallclock()) >= 30_s) {
       A2_LOG_INFO(fmt("CUID#%" PRId64
                       " - HttpServer: Timeout while trasmitting response.",
                       getCuid()));
       return true;
-    } else {
+    }
+    else {
       updateReadWriteCheck();
       e_->addCommand(std::unique_ptr<Command>(this));
       return false;

src/AbstractHttpServerResponseCommand.h

@@ -57,19 +57,17 @@ private:
   bool writeCheck_;
 
   void updateReadWriteCheck();
+
 protected:
-  DownloadEngine* getDownloadEngine()
+  DownloadEngine* getDownloadEngine() { return e_; }
-  {
-    return e_;
-  }
   // Called after content body is completely sent.
   virtual void afterSend(const std::shared_ptr<HttpServer>& httpServer,
                          DownloadEngine* e) = 0;
+
 public:
-  AbstractHttpServerResponseCommand(cuid_t cuid,
+  AbstractHttpServerResponseCommand(
-                                    const std::shared_ptr<HttpServer>& httpServer,
+      cuid_t cuid, const std::shared_ptr<HttpServer>& httpServer,
-                                    DownloadEngine* e,
+      DownloadEngine* e, const std::shared_ptr<SocketCore>& socket);
-                                    const std::shared_ptr<SocketCore>& socket);
 
   virtual ~AbstractHttpServerResponseCommand();
 

src/AbstractOptionHandler.cc

@@ -44,12 +44,10 @@
 
 namespace aria2 {
 
-AbstractOptionHandler::AbstractOptionHandler
+AbstractOptionHandler::AbstractOptionHandler(PrefPtr pref,
-(PrefPtr pref,
                                              const char* description,
                                              const std::string& defaultValue,
- ARG_TYPE argType,
+                                             ARG_TYPE argType, char shortName)
- char shortName)
     : pref_(pref),
       description_(description),
       defaultValue_(defaultValue),
@@ -57,7 +55,8 @@ AbstractOptionHandler::AbstractOptionHandler
       shortName_(shortName),
       tags_(0),
       flags_(0)
-{}
+{
+}
 
 AbstractOptionHandler::~AbstractOptionHandler() {}
 
@@ -65,7 +64,8 @@ void AbstractOptionHandler::parse(Option& option, const std::string& arg) const
 {
   try {
     parseArg(option, arg);
-  } catch(Exception& e) {
+  }
+  catch (Exception& e) {
     throw OPTION_HANDLER_EXCEPTION2(pref_, e);
   }
 }
@@ -75,10 +75,7 @@ bool AbstractOptionHandler::hasTag(uint32_t tag) const
   return (tags_ & (1 << tag));
 }
 
-void AbstractOptionHandler::addTag(uint32_t tag)
+void AbstractOptionHandler::addTag(uint32_t tag) { tags_ |= (1 << tag); }
-{
-  tags_ |= (1 << tag);
-}
 
 std::string AbstractOptionHandler::toTagString() const
 {
@@ -95,29 +92,21 @@ std::string AbstractOptionHandler::toTagString() const
   return s;
 }
 
-const char* AbstractOptionHandler::getName() const
+const char* AbstractOptionHandler::getName() const { return pref_->k; }
-{
-  return pref_->k;
-}
 
 void AbstractOptionHandler::updateFlags(int flag, bool val)
 {
   if (val) {
     flags_ |= flag;
-  } else {
+  }
+  else {
     flags_ &= ~flag;
   }
 }
 
-bool AbstractOptionHandler::isHidden() const
+bool AbstractOptionHandler::isHidden() const { return flags_ & FLAG_HIDDEN; }
-{
-  return flags_ & FLAG_HIDDEN;
-}
 
-void AbstractOptionHandler::hide()
+void AbstractOptionHandler::hide() { updateFlags(FLAG_HIDDEN, true); }
-{
-  updateFlags(FLAG_HIDDEN, true);
-}
 
 bool AbstractOptionHandler::getEraseAfterParse() const
 {

src/AbstractOptionHandler.h

@@ -55,17 +55,16 @@ protected:
   char shortName_;
 
   virtual void parseArg(Option& option, const std::string& arg) const = 0;
+
 public:
-  AbstractOptionHandler(PrefPtr pref,
+  AbstractOptionHandler(PrefPtr pref, const char* description = NO_DESCRIPTION,
-                         const char* description = NO_DESCRIPTION,
                         const std::string& defaultValue = NO_DEFAULT_VALUE,
-                         ARG_TYPE argType = REQ_ARG,
+                        ARG_TYPE argType = REQ_ARG, char shortName = 0);
-                         char shortName = 0);
 
   virtual ~AbstractOptionHandler();
 
-  virtual void parse(Option& option, const std::string& arg) const
+  virtual void parse(Option& option,
-    CXX11_OVERRIDE;
+                     const std::string& arg) const CXX11_OVERRIDE;
 
   virtual bool hasTag(uint32_t tag) const CXX11_OVERRIDE;
 
@@ -85,15 +84,9 @@ public:
     return defaultValue_;
   }
 
-  virtual PrefPtr getPref() const CXX11_OVERRIDE
+  virtual PrefPtr getPref() const CXX11_OVERRIDE { return pref_; }
-  {
-    return pref_;
-  }
 
-  virtual char getShortName() const CXX11_OVERRIDE
+  virtual char getShortName() const CXX11_OVERRIDE { return shortName_; }
-  {
-    return shortName_;
-  }
 
   virtual OptionHandler::ARG_TYPE getArgType() const CXX11_OVERRIDE
   {
@@ -137,6 +130,7 @@ public:
     FLAG_CHANGE_GLOBAL_OPTION = 1 << 5,
     FLAG_CUMULATIVE = 1 << 6
   };
+
 private:
   // bitwise OR of (1 << HelpTag value) defined in help_tags.h.
   uint32_t tags_;

src/AbstractProxyRequestCommand.cc

@@ -49,20 +49,15 @@
 
 namespace aria2 {
 
-AbstractProxyRequestCommand::AbstractProxyRequestCommand
+AbstractProxyRequestCommand::AbstractProxyRequestCommand(
-(cuid_t cuid,
+    cuid_t cuid, const std::shared_ptr<Request>& req,
- const std::shared_ptr<Request>& req,
+    const std::shared_ptr<FileEntry>& fileEntry, RequestGroup* requestGroup,
- const std::shared_ptr<FileEntry>& fileEntry,
+    DownloadEngine* e, const std::shared_ptr<Request>& proxyRequest,
- RequestGroup* requestGroup,
- DownloadEngine* e,
- const std::shared_ptr<Request>& proxyRequest,
     const std::shared_ptr<SocketCore>& s)
-  :
+    : AbstractCommand(cuid, req, fileEntry, requestGroup, e, s),
-  AbstractCommand(cuid, req, fileEntry, requestGroup, e, s),
       proxyRequest_(proxyRequest),
-  httpConnection_
+      httpConnection_(std::make_shared<HttpConnection>(
-  (std::make_shared<HttpConnection>
+          cuid, s, std::make_shared<SocketRecvBuffer>(s)))
-   (cuid, s, std::make_shared<SocketRecvBuffer>(s)))
 {
   setTimeout(std::chrono::seconds(getOption()->getAsInt(PREF_CONNECT_TIMEOUT)));
   disableReadCheckSocket();
@@ -71,7 +66,8 @@ AbstractProxyRequestCommand::AbstractProxyRequestCommand
 
 AbstractProxyRequestCommand::~AbstractProxyRequestCommand() {}
 
-bool AbstractProxyRequestCommand::executeInternal() {
+bool AbstractProxyRequestCommand::executeInternal()
+{
   // socket->setBlockingMode();
   if (httpConnection_->sendBufferIsEmpty()) {
     auto httpRequest = make_unique<HttpRequest>();
@@ -80,13 +76,15 @@ bool AbstractProxyRequestCommand::executeInternal() {
     httpRequest->setProxyRequest(proxyRequest_);
 
     httpConnection_->sendProxyRequest(std::move(httpRequest));
-  } else {
+  }
+  else {
     httpConnection_->sendPendingData();
   }
   if (httpConnection_->sendBufferIsEmpty()) {
     getDownloadEngine()->addCommand(getNextCommand());
     return true;
-  } else {
+  }
+  else {
     setWriteCheckSocket(getSocket());
     addCommandSelf();
     return false;

src/AbstractProxyRequestCommand.h

@@ -47,6 +47,7 @@ private:
   std::shared_ptr<Request> proxyRequest_;
 
   std::shared_ptr<HttpConnection> httpConnection_;
+
 protected:
   virtual bool executeInternal() CXX11_OVERRIDE;
 
@@ -59,12 +60,11 @@ protected:
   {
     return proxyRequest_;
   }
+
 public:
-  AbstractProxyRequestCommand(cuid_t cuid,
+  AbstractProxyRequestCommand(cuid_t cuid, const std::shared_ptr<Request>& req,
-                              const std::shared_ptr<Request>& req,
                               const std::shared_ptr<FileEntry>& fileEntry,
-                              RequestGroup* requestGroup,
+                              RequestGroup* requestGroup, DownloadEngine* e,
-                              DownloadEngine* e,
                               const std::shared_ptr<Request>& proxyRequest,
                               const std::shared_ptr<SocketCore>& s);
 

src/AbstractProxyResponseCommand.cc

@@ -50,21 +50,22 @@
 
 namespace aria2 {
 
-AbstractProxyResponseCommand::AbstractProxyResponseCommand
+AbstractProxyResponseCommand::AbstractProxyResponseCommand(
-(cuid_t cuid,
+    cuid_t cuid, const std::shared_ptr<Request>& req,
- const std::shared_ptr<Request>& req,
+    const std::shared_ptr<FileEntry>& fileEntry, RequestGroup* requestGroup,
- const std::shared_ptr<FileEntry>& fileEntry,
+    const std::shared_ptr<HttpConnection>& httpConnection, DownloadEngine* e,
- RequestGroup* requestGroup,
- const std::shared_ptr<HttpConnection>& httpConnection,
- DownloadEngine* e,
     const std::shared_ptr<SocketCore>& s)
     : AbstractCommand(cuid, req, fileEntry, requestGroup, e, s),
-   httpConnection_(httpConnection) {}
+      httpConnection_(httpConnection)
+{
+}
 
 AbstractProxyResponseCommand::~AbstractProxyResponseCommand() {}
 
-bool AbstractProxyResponseCommand::executeInternal() {
+bool AbstractProxyResponseCommand::executeInternal()
-  std::shared_ptr<HttpResponse> httpResponse = httpConnection_->receiveResponse();
+{
+  std::shared_ptr<HttpResponse> httpResponse =
+      httpConnection_->receiveResponse();
   if (!httpResponse) {
     // the server has not responded our request yet.
     addCommandSelf();

src/AbstractProxyResponseCommand.h

@@ -45,6 +45,7 @@ class SocketCore;
 class AbstractProxyResponseCommand : public AbstractCommand {
 private:
   std::shared_ptr<HttpConnection> httpConnection_;
+
 protected:
   virtual bool executeInternal() CXX11_OVERRIDE;
 
@@ -52,14 +53,12 @@ protected:
   {
     return httpConnection_;
   }
+
 public:
-  AbstractProxyResponseCommand
+  AbstractProxyResponseCommand(
-  (cuid_t cuid,
+      cuid_t cuid, const std::shared_ptr<Request>& req,
-   const std::shared_ptr<Request>& req,
+      const std::shared_ptr<FileEntry>& fileEntry, RequestGroup* requestGroup,
-   const std::shared_ptr<FileEntry>& fileEntry,
+      const std::shared_ptr<HttpConnection>& httpConnection, DownloadEngine* e,
-   RequestGroup* requestGroup,
-   const std::shared_ptr<HttpConnection>& httpConnection,
-   DownloadEngine* e,
       const std::shared_ptr<SocketCore>& s);
 
   virtual ~AbstractProxyResponseCommand();

src/AbstractSingleDiskAdaptor.cc

@@ -46,8 +46,10 @@
 
 namespace aria2 {
 
-AbstractSingleDiskAdaptor::AbstractSingleDiskAdaptor():
+AbstractSingleDiskAdaptor::AbstractSingleDiskAdaptor()
-  totalLength_(0), readOnly_(false) {}
+    : totalLength_(0), readOnly_(false)
+{
+}
 
 AbstractSingleDiskAdaptor::~AbstractSingleDiskAdaptor() {}
 
@@ -61,30 +63,27 @@ void AbstractSingleDiskAdaptor::openFile()
   diskWriter_->openFile(totalLength_);
 }
 
-void AbstractSingleDiskAdaptor::closeFile()
+void AbstractSingleDiskAdaptor::closeFile() { diskWriter_->closeFile(); }
-{
-  diskWriter_->closeFile();
-}
 
 void AbstractSingleDiskAdaptor::openExistingFile()
 {
   diskWriter_->openExistingFile(totalLength_);
 }
 
-void AbstractSingleDiskAdaptor::writeData
+void AbstractSingleDiskAdaptor::writeData(const unsigned char* data, size_t len,
-(const unsigned char* data, size_t len, int64_t offset)
+                                          int64_t offset)
 {
   diskWriter_->writeData(data, len, offset);
 }
 
-ssize_t AbstractSingleDiskAdaptor::readData
+ssize_t AbstractSingleDiskAdaptor::readData(unsigned char* data, size_t len,
-(unsigned char* data, size_t len, int64_t offset)
+                                            int64_t offset)
 {
   return diskWriter_->readData(data, len, offset);
 }
 
-ssize_t AbstractSingleDiskAdaptor::readDataDropCache
+ssize_t AbstractSingleDiskAdaptor::readDataDropCache(unsigned char* data,
-(unsigned char* data, size_t len, int64_t offset)
+                                                     size_t len, int64_t offset)
 {
   auto rv = readData(data, len, offset);
 
@@ -108,19 +107,20 @@ void AbstractSingleDiskAdaptor::writeCache(const WrDiskCacheEntry* entry)
   const WrDiskCacheEntry::DataCellSet& dataSet = entry->getDataSet();
   for (auto& d : dataSet) {
     if (start + static_cast<ssize_t>(buflen) < d->goff) {
-      A2_LOG_DEBUG(fmt("Cache flush goff=%" PRId64 ", len=%lu",
+      A2_LOG_DEBUG(fmt("Cache flush goff=%" PRId64 ", len=%lu", start,
-                       start, static_cast<unsigned long>(buflen)));
+                       static_cast<unsigned long>(buflen)));
       writeData(buf + buffoffset, buflen - buffoffset, start);
       start = d->goff;
       buflen = buffoffset = 0;
     }
     if (buflen == 0 && (d->goff & 0xfff) == 0 && (d->len & 0xfff) == 0) {
       // Already aligned. Write it without copy.
-      A2_LOG_DEBUG(fmt("Cache flush goff=%" PRId64 ", len=%lu",
+      A2_LOG_DEBUG(fmt("Cache flush goff=%" PRId64 ", len=%lu", start,
-                       start, static_cast<unsigned long>(d->len)));
+                       static_cast<unsigned long>(d->len)));
       writeData(d->data + d->offset, d->len, start);
       start += d->len;
-    } else {
+    }
+    else {
       if (buflen == 0) {
         buflen = buffoffset = d->goff & 0xfff;
       }
@@ -128,8 +128,8 @@ void AbstractSingleDiskAdaptor::writeCache(const WrDiskCacheEntry* entry)
       memcpy(buf + buflen, d->data + d->offset, wlen);
       buflen += wlen;
       if (buflen == sizeof(buf)) {
-        A2_LOG_DEBUG(fmt("Cache flush goff=%" PRId64 ", len=%lu",
+        A2_LOG_DEBUG(fmt("Cache flush goff=%" PRId64 ", len=%lu", start,
-                         start, static_cast<unsigned long>(buflen)));
+                         static_cast<unsigned long>(buflen)));
         writeData(buf + buffoffset, buflen - buffoffset, start);
         memcpy(buf, d->data + d->offset + wlen, d->len - wlen);
         start += sizeof(buf) - buffoffset;
@@ -146,10 +146,7 @@ bool AbstractSingleDiskAdaptor::fileExists()
   return File(getFilePath()).exists();
 }
 
-int64_t AbstractSingleDiskAdaptor::size()
+int64_t AbstractSingleDiskAdaptor::size() { return File(getFilePath()).size(); }
-{
-  return File(getFilePath()).size();
-}
 
 void AbstractSingleDiskAdaptor::truncate(int64_t length)
 {
@@ -162,15 +159,15 @@ AbstractSingleDiskAdaptor::fileAllocationIterator()
   switch (getFileAllocationMethod()) {
 #ifdef HAVE_SOME_FALLOCATE
   case (DiskAdaptor::FILE_ALLOC_FALLOC):
-    return make_unique<FallocFileAllocationIterator>
+    return make_unique<FallocFileAllocationIterator>(diskWriter_.get(), size(),
-      (diskWriter_.get(), size() ,totalLength_);
+                                                     totalLength_);
 #endif // HAVE_SOME_FALLOCATE
   case (DiskAdaptor::FILE_ALLOC_TRUNC):
-    return make_unique<TruncFileAllocationIterator>
+    return make_unique<TruncFileAllocationIterator>(diskWriter_.get(), size(),
-      (diskWriter_.get(), size(), totalLength_);
+                                                    totalLength_);
   default:
-    return make_unique<AdaptiveFileAllocationIterator>
+    return make_unique<AdaptiveFileAllocationIterator>(diskWriter_.get(),
-      (diskWriter_.get(), size(), totalLength_);
+                                                       size(), totalLength_);
   }
 }
 
@@ -186,10 +183,7 @@ void AbstractSingleDiskAdaptor::disableReadOnly()
   readOnly_ = false;
 }
 
-void AbstractSingleDiskAdaptor::enableMmap()
+void AbstractSingleDiskAdaptor::enableMmap() { diskWriter_->enableMmap(); }
-{
-  diskWriter_->enableMmap();
-}
 
 void AbstractSingleDiskAdaptor::cutTrailingGarbage()
 {
@@ -198,8 +192,8 @@ void AbstractSingleDiskAdaptor::cutTrailingGarbage()
   }
 }
 
-void AbstractSingleDiskAdaptor::setDiskWriter
+void AbstractSingleDiskAdaptor::setDiskWriter(
-(std::unique_ptr<DiskWriter> diskWriter)
+    std::unique_ptr<DiskWriter> diskWriter)
 {
   diskWriter_ = std::move(diskWriter);
 }

src/AbstractSingleDiskAdaptor.h

@@ -47,6 +47,7 @@ private:
   std::unique_ptr<DiskWriter> diskWriter_;
   int64_t totalLength_;
   bool readOnly_;
+
 public:
   AbstractSingleDiskAdaptor();
 
@@ -63,12 +64,11 @@ public:
   virtual void writeData(const unsigned char* data, size_t len,
                          int64_t offset) CXX11_OVERRIDE;
 
-  virtual ssize_t readData(unsigned char* data, size_t len, int64_t offset)
+  virtual ssize_t readData(unsigned char* data, size_t len,
-    CXX11_OVERRIDE;
+                           int64_t offset) CXX11_OVERRIDE;
 
   virtual ssize_t readDataDropCache(unsigned char* data, size_t len,
-                                    int64_t offset)
+                                    int64_t offset) CXX11_OVERRIDE;
-    CXX11_OVERRIDE;
 
   virtual void writeCache(const WrDiskCacheEntry* entry) CXX11_OVERRIDE;
 
@@ -78,8 +78,8 @@ public:
 
   virtual void truncate(int64_t length) CXX11_OVERRIDE;
 
-  virtual std::unique_ptr<FileAllocationIterator> fileAllocationIterator()
+  virtual std::unique_ptr<FileAllocationIterator>
-    CXX11_OVERRIDE;
+  fileAllocationIterator() CXX11_OVERRIDE;
 
   // Make sure that DiskWriter is set before calling this function.
   virtual void enableReadOnly() CXX11_OVERRIDE;
@@ -104,10 +104,7 @@ public:
 
   void setTotalLength(int64_t totalLength);
 
-  int64_t getTotalLength() const
+  int64_t getTotalLength() const { return totalLength_; }
-  {
-    return totalLength_;
-  }
 };
 
 } // namespace aria2

src/ActivePeerConnectionCommand.cc

@@ -56,10 +56,8 @@
 
 namespace aria2 {
 
-ActivePeerConnectionCommand::ActivePeerConnectionCommand
+ActivePeerConnectionCommand::ActivePeerConnectionCommand(
-(cuid_t cuid,
+    cuid_t cuid, RequestGroup* requestGroup, DownloadEngine* e,
- RequestGroup* requestGroup,
- DownloadEngine* e,
     std::chrono::seconds interval)
     : Command(cuid),
       requestGroup_(requestGroup),
@@ -75,7 +73,8 @@ ActivePeerConnectionCommand::~ActivePeerConnectionCommand()
   requestGroup_->decreaseNumCommand();
 }
 
-bool ActivePeerConnectionCommand::execute() {
+bool ActivePeerConnectionCommand::execute()
+{
   if (btRuntime_->isHalt()) {
     return true;
   }
@@ -85,11 +84,12 @@ bool ActivePeerConnectionCommand::execute() {
     const int maxDownloadLimit = requestGroup_->getMaxDownloadSpeedLimit();
     const int maxUploadLimit = requestGroup_->getMaxUploadSpeedLimit();
     int thresholdSpeed;
-    if(!bittorrent::getTorrentAttrs
+    if (!bittorrent::getTorrentAttrs(requestGroup_->getDownloadContext())
-       (requestGroup_->getDownloadContext())->metadata.empty()) {
+             ->metadata.empty()) {
-      thresholdSpeed =
+      thresholdSpeed = requestGroup_->getOption()->getAsInt(
-        requestGroup_->getOption()->getAsInt(PREF_BT_REQUEST_PEER_SPEED_LIMIT);
+          PREF_BT_REQUEST_PEER_SPEED_LIMIT);
-    } else {
+    }
+    else {
       thresholdSpeed = 0;
     }
     if (maxDownloadLimit > 0) {
@@ -108,10 +108,11 @@ bool ActivePeerConnectionCommand::execute() {
       if (pieceStorage_->downloadFinished()) {
         if (btRuntime_->getMaxPeers() > btRuntime_->getConnections()) {
           numConnection =
-            std::min(numNewConnection_,
+              std::min(numNewConnection_, btRuntime_->getMaxPeers() -
-                     btRuntime_->getMaxPeers()-btRuntime_->getConnections());
+                                              btRuntime_->getConnections());
         }
-      } else {
+      }
+      else {
         numConnection = numNewConnection_;
       }
 
@@ -136,36 +137,36 @@ void ActivePeerConnectionCommand::makeNewConnections(int num)
     if (!peer) {
       break;
     }
-    auto command = make_unique<PeerInitiateConnectionCommand>
+    auto command = make_unique<PeerInitiateConnectionCommand>(
-      (ncuid, requestGroup_, peer, e_, btRuntime_);
+        ncuid, requestGroup_, peer, e_, btRuntime_);
     command->setPeerStorage(peerStorage_);
     command->setPieceStorage(pieceStorage_);
     e_->addCommand(std::move(command));
-    A2_LOG_INFO(fmt(MSG_CONNECTING_TO_PEER, getCuid(),
+    A2_LOG_INFO(
-                    peer->getIPAddress().c_str()));
+        fmt(MSG_CONNECTING_TO_PEER, getCuid(), peer->getIPAddress().c_str()));
   }
 }
 
-void ActivePeerConnectionCommand::setBtRuntime
+void ActivePeerConnectionCommand::setBtRuntime(
-(const std::shared_ptr<BtRuntime>& btRuntime)
+    const std::shared_ptr<BtRuntime>& btRuntime)
 {
   btRuntime_ = btRuntime;
 }
 
-void ActivePeerConnectionCommand::setPieceStorage
+void ActivePeerConnectionCommand::setPieceStorage(
-(const std::shared_ptr<PieceStorage>& pieceStorage)
+    const std::shared_ptr<PieceStorage>& pieceStorage)
 {
   pieceStorage_ = pieceStorage;
 }
 
-void ActivePeerConnectionCommand::setPeerStorage
+void ActivePeerConnectionCommand::setPeerStorage(
-(const std::shared_ptr<PeerStorage>& peerStorage)
+    const std::shared_ptr<PeerStorage>& peerStorage)
 {
   peerStorage_ = peerStorage;
 }
 
-void ActivePeerConnectionCommand::setBtAnnounce
+void ActivePeerConnectionCommand::setBtAnnounce(
-(const std::shared_ptr<BtAnnounce>& btAnnounce)
+    const std::shared_ptr<BtAnnounce>& btAnnounce)
 {
   btAnnounce_ = btAnnounce;
 }

src/ActivePeerConnectionCommand.h

@@ -64,10 +64,8 @@ private:
   Timer checkPoint_;
   int numNewConnection_; // the number of the connection to establish.
 public:
-  ActivePeerConnectionCommand(cuid_t cuid,
+  ActivePeerConnectionCommand(cuid_t cuid, RequestGroup* requestGroup,
-                              RequestGroup* requestGroup,
+                              DownloadEngine* e, std::chrono::seconds interval);
-                              DownloadEngine* e,
-                              std::chrono::seconds interval);
 
   virtual ~ActivePeerConnectionCommand();
 

src/AdaptiveFileAllocationIterator.cc

@@ -45,12 +45,11 @@
 
 namespace aria2 {
 
-AdaptiveFileAllocationIterator::AdaptiveFileAllocationIterator
+AdaptiveFileAllocationIterator::AdaptiveFileAllocationIterator(
-(BinaryStream* stream, int64_t offset, int64_t totalLength)
+    BinaryStream* stream, int64_t offset, int64_t totalLength)
- : stream_(stream),
+    : stream_(stream), offset_(offset), totalLength_(totalLength)
-   offset_(offset),
+{
-   totalLength_(totalLength)
+}
-{}
 
 AdaptiveFileAllocationIterator::~AdaptiveFileAllocationIterator() {}
 
@@ -67,23 +66,25 @@ void AdaptiveFileAllocationIterator::allocateChunk()
         offset_ += len;
       }
       A2_LOG_DEBUG("File system supports fallocate.");
-      allocator_ = make_unique<FallocFileAllocationIterator>
+      allocator_ = make_unique<FallocFileAllocationIterator>(stream_, offset_,
-        (stream_, offset_, totalLength_);
+                                                             totalLength_);
-    } catch(RecoverableException& e) {
+    }
+    catch (RecoverableException& e) {
       A2_LOG_DEBUG("File system does not support fallocate.");
-      auto salloc = make_unique<SingleFileAllocationIterator>
+      auto salloc = make_unique<SingleFileAllocationIterator>(stream_, offset_,
-        (stream_, offset_, totalLength_);
+                                                              totalLength_);
       salloc->init();
       allocator_ = std::move(salloc);
     }
 #else  // !HAVE_FALLOCATE
-    auto salloc = make_unique<SingleFileAllocationIterator>
+    auto salloc = make_unique<SingleFileAllocationIterator>(stream_, offset_,
-      (stream_, offset_, totalLength_);
+                                                            totalLength_);
     salloc->init();
     allocator_ = std::move(salloc);
 #endif // !HAVE_FALLOCATE
     allocator_->allocateChunk();
-  } else {
+  }
+  else {
     allocator_->allocateChunk();
   }
 }
@@ -92,7 +93,8 @@ bool AdaptiveFileAllocationIterator::finished()
 {
   if (!allocator_) {
     return offset_ == totalLength_;
-  } else {
+  }
+  else {
     return allocator_->finished();
   }
 }
@@ -101,7 +103,8 @@ int64_t AdaptiveFileAllocationIterator::getCurrentLength()
 {
   if (!allocator_) {
     return offset_;
-  } else {
+  }
+  else {
     return allocator_->getCurrentLength();
   }
 }

src/AdaptiveFileAllocationIterator.h

@@ -43,8 +43,7 @@ namespace aria2 {
 
 class BinaryStream;
 
-class AdaptiveFileAllocationIterator:public FileAllocationIterator
+class AdaptiveFileAllocationIterator : public FileAllocationIterator {
-{
 private:
   std::unique_ptr<FileAllocationIterator> allocator_;
 
@@ -53,9 +52,10 @@ private:
   int64_t offset_;
 
   int64_t totalLength_;
+
 public:
-  AdaptiveFileAllocationIterator
+  AdaptiveFileAllocationIterator(BinaryStream* stream, int64_t offset,
-  (BinaryStream* stream, int64_t offset, int64_t totalLength);
+                                 int64_t totalLength);
 
   virtual ~AdaptiveFileAllocationIterator();
 

src/AdaptiveURISelector.cc

@@ -65,22 +65,21 @@ namespace aria2 {
  * be tested again. Otherwise, it doesn't return anymore mirrors.
  */
 
-AdaptiveURISelector::AdaptiveURISelector
+AdaptiveURISelector::AdaptiveURISelector(
-(std::shared_ptr<ServerStatMan> serverStatMan, RequestGroup* requestGroup)
+    std::shared_ptr<ServerStatMan> serverStatMan, RequestGroup* requestGroup)
-  : serverStatMan_(std::move(serverStatMan)),
+    : serverStatMan_(std::move(serverStatMan)), requestGroup_(requestGroup)
-    requestGroup_(requestGroup)
 {
   resetCounters();
 }
 
 AdaptiveURISelector::~AdaptiveURISelector() {}
 
-std::string AdaptiveURISelector::select
+std::string AdaptiveURISelector::select(
-(FileEntry* fileEntry,
+    FileEntry* fileEntry,
     const std::vector<std::pair<size_t, std::string>>& usedHosts)
 {
-  A2_LOG_DEBUG(fmt("AdaptiveURISelector: called %d",
+  A2_LOG_DEBUG(
-                   requestGroup_->getNumConnection()));
+      fmt("AdaptiveURISelector: called %d", requestGroup_->getNumConnection()));
   std::deque<std::string>& uris = fileEntry->getRemainingUris();
   if (uris.empty() && requestGroup_->getNumConnection() <= 1) {
     // here we know the download will fail, trying to find previously
@@ -102,7 +101,8 @@ constexpr auto MAX_TIMEOUT = 60_s;
 
 void AdaptiveURISelector::mayRetryWithIncreasedTimeout(FileEntry* fileEntry)
 {
-  if (requestGroup_->getTimeout()*2 >= MAX_TIMEOUT) return;
+  if (requestGroup_->getTimeout() * 2 >= MAX_TIMEOUT)
+    return;
   requestGroup_->setTimeout(requestGroup_->getTimeout() * 2);
 
   std::deque<std::string>& uris = fileEntry->getRemainingUris();
@@ -128,14 +128,16 @@ std::string AdaptiveURISelector::selectOne(const std::deque<std::string>& uris)
 
   if (uris.empty()) {
     return A2STR::NIL;
-  } else {
+  }
+  else {
     const size_t numPieces =
         requestGroup_->getDownloadContext()->getNumPieces();
 
-    bool reservedContext = numPieces > 0 &&
+    bool reservedContext =
-      static_cast<size_t>(nbConnections_) > std::min
+        numPieces > 0 &&
-      (numPieces,
+        static_cast<size_t>(nbConnections_) >
-       static_cast<size_t>(requestGroup_->getNumConcurrentCommand()));
+            std::min(numPieces, static_cast<size_t>(
+                                    requestGroup_->getNumConcurrentCommand()));
     bool selectBest = numPieces == 0 || reservedContext;
 
     if (numPieces > 0)
@@ -162,7 +164,8 @@ std::string AdaptiveURISelector::selectOne(const std::deque<std::string>& uris)
                          " for connection #%d",
                          notTested.c_str(), nbConnections_));
         return notTested;
-      } else {
+      }
+      else {
         /* Here we return a mirror which need to be tested again */
         std::string toReTest = getFirstToTestUri(uris);
         if (toReTest != A2STR::NIL) {
@@ -170,7 +173,8 @@ std::string AdaptiveURISelector::selectOne(const std::deque<std::string>& uris)
                            " not been tested recently for connection #%d",
                            toReTest.c_str(), nbConnections_));
           return toReTest;
-        } else {
+        }
+        else {
           return getBestMirror(uris);
         }
       }
@@ -181,8 +185,8 @@ std::string AdaptiveURISelector::selectOne(const std::deque<std::string>& uris)
   }
 }
 
-std::string AdaptiveURISelector::getBestMirror
+std::string
-(const std::deque<std::string>& uris) const
+AdaptiveURISelector::getBestMirror(const std::deque<std::string>& uris) const
 {
   /* Here we return one of the bests mirrors */
   int max = getMaxDownloadSpeed(uris);
@@ -193,16 +197,14 @@ std::string AdaptiveURISelector::getBestMirror
     std::string uri = getMaxDownloadSpeedUri(uris);
     A2_LOG_DEBUG(fmt("AdaptiveURISelector: choosing the best mirror :"
                      " %.2fKB/s %s (other mirrors are at least 25%% slower)",
-                     (float) max/1024,
+                     (float)max / 1024, uri.c_str()));
-                     uri.c_str()));
     return uri;
-  } else {
+  }
+  else {
     std::string uri = selectRandomUri(bests);
     A2_LOG_DEBUG(fmt("AdaptiveURISelector: choosing randomly one of the best"
                      " mirrors (range [%.2fKB/s, %.2fKB/s]): %s",
-                     (float) min/1024,
+                     (float)min / 1024, (float)max / 1024, uri.c_str()));
-                     (float) max/1024,
-                     uri.c_str()));
     return uri;
   }
 }
@@ -210,36 +212,32 @@ std::string AdaptiveURISelector::getBestMirror
 void AdaptiveURISelector::resetCounters()
 {
   nbConnections_ = 1;
-  nbServerToEvaluate_ =
+  nbServerToEvaluate_ = requestGroup_->getOption()->getAsInt(PREF_SPLIT) - 1;
-    requestGroup_->getOption()->getAsInt(PREF_SPLIT) - 1;
 }
 
-void AdaptiveURISelector::tuneDownloadCommand
+void AdaptiveURISelector::tuneDownloadCommand(
-(const std::deque<std::string>& uris, DownloadCommand* command)
+    const std::deque<std::string>& uris, DownloadCommand* command)
 {
   adjustLowestSpeedLimit(uris, command);
 }
 
-void AdaptiveURISelector::adjustLowestSpeedLimit
+void AdaptiveURISelector::adjustLowestSpeedLimit(
-(const std::deque<std::string>& uris, DownloadCommand* command) const
+    const std::deque<std::string>& uris, DownloadCommand* command) const
 {
-  int lowest =
+  int lowest = requestGroup_->getOption()->getAsInt(PREF_LOWEST_SPEED_LIMIT);
-    requestGroup_->getOption()->getAsInt(PREF_LOWEST_SPEED_LIMIT);
   if (lowest > 0) {
     int low_lowest = 4_k;
     int max = getMaxDownloadSpeed(uris);
     if (max > 0 && lowest > max / 4) {
       A2_LOG_NOTICE(fmt(_("Lowering lowest-speed-limit since known max speed is"
                           " too near (new:%d was:%d max:%d)"),
-                        max / 4,
+                        max / 4, lowest, max));
-                        lowest,
-                        max));
       command->setLowestDownloadSpeedLimit(max / 4);
-    } else if (max == 0 && lowest > low_lowest) {
+    }
+    else if (max == 0 && lowest > low_lowest) {
       A2_LOG_NOTICE(fmt(_("Lowering lowest-speed-limit since we have no clue"
                           " about available speed (now:%d was:%d)"),
-                        low_lowest,
+                        low_lowest, lowest));
-                        lowest));
       command->setLowestDownloadSpeedLimit(low_lowest);
     }
   }
@@ -253,8 +251,8 @@ int getUriMaxSpeed(std::shared_ptr<ServerStat> ss)
 }
 } // namespace
 
-int AdaptiveURISelector::getMaxDownloadSpeed
+int AdaptiveURISelector::getMaxDownloadSpeed(
-(const std::deque<std::string>& uris) const
+    const std::deque<std::string>& uris) const
 {
   std::string uri = getMaxDownloadSpeedUri(uris);
   if (uri == A2STR::NIL)
@@ -262,8 +260,8 @@ int AdaptiveURISelector::getMaxDownloadSpeed
   return getUriMaxSpeed(getServerStats(uri));
 }
 
-std::string AdaptiveURISelector::getMaxDownloadSpeedUri
+std::string AdaptiveURISelector::getMaxDownloadSpeedUri(
-(const std::deque<std::string>& uris) const
+    const std::deque<std::string>& uris) const
 {
   int max = -1;
   std::string uri = A2STR::NIL;
@@ -284,8 +282,9 @@ std::string AdaptiveURISelector::getMaxDownloadSpeedUri
   return uri;
 }
 
-std::deque<std::string> AdaptiveURISelector::getUrisBySpeed
+std::deque<std::string>
-(const std::deque<std::string>& uris, int min) const
+AdaptiveURISelector::getUrisBySpeed(const std::deque<std::string>& uris,
+                                    int min) const
 {
   std::deque<std::string> bests;
   for (auto& uri : uris) {
@@ -300,8 +299,8 @@ std::deque<std::string> AdaptiveURISelector::getUrisBySpeed
   return bests;
 }
 
-std::string AdaptiveURISelector::selectRandomUri
+std::string
-(const std::deque<std::string>& uris) const
+AdaptiveURISelector::selectRandomUri(const std::deque<std::string>& uris) const
 {
   int pos = SimpleRandomizer::getInstance()->getRandomNumber(uris.size());
   auto i = std::begin(uris);
@@ -309,8 +308,8 @@ std::string AdaptiveURISelector::selectRandomUri
   return *i;
 }
 
-std::string AdaptiveURISelector::getFirstNotTestedUri
+std::string AdaptiveURISelector::getFirstNotTestedUri(
-(const std::deque<std::string>& uris) const
+    const std::deque<std::string>& uris) const
 {
   for (const auto& i : uris) {
     std::shared_ptr<ServerStat> ss = getServerStats(i);
@@ -320,8 +319,8 @@ std::string AdaptiveURISelector::getFirstNotTestedUri
   return A2STR::NIL;
 }
 
-std::string AdaptiveURISelector::getFirstToTestUri
+std::string AdaptiveURISelector::getFirstToTestUri(
-(const std::deque<std::string>& uris) const
+    const std::deque<std::string>& uris) const
 {
   int counter;
   int power;
@@ -342,21 +341,22 @@ std::string AdaptiveURISelector::getFirstToTestUri
   return A2STR::NIL;
 }
 
-std::shared_ptr<ServerStat> AdaptiveURISelector::getServerStats
+std::shared_ptr<ServerStat>
-(const std::string& uri) const
+AdaptiveURISelector::getServerStats(const std::string& uri) const
 {
   uri_split_result us;
   if (uri_split(&us, uri.c_str()) == 0) {
     std::string host = uri::getFieldString(us, USR_HOST, uri.c_str());
     std::string protocol = uri::getFieldString(us, USR_SCHEME, uri.c_str());
     return serverStatMan_->find(host, protocol);
-  } else {
+  }
+  else {
     return nullptr;
   }
 }
 
-int AdaptiveURISelector::getNbTestedServers
+int AdaptiveURISelector::getNbTestedServers(
-(const std::deque<std::string>& uris) const
+    const std::deque<std::string>& uris) const
 {
   int counter = 0;
   for (const auto& u : uris) {

src/AdaptiveURISelector.h

@@ -69,20 +69,20 @@ private:
   std::shared_ptr<ServerStat> getServerStats(const std::string& uri) const;
   int getNbTestedServers(const std::deque<std::string>& uris) const;
   std::string getBestMirror(const std::deque<std::string>& uris) const;
+
 public:
   AdaptiveURISelector(std::shared_ptr<ServerStatMan> serverStatMan,
                       RequestGroup* requestGroup);
 
   virtual ~AdaptiveURISelector();
 
-  virtual std::string select
+  virtual std::string
-  (FileEntry* fileEntry,
+  select(FileEntry* fileEntry,
          const std::vector<std::pair<size_t, std::string>>& usedHosts)
       CXX11_OVERRIDE;
 
   virtual void tuneDownloadCommand(const std::deque<std::string>& uris,
-                                   DownloadCommand* command)
+                                   DownloadCommand* command) CXX11_OVERRIDE;
-    CXX11_OVERRIDE;
 
   virtual void resetCounters() CXX11_OVERRIDE;
 };

src/Adler32MessageDigestImpl.cc

@@ -44,22 +44,17 @@ namespace aria2 {
 
 Adler32MessageDigestImpl::Adler32MessageDigestImpl()
     : adler_(adler32(0, Z_NULL, 0))
-{}
-
-size_t Adler32MessageDigestImpl::getDigestLength() const
 {
-  return length();
 }
 
-void Adler32MessageDigestImpl::reset()
+size_t Adler32MessageDigestImpl::getDigestLength() const { return length(); }
-{
+
-  adler_ = adler32(0, Z_NULL, 0);
+void Adler32MessageDigestImpl::reset() { adler_ = adler32(0, Z_NULL, 0); }
-}
 
 void Adler32MessageDigestImpl::update(const void* data, size_t length)
 {
-  adler_ = adler32(adler_, reinterpret_cast<const unsigned char*>(data),
+  adler_ =
-                   length);
+      adler32(adler_, reinterpret_cast<const unsigned char*>(data), length);
 }
 
 void Adler32MessageDigestImpl::digest(unsigned char* md)
@@ -68,9 +63,6 @@ void Adler32MessageDigestImpl::digest(unsigned char* md)
   memcpy(md, &adler, getDigestLength());
 }
 
-size_t Adler32MessageDigestImpl::length()
+size_t Adler32MessageDigestImpl::length() { return 4; }
-{
-  return 4;
-}
 
 } // namespace aria2

src/Adler32MessageDigestImpl.h

@@ -42,7 +42,10 @@ namespace aria2 {
 #ifdef HAVE_ZLIB
 
 #define ADLER32_MESSAGE_DIGEST                                                 \
-  { "adler32", make_hi<Adler32MessageDigestImpl>() },
+  {                                                                            \
+    "adler32", make_hi<Adler32MessageDigestImpl>()                             \
+  }                                                                            \
+  ,
 
 class Adler32MessageDigestImpl : public MessageDigestImpl {
 public:
@@ -52,6 +55,7 @@ public:
   virtual void update(const void* data, size_t length) CXX11_OVERRIDE;
   virtual void digest(unsigned char* md) CXX11_OVERRIDE;
   static size_t length();
+
 private:
   unsigned long adler_;
 };

src/AnnounceList.cc

@@ -44,22 +44,24 @@ namespace aria2 {
 
 AnnounceList::AnnounceList() : currentTrackerInitialized_(false) {}
 
-AnnounceList::AnnounceList
+AnnounceList::AnnounceList(
-(const std::vector<std::vector<std::string>>& announceList):
+    const std::vector<std::vector<std::string>>& announceList)
-  currentTrackerInitialized_(false) {
+    : currentTrackerInitialized_(false)
+{
   reconfigure(announceList);
 }
 
-AnnounceList::AnnounceList
+AnnounceList::AnnounceList(
-(const std::deque<std::shared_ptr<AnnounceTier>>& announceTiers):
+    const std::deque<std::shared_ptr<AnnounceTier>>& announceTiers)
-  tiers_(announceTiers), currentTrackerInitialized_(false)  {
+    : tiers_(announceTiers), currentTrackerInitialized_(false)
+{
   resetIterator();
 }
 
 AnnounceList::~AnnounceList() {}
 
-void AnnounceList::reconfigure
+void AnnounceList::reconfigure(
-(const std::vector<std::vector<std::string>>& announceList)
+    const std::vector<std::vector<std::string>>& announceList)
 {
   for (const auto& vec : announceList) {
     if (vec.empty()) {
@@ -67,38 +69,43 @@ void AnnounceList::reconfigure
     }
 
     std::deque<std::string> uris(std::begin(vec), std::end(vec));
-    auto tier =
+    auto tier = std::make_shared<AnnounceTier>(std::move(uris));
-      std::make_shared<AnnounceTier>(std::move(uris));
     tiers_.push_back(std::move(tier));
   }
   resetIterator();
 }
 
-void AnnounceList::reconfigure(const std::string& url) {
+void AnnounceList::reconfigure(const std::string& url)
+{
   std::deque<std::string> urls{url};
   tiers_.push_back(std::make_shared<AnnounceTier>(std::move(urls)));
   resetIterator();
 }
 
-void AnnounceList::resetIterator() {
+void AnnounceList::resetIterator()
+{
   currentTier_ = std::begin(tiers_);
   if (currentTier_ != std::end(tiers_) && (*currentTier_)->urls.size()) {
     currentTracker_ = std::begin((*currentTier_)->urls);
     currentTrackerInitialized_ = true;
-  } else {
+  }
+  else {
     currentTrackerInitialized_ = false;
   }
 }
 
-std::string AnnounceList::getAnnounce() const {
+std::string AnnounceList::getAnnounce() const
+{
   if (currentTrackerInitialized_) {
     return *currentTracker_;
-  } else {
+  }
+  else {
     return A2STR::NIL;
   }
 }
 
-void AnnounceList::announceSuccess() {
+void AnnounceList::announceSuccess()
+{
   if (currentTrackerInitialized_) {
     (*currentTier_)->nextEvent();
     auto url = *currentTracker_;
@@ -109,7 +116,8 @@ void AnnounceList::announceSuccess() {
   }
 }
 
-void AnnounceList::announceFailure() {
+void AnnounceList::announceFailure()
+{
   if (currentTrackerInitialized_) {
     ++currentTracker_;
     if (currentTracker_ == std::end((*currentTier_)->urls)) {
@@ -118,28 +126,33 @@ void AnnounceList::announceFailure() {
       ++currentTier_;
       if (currentTier_ == std::end(tiers_)) {
         currentTrackerInitialized_ = false;
-      } else {
+      }
+      else {
         currentTracker_ = std::begin((*currentTier_)->urls);
       }
     }
   }
 }
 
-AnnounceTier::AnnounceEvent AnnounceList::getEvent() const {
+AnnounceTier::AnnounceEvent AnnounceList::getEvent() const
+{
   if (currentTrackerInitialized_) {
     return (*currentTier_)->event;
-  } else {
+  }
+  else {
     return AnnounceTier::STARTED;
   }
 }
 
-void AnnounceList::setEvent(AnnounceTier::AnnounceEvent event) {
+void AnnounceList::setEvent(AnnounceTier::AnnounceEvent event)
+{
   if (currentTrackerInitialized_) {
     (*currentTier_)->event = event;
   }
 }
 
-const char* AnnounceList::getEventString() const {
+const char* AnnounceList::getEventString() const
+{
   if (currentTrackerInitialized_) {
     switch ((*currentTier_)->event) {
     case AnnounceTier::STARTED:
@@ -152,7 +165,8 @@ const char* AnnounceList::getEventString() const {
     default:
       return "";
     }
-  } else {
+  }
+  else {
     return "";
   }
 }
@@ -160,7 +174,8 @@ const char* AnnounceList::getEventString() const {
 namespace {
 class FindStoppedAllowedTier {
 public:
-  bool operator()(const std::shared_ptr<AnnounceTier>& tier) const {
+  bool operator()(const std::shared_ptr<AnnounceTier>& tier) const
+  {
     switch (tier->event) {
     case AnnounceTier::DOWNLOADING:
     case AnnounceTier::STOPPED:
@@ -177,7 +192,8 @@ public:
 namespace {
 class FindCompletedAllowedTier {
 public:
-  bool operator()(const std::shared_ptr<AnnounceTier>& tier) const {
+  bool operator()(const std::shared_ptr<AnnounceTier>& tier) const
+  {
     switch (tier->event) {
     case AnnounceTier::DOWNLOADING:
     case AnnounceTier::COMPLETED:
@@ -189,37 +205,43 @@ public:
 };
 } // namespace
 
-size_t AnnounceList::countStoppedAllowedTier() const {
+size_t AnnounceList::countStoppedAllowedTier() const
+{
   return count_if(std::begin(tiers_), std::end(tiers_),
                   FindStoppedAllowedTier());
 }
 
-size_t AnnounceList::countCompletedAllowedTier() const {
+size_t AnnounceList::countCompletedAllowedTier() const
+{
   return count_if(std::begin(tiers_), std::end(tiers_),
                   FindCompletedAllowedTier());
 }
 
-void AnnounceList::setCurrentTier
+void AnnounceList::setCurrentTier(
-(std::deque<std::shared_ptr<AnnounceTier>>::iterator itr) {
+    std::deque<std::shared_ptr<AnnounceTier>>::iterator itr)
+{
   if (itr != std::end(tiers_)) {
     currentTier_ = std::move(itr);
     currentTracker_ = std::begin((*currentTier_)->urls);
   }
 }
 
-void AnnounceList::moveToStoppedAllowedTier() {
+void AnnounceList::moveToStoppedAllowedTier()
+{
   auto itr = find_wrap_if(std::begin(tiers_), std::end(tiers_), currentTier_,
                           FindStoppedAllowedTier());
   setCurrentTier(std::move(itr));
 }
 
-void AnnounceList::moveToCompletedAllowedTier() {
+void AnnounceList::moveToCompletedAllowedTier()
+{
   auto itr = find_wrap_if(std::begin(tiers_), std::end(tiers_), currentTier_,
                           FindCompletedAllowedTier());
   setCurrentTier(std::move(itr));
 }
 
-void AnnounceList::shuffle() {
+void AnnounceList::shuffle()
+{
   for (const auto& tier : tiers_) {
     auto& urls = tier->urls;
     std::shuffle(std::begin(urls), std::end(urls),
@@ -232,10 +254,7 @@ bool AnnounceList::allTiersFailed() const
   return currentTier_ == std::end(tiers_);
 }
 
-void AnnounceList::resetTier()
+void AnnounceList::resetTier() { resetIterator(); }
-{
-  resetIterator();
-}
 
 bool AnnounceList::currentTierAcceptsStoppedEvent() const
 {
@@ -255,9 +274,6 @@ bool AnnounceList::currentTierAcceptsCompletedEvent() const
   return false;
 }
 
-size_t AnnounceList::countTier() const
+size_t AnnounceList::countTier() const { return tiers_.size(); }
-{
-  return tiers_.size();
-}
 
 } // namespace aria2

src/AnnounceList.h

@@ -56,8 +56,8 @@ private:
   bool currentTrackerInitialized_;
 
   void resetIterator();
-  void setCurrentTier
+  void setCurrentTier(std::deque<std::shared_ptr<AnnounceTier>>::iterator itr);
-  (std::deque<std::shared_ptr<AnnounceTier>>::iterator itr);
+
 public:
   AnnounceList();
   AnnounceList(const std::vector<std::vector<std::string>>& announceList);

src/AnnounceTier.cc

@@ -38,7 +38,8 @@ namespace aria2 {
 
 AnnounceTier::AnnounceTier(std::deque<std::string> urls)
     : event(STARTED), urls(std::move(urls))
-{}
+{
+}
 
 AnnounceTier::~AnnounceTier() {}
 

src/AnonDiskWriterFactory.h

@@ -48,8 +48,8 @@ public:
   AnonDiskWriterFactory() {}
   virtual ~AnonDiskWriterFactory() {}
 
-  virtual std::unique_ptr<DiskWriter> newDiskWriter(const std::string& filename)
+  virtual std::unique_ptr<DiskWriter>
-    CXX11_OVERRIDE
+  newDiskWriter(const std::string& filename) CXX11_OVERRIDE
   {
     return make_unique<DiskWriterType>();
   }

src/ApiCallbackDownloadEventListener.cc

@@ -37,19 +37,16 @@
 
 namespace aria2 {
 
-ApiCallbackDownloadEventListener::ApiCallbackDownloadEventListener
+ApiCallbackDownloadEventListener::ApiCallbackDownloadEventListener(
-(Session* session,
+    Session* session, DownloadEventCallback callback, void* userData)
- DownloadEventCallback callback,
+    : session_(session), callback_(callback), userData_(userData)
- void* userData)
+{
-  : session_(session),
+}
-    callback_(callback),
-    userData_(userData)
-{}
 
 ApiCallbackDownloadEventListener::~ApiCallbackDownloadEventListener() {}
 
-void ApiCallbackDownloadEventListener::onEvent
+void ApiCallbackDownloadEventListener::onEvent(DownloadEvent event,
-(DownloadEvent event, const RequestGroup* group)
+                                               const RequestGroup* group)
 {
   callback_(session_, event, group->getGID(), userData_);
 }

src/ApiCallbackDownloadEventListener.h

@@ -45,8 +45,9 @@ public:
                                    DownloadEventCallback callback,
                                    void* userData);
   virtual ~ApiCallbackDownloadEventListener();
-  virtual void onEvent(DownloadEvent event, const RequestGroup* group)
+  virtual void onEvent(DownloadEvent event,
-    CXX11_OVERRIDE;
+                       const RequestGroup* group) CXX11_OVERRIDE;
+
 private:
   Session* session_;
   DownloadEventCallback callback_;

src/AppleMessageDigestImpl.cc

@@ -42,9 +42,7 @@
 namespace aria2 {
 namespace {
 
-template<size_t dlen,
+template <size_t dlen, typename ctx_t, int (*init_fn)(ctx_t*),
-         typename ctx_t,
-         int (*init_fn)(ctx_t*),
           int (*update_fn)(ctx_t*, const void*, CC_LONG),
           int (*final_fn)(unsigned char*, ctx_t*)>
 class MessageDigestBase : public MessageDigestImpl {
@@ -52,67 +50,42 @@ public:
   MessageDigestBase() { reset(); }
   virtual ~MessageDigestBase() {}
 
-  static  size_t length() {
+  static size_t length() { return dlen; }
-    return dlen;
+  virtual size_t getDigestLength() const CXX11_OVERRIDE { return dlen; }
-  }
+  virtual void reset() CXX11_OVERRIDE { init_fn(&ctx_); }
-  virtual size_t getDigestLength() const CXX11_OVERRIDE {
+  virtual void update(const void* data, size_t length) CXX11_OVERRIDE
-    return dlen;
+  {
-  }
-  virtual void reset() CXX11_OVERRIDE {
-    init_fn(&ctx_);
-  }
-  virtual void update(const void* data, size_t length) CXX11_OVERRIDE {
     auto bytes = reinterpret_cast<const char*>(data);
     while (length) {
-      CC_LONG l = std::min(length, (size_t)std::numeric_limits<uint32_t>::max());
+      CC_LONG l =
+          std::min(length, (size_t)std::numeric_limits<uint32_t>::max());
       update_fn(&ctx_, bytes, l);
       length -= l;
       bytes += l;
     }
   }
-  virtual void digest(unsigned char* md) CXX11_OVERRIDE {
+  virtual void digest(unsigned char* md) CXX11_OVERRIDE { final_fn(md, &ctx_); }
-    final_fn(md, &ctx_);
+
-  }
 private:
   ctx_t ctx_;
 };
 
-typedef MessageDigestBase<CC_MD5_DIGEST_LENGTH,
+typedef MessageDigestBase<CC_MD5_DIGEST_LENGTH, CC_MD5_CTX, CC_MD5_Init,
-                          CC_MD5_CTX,
+                          CC_MD5_Update, CC_MD5_Final> MessageDigestMD5;
-                          CC_MD5_Init,
+typedef MessageDigestBase<CC_SHA1_DIGEST_LENGTH, CC_SHA1_CTX, CC_SHA1_Init,
-                          CC_MD5_Update,
+                          CC_SHA1_Update, CC_SHA1_Final> MessageDigestSHA1;
-                          CC_MD5_Final>
+typedef MessageDigestBase<CC_SHA224_DIGEST_LENGTH, CC_SHA256_CTX,
-MessageDigestMD5;
+                          CC_SHA224_Init, CC_SHA224_Update,
-typedef MessageDigestBase<CC_SHA1_DIGEST_LENGTH,
+                          CC_SHA224_Final> MessageDigestSHA224;
-                          CC_SHA1_CTX,
+typedef MessageDigestBase<CC_SHA256_DIGEST_LENGTH, CC_SHA256_CTX,
-                          CC_SHA1_Init,
+                          CC_SHA256_Init, CC_SHA256_Update,
-                          CC_SHA1_Update,
+                          CC_SHA256_Final> MessageDigestSHA256;
-                          CC_SHA1_Final>
+typedef MessageDigestBase<CC_SHA384_DIGEST_LENGTH, CC_SHA512_CTX,
-MessageDigestSHA1;
+                          CC_SHA384_Init, CC_SHA384_Update,
-typedef MessageDigestBase<CC_SHA224_DIGEST_LENGTH,
+                          CC_SHA384_Final> MessageDigestSHA384;
-                          CC_SHA256_CTX,
+typedef MessageDigestBase<CC_SHA512_DIGEST_LENGTH, CC_SHA512_CTX,
-                          CC_SHA224_Init,
+                          CC_SHA512_Init, CC_SHA512_Update,
-                          CC_SHA224_Update,
+                          CC_SHA512_Final> MessageDigestSHA512;
-                          CC_SHA224_Final>
-MessageDigestSHA224;
-typedef MessageDigestBase<CC_SHA256_DIGEST_LENGTH,
-                          CC_SHA256_CTX,
-                          CC_SHA256_Init,
-                          CC_SHA256_Update,
-                          CC_SHA256_Final>
-MessageDigestSHA256;
-typedef MessageDigestBase<CC_SHA384_DIGEST_LENGTH,
-                          CC_SHA512_CTX,
-                          CC_SHA384_Init,
-                          CC_SHA384_Update,
-                          CC_SHA384_Final>
-MessageDigestSHA384;
-typedef MessageDigestBase<CC_SHA512_DIGEST_LENGTH,
-                          CC_SHA512_CTX,
-                          CC_SHA512_Init,
-                          CC_SHA512_Update,
-                          CC_SHA512_Final>
-MessageDigestSHA512;
 
 } // namespace
 
@@ -128,7 +101,6 @@ MessageDigestImpl::hashes_t MessageDigestImpl::hashes = {
     {"sha-384", make_hi<MessageDigestSHA384>()},
     {"sha-512", make_hi<MessageDigestSHA512>()},
     {"md5", make_hi<MessageDigestMD5>()},
-  ADLER32_MESSAGE_DIGEST
+    ADLER32_MESSAGE_DIGEST};
-};
 
 } // namespace aria2

src/AppleTLSContext.cc

@@ -56,17 +56,11 @@ using namespace aria2;
 #if defined(__MAC_10_6)
 
 #if defined(__MAC_10_7)
-static const void* query_keys[] = {
+static const void* query_keys[] = {kSecClass, kSecReturnRef, kSecMatchPolicy,
-  kSecClass,
+                                   kSecMatchLimit};
-  kSecReturnRef,
-  kSecMatchPolicy,
-  kSecMatchLimit
-};
 #endif // defined(__MAC_10_7)
 
-template <typename T>
+template <typename T> class CFRef {
-class CFRef
-{
   T ref_;
 
 public:
@@ -74,10 +68,7 @@ public:
 
   CFRef(T ref) : ref_(ref) {}
 
-  ~CFRef()
+  ~CFRef() { reset(nullptr); }
-  {
-    reset(nullptr);
-  }
 
   void reset(T ref)
   {
@@ -87,20 +78,11 @@ public:
     ref_ = ref;
   }
 
-  T get()
+  T get() { return ref_; }
-  {
-    return ref_;
-  }
 
-  const T get() const
+  const T get() const { return ref_; }
-  {
-    return ref_;
-  }
 
-  operator bool() const
+  operator bool() const { return !!ref_; }
-  {
-    return !!ref_;
-  }
 };
 
 static inline bool isWhitespace(char c)
@@ -116,8 +98,7 @@ static inline std::string stripWhitespace(std::string str)
   return str;
 }
 
-struct hash_validator
+struct hash_validator {
-{
   const std::string& hash_;
 
   hash_validator(const std::string& hash) : hash_(hash) {}
@@ -128,14 +109,14 @@ struct hash_validator
   }
 };
 
-struct hash_finder
+struct hash_finder {
-{
   CFDataRef data_;
   const std::string& hash_;
 
   hash_finder(CFDataRef data, const std::string& hash)
       : data_(data), hash_(hash)
-  {}
+  {
+  }
 
   inline bool operator()(std::string type) const
   {
@@ -163,8 +144,7 @@ std::string errToString(OSStatus err)
   return rv;
 }
 
-bool checkIdentity(const SecIdentityRef id,
+bool checkIdentity(const SecIdentityRef id, const std::string& fingerPrint,
-                   const std::string& fingerPrint,
                    const std::vector<std::string> supported)
 {
   CFRef<SecCertificateRef> ref;
@@ -235,10 +215,7 @@ bool AppleTLSContext::addTrustedCACertFile(const std::string& certfile)
   return false;
 }
 
-SecIdentityRef AppleTLSContext::getCredentials()
+SecIdentityRef AppleTLSContext::getCredentials() { return credentials_; }
-{
-  return credentials_;
-}
 
 bool AppleTLSContext::tryAsFingerprint(const std::string& fingerprint)
 {
@@ -264,12 +241,8 @@ bool AppleTLSContext::tryAsFingerprint(const std::string& fingerprint)
     A2_LOG_ERROR("Failed to create SecPolicy");
     return false;
   }
-  const void* query_values[] = {
+  const void* query_values[] = {kSecClassIdentity, kCFBooleanTrue, policy.get(),
-    kSecClassIdentity,
+                                kSecMatchLimitAll};
-    kCFBooleanTrue,
-    policy.get(),
-    kSecMatchLimitAll
-  };
   CFRef<CFDictionaryRef> query(CFDictionaryCreate(
       nullptr, query_keys, query_values, 4, nullptr, nullptr));
   if (!query) {
@@ -372,18 +345,12 @@ bool AppleTLSContext::tryAsPKCS12(CFDataRef data, const char* password)
 #if defined(__MAC_10_6)
   CFRef<CFStringRef> passwordRef;
   if (password) {
-    passwordRef.reset(CFStringCreateWithBytes(nullptr,
+    passwordRef.reset(CFStringCreateWithBytes(nullptr, (const UInt8*)password,
-                                              (const UInt8*)password,
                                               strlen(password),
-                                              kCFStringEncodingUTF8,
+                                              kCFStringEncodingUTF8, false));
-                                              false));
   }
-  const void* keys[] = {
+  const void* keys[] = {kSecImportExportPassphrase};
-    kSecImportExportPassphrase
+  const void* values[] = {passwordRef.get()};
-  };
-  const void* values[] = {
-    passwordRef.get()
-  };
   CFRef<CFDictionaryRef> options(
       CFDictionaryCreate(nullptr, keys, values, 1, nullptr, nullptr));
   if (!options) {

src/AppleTLSContext.h

@@ -46,12 +46,12 @@
 
 namespace aria2 {
 
-class AppleTLSContext : public TLSContext
+class AppleTLSContext : public TLSContext {
-{
 public:
   AppleTLSContext(TLSSessionSide side, TLSVersion ver)
       : side_(side), minTLSVer_(ver), verifyPeer_(true), credentials_(nullptr)
-  {}
+  {
+  }
 
   virtual ~AppleTLSContext();
 
@@ -59,28 +59,16 @@ public:
   virtual bool addCredentialFile(const std::string& certfile,
                                  const std::string& keyfile) CXX11_OVERRIDE;
 
-  virtual bool addSystemTrustedCACerts() CXX11_OVERRIDE
+  virtual bool addSystemTrustedCACerts() CXX11_OVERRIDE { return true; }
-  {
-    return true;
-  }
 
   // certfile can contain multiple certificates.
   virtual bool addTrustedCACertFile(const std::string& certfile) CXX11_OVERRIDE;
 
-  virtual bool good() const CXX11_OVERRIDE
+  virtual bool good() const CXX11_OVERRIDE { return true; }
-  {
-    return true;
-  }
 
-  virtual TLSSessionSide getSide() const CXX11_OVERRIDE
+  virtual TLSSessionSide getSide() const CXX11_OVERRIDE { return side_; }
-  {
-    return side_;
-  }
 
-  virtual bool getVerifyPeer() const CXX11_OVERRIDE
+  virtual bool getVerifyPeer() const CXX11_OVERRIDE { return verifyPeer_; }
-  {
-    return verifyPeer_;
-  }
 
   virtual void setVerifyPeer(bool verify) CXX11_OVERRIDE
   {
@@ -89,10 +77,7 @@ public:
 
   SecIdentityRef getCredentials();
 
-  TLSVersion getMinTLSVersion() const
+  TLSVersion getMinTLSVersion() const { return minTLSVer_; }
-  {
-    return minTLSVer_;
-  }
 
 private:
   TLSSessionSide side_;

src/AppleTLSSession.cc

@@ -101,15 +101,13 @@ static inline const char* protoToString(SSLProtocol proto)
   {                                                                            \
     n, #s                                                                      \
   }
-static struct
+static struct {
-{
   SSLCipherSuite suite;
   const char* name;
 } kSuites[] = {
     // From CipherSuite.h (10.9)
     SUITE(SSL_NULL_WITH_NULL_NULL, 0x0000),
-      SUITE(SSL_RSA_WITH_NULL_MD5, 0x0001),
+    SUITE(SSL_RSA_WITH_NULL_MD5, 0x0001), SUITE(SSL_RSA_WITH_NULL_SHA, 0x0002),
-      SUITE(SSL_RSA_WITH_NULL_SHA, 0x0002),
     SUITE(SSL_RSA_EXPORT_WITH_RC4_40_MD5, 0x0003),
     SUITE(SSL_RSA_WITH_RC4_128_MD5, 0x0004),
     SUITE(SSL_RSA_WITH_RC4_128_SHA, 0x0005),
@@ -175,8 +173,7 @@ static struct
     SUITE(TLS_ECDH_anon_WITH_AES_128_CBC_SHA, 0xC018),
     SUITE(TLS_ECDH_anon_WITH_AES_256_CBC_SHA, 0xC019),
     SUITE(TLS_NULL_WITH_NULL_NULL, 0x0000),
-      SUITE(TLS_RSA_WITH_NULL_MD5, 0x0001),
+    SUITE(TLS_RSA_WITH_NULL_MD5, 0x0001), SUITE(TLS_RSA_WITH_NULL_SHA, 0x0002),
-      SUITE(TLS_RSA_WITH_NULL_SHA, 0x0002),
     SUITE(TLS_RSA_WITH_RC4_128_MD5, 0x0004),
     SUITE(TLS_RSA_WITH_RC4_128_SHA, 0x0005),
     SUITE(TLS_RSA_WITH_3DES_EDE_CBC_SHA, 0x000A),
@@ -265,8 +262,7 @@ static struct
     SUITE(SSL_RSA_WITH_IDEA_CBC_MD5, 0xFF81),
     SUITE(SSL_RSA_WITH_DES_CBC_MD5, 0xFF82),
     SUITE(SSL_RSA_WITH_3DES_EDE_CBC_MD5, 0xFF83),
-      SUITE(SSL_NO_SUCH_CIPHERSUITE, 0xFFFF)
+    SUITE(SSL_NO_SUCH_CIPHERSUITE, 0xFFFF)};
-};
 #undef SUITE
 
 static inline std::string suiteToString(const SSLCipherSuite suite)
@@ -283,9 +279,8 @@ static inline std::string suiteToString(const SSLCipherSuite suite)
   return ss.str();
 }
 
-static const char* kBlocked[] = {
+static const char* kBlocked[] = {"NULL", "anon",    "MD5",   "EXPORT", "DES",
-  "NULL", "anon",    "MD5",   "EXPORT", "DES", "IDEA", "NO_SUCH", "EMPTY", "PSK"
+                                 "IDEA", "NO_SUCH", "EMPTY", "PSK"};
-};
 
 static inline bool isBlockedSuite(SSLCipherSuite suite)
 {
@@ -352,9 +347,8 @@ AppleTLSSession::AppleTLSSession(AppleTLSContext* ctx)
       writeBuffered_(0)
 {
 #if defined(__MAC_10_8)
-  sslCtx_ = SSLCreateContext(nullptr,
+  sslCtx_ = SSLCreateContext(
-                             ctx->getSide() == TLS_SERVER ? kSSLServerSide :
+      nullptr, ctx->getSide() == TLS_SERVER ? kSSLServerSide : kSSLClientSide,
-                                                            kSSLClientSide,
       kSSLStreamType);
   lastError_ = sslCtx_ ? noErr : paramErr;
 #else
@@ -414,8 +408,8 @@ AppleTLSSession::AppleTLSSession(AppleTLSContext* ctx)
 #if defined(__MAC_10_8)
   if (!ctx->getVerifyPeer()) {
     // This disables client verification
-    (void)SSLSetSessionOption(
+    (void)SSLSetSessionOption(sslCtx_, kSSLSessionOptionBreakOnServerAuth,
-        sslCtx_, kSSLSessionOptionBreakOnServerAuth, true);
+                              true);
   }
 #else
   (void)SSLSetEnableCertVerify(sslCtx_, ctx->getVerifyPeer());
@@ -700,8 +694,7 @@ OSStatus AppleTLSSession::sockRead(void* data, size_t* len)
 }
 
 int AppleTLSSession::tlsConnect(const std::string& hostname,
-                                TLSVersion& version,
+                                TLSVersion& version, std::string& handshakeErr)
-                                std::string& handshakeErr)
 {
   if (state_ != st_initialized) {
     return TLS_ERR_ERROR;
@@ -733,10 +726,8 @@ int AppleTLSSession::tlsConnect(const std::string& hostname,
   (void)SSLGetNegotiatedProtocolVersion(sslCtx_, &proto);
   SSLCipherSuite suite = SSL_NO_SUCH_CIPHERSUITE;
   (void)SSLGetNegotiatedCipher(sslCtx_, &suite);
-  A2_LOG_INFO(fmt("AppleTLS: Connected to %s with %s (%s)",
+  A2_LOG_INFO(fmt("AppleTLS: Connected to %s with %s (%s)", hostname.c_str(),
-                  hostname.c_str(),
+                  protoToString(proto), suiteToString(suite).c_str()));
-                  protoToString(proto),
-                  suiteToString(suite).c_str()));
 
   switch (proto) {
   case kSSLProtocol3:

src/AppleTLSSession.h

@@ -41,8 +41,7 @@
 
 namespace aria2 {
 
-class AppleTLSSession : public TLSSession
+class AppleTLSSession : public TLSSession {
-{
   enum state_t {
     st_constructed,
     st_initialized,
@@ -95,8 +94,7 @@ public:
   // if the underlying transport blocks, or TLS_ERR_ERROR.
   // When returning TLS_ERR_ERROR, provide certificate validation error
   // in |handshakeErr|.
-  virtual int tlsConnect(const std::string& hostname,
+  virtual int tlsConnect(const std::string& hostname, TLSVersion& version,
-                         TLSVersion& version,
                          std::string& handshakeErr) CXX11_OVERRIDE;
 
   // Performs server side handshake. This function returns TLS_ERR_OK
@@ -108,8 +106,8 @@ public:
   virtual std::string getLastErrorString() CXX11_OVERRIDE;
 
 private:
-  static OSStatus
+  static OSStatus SocketWrite(SSLConnectionRef conn, const void* data,
-  SocketWrite(SSLConnectionRef conn, const void* data, size_t* len)
+                              size_t* len)
   {
     return ((AppleTLSSession*)conn)->sockWrite(data, len);
   }

src/AsyncNameResolver.cc

@@ -60,19 +60,19 @@ void callback(void* arg, int status, int timeouts, struct hostent* host)
   if (resolverPtr->resolvedAddresses_.empty()) {
     resolverPtr->error_ = "no address returned or address conversion failed";
     resolverPtr->status_ = AsyncNameResolver::STATUS_ERROR;
-  } else {
+  }
+  else {
     resolverPtr->status_ = AsyncNameResolver::STATUS_SUCCESS;
   }
 }
 
-AsyncNameResolver::AsyncNameResolver
+AsyncNameResolver::AsyncNameResolver(int family
-(int family
 #ifdef HAVE_ARES_ADDR_NODE
- , ares_addr_node* servers
+                                     ,
+                                     ares_addr_node* servers
 #endif // HAVE_ARES_ADDR_NODE
                                      )
-  : status_(STATUS_READY),
+    : status_(STATUS_READY), family_(family)
-    family_(family)
 {
   // TODO evaluate return value
   ares_init(&channel_);
@@ -86,10 +86,7 @@ AsyncNameResolver::AsyncNameResolver
 #endif // HAVE_ARES_SET_SERVERS && HAVE_ARES_ADDR_NODE
 }
 
-AsyncNameResolver::~AsyncNameResolver()
+AsyncNameResolver::~AsyncNameResolver() { ares_destroy(channel_); }
-{
-  ares_destroy(channel_);
-}
 
 void AsyncNameResolver::resolve(const std::string& name)
 {

src/AsyncNameResolver.h

@@ -47,8 +47,9 @@
 namespace aria2 {
 
 class AsyncNameResolver {
-  friend void callback
+  friend void callback(void* arg, int status, int timeouts,
-  (void* arg, int status, int timeouts, struct hostent* host);
+                       struct hostent* host);
+
 public:
   enum STATUS {
     STATUS_READY,
@@ -56,6 +57,7 @@ public:
     STATUS_SUCCESS,
     STATUS_ERROR,
   };
+
 private:
   STATUS status_;
   int family_;
@@ -64,11 +66,12 @@ private:
   std::vector<std::string> resolvedAddresses_;
   std::string error_;
   std::string hostname_;
+
 public:
-  AsyncNameResolver
+  AsyncNameResolver(int family
-  (int family
 #ifdef HAVE_ARES_ADDR_NODE
-   , ares_addr_node* servers
+                    ,
+                    ares_addr_node* servers
 #endif // HAVE_ARES_ADDR_NODE
                     );
 
@@ -81,24 +84,15 @@ public:
     return resolvedAddresses_;
   }
 
-  const std::string& getError() const
+  const std::string& getError() const { return error_; }
-  {
-    return error_;
-  }
 
-  STATUS getStatus() const
+  STATUS getStatus() const { return status_; }
-  {
-    return status_;
-  }
 
   int getFds(fd_set* rfdsPtr, fd_set* wfdsPtr) const;
 
   void process(fd_set* rfdsPtr, fd_set* wfdsPtr);
 
-  int getFamily() const
+  int getFamily() const { return family_; }
-  {
-    return family_;
-  }
 #ifdef HAVE_LIBCARES
 
   int getsock(sock_t* sockets) const;
@@ -113,11 +107,7 @@ public:
 
   void reset();
 
-  const std::string& getHostname() const
+  const std::string& getHostname() const { return hostname_; }
-  {
-    return hostname_;
-  }
-
 };
 
 #ifdef HAVE_ARES_ADDR_NODE
@@ -126,7 +116,6 @@ ares_addr_node* parseAsyncDNSServers(const std::string& serversOpt);
 
 #endif // HAVE_ARES_ADDR_NODE
 
-
 } // namespace aria2
 
 #endif // D_ASYNC_NAME_RESOLVER_H

src/AsyncNameResolverMan.cc

@@ -49,17 +49,12 @@
 namespace aria2 {
 
 AsyncNameResolverMan::AsyncNameResolverMan()
-  : numResolver_(0),
+    : numResolver_(0), resolverCheck_(0), ipv4_(true), ipv6_(true)
-    resolverCheck_(0),
-    ipv4_(true),
-    ipv6_(true)
-{}
-
-AsyncNameResolverMan::~AsyncNameResolverMan()
 {
-  assert(!resolverCheck_);
 }
 
+AsyncNameResolverMan::~AsyncNameResolverMan() { assert(!resolverCheck_); }
+
 bool AsyncNameResolverMan::started() const
 {
   for (size_t i = 0; i < numResolver_; ++i) {
@@ -71,8 +66,7 @@ bool AsyncNameResolverMan::started() const
 }
 
 void AsyncNameResolverMan::startAsync(const std::string& hostname,
-                                      DownloadEngine* e,
+                                      DownloadEngine* e, Command* command)
-                                      Command* command)
 {
   numResolver_ = 0;
   // Set IPv6 resolver first, so that we can push IPv6 address in
@@ -85,17 +79,16 @@ void AsyncNameResolverMan::startAsync(const std::string& hostname,
     startAsyncFamily(hostname, AF_INET, e, command);
     ++numResolver_;
   }
-  A2_LOG_INFO(fmt(MSG_RESOLVING_HOSTNAME, command->getCuid(),
+  A2_LOG_INFO(
-                  hostname.c_str()));
+      fmt(MSG_RESOLVING_HOSTNAME, command->getCuid(), hostname.c_str()));
 }
 
 void AsyncNameResolverMan::startAsyncFamily(const std::string& hostname,
-                                            int family,
+                                            int family, DownloadEngine* e,
-                                            DownloadEngine* e,
                                             Command* command)
 {
-  asyncNameResolver_[numResolver_] = std::make_shared<AsyncNameResolver>
+  asyncNameResolver_[numResolver_] =
-    (family
+      std::make_shared<AsyncNameResolver>(family
 #ifdef HAVE_ARES_ADDR_NODE
                                           ,
                                           e->getAsyncDNSServers()
@@ -105,8 +98,8 @@ void AsyncNameResolverMan::startAsyncFamily(const std::string& hostname,
   setNameResolverCheck(numResolver_, e, command);
 }
 
-void AsyncNameResolverMan::getResolvedAddress(std::vector<std::string>& res)
+void AsyncNameResolverMan::getResolvedAddress(
-const
+    std::vector<std::string>& res) const
 {
   for (size_t i = 0; i < numResolver_; ++i) {
     if (asyncNameResolver_[i]->getStatus() ==
@@ -126,8 +119,7 @@ void AsyncNameResolverMan::setNameResolverCheck(DownloadEngine* e,
   }
 }
 
-void AsyncNameResolverMan::setNameResolverCheck(size_t index,
+void AsyncNameResolverMan::setNameResolverCheck(size_t index, DownloadEngine* e,
-                                                DownloadEngine* e,
                                                 Command* command)
 {
   if (asyncNameResolver_[index]) {
@@ -182,9 +174,11 @@ int AsyncNameResolverMan::getStatus() const
   // almost all of them can respond to A queries just fine.
   if ((success && ipv4Success) || success == numResolver_) {
     return 1;
-  } else if(error == numResolver_) {
+  }
+  else if (error == numResolver_) {
     return -1;
-  } else {
+  }
+  else {
     return 0;
   }
 }
@@ -225,8 +219,7 @@ void configureAsyncNameResolverMan(AsyncNameResolverMan* asyncNameResolverMan,
   if (!net::getIPv4AddrConfigured()) {
     asyncNameResolverMan->setIPv4(false);
   }
-  if(!net::getIPv6AddrConfigured() ||
+  if (!net::getIPv6AddrConfigured() || option->getAsBool(PREF_DISABLE_IPV6)) {
-     option->getAsBool(PREF_DISABLE_IPV6)) {
     asyncNameResolverMan->setIPv6(false);
   }
 }

src/AsyncNameResolverMan.h

@@ -55,15 +55,9 @@ public:
   // must call it before the destruction of this object.
   ~AsyncNameResolverMan();
   // Enable IPv4 address lookup. default: true
-  void setIPv4(bool ipv4)
+  void setIPv4(bool ipv4) { ipv4_ = ipv4; }
-  {
-    ipv4_ = ipv4;
-  }
   // Enable IPv6 address lookup. default: true
-  void setIPv6(bool ipv6)
+  void setIPv6(bool ipv6) { ipv6_ = ipv6; }
-  {
-    ipv6_ = ipv6;
-  }
   // Returns true if asynchronous name resolution has been started.
   bool started() const;
   // Starts asynchronous name resolution.
@@ -76,10 +70,7 @@ public:
   // Removes resolvers from DownloadEngine.
   void disableNameResolverCheck(DownloadEngine* e, Command* command);
   // Returns true if any of resolvers are added in DownloadEngine.
-  bool resolverChecked() const
+  bool resolverChecked() const { return resolverCheck_; }
-  {
-    return resolverCheck_;
-  }
   // Returns status value: 0 for inprogress, 1 for success and -1 for
   // failure.
   int getStatus() const;
@@ -87,9 +78,9 @@ public:
   const std::string& getLastError() const;
   // Resets state. Also removes resolvers from DownloadEngine.
   void reset(DownloadEngine* e, Command* command);
+
 private:
-  void startAsyncFamily(const std::string& hostname,
+  void startAsyncFamily(const std::string& hostname, int family,
-                        int family,
                         DownloadEngine* e, Command* command);
   void setNameResolverCheck(size_t resolverIndex, DownloadEngine* e,
                             Command* command);

src/AuthConfig.cc

@@ -43,9 +43,9 @@ namespace aria2 {
 AuthConfig::AuthConfig() {}
 
 AuthConfig::AuthConfig(std::string user, std::string password)
-  : user_(std::move(user)),
+    : user_(std::move(user)), password_(std::move(password))
-    password_(std::move(password))
+{
-{}
+}
 
 AuthConfig::~AuthConfig() {}
 
@@ -57,12 +57,13 @@ std::string AuthConfig::getAuthText() const
   return s;
 }
 
-std::unique_ptr<AuthConfig> AuthConfig::create
+std::unique_ptr<AuthConfig> AuthConfig::create(std::string user,
-(std::string user, std::string password)
+                                               std::string password)
 {
   if (user.empty()) {
     return nullptr;
-  } else {
+  }
+  else {
     return make_unique<AuthConfig>(std::move(user), std::move(password));
   }
 }

src/AuthConfig.h

@@ -48,6 +48,7 @@ private:
   std::string authScheme_;
   std::string user_;
   std::string password_;
+
 public:
   AuthConfig();
   AuthConfig(std::string user, std::string password);
@@ -59,18 +60,12 @@ public:
 
   std::string getAuthText() const;
 
-  const std::string& getUser() const
+  const std::string& getUser() const { return user_; }
-  {
-    return user_;
-  }
 
-  const std::string& getPassword() const
+  const std::string& getPassword() const { return password_; }
-  {
-    return password_;
-  }
 
-  static std::unique_ptr<AuthConfig> create
+  static std::unique_ptr<AuthConfig> create(std::string user,
-  (std::string user, std::string password);
+                                            std::string password);
 };
 
 std::ostream& operator<<(std::ostream& o,

src/AuthConfigFactory.cc

@@ -57,17 +57,15 @@ AuthConfigFactory::AuthConfigFactory() {}
 AuthConfigFactory::~AuthConfigFactory() {}
 
 std::unique_ptr<AuthConfig>
-AuthConfigFactory::createAuthConfig
+AuthConfigFactory::createAuthConfig(const std::shared_ptr<Request>& request,
-(const std::shared_ptr<Request>& request, const Option* op)
+                                    const Option* op)
 {
   if (request->getProtocol() == "http" || request->getProtocol() == "https") {
     if (op->getAsBool(PREF_HTTP_AUTH_CHALLENGE)) {
       if (!request->getUsername().empty()) {
-        updateBasicCred(make_unique<BasicCred>(request->getUsername(),
+        updateBasicCred(make_unique<BasicCred>(
-                                               request->getPassword(),
+            request->getUsername(), request->getPassword(), request->getHost(),
-                                               request->getHost(),
+            request->getPort(), request->getDir(), true));
-                                               request->getPort(),
-                                               request->getDir(), true));
         return AuthConfig::create(request->getUsername(),
                                   request->getPassword());
       }
@@ -75,25 +73,30 @@ AuthConfigFactory::createAuthConfig
                              request->getDir());
       if (i == std::end(basicCreds_)) {
         return nullptr;
-      } else {
+      }
+      else {
         return AuthConfig::create((*i)->user_, (*i)->password_);
       }
-    } else {
+    }
+    else {
       if (!request->getUsername().empty()) {
         return AuthConfig::create(request->getUsername(),
                                   request->getPassword());
-      } else {
+      }
-        return
+      else {
-          createHttpAuthResolver(op)->resolveAuthConfig(request->getHost());
+        return createHttpAuthResolver(op)
+            ->resolveAuthConfig(request->getHost());
       }
     }
-  } else if(request->getProtocol() == "ftp" ||
+  }
+  else if (request->getProtocol() == "ftp" ||
            request->getProtocol() == "sftp") {
     if (!request->getUsername().empty()) {
       if (request->hasPassword()) {
         return AuthConfig::create(request->getUsername(),
                                   request->getPassword());
-      } else {
+      }
+      else {
         if (!op->getAsBool(PREF_NO_NETRC)) {
           // First, check we have password corresponding to host and
           // username
@@ -110,22 +113,24 @@ AuthConfigFactory::createAuthConfig
         return AuthConfig::create(request->getUsername(),
                                   op->get(PREF_FTP_PASSWD));
       }
-    } else {
-      return
-        createFtpAuthResolver(op)->resolveAuthConfig(request->getHost());
     }
-  } else {
+    else {
+      return createFtpAuthResolver(op)->resolveAuthConfig(request->getHost());
+    }
+  }
+  else {
     return nullptr;
   }
 }
 
-std::unique_ptr<AuthResolver> AuthConfigFactory::createHttpAuthResolver
+std::unique_ptr<AuthResolver>
-(const Option* op) const
+AuthConfigFactory::createHttpAuthResolver(const Option* op) const
 {
   std::unique_ptr<AbstractAuthResolver> resolver;
   if (op->getAsBool(PREF_NO_NETRC)) {
     resolver = make_unique<DefaultAuthResolver>();
-  } else {
+  }
+  else {
     auto authResolver = make_unique<NetrcAuthResolver>();
     authResolver->setNetrc(netrc_.get());
     authResolver->ignoreDefault();
@@ -136,13 +141,14 @@ std::unique_ptr<AuthResolver> AuthConfigFactory::createHttpAuthResolver
   return std::move(resolver);
 }
 
-std::unique_ptr<AuthResolver> AuthConfigFactory::createFtpAuthResolver
+std::unique_ptr<AuthResolver>
-(const Option* op) const
+AuthConfigFactory::createFtpAuthResolver(const Option* op) const
 {
   std::unique_ptr<AbstractAuthResolver> resolver;
   if (op->getAsBool(PREF_NO_NETRC)) {
     resolver = make_unique<DefaultAuthResolver>();
-  } else {
+  }
+  else {
     auto authResolver = make_unique<NetrcAuthResolver>();
     authResolver->setNetrc(netrc_.get());
     resolver = std::move(authResolver);
@@ -163,13 +169,13 @@ void AuthConfigFactory::updateBasicCred(std::unique_ptr<BasicCred> basicCred)
   auto i = basicCreds_.lower_bound(basicCred);
   if (i != std::end(basicCreds_) && *i == basicCred) {
     *(*i) = std::move(*basicCred);
-  } else {
+  }
+  else {
     basicCreds_.insert(i, std::move(basicCred));
   }
 }
 
-bool AuthConfigFactory::activateBasicCred
+bool AuthConfigFactory::activateBasicCred(const std::string& host,
-(const std::string& host,
                                           uint16_t port,
                                           const std::string& path,
                                           const Option* op)
@@ -179,22 +185,22 @@ bool AuthConfigFactory::activateBasicCred
     auto authConfig = createHttpAuthResolver(op)->resolveAuthConfig(host);
     if (!authConfig) {
       return false;
-    } else {
+    }
+    else {
       basicCreds_.insert(make_unique<BasicCred>(authConfig->getUser(),
-                                                authConfig->getPassword(),
+                                                authConfig->getPassword(), host,
-                                                host, port, path, true));
+                                                port, path, true));
       return true;
     }
-  } else {
+  }
+  else {
     (*i)->activate();
     return true;
   }
 }
 
-BasicCred::BasicCred
+BasicCred::BasicCred(std::string user, std::string password, std::string host,
-(std::string user, std::string password,
+                     uint16_t port, std::string path, bool activated)
- std::string host, uint16_t port, std::string path,
- bool activated)
     : user_(std::move(user)),
       password_(std::move(password)),
       host_(std::move(host)),
@@ -207,15 +213,9 @@ BasicCred::BasicCred
   }
 }
 
-void BasicCred::activate()
+void BasicCred::activate() { activated_ = true; }
-{
-  activated_ = true;
-}
 
-bool BasicCred::isActivated() const
+bool BasicCred::isActivated() const { return activated_; }
-{
-  return activated_;
-}
 
 bool BasicCred::operator==(const BasicCred& cred) const
 {
@@ -224,21 +224,20 @@ bool BasicCred::operator==(const BasicCred& cred) const
 
 bool BasicCred::operator<(const BasicCred& cred) const
 {
-  return host_ < cred.host_ ||
+  return host_ < cred.host_ || (!(cred.host_ < host_) &&
-    (!(cred.host_ < host_) && (port_ < cred.port_ ||
+                                (port_ < cred.port_ || (!(cred.port_ < port_) &&
-                               (!(cred.port_ < port_) && path_ > cred.path_)));
+                                                        path_ > cred.path_)));
 }
 
-AuthConfigFactory::BasicCredSet::iterator AuthConfigFactory::findBasicCred
+AuthConfigFactory::BasicCredSet::iterator
-(const std::string& host,
+AuthConfigFactory::findBasicCred(const std::string& host, uint16_t port,
- uint16_t port,
                                  const std::string& path)
 {
   auto bc = make_unique<BasicCred>("", "", host, port, path);
   auto i = basicCreds_.lower_bound(bc);
-  for(; i != std::end(basicCreds_) &&
+  for (;
-        (*i)->host_ == host &&
+       i != std::end(basicCreds_) && (*i)->host_ == host && (*i)->port_ == port;
-        (*i)->port_ == port; ++i) {
+       ++i) {
     if (util::startsWith(bc->path_, (*i)->path_)) {
       return i;
     }

src/AuthConfigFactory.h

@@ -61,9 +61,8 @@ public:
   std::string path_;
   bool activated_;
 
-  BasicCred(std::string user, std::string password,
+  BasicCred(std::string user, std::string password, std::string host,
-            std::string host, uint16_t port, std::string path,
+            uint16_t port, std::string path, bool activated = false);
-            bool activated = false);
 
   void activate();
 
@@ -78,6 +77,7 @@ class AuthConfigFactory {
 public:
   typedef std::set<std::unique_ptr<BasicCred>,
                    DerefLess<std::unique_ptr<BasicCred>>> BasicCredSet;
+
 private:
   std::unique_ptr<Netrc> netrc_;
 
@@ -86,6 +86,7 @@ private:
   std::unique_ptr<AuthResolver> createFtpAuthResolver(const Option* op) const;
 
   BasicCredSet basicCreds_;
+
 public:
   AuthConfigFactory();
 
@@ -95,8 +96,8 @@ public:
   // are used in this method: PREF_HTTP_USER, PREF_HTTP_PASSWD,
   // PREF_FTP_USER, PREF_FTP_PASSWD, PREF_NO_NETRC and
   // PREF_HTTP_AUTH_CHALLENGE.
-  std::unique_ptr<AuthConfig> createAuthConfig
+  std::unique_ptr<AuthConfig>
-  (const std::shared_ptr<Request>& request, const Option* op);
+  createAuthConfig(const std::shared_ptr<Request>& request, const Option* op);
 
   void setNetrc(std::unique_ptr<Netrc> netrc);
 
@@ -106,19 +107,13 @@ public:
   // null, then returns false. Otherwise new BasicCred is created
   // using this AuthConfig object with given host and path "/" and
   // returns true.
-  bool activateBasicCred
+  bool activateBasicCred(const std::string& host, uint16_t port,
-  (const std::string& host,
+                         const std::string& path, const Option* op);
-   uint16_t port,
-   const std::string& path,
-   const Option* op);
 
   // Find a BasicCred using host, port and path and return the
   // iterator pointing to it. If not found, then return
   // basicCreds_.end().
-  BasicCredSet::iterator
+  BasicCredSet::iterator findBasicCred(const std::string& host, uint16_t port,
-  findBasicCred
-  (const std::string& host,
-   uint16_t port,
                                        const std::string& path);
 
   // If the same BasicCred is already added, then it is replaced with

src/AuthResolver.h

@@ -48,8 +48,8 @@ class AuthResolver {
 public:
   virtual ~AuthResolver() {}
 
-  virtual std::unique_ptr<AuthConfig> resolveAuthConfig
+  virtual std::unique_ptr<AuthConfig>
-  (const std::string& hostname) = 0;
+  resolveAuthConfig(const std::string& hostname) = 0;
 };
 
 } // namespace aria2

src/AutoSaveCommand.cc

@@ -41,7 +41,8 @@ namespace aria2 {
 AutoSaveCommand::AutoSaveCommand(cuid_t cuid, DownloadEngine* e,
                                  std::chrono::seconds interval)
     : TimeBasedCommand(cuid, e, std::move(interval), true)
-{}
+{
+}
 
 AutoSaveCommand::~AutoSaveCommand() {}
 

src/AutoSaveCommand.h

@@ -39,8 +39,7 @@
 
 namespace aria2 {
 
-class AutoSaveCommand : public TimeBasedCommand
+class AutoSaveCommand : public TimeBasedCommand {
-{
 public:
   AutoSaveCommand(cuid_t cuid, DownloadEngine* e,
                   std::chrono::seconds interval);

src/BackupIPv4ConnectCommand.cc

@@ -45,12 +45,10 @@
 
 namespace aria2 {
 
-BackupConnectInfo::BackupConnectInfo()
+BackupConnectInfo::BackupConnectInfo() : cancel(false) {}
-  : cancel(false)
-{}
 
-BackupIPv4ConnectCommand::BackupIPv4ConnectCommand
+BackupIPv4ConnectCommand::BackupIPv4ConnectCommand(
-(cuid_t cuid, const std::string& ipaddr, uint16_t port,
+    cuid_t cuid, const std::string& ipaddr, uint16_t port,
     const std::shared_ptr<BackupConnectInfo>& info, Command* mainCommand,
     RequestGroup* requestGroup, DownloadEngine* e)
     : Command(cuid),
@@ -82,35 +80,41 @@ bool BackupIPv4ConnectCommand::execute()
   bool retval = false;
   if (requestGroup_->downloadFinished() || requestGroup_->isHaltRequested()) {
     retval = true;
-  } else if(info_->cancel) {
+  }
-    A2_LOG_INFO(fmt("CUID#%" PRId64 " - Backup connection canceled",
+  else if (info_->cancel) {
-                    getCuid()));
+    A2_LOG_INFO(
+        fmt("CUID#%" PRId64 " - Backup connection canceled", getCuid()));
     retval = true;
-  } else if(socket_) {
+  }
+  else if (socket_) {
     if (writeEventEnabled()) {
       try {
         std::string error = socket_->getSocketError();
         if (error.empty()) {
           A2_LOG_INFO(fmt("CUID#%" PRId64 " - Backup connection to %s "
-                          "established", getCuid(), ipaddr_.c_str()));
+                          "established",
+                          getCuid(), ipaddr_.c_str()));
           info_->ipaddr = ipaddr_;
           e_->deleteSocketForWriteCheck(socket_, this);
           info_->socket.swap(socket_);
           mainCommand_->setStatus(STATUS_ONESHOT_REALTIME);
           e_->setNoWait(true);
           retval = true;
-        } else {
+        }
+        else {
           A2_LOG_INFO(fmt("CUID#%" PRId64 " - Backup connection failed: %s",
                           getCuid(), error.c_str()));
           retval = true;
         }
-      } catch(RecoverableException& e) {
+      }
-        A2_LOG_INFO_EX(fmt("CUID#%" PRId64 " - Backup connection failed",
+      catch (RecoverableException& e) {
-                           getCuid()), e);
+        A2_LOG_INFO_EX(
+            fmt("CUID#%" PRId64 " - Backup connection failed", getCuid()), e);
         retval = true;
       }
     }
-  } else if(!socket_) {
+  }
+  else if (!socket_) {
     // TODO Although we check 300ms initial timeout as described in
     // RFC 6555, the interval will be much longer and around 1 second
     // due to the refresh interval mechanism in DownloadEngine.
@@ -121,16 +125,18 @@ bool BackupIPv4ConnectCommand::execute()
         socket_->establishConnection(ipaddr_, port_);
         e_->addSocketForWriteCheck(socket_, this);
         timeoutCheck_ = global::wallclock();
-      } catch(RecoverableException& e) {
+      }
-        A2_LOG_INFO_EX(fmt("CUID#%" PRId64 " - Backup connection failed",
+      catch (RecoverableException& e) {
-                           getCuid()), e);
+        A2_LOG_INFO_EX(
+            fmt("CUID#%" PRId64 " - Backup connection failed", getCuid()), e);
         socket_.reset();
         retval = true;
       }
     }
-  } else if(timeoutCheck_.difference(global::wallclock()) >= timeout_) {
+  }
-    A2_LOG_INFO(fmt("CUID#%" PRId64 " - Backup connection command timeout",
+  else if (timeoutCheck_.difference(global::wallclock()) >= timeout_) {
-                    getCuid()));
+    A2_LOG_INFO(
+        fmt("CUID#%" PRId64 " - Backup connection command timeout", getCuid()));
     retval = true;
   }
   if (!retval) {

src/BackupIPv4ConnectCommand.h

@@ -64,13 +64,14 @@ struct BackupConnectInfo {
 // "Happy Eyeballs" implementation.
 class BackupIPv4ConnectCommand : public Command {
 public:
-  BackupIPv4ConnectCommand(cuid_t cuid,
+  BackupIPv4ConnectCommand(cuid_t cuid, const std::string& ipaddr,
-                           const std::string& ipaddr, uint16_t port,
+                           uint16_t port,
                            const std::shared_ptr<BackupConnectInfo>& info,
-                           Command* mainCommand,
+                           Command* mainCommand, RequestGroup* requestGroup,
-                           RequestGroup* requestGroup, DownloadEngine* e);
+                           DownloadEngine* e);
   ~BackupIPv4ConnectCommand();
   virtual bool execute() CXX11_OVERRIDE;
+
 private:
   std::string ipaddr_;
   uint16_t port_;

src/BencodeParser.cc

@@ -71,15 +71,15 @@ BencodeParser::BencodeParser(StructParserStateMachine* psm)
   stateStack_.push(BENCODE_FINISH);
 }
 
-BencodeParser::~BencodeParser()
+BencodeParser::~BencodeParser() {}
-{}
 
 ssize_t BencodeParser::parseUpdate(const char* data, size_t size)
 {
   size_t i;
   if (currentState_ == BENCODE_FINISH) {
     return 0;
-  } else if(currentState_ == BENCODE_ERROR) {
+  }
+  else if (currentState_ == BENCODE_ERROR) {
     return lastError_;
   }
   for (i = 0; i < size && currentState_ != BENCODE_FINISH; ++i) {
@@ -89,7 +89,8 @@ ssize_t BencodeParser::parseUpdate(const char* data, size_t size)
       if (c == 'e') {
         onListEnd();
         break;
-      } else {
+      }
+      else {
         int rv = pushState(currentState_);
         if (rv < 0) {
           return rv;
@@ -124,7 +125,8 @@ ssize_t BencodeParser::parseUpdate(const char* data, size_t size)
           currentState_ = BENCODE_STRING_LEN;
           runBeginCallback(STRUCT_STRING_T);
           break;
-        } else {
+        }
+        else {
           currentState_ = BENCODE_ERROR;
           return lastError_ = ERR_UNEXPECTED_CHAR_BEFORE_VAL;
         }
@@ -167,7 +169,8 @@ ssize_t BencodeParser::parseUpdate(const char* data, size_t size)
           runCharactersCallback(nullptr, 0);
           onStringEnd();
         }
-      } else {
+      }
+      else {
         i = j - 1;
       }
       break;
@@ -219,7 +222,8 @@ ssize_t BencodeParser::parseUpdate(const char* data, size_t size)
         }
         i = j;
         onNumberEnd();
-      } else {
+      }
+      else {
         i = j - 1;
       }
       break;
@@ -234,8 +238,7 @@ ssize_t BencodeParser::parseFinal(const char* data, size_t len)
   ssize_t rv;
   rv = parseUpdate(data, len);
   if (rv >= 0) {
-    if(currentState_ != BENCODE_FINISH &&
+    if (currentState_ != BENCODE_FINISH && currentState_ != BENCODE_INITIAL) {
-       currentState_ != BENCODE_INITIAL) {
       rv = ERR_PREMATURE_DATA;
     }
   }
@@ -255,8 +258,8 @@ void BencodeParser::reset()
 
 void BencodeParser::onStringEnd()
 {
-  runEndCallback(stateTop() == BENCODE_DICT_KEY ?
+  runEndCallback(stateTop() == BENCODE_DICT_KEY ? STRUCT_DICT_KEY_T
-                 STRUCT_DICT_KEY_T : STRUCT_STRING_T);
+                                                : STRUCT_STRING_T);
   onValueEnd();
 }
 
@@ -309,16 +312,14 @@ int BencodeParser::pushState(int state)
 {
   if (stateStack_.size() >= 50) {
     return ERR_STRUCTURE_TOO_DEEP;
-  } else {
+  }
+  else {
     stateStack_.push(state);
     return 0;
   }
 }
 
-int BencodeParser::stateTop() const
+int BencodeParser::stateTop() const { return stateStack_.top(); }
-{
-  return stateStack_.top();
-}
 
 int BencodeParser::popState()
 {

src/BencodeParser.h

@@ -72,6 +72,7 @@ public:
   // Resets the internal state of the parser and makes it ready for
   // reuse.
   void reset();
+
 private:
   int pushState(int state);
   int stateTop() const;

src/BitfieldMan.cc

@@ -115,7 +115,8 @@ BitfieldMan& BitfieldMan::operator=(const BitfieldMan& bitfieldMan)
     if (filterEnabled_) {
       filterBitfield_ = new unsigned char[bitfieldLength_];
       memcpy(filterBitfield_, bitfieldMan.filterBitfield_, bitfieldLength_);
-    } else {
+    }
+    else {
       filterBitfield_ = nullptr;
     }
 
@@ -124,7 +125,8 @@ BitfieldMan& BitfieldMan::operator=(const BitfieldMan& bitfieldMan)
   return *this;
 }
 
-BitfieldMan::~BitfieldMan() {
+BitfieldMan::~BitfieldMan()
+{
   delete[] bitfield_;
   delete[] useBitfield_;
   delete[] filterBitfield_;
@@ -139,15 +141,17 @@ int32_t BitfieldMan::getBlockLength(size_t index) const
 {
   if (index == blocks_ - 1) {
     return getLastBlockLength();
-  } else if(index < blocks_-1) {
+  }
+  else if (index < blocks_ - 1) {
     return getBlockLength();
-  } else {
+  }
+  else {
     return 0;
   }
 }
 
-bool BitfieldMan::hasMissingPiece
+bool BitfieldMan::hasMissingPiece(const unsigned char* peerBitfield,
-(const unsigned char* peerBitfield, size_t length) const
+                                  size_t length) const
 {
   if (bitfieldLength_ != length) {
     return false;
@@ -169,48 +173,55 @@ bool BitfieldMan::hasMissingPiece
 bool BitfieldMan::getFirstMissingUnusedIndex(size_t& index) const
 {
   if (filterEnabled_) {
-    return bitfield::getFirstSetBitIndex
+    return bitfield::getFirstSetBitIndex(index, ~array(bitfield_) &
-      (index, ~array(bitfield_)&~array(useBitfield_)&array(filterBitfield_),
+                                                    ~array(useBitfield_) &
+                                                    array(filterBitfield_),
                                          blocks_);
-  } else {
+  }
-    return bitfield::getFirstSetBitIndex
+  else {
-      (index, ~array(bitfield_)&~array(useBitfield_), blocks_);
+    return bitfield::getFirstSetBitIndex(
+        index, ~array(bitfield_) & ~array(useBitfield_), blocks_);
   }
 }
 
-size_t BitfieldMan::getFirstNMissingUnusedIndex
+size_t BitfieldMan::getFirstNMissingUnusedIndex(std::vector<size_t>& out,
-(std::vector<size_t>& out, size_t n) const
+                                                size_t n) const
 {
   if (filterEnabled_) {
-    return bitfield::getFirstNSetBitIndex
+    return bitfield::getFirstNSetBitIndex(
-      (std::back_inserter(out), n,
+        std::back_inserter(out), n,
-       ~array(bitfield_)&~array(useBitfield_)&array(filterBitfield_), blocks_);
+        ~array(bitfield_) & ~array(useBitfield_) & array(filterBitfield_),
-  } else {
+        blocks_);
-    return bitfield::getFirstNSetBitIndex
+  }
-      (std::back_inserter(out), n,
+  else {
-       ~array(bitfield_)&~array(useBitfield_), blocks_);
+    return bitfield::getFirstNSetBitIndex(
+        std::back_inserter(out), n, ~array(bitfield_) & ~array(useBitfield_),
+        blocks_);
   }
 }
 
 bool BitfieldMan::getFirstMissingIndex(size_t& index) const
 {
   if (filterEnabled_) {
-    return bitfield::getFirstSetBitIndex
+    return bitfield::getFirstSetBitIndex(
-      (index, ~array(bitfield_)&array(filterBitfield_), blocks_);
+        index, ~array(bitfield_) & array(filterBitfield_), blocks_);
-  } else {
+  }
+  else {
     return bitfield::getFirstSetBitIndex(index, ~array(bitfield_), blocks_);
   }
 }
 
 namespace {
 template <typename Array>
-size_t getStartIndex(size_t index, const Array& bitfield, size_t blocks) {
+size_t getStartIndex(size_t index, const Array& bitfield, size_t blocks)
+{
   while (index < blocks && bitfield::test(bitfield, blocks, index)) {
     ++index;
   }
   if (blocks <= index) {
     return blocks;
-  } else {
+  }
+  else {
     return index;
   }
 }
@@ -218,7 +229,8 @@ size_t getStartIndex(size_t index, const Array& bitfield, size_t blocks) {
 
 namespace {
 template <typename Array>
-size_t getEndIndex(size_t index, const Array& bitfield, size_t blocks) {
+size_t getEndIndex(size_t index, const Array& bitfield, size_t blocks)
+{
   while (index < blocks && !bitfield::test(bitfield, blocks, index)) {
     ++index;
   }
@@ -228,20 +240,16 @@ size_t getEndIndex(size_t index, const Array& bitfield, size_t blocks) {
 
 namespace {
 template <typename Array>
-bool getSparseMissingUnusedIndex
+bool getSparseMissingUnusedIndex(size_t& index, int32_t minSplitSize,
-(size_t& index,
- int32_t minSplitSize,
                                  const Array& bitfield,
                                  const unsigned char* useBitfield,
- int32_t blockLength,
+                                 int32_t blockLength, size_t blocks)
- size_t blocks)
 {
   BitfieldMan::Range maxRange;
   BitfieldMan::Range currentRange;
   size_t nextIndex = 0;
   while (nextIndex < blocks) {
-    currentRange.startIndex =
+    currentRange.startIndex = getStartIndex(nextIndex, bitfield, blocks);
-      getStartIndex(nextIndex, bitfield, blocks);
     if (currentRange.startIndex == blocks) {
       break;
     }
@@ -256,54 +264,54 @@ bool getSparseMissingUnusedIndex
     // If range is equal, choose a range where its startIndex-1 is
     // set.
     if (maxRange < currentRange ||
-       (maxRange == currentRange &&
+        (maxRange == currentRange && maxRange.startIndex > 0 &&
-        maxRange.startIndex > 0 && currentRange.startIndex > 0 &&
+         currentRange.startIndex > 0 &&
          (!bitfield::test(bitfield, blocks, maxRange.startIndex - 1) ||
-         bitfield::test(useBitfield, blocks, maxRange.startIndex-1))
+          bitfield::test(useBitfield, blocks, maxRange.startIndex - 1)) &&
-        &&
          bitfield::test(bitfield, blocks, currentRange.startIndex - 1) &&
          !bitfield::test(useBitfield, blocks, currentRange.startIndex - 1))) {
       maxRange = currentRange;
     }
     nextIndex = currentRange.endIndex;
-
   }
   if (maxRange.getSize()) {
     if (maxRange.startIndex == 0) {
       index = 0;
       return true;
-    } else {
+    }
+    else {
       if ((!bitfield::test(useBitfield, blocks, maxRange.startIndex - 1) &&
            bitfield::test(bitfield, blocks, maxRange.startIndex - 1)) ||
           (static_cast<int64_t>(maxRange.endIndex - maxRange.startIndex) *
-          blockLength >= minSplitSize)) {
+               blockLength >=
+           minSplitSize)) {
         index = maxRange.startIndex;
         return true;
-      } else {
+      }
+      else {
         return false;
       }
     }
-  } else {
+  }
+  else {
     return false;
   }
 }
 } // namespace
 
-bool BitfieldMan::getSparseMissingUnusedIndex
+bool BitfieldMan::getSparseMissingUnusedIndex(
-(size_t& index,
+    size_t& index, int32_t minSplitSize, const unsigned char* ignoreBitfield,
- int32_t minSplitSize,
- const unsigned char* ignoreBitfield,
     size_t ignoreBitfieldLength) const
 {
   if (filterEnabled_) {
-    return aria2::getSparseMissingUnusedIndex
+    return aria2::getSparseMissingUnusedIndex(
-      (index, minSplitSize,
+        index, minSplitSize, array(ignoreBitfield) | ~array(filterBitfield_) |
-       array(ignoreBitfield)|~array(filterBitfield_)|
                                  array(bitfield_) | array(useBitfield_),
         useBitfield_, blockLength_, blocks_);
-  } else {
+  }
-    return aria2::getSparseMissingUnusedIndex
+  else {
-      (index, minSplitSize,
+    return aria2::getSparseMissingUnusedIndex(
+        index, minSplitSize,
         array(ignoreBitfield) | array(bitfield_) | array(useBitfield_),
         useBitfield_, blockLength_, blocks_);
   }
@@ -311,14 +319,10 @@ bool BitfieldMan::getSparseMissingUnusedIndex
 
 namespace {
 template <typename Array>
-bool getGeomMissingUnusedIndex
+bool getGeomMissingUnusedIndex(size_t& index, int32_t minSplitSize,
-(size_t& index,
- int32_t minSplitSize,
                                const Array& bitfield,
                                const unsigned char* useBitfield,
- int32_t blockLength,
+                               int32_t blockLength, size_t blocks, double base,
- size_t blocks,
- double base,
                                size_t offsetIndex)
 {
   double start = 0;
@@ -330,57 +334,51 @@ bool getGeomMissingUnusedIndex
          i < eoi; ++i) {
       if (bitfield::test(useBitfield, blocks, i)) {
         break;
-      } else if(!bitfield::test(bitfield, blocks, i)) {
+      }
+      else if (!bitfield::test(bitfield, blocks, i)) {
         index = i;
         break;
       }
     }
     if (index < blocks) {
       return true;
-    } else {
+    }
+    else {
       start = end;
       end *= base;
     }
   }
-  return getSparseMissingUnusedIndex(index, minSplitSize,
+  return getSparseMissingUnusedIndex(index, minSplitSize, bitfield, useBitfield,
-                                     bitfield, useBitfield,
                                      blockLength, blocks);
 }
 } // namespace
 
-bool BitfieldMan::getGeomMissingUnusedIndex
+bool BitfieldMan::getGeomMissingUnusedIndex(size_t& index, int32_t minSplitSize,
-(size_t& index,
- int32_t minSplitSize,
                                             const unsigned char* ignoreBitfield,
                                             size_t ignoreBitfieldLength,
                                             double base,
                                             size_t offsetIndex) const
 {
   if (filterEnabled_) {
-    return aria2::getGeomMissingUnusedIndex
+    return aria2::getGeomMissingUnusedIndex(
-      (index, minSplitSize,
+        index, minSplitSize, array(ignoreBitfield) | ~array(filterBitfield_) |
-       array(ignoreBitfield)|~array(filterBitfield_)|
                                  array(bitfield_) | array(useBitfield_),
-       useBitfield_, blockLength_, blocks_,
+        useBitfield_, blockLength_, blocks_, base, offsetIndex);
-       base, offsetIndex);
+  }
-  } else {
+  else {
-    return aria2::getGeomMissingUnusedIndex
+    return aria2::getGeomMissingUnusedIndex(
-      (index, minSplitSize,
+        index, minSplitSize,
         array(ignoreBitfield) | array(bitfield_) | array(useBitfield_),
-       useBitfield_, blockLength_, blocks_,
+        useBitfield_, blockLength_, blocks_, base, offsetIndex);
-       base, offsetIndex);
   }
 }
 
 namespace {
 template <typename Array>
-bool getInorderMissingUnusedIndex
+bool getInorderMissingUnusedIndex(size_t& index, int32_t minSplitSize,
-(size_t& index,
- int32_t minSplitSize,
                                   const Array& bitfield,
                                   const unsigned char* useBitfield,
- int32_t blockLength,
+                                  int32_t blockLength, size_t blocks)
- size_t blocks)
 {
   // We always return first piece if it is available.
   if (!bitfield::test(bitfield, blocks, 0) &&
@@ -411,7 +409,8 @@ bool getInorderMissingUnusedIndex
         }
       }
       i = j + 1;
-    } else {
+    }
+    else {
       ++i;
     }
   }
@@ -419,21 +418,19 @@ bool getInorderMissingUnusedIndex
 }
 } // namespace
 
-bool BitfieldMan::getInorderMissingUnusedIndex
+bool BitfieldMan::getInorderMissingUnusedIndex(
-(size_t& index,
+    size_t& index, int32_t minSplitSize, const unsigned char* ignoreBitfield,
- int32_t minSplitSize,
- const unsigned char* ignoreBitfield,
     size_t ignoreBitfieldLength) const
 {
   if (filterEnabled_) {
-    return aria2::getInorderMissingUnusedIndex
+    return aria2::getInorderMissingUnusedIndex(
-      (index, minSplitSize,
+        index, minSplitSize, array(ignoreBitfield) | ~array(filterBitfield_) |
-       array(ignoreBitfield)|~array(filterBitfield_)|
                                  array(bitfield_) | array(useBitfield_),
         useBitfield_, blockLength_, blocks_);
-  } else {
+  }
-    return aria2::getInorderMissingUnusedIndex
+  else {
-      (index, minSplitSize,
+    return aria2::getInorderMissingUnusedIndex(
+        index, minSplitSize,
         array(ignoreBitfield) | array(bitfield_) | array(useBitfield_),
         useBitfield_, blockLength_, blocks_);
   }
@@ -455,14 +452,15 @@ bool copyBitfield(unsigned char* dst, const Array& src, size_t blocks)
 }
 } // namespace
 
-bool BitfieldMan::getAllMissingIndexes(unsigned char* misbitfield, size_t len)
+bool BitfieldMan::getAllMissingIndexes(unsigned char* misbitfield,
-  const
+                                       size_t len) const
 {
   assert(len == bitfieldLength_);
   if (filterEnabled_) {
-    return copyBitfield
+    return copyBitfield(misbitfield, ~array(bitfield_) & array(filterBitfield_),
-      (misbitfield, ~array(bitfield_)&array(filterBitfield_), blocks_);
+                        blocks_);
-  } else {
+  }
+  else {
     return copyBitfield(misbitfield, ~array(bitfield_), blocks_);
   }
 }
@@ -476,13 +474,12 @@ bool BitfieldMan::getAllMissingIndexes(unsigned char* misbitfield, size_t len,
     return false;
   }
   if (filterEnabled_) {
-    return copyBitfield
+    return copyBitfield(misbitfield, ~array(bitfield_) & array(peerBitfield) &
-      (misbitfield,
+                                         array(filterBitfield_),
-       ~array(bitfield_)&array(peerBitfield)&array(filterBitfield_),
                         blocks_);
-  } else {
+  }
-    return copyBitfield
+  else {
-      (misbitfield, ~array(bitfield_)&array(peerBitfield),
+    return copyBitfield(misbitfield, ~array(bitfield_) & array(peerBitfield),
                         blocks_);
   }
 }
@@ -497,73 +494,83 @@ bool BitfieldMan::getAllMissingUnusedIndexes(unsigned char* misbitfield,
     return false;
   }
   if (filterEnabled_) {
-    return copyBitfield
+    return copyBitfield(misbitfield,
-      (misbitfield,
+                        ~array(bitfield_) & ~array(useBitfield_) &
-       ~array(bitfield_)&~array(useBitfield_)&array(peerBitfield)&
+                            array(peerBitfield) & array(filterBitfield_),
-       array(filterBitfield_),
                         blocks_);
-  } else {
+  }
-    return copyBitfield
+  else {
-      (misbitfield,
+    return copyBitfield(misbitfield, ~array(bitfield_) & ~array(useBitfield_) &
-       ~array(bitfield_)&~array(useBitfield_)&array(peerBitfield),
+                                         array(peerBitfield),
                         blocks_);
   }
 }
 
-size_t BitfieldMan::countMissingBlock() const {
+size_t BitfieldMan::countMissingBlock() const { return cachedNumMissingBlock_; }
-  return cachedNumMissingBlock_;
-}
 
-size_t BitfieldMan::countMissingBlockNow() const {
+size_t BitfieldMan::countMissingBlockNow() const
+{
   if (filterEnabled_) {
     return bitfield::countSetBit(filterBitfield_, blocks_) -
            bitfield::countSetBitSlow(array(bitfield_) & array(filterBitfield_),
                                      blocks_);
-  } else {
+  }
+  else {
     return blocks_ - bitfield::countSetBit(bitfield_, blocks_);
   }
 }
 
-size_t BitfieldMan::countFilteredBlockNow() const {
+size_t BitfieldMan::countFilteredBlockNow() const
+{
   if (filterEnabled_) {
     return bitfield::countSetBit(filterBitfield_, blocks_);
-  } else {
+  }
+  else {
     return 0;
   }
 }
 
-bool BitfieldMan::setBitInternal(unsigned char* bitfield, size_t index, bool on) {
+bool BitfieldMan::setBitInternal(unsigned char* bitfield, size_t index, bool on)
-  if(blocks_ <= index) { return false; }
+{
+  if (blocks_ <= index) {
+    return false;
+  }
   unsigned char mask = 128 >> (index % 8);
   if (on) {
     bitfield[index / 8] |= mask;
-  } else {
+  }
+  else {
     bitfield[index / 8] &= ~mask;
   }
   return true;
 }
 
-bool BitfieldMan::setUseBit(size_t index) {
+bool BitfieldMan::setUseBit(size_t index)
+{
   return setBitInternal(useBitfield_, index, true);
 }
 
-bool BitfieldMan::unsetUseBit(size_t index) {
+bool BitfieldMan::unsetUseBit(size_t index)
+{
   return setBitInternal(useBitfield_, index, false);
 }
 
-bool BitfieldMan::setBit(size_t index) {
+bool BitfieldMan::setBit(size_t index)
+{
   bool b = setBitInternal(bitfield_, index, true);
   updateCache();
   return b;
 }
 
-bool BitfieldMan::unsetBit(size_t index) {
+bool BitfieldMan::unsetBit(size_t index)
+{
   bool b = setBitInternal(bitfield_, index, false);
   updateCache();
   return b;
 }
 
-bool BitfieldMan::isFilteredAllBitSet() const {
+bool BitfieldMan::isFilteredAllBitSet() const
+{
   if (filterEnabled_) {
     for (size_t i = 0; i < bitfieldLength_; ++i) {
       if ((bitfield_[i] & filterBitfield_[i]) != filterBitfield_[i]) {
@@ -571,14 +578,14 @@ bool BitfieldMan::isFilteredAllBitSet() const {
       }
     }
     return true;
-  } else {
+  }
+  else {
     return isAllBitSet();
   }
 }
 
 namespace {
-bool testAllBitSet
+bool testAllBitSet(const unsigned char* bitfield, size_t length, size_t blocks)
-(const unsigned char* bitfield, size_t length, size_t blocks)
 {
   if (length == 0) {
     return true;
@@ -605,10 +612,12 @@ bool BitfieldMan::isAllFilterBitSet() const
   return testAllBitSet(filterBitfield_, bitfieldLength_, blocks_);
 }
 
-bool BitfieldMan::isFilterBitSet(size_t index) const {
+bool BitfieldMan::isFilterBitSet(size_t index) const
+{
   if (filterBitfield_) {
     return bitfield::test(filterBitfield_, blocks_, index);
-  } else {
+  }
+  else {
     return false;
   }
 }
@@ -623,7 +632,9 @@ bool BitfieldMan::isUseBitSet(size_t index) const
   return bitfield::test(useBitfield_, blocks_, index);
 }
 
-void BitfieldMan::setBitfield(const unsigned char* bitfield, size_t bitfieldLength) {
+void BitfieldMan::setBitfield(const unsigned char* bitfield,
+                              size_t bitfieldLength)
+{
   if (bitfieldLength_ != bitfieldLength) {
     return;
   }
@@ -632,30 +643,35 @@ void BitfieldMan::setBitfield(const unsigned char* bitfield, size_t bitfieldLeng
   updateCache();
 }
 
-void BitfieldMan::clearAllBit() {
+void BitfieldMan::clearAllBit()
+{
   memset(bitfield_, 0, bitfieldLength_);
   updateCache();
 }
 
-void BitfieldMan::setAllBit() {
+void BitfieldMan::setAllBit()
+{
   for (size_t i = 0; i < blocks_; ++i) {
     setBitInternal(bitfield_, i, true);
   }
   updateCache();
 }
 
-void BitfieldMan::clearAllUseBit() {
+void BitfieldMan::clearAllUseBit()
+{
   memset(useBitfield_, 0, bitfieldLength_);
   updateCache();
 }
 
-void BitfieldMan::setAllUseBit() {
+void BitfieldMan::setAllUseBit()
+{
   for (size_t i = 0; i < blocks_; ++i) {
     setBitInternal(useBitfield_, i, true);
   }
 }
 
-bool BitfieldMan::setFilterBit(size_t index) {
+bool BitfieldMan::setFilterBit(size_t index)
+{
   return setBitInternal(filterBitfield_, index, true);
 }
 
@@ -667,7 +683,8 @@ void BitfieldMan::ensureFilterBitfield()
   }
 }
 
-void BitfieldMan::addFilter(int64_t offset, int64_t length) {
+void BitfieldMan::addFilter(int64_t offset, int64_t length)
+{
   ensureFilterBitfield();
   if (length > 0) {
     size_t startBlock = offset / blockLength_;
@@ -679,7 +696,8 @@ void BitfieldMan::addFilter(int64_t offset, int64_t length) {
   updateCache();
 }
 
-void BitfieldMan::removeFilter(int64_t offset, int64_t length) {
+void BitfieldMan::removeFilter(int64_t offset, int64_t length)
+{
   ensureFilterBitfield();
   if (length > 0) {
     size_t startBlock = offset / blockLength_;
@@ -710,18 +728,21 @@ void BitfieldMan::addNotFilter(int64_t offset, int64_t length)
   updateCache();
 }
 
-void BitfieldMan::enableFilter() {
+void BitfieldMan::enableFilter()
+{
   ensureFilterBitfield();
   filterEnabled_ = true;
   updateCache();
 }
 
-void BitfieldMan::disableFilter() {
+void BitfieldMan::disableFilter()
+{
   filterEnabled_ = false;
   updateCache();
 }
 
-void BitfieldMan::clearFilter() {
+void BitfieldMan::clearFilter()
+{
   if (filterBitfield_) {
     delete[] filterBitfield_;
     filterBitfield_ = nullptr;
@@ -730,7 +751,8 @@ void BitfieldMan::clearFilter() {
   updateCache();
 }
 
-int64_t BitfieldMan::getFilteredTotalLengthNow() const {
+int64_t BitfieldMan::getFilteredTotalLengthNow() const
+{
   if (!filterBitfield_) {
     return 0;
   }
@@ -740,15 +762,15 @@ int64_t BitfieldMan::getFilteredTotalLengthNow() const {
   }
   if (bitfield::test(filterBitfield_, blocks_, blocks_ - 1)) {
     return ((int64_t)filteredBlocks - 1) * blockLength_ + getLastBlockLength();
-  } else {
+  }
+  else {
     return ((int64_t)filteredBlocks) * blockLength_;
   }
 }
 
 namespace {
 template <typename Array, typename CountFun>
-int64_t computeCompletedLength(const Array& bitfield,
+int64_t computeCompletedLength(const Array& bitfield, const BitfieldMan* btman,
-                               const BitfieldMan* btman,
                                CountFun cntfun)
 {
   size_t nbits = btman->countBlock();
@@ -756,11 +778,14 @@ int64_t computeCompletedLength(const Array& bitfield,
   int64_t completedLength = 0;
   if (completedBlocks == 0) {
     completedLength = 0;
-  } else {
+  }
+  else {
     if (bitfield::test(bitfield, nbits, nbits - 1)) {
-      completedLength = ((int64_t)completedBlocks-1)*btman->getBlockLength() +
+      completedLength =
+          ((int64_t)completedBlocks - 1) * btman->getBlockLength() +
           btman->getLastBlockLength();
-    } else {
+    }
+    else {
       completedLength = ((int64_t)completedBlocks) * btman->getBlockLength();
     }
   }
@@ -768,22 +793,25 @@ int64_t computeCompletedLength(const Array& bitfield,
 }
 } // namespace
 
-int64_t BitfieldMan::getCompletedLength(bool useFilter) const {
+int64_t BitfieldMan::getCompletedLength(bool useFilter) const
+{
   if (useFilter && filterEnabled_) {
     auto arr = array(bitfield_) & array(filterBitfield_);
-    return computeCompletedLength(arr,
+    return computeCompletedLength(arr, this,
-                                  this,
                                   &bitfield::countSetBitSlow<decltype(arr)>);
-  } else {
+  }
+  else {
     return computeCompletedLength(bitfield_, this, &bitfield::countSetBit);
   }
 }
 
-int64_t BitfieldMan::getCompletedLengthNow() const {
+int64_t BitfieldMan::getCompletedLengthNow() const
+{
   return getCompletedLength(false);
 }
 
-int64_t BitfieldMan::getFilteredCompletedLengthNow() const {
+int64_t BitfieldMan::getFilteredCompletedLengthNow() const
+{
   return getCompletedLength(true);
 }
 
@@ -843,8 +871,7 @@ bool BitfieldMan::isBitSetOffsetRange(int64_t offset, int64_t length) const
   return true;
 }
 
-int64_t BitfieldMan::getOffsetCompletedLength
+int64_t BitfieldMan::getOffsetCompletedLength(int64_t offset,
-(int64_t offset,
                                               int64_t length) const
 {
   int64_t res = 0;
@@ -860,7 +887,8 @@ int64_t BitfieldMan::getOffsetCompletedLength
     if (isBitSet(start)) {
       res = length;
     }
-  } else {
+  }
+  else {
     if (isBitSet(start)) {
       res += static_cast<int64_t>(start + 1) * blockLength_ - offset;
     }
@@ -892,16 +920,12 @@ int64_t BitfieldMan::getMissingUnusedLength(size_t startingIndex) const
 }
 
 BitfieldMan::Range::Range(size_t startIndex, size_t endIndex)
- :
+    : startIndex(startIndex), endIndex(endIndex)
-  startIndex(startIndex),
-  endIndex(endIndex)
-{}
-
-size_t BitfieldMan::Range::getSize() const
 {
-  return endIndex-startIndex;
 }
 
+size_t BitfieldMan::Range::getSize() const { return endIndex - startIndex; }
+
 size_t BitfieldMan::Range::getMidIndex() const
 {
   return (endIndex - startIndex) / 2 + startIndex;

src/BitfieldMan.h

@@ -92,10 +92,7 @@ public:
 
   BitfieldMan& operator=(const BitfieldMan& bitfieldMan);
 
-  int32_t getBlockLength() const
+  int32_t getBlockLength() const { return blockLength_; }
-  {
-    return blockLength_;
-  }
 
   int32_t getLastBlockLength() const;
 
@@ -131,9 +128,7 @@ public:
   // if such bit index is found. Otherwise returns false.
   //
   // affected by filter
-  bool getSparseMissingUnusedIndex
+  bool getSparseMissingUnusedIndex(size_t& index, int32_t minSplitSize,
-  (size_t& index,
-   int32_t minSplitSize,
                                    const unsigned char* ignoreBitfield,
                                    size_t ignoreBitfieldLength) const;
 
@@ -151,12 +146,9 @@ public:
   // result.
   //
   // affected by filter
-  bool getGeomMissingUnusedIndex
+  bool getGeomMissingUnusedIndex(size_t& index, int32_t minSplitSize,
-  (size_t& index,
-   int32_t minSplitSize,
                                  const unsigned char* ignoreBitfield,
-   size_t ignoreBitfieldLength,
+                                 size_t ignoreBitfieldLength, double base,
-   double base,
                                  size_t offsetIndex) const;
 
   // Stores missing bit index to index. This function selects smallest
@@ -165,9 +157,7 @@ public:
   // found. Otherwise returns false.
   //
   // affected by filter
-  bool getInorderMissingUnusedIndex
+  bool getInorderMissingUnusedIndex(size_t& index, int32_t minSplitSize,
-  (size_t& index,
-   int32_t minSplitSize,
                                     const unsigned char* ignoreBitfield,
                                     size_t ignoreBitfieldLength) const;
 
@@ -206,34 +196,19 @@ public:
   // filterBitfield_ is NULL, returns false.
   bool isFilterBitSet(size_t index) const;
 
-  const unsigned char* getBitfield() const
+  const unsigned char* getBitfield() const { return bitfield_; }
-  {
-    return bitfield_;
-  }
 
-  size_t getBitfieldLength() const
+  size_t getBitfieldLength() const { return bitfieldLength_; }
-  {
-    return bitfieldLength_;
-  }
 
   // affected by filter
-  size_t countFilteredBlock() const
+  size_t countFilteredBlock() const { return cachedNumFilteredBlock_; }
-  {
-    return cachedNumFilteredBlock_;
-  }
 
-  size_t countBlock() const
+  size_t countBlock() const { return blocks_; }
-  {
-    return blocks_;
-  }
 
   // affected by filter
   size_t countFilteredBlockNow() const;
 
-  size_t getMaxIndex() const
+  size_t getMaxIndex() const { return blocks_ - 1; }
-  {
-    return blocks_-1;
-  }
 
   void setBitfield(const unsigned char* bitfield, size_t bitfieldLength);
 
@@ -253,24 +228,15 @@ public:
 
   void enableFilter();
   void disableFilter();
-  bool isFilterEnabled() const
+  bool isFilterEnabled() const { return filterEnabled_; }
-  {
-    return filterEnabled_;
-  }
 
   // affected by filter
-  int64_t getFilteredTotalLength() const
+  int64_t getFilteredTotalLength() const { return cachedFilteredTotalLength_; }
-  {
-    return cachedFilteredTotalLength_;
-  }
 
   // affected by filter
   int64_t getFilteredTotalLengthNow() const;
 
-  int64_t getCompletedLength() const
+  int64_t getCompletedLength() const { return cachedCompletedLength_; }
-  {
-    return cachedCompletedLength_;
-  }
 
   int64_t getCompletedLengthNow() const;
 
@@ -299,10 +265,7 @@ public:
 
   int64_t getMissingUnusedLength(size_t startingIndex) const;
 
-  const unsigned char* getFilterBitfield() const
+  const unsigned char* getFilterBitfield() const { return filterBitfield_; }
-  {
-    return filterBitfield_;
-  }
 };
 
 } // namespace aria2

src/BtAbortOutstandingRequestEvent.cc

@@ -37,10 +37,11 @@
 
 namespace aria2 {
 
-BtAbortOutstandingRequestEvent::BtAbortOutstandingRequestEvent
+BtAbortOutstandingRequestEvent::BtAbortOutstandingRequestEvent(
-(const std::shared_ptr<Piece>& piece)
+    const std::shared_ptr<Piece>& piece)
     : piece_(piece)
-{}
+{
+}
 
 BtAbortOutstandingRequestEvent::~BtAbortOutstandingRequestEvent() {}
 

src/BtAbortOutstandingRequestEvent.h

@@ -46,6 +46,7 @@ class Piece;
 class BtAbortOutstandingRequestEvent {
 private:
   std::shared_ptr<Piece> piece_;
+
 public:
   BtAbortOutstandingRequestEvent(const std::shared_ptr<Piece>& piece);
   ~BtAbortOutstandingRequestEvent();

src/BtAllowedFastMessage.cc

@@ -42,19 +42,21 @@ namespace aria2 {
 
 const char BtAllowedFastMessage::NAME[] = "allowed fast";
 
-BtAllowedFastMessage::BtAllowedFastMessage(size_t index):
+BtAllowedFastMessage::BtAllowedFastMessage(size_t index)
-  IndexBtMessage(ID, NAME, index) {}
+    : IndexBtMessage(ID, NAME, index)
+{
+}
 
-std::unique_ptr<BtAllowedFastMessage> BtAllowedFastMessage::create
+std::unique_ptr<BtAllowedFastMessage>
-(const unsigned char* data, size_t dataLength)
+BtAllowedFastMessage::create(const unsigned char* data, size_t dataLength)
 {
   return IndexBtMessage::create<BtAllowedFastMessage>(data, dataLength);
 }
 
-void BtAllowedFastMessage::doReceivedAction() {
+void BtAllowedFastMessage::doReceivedAction()
+{
   if (!getPeer()->isFastExtensionEnabled()) {
-    throw DL_ABORT_EX
+    throw DL_ABORT_EX(fmt("%s received while fast extension is disabled",
-      (fmt("%s received while fast extension is disabled",
                           toString().c_str()));
   }
   if (isMetadataGetMode()) {
@@ -66,7 +68,9 @@ void BtAllowedFastMessage::doReceivedAction() {
 namespace {
 struct ThisProgressUpdate : public ProgressUpdate {
   ThisProgressUpdate(std::shared_ptr<Peer> peer, size_t index)
-    : peer(std::move(peer)), index(index) {}
+      : peer(std::move(peer)), index(index)
+  {
+  }
   virtual void update(size_t length, bool complete) CXX11_OVERRIDE
   {
     if (complete) {

src/BtAllowedFastMessage.h

@@ -47,8 +47,8 @@ public:
 
   static const char NAME[];
 
-  static std::unique_ptr<BtAllowedFastMessage> create
+  static std::unique_ptr<BtAllowedFastMessage> create(const unsigned char* data,
-  (const unsigned char* data, size_t dataLength);
+                                                      size_t dataLength);
 
   virtual void doReceivedAction() CXX11_OVERRIDE;
 

src/BtAnnounce.h

@@ -104,8 +104,8 @@ public:
   virtual void processAnnounceResponse(const unsigned char* trackerResponse,
                                        size_t trackerResponseLength) = 0;
 
-  virtual void processUDPTrackerResponse
+  virtual void
-  (const std::shared_ptr<UDPTrackerRequest>& req) = 0;
+  processUDPTrackerResponse(const std::shared_ptr<UDPTrackerRequest>& req) = 0;
 
   /**
    * Returns true if no more announce is needed.

src/BtBitfieldMessage.cc

@@ -49,23 +49,22 @@ namespace aria2 {
 const char BtBitfieldMessage::NAME[] = "bitfield";
 
 BtBitfieldMessage::BtBitfieldMessage()
-  : SimpleBtMessage(ID, NAME),
+    : SimpleBtMessage(ID, NAME), bitfieldLength_(0)
-    bitfieldLength_(0)
+{
-{}
+}
 
-BtBitfieldMessage::BtBitfieldMessage
+BtBitfieldMessage::BtBitfieldMessage(const unsigned char* bitfield,
-(const unsigned char* bitfield, size_t bitfieldLength)
+                                     size_t bitfieldLength)
-  : SimpleBtMessage(ID, NAME),
+    : SimpleBtMessage(ID, NAME), bitfieldLength_(0)
-    bitfieldLength_(0)
 {
   setBitfield(bitfield, bitfieldLength);
 }
 
-BtBitfieldMessage::~BtBitfieldMessage()
+BtBitfieldMessage::~BtBitfieldMessage() {}
-{}
 
-void BtBitfieldMessage::setBitfield
+void BtBitfieldMessage::setBitfield(const unsigned char* bitfield,
-(const unsigned char* bitfield, size_t bitfieldLength) {
+                                    size_t bitfieldLength)
+{
   if (bitfield_.get() == bitfield) {
     return;
   }
@@ -85,7 +84,8 @@ BtBitfieldMessage::create(const unsigned char* data, size_t dataLength)
   return message;
 }
 
-void BtBitfieldMessage::doReceivedAction() {
+void BtBitfieldMessage::doReceivedAction()
+{
   if (isMetadataGetMode()) {
     return;
   }
@@ -97,7 +97,8 @@ void BtBitfieldMessage::doReceivedAction() {
   }
 }
 
-unsigned char* BtBitfieldMessage::createMessage() {
+unsigned char* BtBitfieldMessage::createMessage()
+{
   /**
    * len --- 1+bitfieldLength, 4bytes
    * id --- 5, 1byte
@@ -111,11 +112,10 @@ unsigned char* BtBitfieldMessage::createMessage() {
   return msg;
 }
 
-size_t BtBitfieldMessage::getMessageLength() {
+size_t BtBitfieldMessage::getMessageLength() { return 5 + bitfieldLength_; }
-  return 5+bitfieldLength_;
-}
 
-std::string BtBitfieldMessage::toString() const {
+std::string BtBitfieldMessage::toString() const
+{
   std::string s = NAME;
   s += " ";
   s += util::toHex(bitfield_.get(), bitfieldLength_);

src/BtBitfieldMessage.h

@@ -43,6 +43,7 @@ class BtBitfieldMessage : public SimpleBtMessage {
 private:
   std::unique_ptr<unsigned char[]> bitfield_;
   size_t bitfieldLength_;
+
 public:
   BtBitfieldMessage();
 
@@ -60,8 +61,8 @@ public:
 
   size_t getBitfieldLength() const { return bitfieldLength_; }
 
-  static std::unique_ptr<BtBitfieldMessage> create
+  static std::unique_ptr<BtBitfieldMessage> create(const unsigned char* data,
-  (const unsigned char* data, size_t dataLength);
+                                                   size_t dataLength);
 
   virtual void doReceivedAction() CXX11_OVERRIDE;
 

src/BtBitfieldMessageValidator.cc

@@ -38,19 +38,18 @@
 
 namespace aria2 {
 
-BtBitfieldMessageValidator::BtBitfieldMessageValidator
+BtBitfieldMessageValidator::BtBitfieldMessageValidator(
-(const BtBitfieldMessage* message, size_t numPiece)
+    const BtBitfieldMessage* message, size_t numPiece)
-  : message_(message),
+    : message_(message), numPiece_(numPiece)
-    numPiece_(numPiece)
+{
-{}
+}
 
 BtBitfieldMessageValidator::~BtBitfieldMessageValidator() {}
 
 void BtBitfieldMessageValidator::validate()
 {
   bittorrent::checkBitfield(message_->getBitfield(),
-                            message_->getBitfieldLength(),
+                            message_->getBitfieldLength(), numPiece_);
-                            numPiece_);
 }
 
 } // namespace aria2

src/BtBitfieldMessageValidator.h

@@ -45,9 +45,9 @@ class BtBitfieldMessageValidator : public BtMessageValidator {
 private:
   const BtBitfieldMessage* message_;
   size_t numPiece_;
+
 public:
-  BtBitfieldMessageValidator(const BtBitfieldMessage* message,
+  BtBitfieldMessageValidator(const BtBitfieldMessage* message, size_t numPiece);
-                             size_t numPiece);
   ~BtBitfieldMessageValidator();
 
   virtual void validate() CXX11_OVERRIDE;

src/BtCancelMessage.cc

@@ -39,12 +39,13 @@ namespace aria2 {
 
 const char BtCancelMessage::NAME[] = "cancel";
 
-BtCancelMessage::BtCancelMessage
+BtCancelMessage::BtCancelMessage(size_t index, int32_t begin, int32_t length)
-(size_t index, int32_t begin, int32_t length)
+    : RangeBtMessage(ID, NAME, index, begin, length)
-  :RangeBtMessage(ID, NAME, index, begin, length) {}
+{
+}
 
-std::unique_ptr<BtCancelMessage> BtCancelMessage::create
+std::unique_ptr<BtCancelMessage>
-(const unsigned char* data, size_t dataLength)
+BtCancelMessage::create(const unsigned char* data, size_t dataLength)
 {
   return RangeBtMessage::create<BtCancelMessage>(data, dataLength);
 }
@@ -54,8 +55,8 @@ void BtCancelMessage::doReceivedAction()
   if (isMetadataGetMode()) {
     return;
   }
-  getBtMessageDispatcher()->doCancelSendingPieceAction
+  getBtMessageDispatcher()->doCancelSendingPieceAction(getIndex(), getBegin(),
-    (getIndex(), getBegin(), getLength());
+                                                       getLength());
 }
 
 } // namespace aria2

src/BtCancelMessage.h

@@ -47,8 +47,8 @@ public:
 
   static const char NAME[];
 
-  static std::unique_ptr<BtCancelMessage> create
+  static std::unique_ptr<BtCancelMessage> create(const unsigned char* data,
-  (const unsigned char* data, size_t dataLength);
+                                                 size_t dataLength);
 
   virtual void doReceivedAction() CXX11_OVERRIDE;
 };

src/BtCancelSendingPieceEvent.h

@@ -44,9 +44,12 @@ private:
   size_t index_;
   int32_t begin_;
   int32_t length_;
+
 public:
-  BtCancelSendingPieceEvent(size_t index, int32_t begin, int32_t length):
+  BtCancelSendingPieceEvent(size_t index, int32_t begin, int32_t length)
-    index_(index), begin_(begin), length_(length) {}
+      : index_(index), begin_(begin), length_(length)
+  {
+  }
 
   size_t getIndex() const { return index_; }
 

src/BtCheckIntegrityEntry.cc

@@ -46,13 +46,15 @@
 
 namespace aria2 {
 
-BtCheckIntegrityEntry::BtCheckIntegrityEntry(RequestGroup* requestGroup):
+BtCheckIntegrityEntry::BtCheckIntegrityEntry(RequestGroup* requestGroup)
-  PieceHashCheckIntegrityEntry(requestGroup, nullptr) {}
+    : PieceHashCheckIntegrityEntry(requestGroup, nullptr)
+{
+}
 
 BtCheckIntegrityEntry::~BtCheckIntegrityEntry() {}
 
-void BtCheckIntegrityEntry::onDownloadIncomplete
+void BtCheckIntegrityEntry::onDownloadIncomplete(
-(std::vector<std::unique_ptr<Command>>& commands, DownloadEngine* e)
+    std::vector<std::unique_ptr<Command>>& commands, DownloadEngine* e)
 {
   auto& ps = getRequestGroup()->getPieceStorage();
   ps->onDownloadIncomplete();
@@ -66,22 +68,20 @@ void BtCheckIntegrityEntry::onDownloadIncomplete
     diskAdaptor->disableReadOnly();
     diskAdaptor->openFile();
   }
-  proceedFileAllocation(commands,
+  proceedFileAllocation(
-                        make_unique<BtFileAllocationEntry>
+      commands, make_unique<BtFileAllocationEntry>(getRequestGroup()), e);
-                        (getRequestGroup()),
-                        e);
 }
 
-void BtCheckIntegrityEntry::onDownloadFinished
+void BtCheckIntegrityEntry::onDownloadFinished(
-(std::vector<std::unique_ptr<Command>>& commands, DownloadEngine* e)
+    std::vector<std::unique_ptr<Command>>& commands, DownloadEngine* e)
 {
   auto group = getRequestGroup();
   const auto& option = group->getOption();
   if (option->getAsBool(PREF_BT_ENABLE_HOOK_AFTER_HASH_CHECK)) {
     util::executeHookByOptName(group, option.get(),
                                PREF_ON_BT_DOWNLOAD_COMPLETE);
-    SingletonHolder<Notifier>::instance()->notifyDownloadEvent
+    SingletonHolder<Notifier>::instance()->notifyDownloadEvent(
-      (EVENT_ON_BT_DOWNLOAD_COMPLETE, group);
+        EVENT_ON_BT_DOWNLOAD_COMPLETE, group);
   }
   // TODO Currently,when all the checksums
   // are valid, then aria2 goes to seeding mode. Sometimes it is better
@@ -89,12 +89,9 @@ void BtCheckIntegrityEntry::onDownloadFinished
   // behavior.
   if (!option->getAsBool(PREF_HASH_CHECK_ONLY) &&
       option->getAsBool(PREF_BT_HASH_CHECK_SEED)) {
-    proceedFileAllocation(commands,
+    proceedFileAllocation(
-                          make_unique<BtFileAllocationEntry>
+        commands, make_unique<BtFileAllocationEntry>(getRequestGroup()), e);
-                          (getRequestGroup()),
-                          e);
   }
 }
 
-
 } // namespace aria2

src/BtCheckIntegrityEntry.h

@@ -45,13 +45,13 @@ public:
 
   virtual ~BtCheckIntegrityEntry();
 
-  virtual void onDownloadFinished
+  virtual void
-  (std::vector<std::unique_ptr<Command>>& commands, DownloadEngine* e)
+  onDownloadFinished(std::vector<std::unique_ptr<Command>>& commands,
-    CXX11_OVERRIDE;
+                     DownloadEngine* e) CXX11_OVERRIDE;
 
-  virtual void onDownloadIncomplete
+  virtual void
-  (std::vector<std::unique_ptr<Command>>& commands, DownloadEngine* e)
+  onDownloadIncomplete(std::vector<std::unique_ptr<Command>>& commands,
-    CXX11_OVERRIDE;
+                       DownloadEngine* e) CXX11_OVERRIDE;
 };
 
 } // namespace aria2

src/BtChokeMessage.cc

@@ -44,8 +44,8 @@ const char BtChokeMessage::NAME[] = "choke";
 
 BtChokeMessage::BtChokeMessage() : ZeroBtMessage{ID, NAME} {}
 
-std::unique_ptr<BtChokeMessage> BtChokeMessage::create
+std::unique_ptr<BtChokeMessage>
-(const unsigned char* data, size_t dataLength)
+BtChokeMessage::create(const unsigned char* data, size_t dataLength)
 {
   return ZeroBtMessage::create<BtChokeMessage>(data, dataLength);
 }
@@ -60,16 +60,14 @@ void BtChokeMessage::doReceivedAction()
   getBtRequestFactory()->doChokedAction();
 }
 
-bool BtChokeMessage::sendPredicate() const
+bool BtChokeMessage::sendPredicate() const { return !getPeer()->amChoking(); }
-{
-  return !getPeer()->amChoking();
-}
 
 namespace {
 struct ThisProgressUpdate : public ProgressUpdate {
-  ThisProgressUpdate(std::shared_ptr<Peer>  peer,
+  ThisProgressUpdate(std::shared_ptr<Peer> peer, BtMessageDispatcher* disp)
-                     BtMessageDispatcher* disp)
+      : peer(std::move(peer)), disp(disp)
-    : peer(std::move(peer)), disp(disp) {}
+  {
+  }
   virtual void update(size_t length, bool complete) CXX11_OVERRIDE
   {
     if (complete) {

src/BtChokeMessage.h

@@ -49,8 +49,8 @@ public:
 
   virtual void doReceivedAction() CXX11_OVERRIDE;
 
-  static std::unique_ptr<BtChokeMessage> create
+  static std::unique_ptr<BtChokeMessage> create(const unsigned char* data,
-  (const unsigned char* data, size_t dataLength);
+                                                size_t dataLength);
 
   virtual bool sendPredicate() const CXX11_OVERRIDE;
 

src/BtChokingEvent.h

@@ -39,7 +39,8 @@
 
 namespace aria2 {
 
-class BtChokingEvent {};
+class BtChokingEvent {
+};
 
 } // namespace aria2
 

src/BtDependency.cc

@@ -53,12 +53,11 @@
 
 namespace aria2 {
 
-BtDependency::BtDependency
+BtDependency::BtDependency(RequestGroup* dependant,
-(RequestGroup* dependant,
                            const std::shared_ptr<RequestGroup>& dependee)
-  : dependant_(dependant),
+    : dependant_(dependant), dependee_(dependee)
-    dependee_(dependee)
+{
-{}
+}
 
 BtDependency::~BtDependency() {}
 
@@ -77,8 +76,7 @@ void copyValues(const std::shared_ptr<FileEntry>& d,
 
 namespace {
 struct EntryCmp {
-  bool operator()
+  bool operator()(const std::shared_ptr<FileEntry>& lhs,
-  (const std::shared_ptr<FileEntry>& lhs,
                   const std::shared_ptr<FileEntry>& rhs) const
   {
     return lhs->getOriginalName() < rhs->getOriginalName();
@@ -104,14 +102,14 @@ bool BtDependency::resolve()
       if (dependee->getDownloadContext()->hasAttribute(CTX_ATTR_BT)) {
         auto attrs =
             bittorrent::getTorrentAttrs(dependee->getDownloadContext());
-        bittorrent::loadFromMemory
+        bittorrent::loadFromMemory(bittorrent::metadata2Torrent(content, attrs),
-          (bittorrent::metadata2Torrent(content, attrs), context,
+                                   context, dependant_->getOption(), "default");
-           dependant_->getOption(), "default");
         // We don't call bittorrent::adjustAnnounceUri() because it
         // has already been called with attrs.
-      } else {
+      }
-        bittorrent::loadFromMemory
+      else {
-          (content, context, dependant_->getOption(),
+        bittorrent::loadFromMemory(
+            content, context, dependant_->getOption(),
             File(dependee->getFirstFilePath()).getBasename());
         bittorrent::adjustAnnounceUri(bittorrent::getTorrentAttrs(context),
                                       dependant_->getOption());
@@ -131,7 +129,8 @@ bool BtDependency::resolve()
       if (fileEntries.size() == 1 && dependantFileEntries.size() == 1 &&
           dependantFileEntries[0]->getOriginalName().empty()) {
         copyValues(fileEntries[0], dependantFileEntries[0]);
-      } else {
+      }
+      else {
         std::vector<std::shared_ptr<FileEntry>> destFiles;
         destFiles.reserve(fileEntries.size());
         for (auto& e : fileEntries) {
@@ -147,14 +146,16 @@ bool BtDependency::resolve()
                                           std::end(destFiles), e, EntryCmp());
           if (d == std::end(destFiles) ||
               (*d)->getOriginalName() != e->getOriginalName()) {
-            throw DL_ABORT_EX
+            throw DL_ABORT_EX(fmt("No entry %s in torrent file",
-              (fmt("No entry %s in torrent file", e->getOriginalName().c_str()));
+                                  e->getOriginalName().c_str()));
-          } else {
+          }
+          else {
             copyValues(*d, e);
           }
         }
       }
-    } catch(RecoverableException& e) {
+    }
+    catch (RecoverableException& e) {
       A2_LOG_ERROR_EX(EX_EXCEPTION_CAUGHT, e);
       A2_LOG_INFO(fmt("BtDependency for GID#%s failed. Go without Bt.",
                       GroupId::toHex(dependant_->getGID()).c_str()));
@@ -164,14 +165,16 @@ bool BtDependency::resolve()
                     GroupId::toHex(dependant_->getGID()).c_str()));
     dependant_->setDownloadContext(context);
     return true;
-  } else if(dependee_->getNumCommand() == 0) {
+  }
+  else if (dependee_->getNumCommand() == 0) {
     // dependee_'s download failed.
     // cut reference here
     dependee_.reset();
     A2_LOG_INFO(fmt("BtDependency for GID#%s failed. Go without Bt.",
                     GroupId::toHex(dependant_->getGID()).c_str()));
     return true;
-  } else {
+  }
+  else {
     return false;
   }
 }

src/BtDependency.h

@@ -44,11 +44,11 @@ namespace aria2 {
 class RequestGroup;
 class Option;
 
-class BtDependency : public Dependency
+class BtDependency : public Dependency {
-{
 private:
   RequestGroup* dependant_;
   std::shared_ptr<RequestGroup> dependee_;
+
 public:
   BtDependency(RequestGroup* dependant,
                const std::shared_ptr<RequestGroup>& dependee);

src/BtExtendedMessage.cc

@@ -50,12 +50,13 @@ namespace aria2 {
 
 const char BtExtendedMessage::NAME[] = "extended";
 
-BtExtendedMessage::BtExtendedMessage
+BtExtendedMessage::BtExtendedMessage(
-(std::unique_ptr<ExtensionMessage> extensionMessage):
+    std::unique_ptr<ExtensionMessage> extensionMessage)
-  SimpleBtMessage(ID, NAME),
+    : SimpleBtMessage(ID, NAME),
       extensionMessage_(std::move(extensionMessage)),
       msgLength_(0)
-{}
+{
+}
 
 unsigned char* BtExtendedMessage::createMessage()
 {
@@ -75,7 +76,8 @@ unsigned char* BtExtendedMessage::createMessage()
   return msg;
 }
 
-size_t BtExtendedMessage::getMessageLength() {
+size_t BtExtendedMessage::getMessageLength()
+{
   if (!msgLength_) {
     msgLength_ = 6 + extensionMessage_->getPayload().size();
   }
@@ -87,7 +89,8 @@ bool BtExtendedMessage::sendPredicate() const
   return getPeer()->isExtendedMessagingEnabled();
 }
 
-std::string BtExtendedMessage::toString() const {
+std::string BtExtendedMessage::toString() const
+{
   std::string s = NAME;
   s += " ";
   s += extensionMessage_->toString();
@@ -102,8 +105,8 @@ BtExtendedMessage::create(ExtensionMessageFactory* factory,
   bittorrent::assertPayloadLengthGreater(1, dataLength, NAME);
   bittorrent::assertID(ID, data, NAME);
   assert(factory);
-  return make_unique<BtExtendedMessage>
+  return make_unique<BtExtendedMessage>(
-    (factory->createMessage(data+1, dataLength-1));
+      factory->createMessage(data + 1, dataLength - 1));
 }
 
 void BtExtendedMessage::doReceivedAction()

src/BtExtendedMessage.h

@@ -41,12 +41,12 @@ namespace aria2 {
 class ExtensionMessage;
 class ExtensionMessageFactory;
 
-class BtExtendedMessage:public SimpleBtMessage
+class BtExtendedMessage : public SimpleBtMessage {
-{
 private:
   std::unique_ptr<ExtensionMessage> extensionMessage_;
 
   size_t msgLength_;
+
 public:
   BtExtendedMessage(std::unique_ptr<ExtensionMessage> extensionMessage =
                         std::unique_ptr<ExtensionMessage>{});
@@ -55,11 +55,9 @@ public:
 
   static const char NAME[];
 
-  static std::unique_ptr<BtExtendedMessage> create
+  static std::unique_ptr<BtExtendedMessage>
-  (ExtensionMessageFactory* factory,
+  create(ExtensionMessageFactory* factory, const std::shared_ptr<Peer>& peer,
-   const std::shared_ptr<Peer>& peer,
+         const unsigned char* data, size_t dataLength);
-   const unsigned char* data,
-   size_t dataLength);
 
   virtual void doReceivedAction() CXX11_OVERRIDE;
 

src/BtFileAllocationEntry.cc

@@ -50,13 +50,15 @@
 
 namespace aria2 {
 
-BtFileAllocationEntry::BtFileAllocationEntry(RequestGroup* requestGroup):
+BtFileAllocationEntry::BtFileAllocationEntry(RequestGroup* requestGroup)
-  FileAllocationEntry(requestGroup, nullptr) {}
+    : FileAllocationEntry(requestGroup, nullptr)
+{
+}
 
 BtFileAllocationEntry::~BtFileAllocationEntry() {}
 
-void BtFileAllocationEntry::prepareForNextAction
+void BtFileAllocationEntry::prepareForNextAction(
-(std::vector<std::unique_ptr<Command>>& commands, DownloadEngine* e)
+    std::vector<std::unique_ptr<Command>>& commands, DownloadEngine* e)
 {
   auto& option = getRequestGroup()->getOption();
 
@@ -71,11 +73,12 @@ void BtFileAllocationEntry::prepareForNextAction
     getRequestGroup()->getDownloadContext()->resetDownloadStartTime();
     const std::vector<std::shared_ptr<FileEntry>>& fileEntries =
         getRequestGroup()->getDownloadContext()->getFileEntries();
-    if(isUriSuppliedForRequsetFileEntry
+    if (isUriSuppliedForRequsetFileEntry(std::begin(fileEntries),
-       (std::begin(fileEntries), std::end(fileEntries))) {
+                                         std::end(fileEntries))) {
       getRequestGroup()->createNextCommandWithAdj(commands, e, 0);
     }
-  } else {
+  }
+  else {
 #ifdef __MINGW32__
     const std::shared_ptr<DiskAdaptor>& diskAdaptor =
         getRequestGroup()->getPieceStorage()->getDiskAdaptor();

src/BtFileAllocationEntry.h

@@ -45,9 +45,9 @@ public:
 
   virtual ~BtFileAllocationEntry();
 
-  virtual void prepareForNextAction
+  virtual void
-  (std::vector<std::unique_ptr<Command>>& commands, DownloadEngine* e)
+  prepareForNextAction(std::vector<std::unique_ptr<Command>>& commands,
-    CXX11_OVERRIDE;
+                       DownloadEngine* e) CXX11_OVERRIDE;
 };
 
 } // namespace aria2

src/BtHandshakeMessage.cc

@@ -47,21 +47,19 @@ const char BtHandshakeMessage::NAME[] = "handshake";
 const unsigned char* BtHandshakeMessage::BT_PSTR =
     reinterpret_cast<const unsigned char*>("BitTorrent protocol");
 
-BtHandshakeMessage::BtHandshakeMessage():SimpleBtMessage(ID, NAME)
+BtHandshakeMessage::BtHandshakeMessage() : SimpleBtMessage(ID, NAME) { init(); }
-{
-  init();
-}
 
 BtHandshakeMessage::BtHandshakeMessage(const unsigned char* infoHash,
-                                       const unsigned char* peerId):
+                                       const unsigned char* peerId)
-  SimpleBtMessage(ID, NAME)
+    : SimpleBtMessage(ID, NAME)
 {
   init();
   memcpy(infoHash_, infoHash, INFO_HASH_LENGTH);
   memcpy(peerId_, peerId, PEER_ID_LENGTH);
 }
 
-void BtHandshakeMessage::init() {
+void BtHandshakeMessage::init()
+{
   pstrlen_ = 19;
   pstr_ = new unsigned char[PSTR_LENGTH];
   reserved_ = new unsigned char[RESERVED_LENGTH];
@@ -98,18 +96,17 @@ unsigned char* BtHandshakeMessage::createMessage()
   return msg;
 }
 
-size_t BtHandshakeMessage::getMessageLength() {
+size_t BtHandshakeMessage::getMessageLength() { return MESSAGE_LENGTH; }
-  return MESSAGE_LENGTH;
-}
 
-std::string BtHandshakeMessage::toString() const {
+std::string BtHandshakeMessage::toString() const
-  return fmt("%s peerId=%s, reserved=%s",
+{
-             NAME,
+  return fmt("%s peerId=%s, reserved=%s", NAME,
              util::percentEncode(peerId_, PEER_ID_LENGTH).c_str(),
              util::toHex(reserved_, RESERVED_LENGTH).c_str());
 }
 
-bool BtHandshakeMessage::isFastExtensionSupported() const {
+bool BtHandshakeMessage::isFastExtensionSupported() const
+{
   return reserved_[7] & 0x04u;
 }
 
@@ -118,10 +115,7 @@ bool BtHandshakeMessage::isExtendedMessagingEnabled() const
   return reserved_[5] & 0x10u;
 }
 
-bool BtHandshakeMessage::isDHTEnabled() const
+bool BtHandshakeMessage::isDHTEnabled() const { return reserved_[7] & 0x01u; }
-{
-  return reserved_[7]&0x01u;
-}
 
 void BtHandshakeMessage::setInfoHash(const unsigned char* infoHash)
 {

src/BtHandshakeMessage.h

@@ -45,6 +45,7 @@ public:
   static const unsigned char* BT_PSTR;
   static const size_t RESERVED_LENGTH = 8;
   static const size_t MESSAGE_LENGTH = 68;
+
 private:
   uint8_t pstrlen_;
   unsigned char* pstr_;
@@ -52,18 +53,21 @@ private:
   unsigned char* infoHash_;
   unsigned char* peerId_;
   void init();
+
 public:
   BtHandshakeMessage();
   /**
    * infoHash must be 20 byte length.
    * peerId must be 20 byte length.
    */
-  BtHandshakeMessage(const unsigned char* infoHash, const unsigned char* peerId);
+  BtHandshakeMessage(const unsigned char* infoHash,
+                     const unsigned char* peerId);
 
-  static std::unique_ptr<BtHandshakeMessage>
+  static std::unique_ptr<BtHandshakeMessage> create(const unsigned char* data,
-  create(const unsigned char* data, size_t dataLength);
+                                                    size_t dataLength);
 
-  virtual ~BtHandshakeMessage() {
+  virtual ~BtHandshakeMessage()
+  {
     delete[] pstr_;
     delete[] reserved_;
     delete[] infoHash_;
@@ -92,32 +96,23 @@ public:
   {
     if (enabled) {
       reserved_[7] |= 0x01u;
-    } else {
+    }
+    else {
       reserved_[7] &= ~0x01u;
     }
   }
 
-  uint8_t getPstrlen() const {
+  uint8_t getPstrlen() const { return pstrlen_; }
-    return pstrlen_;
-  }
 
-  const unsigned char* getPstr() const {
+  const unsigned char* getPstr() const { return pstr_; }
-    return pstr_;
-  }
 
-  const unsigned char* getReserved() const {
+  const unsigned char* getReserved() const { return reserved_; }
-    return reserved_;
-  }
 
-  const unsigned char* getInfoHash() const {
+  const unsigned char* getInfoHash() const { return infoHash_; }
-    return infoHash_;
-  }
 
   void setInfoHash(const unsigned char* infoHash);
 
-  const unsigned char* getPeerId() const {
+  const unsigned char* getPeerId() const { return peerId_; }
-    return peerId_;
-  }
 
   void setPeerId(const unsigned char* peerId);
 };

src/BtHandshakeMessageValidator.cc

@@ -43,8 +43,8 @@
 
 namespace aria2 {
 
-BtHandshakeMessageValidator::BtHandshakeMessageValidator
+BtHandshakeMessageValidator::BtHandshakeMessageValidator(
-(const BtHandshakeMessage* message, const unsigned char* infoHash)
+    const BtHandshakeMessage* message, const unsigned char* infoHash)
     : message_(message)
 {
   memcpy(infoHash_, infoHash, sizeof(infoHash_));
@@ -55,21 +55,19 @@ BtHandshakeMessageValidator::~BtHandshakeMessageValidator() {}
 void BtHandshakeMessageValidator::validate()
 {
   if (message_->getPstrlen() != 19) {
-    throw DL_ABORT_EX(fmt("invalid handshake pstrlen=%u",
+    throw DL_ABORT_EX(
-                          message_->getPstrlen()));
+        fmt("invalid handshake pstrlen=%u", message_->getPstrlen()));
   }
   if (memcmp(BtHandshakeMessage::BT_PSTR, message_->getPstr(), 19) != 0) {
-    throw DL_ABORT_EX
+    throw DL_ABORT_EX(
-      (fmt("invalid handshake pstr=%s",
+        fmt("invalid handshake pstr=%s",
-           util::percentEncode
+            util::percentEncode(message_->getPstr(), 19).c_str()));
-           (message_->getPstr(), 19).c_str()));
   }
   if (memcmp(infoHash_, message_->getInfoHash(), sizeof(infoHash_)) != 0) {
-    throw DL_ABORT_EX
+    throw DL_ABORT_EX(
-      (fmt("invalid handshake info hash: expected:%s, actual:%s",
+        fmt("invalid handshake info hash: expected:%s, actual:%s",
             util::toHex(infoHash_, sizeof(infoHash_)).c_str(),
-           util::toHex(message_->getInfoHash(),
+            util::toHex(message_->getInfoHash(), INFO_HASH_LENGTH).c_str()));
-                       INFO_HASH_LENGTH).c_str()));
   }
 }
 

src/BtHandshakeMessageValidator.h

@@ -49,6 +49,7 @@ class BtHandshakeMessageValidator : public BtMessageValidator {
 private:
   const BtHandshakeMessage* message_;
   unsigned char infoHash_[INFO_HASH_LENGTH];
+
 public:
   BtHandshakeMessageValidator(const BtHandshakeMessage* message,
                               const unsigned char* infoHash);

src/BtHaveAllMessage.cc

@@ -45,8 +45,8 @@ const char BtHaveAllMessage::NAME[] = "have all";
 
 BtHaveAllMessage::BtHaveAllMessage() : ZeroBtMessage(ID, NAME) {}
 
-std::unique_ptr<BtHaveAllMessage> BtHaveAllMessage::create
+std::unique_ptr<BtHaveAllMessage>
-(const unsigned char* data, size_t dataLength)
+BtHaveAllMessage::create(const unsigned char* data, size_t dataLength)
 {
   return ZeroBtMessage::create<BtHaveAllMessage>(data, dataLength);
 }
@@ -54,8 +54,7 @@ std::unique_ptr<BtHaveAllMessage> BtHaveAllMessage::create
 void BtHaveAllMessage::doReceivedAction()
 {
   if (!getPeer()->isFastExtensionEnabled()) {
-    throw DL_ABORT_EX
+    throw DL_ABORT_EX(fmt("%s received while fast extension is disabled",
-      (fmt("%s received while fast extension is disabled",
                           toString().c_str()));
   }
   if (isMetadataGetMode()) {
@@ -64,8 +63,8 @@ void BtHaveAllMessage::doReceivedAction()
   getPieceStorage()->subtractPieceStats(getPeer()->getBitfield(),
                                         getPeer()->getBitfieldLength());
   getPeer()->setAllBitfield();
-  getPieceStorage()->addPieceStats
+  getPieceStorage()->addPieceStats(getPeer()->getBitfield(),
-    (getPeer()->getBitfield(), getPeer()->getBitfieldLength());
+                                   getPeer()->getBitfieldLength());
   if (getPeer()->isSeeder() && getPieceStorage()->downloadFinished()) {
     throw DL_ABORT_EX(MSG_GOOD_BYE_SEEDER);
   }

src/BtHaveAllMessage.h

@@ -47,8 +47,8 @@ public:
 
   static const char NAME[];
 
-  static std::unique_ptr<BtHaveAllMessage> create
+  static std::unique_ptr<BtHaveAllMessage> create(const unsigned char* data,
-  (const unsigned char* data, size_t dataLength);
+                                                  size_t dataLength);
 
   virtual void doReceivedAction() CXX11_OVERRIDE;
 };

src/BtHaveMessage.cc

@@ -44,8 +44,8 @@ const char BtHaveMessage::NAME[] = "have";
 
 BtHaveMessage::BtHaveMessage(size_t index) : IndexBtMessage(ID, NAME, index) {}
 
-std::unique_ptr<BtHaveMessage> BtHaveMessage::create
+std::unique_ptr<BtHaveMessage> BtHaveMessage::create(const unsigned char* data,
-(const unsigned char* data, size_t dataLength)
+                                                     size_t dataLength)
 {
   return IndexBtMessage::create<BtHaveMessage>(data, dataLength);
 }

src/BtHaveMessage.h

@@ -47,8 +47,8 @@ public:
 
   static const char NAME[];
 
-  static std::unique_ptr<BtHaveMessage> create
+  static std::unique_ptr<BtHaveMessage> create(const unsigned char* data,
-  (const unsigned char* data, size_t dataLength);
+                                               size_t dataLength);
 
   virtual void doReceivedAction() CXX11_OVERRIDE;
 };

src/BtHaveNoneMessage.cc

@@ -43,8 +43,8 @@ const char BtHaveNoneMessage::NAME[] = "have none";
 
 BtHaveNoneMessage::BtHaveNoneMessage() : ZeroBtMessage(ID, NAME) {}
 
-std::unique_ptr<BtHaveNoneMessage> BtHaveNoneMessage::create
+std::unique_ptr<BtHaveNoneMessage>
-(const unsigned char* data, size_t dataLength)
+BtHaveNoneMessage::create(const unsigned char* data, size_t dataLength)
 {
   return ZeroBtMessage::create<BtHaveNoneMessage>(data, dataLength);
 }
@@ -52,8 +52,7 @@ std::unique_ptr<BtHaveNoneMessage> BtHaveNoneMessage::create
 void BtHaveNoneMessage::doReceivedAction()
 {
   if (!getPeer()->isFastExtensionEnabled()) {
-    throw DL_ABORT_EX
+    throw DL_ABORT_EX(fmt("%s received while fast extension is disabled",
-      (fmt("%s received while fast extension is disabled",
                           toString().c_str()));
   }
 }

src/BtHaveNoneMessage.h

@@ -47,8 +47,8 @@ public:
 
   static const char NAME[];
 
-  static std::unique_ptr<BtHaveNoneMessage> create
+  static std::unique_ptr<BtHaveNoneMessage> create(const unsigned char* data,
-  (const unsigned char* data, size_t dataLength);
+                                                   size_t dataLength);
 
   virtual void doReceivedAction() CXX11_OVERRIDE;
 };

src/BtInteractive.h

@@ -41,7 +41,6 @@
 
 namespace aria2 {
 
-
 class BtHandshakeMessage;
 
 class BtInteractive {
@@ -50,8 +49,8 @@ public:
 
   virtual void initiateHandshake() = 0;
 
-  virtual std::unique_ptr<BtHandshakeMessage> receiveHandshake
+  virtual std::unique_ptr<BtHandshakeMessage>
-  (bool quickReply = false) = 0;
+  receiveHandshake(bool quickReply = false) = 0;
 
   virtual std::unique_ptr<BtHandshakeMessage> receiveAndSendHandshake() = 0;
 

src/BtInterestedMessage.cc

@@ -42,14 +42,14 @@ namespace aria2 {
 const char BtInterestedMessage::NAME[] = "interested";
 
 BtInterestedMessage::BtInterestedMessage()
-  : ZeroBtMessage(ID, NAME),
+    : ZeroBtMessage(ID, NAME), peerStorage_(nullptr)
-    peerStorage_(nullptr)
+{
-{}
+}
 
 BtInterestedMessage::~BtInterestedMessage() {}
 
-std::unique_ptr<BtInterestedMessage> BtInterestedMessage::create
+std::unique_ptr<BtInterestedMessage>
-(const unsigned char* data, size_t dataLength)
+BtInterestedMessage::create(const unsigned char* data, size_t dataLength)
 {
   return ZeroBtMessage::create<BtInterestedMessage>(data, dataLength);
 }
@@ -72,8 +72,7 @@ bool BtInterestedMessage::sendPredicate() const
 
 namespace {
 struct ThisProgressUpdate : public ProgressUpdate {
-  ThisProgressUpdate(std::shared_ptr<Peer>  peer)
+  ThisProgressUpdate(std::shared_ptr<Peer> peer) : peer(std::move(peer)) {}
-    : peer(std::move(peer)) {}
   virtual void update(size_t length, bool complete) CXX11_OVERRIDE
   {
     if (complete) {

src/BtInterestedMessage.h

@@ -45,6 +45,7 @@ class BtInterestedMessage;
 class BtInterestedMessage : public ZeroBtMessage {
 private:
   PeerStorage* peerStorage_;
+
 public:
   BtInterestedMessage();
   virtual ~BtInterestedMessage();
@@ -53,8 +54,8 @@ public:
 
   static const char NAME[];
 
-  static std::unique_ptr<BtInterestedMessage> create
+  static std::unique_ptr<BtInterestedMessage> create(const unsigned char* data,
-  (const unsigned char* data, size_t dataLength);
+                                                     size_t dataLength);
 
   virtual void doReceivedAction() CXX11_OVERRIDE;
 

src/BtKeepAliveMessage.cc

@@ -50,9 +50,6 @@ unsigned char* BtKeepAliveMessage::createMessage()
   return msg;
 }
 
-size_t BtKeepAliveMessage::getMessageLength()
+size_t BtKeepAliveMessage::getMessageLength() { return MESSAGE_LENGTH; }
-{
-  return MESSAGE_LENGTH;
-}
 
 } // namespace aria2

src/BtKeepAliveMessage.h

@@ -42,6 +42,7 @@ namespace aria2 {
 class BtKeepAliveMessage : public SimpleBtMessage {
 private:
   static const size_t MESSAGE_LENGTH = 4;
+
 public:
   BtKeepAliveMessage() : SimpleBtMessage(ID, NAME) {}
 
@@ -55,10 +56,7 @@ public:
 
   virtual size_t getMessageLength() CXX11_OVERRIDE;
 
-  virtual std::string toString() const CXX11_OVERRIDE
+  virtual std::string toString() const CXX11_OVERRIDE { return NAME; }
-  {
-    return NAME;
-  }
 };
 
 } // namespace aria2

src/BtLeecherStateChoke.cc

@@ -46,9 +46,9 @@
 namespace aria2 {
 
 BtLeecherStateChoke::BtLeecherStateChoke()
-  : round_(0),
+    : round_(0), lastRound_(Timer::zero())
-    lastRound_(Timer::zero())
+{
-{}
+}
 
 BtLeecherStateChoke::~BtLeecherStateChoke() {}
 
@@ -66,7 +66,8 @@ BtLeecherStateChoke::PeerEntry::PeerEntry(const PeerEntry& c)
     : peer_(c.peer_),
       downloadSpeed_(c.downloadSpeed_),
       regularUnchoker_(c.regularUnchoker_)
-{}
+{
+}
 
 void BtLeecherStateChoke::PeerEntry::swap(PeerEntry& c)
 {
@@ -76,8 +77,8 @@ void BtLeecherStateChoke::PeerEntry::swap(PeerEntry& c)
   swap(regularUnchoker_, c.regularUnchoker_);
 }
 
-BtLeecherStateChoke::PeerEntry& BtLeecherStateChoke::PeerEntry::operator=
+BtLeecherStateChoke::PeerEntry& BtLeecherStateChoke::PeerEntry::
-(const PeerEntry& c)
+operator=(const PeerEntry& c)
 {
   if (this != &c) {
     peer_ = c.peer_;
@@ -129,22 +130,20 @@ bool BtLeecherStateChoke::PeerEntry::operator<(const PeerEntry& peerEntry) const
   return downloadSpeed_ > peerEntry.downloadSpeed_;
 }
 
-void swap
+void swap(BtLeecherStateChoke::PeerEntry& a, BtLeecherStateChoke::PeerEntry& b)
-(BtLeecherStateChoke::PeerEntry& a,
- BtLeecherStateChoke::PeerEntry& b)
 {
   a.swap(b);
 }
 
-bool BtLeecherStateChoke::PeerFilter::operator()
+bool BtLeecherStateChoke::PeerFilter::
-  (const PeerEntry& peerEntry) const
+operator()(const PeerEntry& peerEntry) const
 {
   return peerEntry.getPeer()->amChoking() == amChoking_ &&
          peerEntry.getPeer()->peerInterested() == peerInterested_;
 }
 
-void BtLeecherStateChoke::plannedOptimisticUnchoke
+void BtLeecherStateChoke::plannedOptimisticUnchoke(
-(std::vector<PeerEntry>& peerEntries)
+    std::vector<PeerEntry>& peerEntries)
 {
   std::for_each(std::begin(peerEntries), std::end(peerEntries),
                 std::mem_fn(&PeerEntry::disableOptUnchoking));
@@ -190,7 +189,8 @@ void BtLeecherStateChoke::regularUnchoke(std::vector<PeerEntry>& peerEntries)
         p.enableOptUnchoking();
         A2_LOG_INFO(fmt("OU: %s", p.getPeer()->getIPAddress().c_str()));
         break;
-      } else {
+      }
+      else {
         p.disableChokingRequired();
         A2_LOG_INFO(fmt("OU: %s", p.getPeer()->getIPAddress().c_str()));
       }
@@ -222,9 +222,6 @@ void BtLeecherStateChoke::executeChoke(const PeerSet& peerSet)
   }
 }
 
-const Timer& BtLeecherStateChoke::getLastRound() const
+const Timer& BtLeecherStateChoke::getLastRound() const { return lastRound_; }
-{
-  return lastRound_;
-}
 
 } // namespace aria2

src/BtLeecherStateChoke.h

@@ -58,6 +58,7 @@ private:
     std::shared_ptr<Peer> peer_;
     int downloadSpeed_;
     bool regularUnchoker_;
+
   public:
     PeerEntry(const std::shared_ptr<Peer>& peer);
     PeerEntry(const PeerEntry& c);
@@ -92,13 +93,16 @@ private:
   private:
     bool amChoking_;
     bool peerInterested_;
+
   public:
-    PeerFilter(bool amChoking, bool peerInterested):
+    PeerFilter(bool amChoking, bool peerInterested)
-      amChoking_(amChoking),
+        : amChoking_(amChoking), peerInterested_(peerInterested)
-      peerInterested_(peerInterested) {}
+    {
+    }
 
     bool operator()(const PeerEntry& peerEntry) const;
   };
+
 public:
   BtLeecherStateChoke();
 
@@ -111,9 +115,7 @@ public:
   friend void swap(PeerEntry& a, PeerEntry& b);
 };
 
-void swap
+void swap(BtLeecherStateChoke::PeerEntry& a, BtLeecherStateChoke::PeerEntry& b);
-(BtLeecherStateChoke::PeerEntry& a,
- BtLeecherStateChoke::PeerEntry& b);
 
 } // namespace aria2
 

src/BtMessage.h

@@ -50,6 +50,7 @@ class BtEvent;
 class BtMessage {
 private:
   uint8_t id_;
+
 public:
   BtMessage(uint8_t id) : id_(id) {}
 
@@ -67,18 +68,17 @@ public:
 
   virtual void validate() = 0;
 
-  virtual void onAbortOutstandingRequestEvent
+  virtual void onAbortOutstandingRequestEvent(
-  (const BtAbortOutstandingRequestEvent& event) = 0;
+      const BtAbortOutstandingRequestEvent& event) = 0;
 
-  virtual void onCancelSendingPieceEvent
+  virtual void
-  (const BtCancelSendingPieceEvent& event) = 0;
+  onCancelSendingPieceEvent(const BtCancelSendingPieceEvent& event) = 0;
 
   virtual void onChokingEvent(const BtChokingEvent& event) = 0;
 
   virtual void onQueued() = 0;
 
   virtual std::string toString() const = 0;
-
 };
 
 } // namespace aria2

src/BtMessageDispatcher.h

@@ -55,12 +55,14 @@ public:
 
   virtual void sendMessages() = 0;
 
-  virtual void doCancelSendingPieceAction
+  virtual void doCancelSendingPieceAction(size_t index, int32_t begin,
-  (size_t index, int32_t begin, int32_t length) = 0;
+                                          int32_t length) = 0;
 
-  virtual void doCancelSendingPieceAction(const std::shared_ptr<Piece>& piece) = 0;
+  virtual void
+  doCancelSendingPieceAction(const std::shared_ptr<Piece>& piece) = 0;
 
-  virtual void doAbortOutstandingRequestAction(const std::shared_ptr<Piece>& piece) = 0;
+  virtual void
+  doAbortOutstandingRequestAction(const std::shared_ptr<Piece>& piece) = 0;
 
   virtual void doChokedAction() = 0;
 
@@ -76,8 +78,8 @@ public:
 
   virtual bool isOutstandingRequest(size_t index, size_t blockIndex) = 0;
 
-  virtual const RequestSlot* getOutstandingRequest
+  virtual const RequestSlot* getOutstandingRequest(size_t index, int32_t begin,
-  (size_t index, int32_t begin, int32_t length) = 0;
+                                                   int32_t length) = 0;
 
   virtual void removeOutstandingRequest(const RequestSlot* slot) = 0;
 

src/BtMessageFactory.h

@@ -66,8 +66,8 @@ class BtMessageFactory {
 public:
   virtual ~BtMessageFactory() {}
 
-  virtual std::unique_ptr<BtMessage>
+  virtual std::unique_ptr<BtMessage> createBtMessage(const unsigned char* msg,
-  createBtMessage(const unsigned char* msg, size_t msgLength) = 0;
+                                                     size_t msgLength) = 0;
 
   virtual std::unique_ptr<BtHandshakeMessage>
   createHandshakeMessage(const unsigned char* msg, size_t msgLength) = 0;

src/BtMessageReceiver.h

@@ -48,8 +48,8 @@ class BtMessageReceiver {
 public:
   virtual ~BtMessageReceiver() {}
 
-  virtual std::unique_ptr<BtHandshakeMessage> receiveHandshake
+  virtual std::unique_ptr<BtHandshakeMessage>
-  (bool quickReply = false) = 0;
+  receiveHandshake(bool quickReply = false) = 0;
 
   virtual std::unique_ptr<BtHandshakeMessage> receiveAndSendHandshake() = 0;