make clang-format using clang-format-3.6

1 files changed, 95 insertions, 121 deletions

diff --git a/src/AbstractCommand.cc b/src/AbstractCommand.cc
index 59b92c06..27762cc8 100644
--- a/src/AbstractCommand.cc
+++ b/src/AbstractCommand.cc
@@ -74,31 +74,28 @@
 
 namespace aria2 {
 
-AbstractCommand::AbstractCommand
-(cuid_t cuid,
- const std::shared_ptr<Request>& req,
- const std::shared_ptr<FileEntry>& fileEntry,
- RequestGroup* requestGroup,
- DownloadEngine* e,
- const std::shared_ptr<SocketCore>& s,
- const std::shared_ptr<SocketRecvBuffer>& socketRecvBuffer,
- bool incNumConnection)
-  : Command(cuid),
-    req_(req),
-    fileEntry_(fileEntry),
-    socket_(s),
-    socketRecvBuffer_(socketRecvBuffer),
+AbstractCommand::AbstractCommand(
+    cuid_t cuid, const std::shared_ptr<Request>& req,
+    const std::shared_ptr<FileEntry>& fileEntry, RequestGroup* requestGroup,
+    DownloadEngine* e, const std::shared_ptr<SocketCore>& s,
+    const std::shared_ptr<SocketRecvBuffer>& socketRecvBuffer,
+    bool incNumConnection)
+    : Command(cuid),
+      req_(req),
+      fileEntry_(fileEntry),
+      socket_(s),
+      socketRecvBuffer_(socketRecvBuffer),
 #ifdef ENABLE_ASYNC_DNS
-    asyncNameResolverMan_(make_unique<AsyncNameResolverMan>()),
+      asyncNameResolverMan_(make_unique<AsyncNameResolverMan>()),
 #endif // ENABLE_ASYNC_DNS
-    requestGroup_(requestGroup),
-    e_(e),
-    checkPoint_(global::wallclock()),
-    serverStatTimer_(global::wallclock()),
-    timeout_(requestGroup->getTimeout()),
-    checkSocketIsReadable_(false),
-    checkSocketIsWritable_(false),
-    incNumConnection_(incNumConnection)
+      requestGroup_(requestGroup),
+      e_(e),
+      checkPoint_(global::wallclock()),
+      serverStatTimer_(global::wallclock()),
+      timeout_(requestGroup->getTimeout()),
+      checkSocketIsReadable_(false),
+      checkSocketIsWritable_(false),
+      incNumConnection_(incNumConnection)
 {
   if (socket_ && socket_->isOpen()) {
     setReadCheckSocket(socket_);
@@ -127,19 +124,18 @@ AbstractCommand::~AbstractCommand()
   }
 }
 
-void
-AbstractCommand::useFasterRequest(const std::shared_ptr<Request>& fasterRequest)
+void AbstractCommand::useFasterRequest(
+    const std::shared_ptr<Request>& fasterRequest)
 {
   A2_LOG_INFO(fmt("CUID#%" PRId64 " - Use faster Request hostname=%s, port=%u",
-                  getCuid(),
-                  fasterRequest->getHost().c_str(),
+                  getCuid(), fasterRequest->getHost().c_str(),
                   fasterRequest->getPort()));
   // Cancel current Request object and use faster one.
   fileEntry_->removeRequest(req_);
   e_->setNoWait(true);
-  e_->addCommand
-    (InitiateConnectionCommandFactory::createInitiateConnectionCommand
-     (getCuid(), fasterRequest, fileEntry_, requestGroup_, e_));
+  e_->addCommand(
+      InitiateConnectionCommandFactory::createInitiateConnectionCommand(
+          getCuid(), fasterRequest, fileEntry_, requestGroup_, e_));
 }
 
 bool AbstractCommand::shouldProcess() const
@@ -167,7 +163,7 @@ bool AbstractCommand::shouldProcess() const
   if (!checkSocketIsReadable_ && !checkSocketIsWritable_ && !resolverChecked) {
     return true;
   }
-#else // ENABLE_ASYNC_DNS
+#else  // ENABLE_ASYNC_DNS
   if (!checkSocketIsReadable_ && !checkSocketIsWritable_) {
     return true;
   }
@@ -180,11 +176,8 @@ bool AbstractCommand::execute()
 {
   A2_LOG_DEBUG(fmt("CUID#%" PRId64
                    " - socket: read:%d, write:%d, hup:%d, err:%d",
-                   getCuid(),
-                   readEventEnabled(),
-                   writeEventEnabled(),
-                   hupEventEnabled(),
-                   errorEventEnabled()));
+                   getCuid(), readEventEnabled(), 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(),
-                       req_->getUri().c_str()));
+                       getCuid(), 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
-          (req_, usedHosts, e_->getRequestGroupMan()->getServerStatMan());
+        auto fasterRequest = fileEntry_->findFasterRequest(
+            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
-            (segments_, getCuid(), minSplitSize, fileEntry_, maxSegments);
+          sm->getSegment(segments_, getCuid(), minSplitSize, fileEntry_,
+                         maxSegments);
         }
         if (segments_.empty()) {
           return prepareForRetry(0);
@@ -308,22 +300,21 @@ bool AbstractCommand::execute()
     }
 
     if (errorEventEnabled()) {
-      throw DL_RETRY_EX
-        (fmt(MSG_NETWORK_PROBLEM, socket_->getSocketError().c_str()));
+      throw DL_RETRY_EX(
+          fmt(MSG_NETWORK_PROBLEM, socket_->getSocketError().c_str()));
     }
 
     if (checkPoint_.difference(global::wallclock()) >= timeout_) {
       // timeout triggers ServerStat error state.
-      auto ss = e_->getRequestGroupMan()->getOrCreateServerStat
-        (req_->getHost(), req_->getProtocol());
+      auto ss = e_->getRequestGroupMan()->getOrCreateServerStat(
+          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(),
-                         req_->getConnectedAddr().c_str()));
+                         getCuid(), req_->getConnectedAddr().c_str()));
         e_->markBadIPAddress(req_->getConnectedHostname(),
                              req_->getConnectedAddr(),
                              req_->getConnectedPort());
@@ -345,9 +336,9 @@ bool AbstractCommand::execute()
   catch (DlAbortEx& err) {
     requestGroup_->setLastErrorCode(err.getErrorCode(), err.what());
     if (req_) {
-      A2_LOG_ERROR_EX
-        (fmt(MSG_DOWNLOAD_ABORTED, getCuid(), req_->getUri().c_str()),
-         DL_ABORT_EX2(fmt("URI=%s", req_->getCurrentUri().c_str()), err));
+      A2_LOG_ERROR_EX(
+          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) {
         requestGroup_->increaseResumeFailureCount();
@@ -362,9 +353,9 @@ bool AbstractCommand::execute()
   }
   catch (DlRetryEx& err) {
     assert(req_);
-    A2_LOG_INFO_EX
-      (fmt(MSG_RESTARTING_DOWNLOAD, getCuid(), req_->getUri().c_str()),
-       DL_RETRY_EX2(fmt("URI=%s", req_->getCurrentUri().c_str()), err));
+    A2_LOG_INFO_EX(
+        fmt(MSG_RESTARTING_DOWNLOAD, getCuid(), req_->getUri().c_str()),
+        DL_RETRY_EX2(fmt("URI=%s", req_->getCurrentUri().c_str()), err));
     req_->addTryCount();
     req_->resetRedirectCount();
     req_->resetUri();
@@ -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
-        (fmt(MSG_DOWNLOAD_ABORTED, getCuid(), req_->getUri().c_str()), err);
+      A2_LOG_ERROR_EX(
+          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
-        (fmt(MSG_DOWNLOAD_ABORTED, getCuid(), req_->getUri().c_str()),
-         DL_ABORT_EX2(fmt("URI=%s", req_->getCurrentUri().c_str()), err));
+      A2_LOG_ERROR_EX(
+          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
-    (fmt("CUID#%" PRId64 " - Trying reserved/pooled request.", getCuid()));
+  A2_LOG_DEBUG(
+      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",
-                     getCuid(),
+    A2_LOG_DEBUG(fmt("CUID#%" PRId64 " - Pooling request URI=%s", 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.",
-                   getCuid(),
+  A2_LOG_DEBUG(fmt("CUID#%" PRId64 " - %lu URIs found.", 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
-AbstractCommand::setReadCheckSocket(const std::shared_ptr<SocketCore>& socket)
+void AbstractCommand::setReadCheckSocket(
+    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
-AbstractCommand::setReadCheckSocketIf(const std::shared_ptr<SocketCore>& socket,
-                                      bool pred)
+void AbstractCommand::setReadCheckSocketIf(
+    const std::shared_ptr<SocketCore>& socket, bool pred)
 {
   if (pred) {
     setReadCheckSocket(socket);
@@ -580,8 +569,8 @@ void AbstractCommand::disableWriteCheckSocket()
   writeCheckTarget_.reset();
 }
 
-void
-AbstractCommand::setWriteCheckSocket(const std::shared_ptr<SocketCore>& socket)
+void AbstractCommand::setWriteCheckSocket(
+    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
-(const std::shared_ptr<SocketCore>& socket, bool pred)
+void AbstractCommand::setWriteCheckSocketIf(
+    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,
-                         PrefPtr proxyUser,
-                         PrefPtr proxyPasswd,
-                         const Option* option)
+std::string makeProxyUri(PrefPtr proxyPref, PrefPtr proxyUser,
+                         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,
-                              PrefPtr proxyUser,
-                              PrefPtr proxyPasswd,
-                              const Option* option)
+std::string getProxyOptionFor(PrefPtr proxyPref, PrefPtr proxyUser,
+                              PrefPtr proxyPasswd, const Option* option)
 {
   std::string uri = makeProxyUri(proxyPref, proxyUser, proxyPasswd, option);
   if (uri.empty()) {
-    return makeProxyUri
-      (PREF_ALL_PROXY, PREF_ALL_PROXY_USER, PREF_ALL_PROXY_PASSWD, option);
+    return makeProxyUri(PREF_ALL_PROXY, PREF_ALL_PROXY_USER,
+                        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
-      (PREF_HTTP_PROXY, PREF_HTTP_PROXY_USER, PREF_HTTP_PROXY_PASSWD, option);
+    return getProxyOptionFor(PREF_HTTP_PROXY, PREF_HTTP_PROXY_USER,
+                             PREF_HTTP_PROXY_PASSWD, option);
   }
 
   if (protocol == "https") {
-    return getProxyOptionFor(PREF_HTTPS_PROXY,
-                             PREF_HTTPS_PROXY_USER,
-                             PREF_HTTPS_PROXY_PASSWD,
-                             option);
+    return getProxyOptionFor(PREF_HTTPS_PROXY, PREF_HTTPS_PROXY_USER,
+                             PREF_HTTPS_PROXY_PASSWD, option);
   }
 
   if (protocol == "ftp" || protocol == "sftp") {
-    return getProxyOptionFor
-      (PREF_FTP_PROXY, PREF_FTP_PROXY_USER, PREF_FTP_PROXY_PASSWD, option);
+    return getProxyOptionFor(PREF_FTP_PROXY, PREF_FTP_PROXY_USER,
+                             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
-        (fmt("CUID#%" PRId64 " - Failed to parse proxy string", getCuid()));
+      A2_LOG_DEBUG(
+          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,
-                             getCuid(),
+      throw DL_ABORT_EX2(fmt(MSG_NAME_RESOLUTION_FAILED, 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,
-                               getCuid(),
-                               hostname.c_str(),
-                               "No address returned"),
+        throw DL_ABORT_EX2(fmt(MSG_NAME_RESOLUTION_FAILED, getCuid(),
+                               hostname.c_str(), "No address returned"),
                            error_code::NAME_RESOLVE_ERROR);
       }
       break;
@@ -829,21 +809,20 @@ std::string AbstractCommand::resolveHostname(std::vector<std::string>& addrs,
   return ipaddr;
 }
 
-void AbstractCommand::prepareForNextAction
-(std::unique_ptr<CheckIntegrityEntry> checkEntry)
+void AbstractCommand::prepareForNextAction(
+    std::unique_ptr<CheckIntegrityEntry> checkEntry)
 {
   std::vector<std::unique_ptr<Command>> commands;
-  requestGroup_->processCheckIntegrityEntry
-    (commands, std::move(checkEntry), e_);
+  requestGroup_->processCheckIntegrityEntry(commands, std::move(checkEntry),
+                                            e_);
   e_->addCommand(std::move(commands));
   e_->setNoWait(true);
 }
 
-bool AbstractCommand::checkIfConnectionEstablished
-(const std::shared_ptr<SocketCore>& socket,
- const std::string& connectedHostname,
- const std::string& connectedAddr,
- uint16_t connectedPort)
+bool AbstractCommand::checkIfConnectionEstablished(
+    const std::shared_ptr<SocketCore>& socket,
+    const std::string& connectedHostname, const std::string& connectedAddr,
+    uint16_t connectedPort)
 {
   std::string error = socket->getSocketError();
   if (error.empty()) {
@@ -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,
-                  getCuid(),
-                  connectedAddr.c_str(),
-                  connectedPort));
+  A2_LOG_INFO(fmt(MSG_CONNECT_FAILED_AND_RETRY, getCuid(),
+                  connectedAddr.c_str(), connectedPort));
   e_->setNoWait(true);
-  e_->addCommand
-    (InitiateConnectionCommandFactory::createInitiateConnectionCommand
-     (getCuid(), req_, fileEntry_, requestGroup_, e_));
+  e_->addCommand(
+      InitiateConnectionCommandFactory::createInitiateConnectionCommand(
+          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()
-{
-  req_.reset();
-}
+void AbstractCommand::resetRequest() { req_.reset(); }
 
 void AbstractCommand::setFileEntry(const std::shared_ptr<FileEntry>& fileEntry)
 {