Use uri_split instead of uri::parse where appropriate

src/AdaptiveURISelector.cc

@@ -345,9 +345,11 @@ std::string AdaptiveURISelector::getFirstToTestUri
 SharedHandle<ServerStat> AdaptiveURISelector::getServerStats
 (const std::string& uri) const
 {
-  uri::UriStruct us;
-  if(uri::parse(us, uri)) {
-    return serverStatMan_->find(us.host, us.protocol);
+  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 {
     return SharedHandle<ServerStat>();
   }

src/DefaultBtAnnounce.cc

@@ -106,9 +106,9 @@ bool DefaultBtAnnounce::isAnnounceReady() {
 namespace {
 bool uriHasQuery(const std::string& uri)
 {
-  uri::UriStruct us;
-  if(uri::parse(us, uri)) {
-    return !us.query.empty();
+  uri_split_result us;
+  if(uri_split(&us, uri.c_str()) == 0) {
+    return (us.field_set & (1 << USR_QUERY)) && us.fields[USR_QUERY].len > 0;
   } else {
     return false;
   }

src/FeedbackURISelector.cc

@@ -94,17 +94,18 @@ std::string FeedbackURISelector::selectRarer
   std::vector<std::pair<std::string, std::string> > cands;
   for(std::deque<std::string>::const_iterator i = uris.begin(),
         eoi = uris.end(); i != eoi; ++i) {
-    uri::UriStruct us;
-    if(!uri::parse(us, *i)) {
+    uri_split_result us;
+    if(uri_split(&us, (*i).c_str()) == -1) {
       continue;
     }
-    SharedHandle<ServerStat> ss =
-      serverStatMan_->find(us.host, us.protocol);
+    std::string host = uri::getFieldString(us, USR_HOST, (*i).c_str());
+    std::string protocol = uri::getFieldString(us, USR_SCHEME, (*i).c_str());
+    SharedHandle<ServerStat> ss = serverStatMan_->find(host, protocol);
     if(ss && ss->isError()) {
       A2_LOG_DEBUG(fmt("Error not considered: %s", (*i).c_str()));
       continue;
     }
-    cands.push_back(std::make_pair(us.host, *i));
+    cands.push_back(std::make_pair(host, *i));
   }
   for(std::vector<std::pair<size_t, std::string> >::const_iterator i =
         usedHosts.begin(), eoi = usedHosts.end(); i != eoi; ++i) {
@@ -131,17 +132,18 @@ std::string FeedbackURISelector::selectFaster
   std::vector<std::string> normCands;
   for(std::deque<std::string>::const_iterator i = uris.begin(),
         eoi = uris.end(); i != eoi && fastCands.size() < NUM_URI; ++i) {
-    uri::UriStruct us;
-    if(!uri::parse(us, *i)) {
+    uri_split_result us;
+    if(uri_split(&us, (*i).c_str()) == -1) {
       continue;
     }
-    if(findSecond(usedHosts.begin(), usedHosts.end(), us.host) !=
+    std::string host = uri::getFieldString(us, USR_HOST, (*i).c_str());
+    if(findSecond(usedHosts.begin(), usedHosts.end(), host) !=
        usedHosts.end()) {
       A2_LOG_DEBUG(fmt("%s is in usedHosts, not considered", (*i).c_str()));
       continue;
     }
-    SharedHandle<ServerStat> ss =
-      serverStatMan_->find(us.host, us.protocol);
+    std::string protocol = uri::getFieldString(us, USR_SCHEME, (*i).c_str());
+    SharedHandle<ServerStat> ss = serverStatMan_->find(host, protocol);
     if(!ss) {
       normCands.push_back(*i);
     } else if(ss->isOK()) {

src/FileEntry.cc

@@ -130,9 +130,9 @@ OutputIterator enumerateInFlightHosts
 (InputIterator first, InputIterator last, OutputIterator out)
 {
   for(; first != last; ++first) {
-    uri::UriStruct us;
-    if(uri::parse(us, (*first)->getUri())) {
-      *out++ = us.host;
+    uri_split_result us;
+    if(uri_split(&us, (*first)->getUri().c_str()) == 0) {
+      *out++ = uri::getFieldString(us, USR_HOST, (*first)->getUri().c_str());
     }
   }
   return out;
@@ -261,23 +261,25 @@ FileEntry::findFasterRequest
   std::vector<std::string> normCands;
   for(std::deque<std::string>::const_iterator i = uris_.begin(),
         eoi = uris_.end(); i != eoi && fastCands.size() < NUM_URI; ++i) {
-    uri::UriStruct us;
-    if(!uri::parse(us, *i)) {
+    uri_split_result us;
+    if(uri_split(&us, (*i).c_str()) == -1) {
       continue;
     }
-    if(std::count(inFlightHosts.begin(), inFlightHosts.end(),us.host)
+    std::string host = uri::getFieldString(us, USR_HOST, (*i).c_str());
+    std::string protocol = uri::getFieldString(us, USR_SCHEME, (*i).c_str());
+    if(std::count(inFlightHosts.begin(), inFlightHosts.end(), host)
        >= maxConnectionPerServer_) {
       A2_LOG_DEBUG(fmt("%s has already used %d times, not considered.",
                        (*i).c_str(),
                        maxConnectionPerServer_));
       continue;
     }
-    if(findSecond(usedHosts.begin(), usedHosts.end(), us.host) !=
+    if(findSecond(usedHosts.begin(), usedHosts.end(), host) !=
        usedHosts.end()) {
       A2_LOG_DEBUG(fmt("%s is in usedHosts, not considered", (*i).c_str()));
       continue;
     }
-    SharedHandle<ServerStat> ss = serverStatMan->find(us.host, us.protocol);
+    SharedHandle<ServerStat> ss = serverStatMan->find(host, protocol);
     if(ss && ss->isOK()) {
       if((basestat &&
           ss->getDownloadSpeed() > basestat->calculateDownloadSpeed()*1.5) ||
@@ -332,11 +334,13 @@ void FileEntry::removeURIWhoseHostnameIs(const std::string& hostname)
   std::deque<std::string> newURIs;
   for(std::deque<std::string>::const_iterator itr = uris_.begin(),
         eoi = uris_.end(); itr != eoi; ++itr) {
-    uri::UriStruct us;
-    if(!uri::parse(us, *itr)) {
+    uri_split_result us;
+    if(uri_split(&us, (*itr).c_str()) == -1) {
       continue;
     }
-    if(us.host != hostname) {
+    if(us.fields[USR_HOST].len != hostname.size() ||
+       memcmp((*itr).c_str()+us.fields[USR_HOST].off, hostname.c_str(),
+              hostname.size()) != 0) {
       newURIs.push_back(*itr);
     }
   }
@@ -411,9 +415,11 @@ void FileEntry::reuseUri(const std::vector<std::string>& ignore)
   std::vector<std::string>::iterator insertionPoint = reusableURIs.begin();
   for(std::vector<std::string>::iterator i = reusableURIs.begin(),
         eoi = reusableURIs.end(); i != eoi; ++i) {
-    uri::UriStruct us;
-    if(uri::parse(us, *i) &&
-       std::find(ignore.begin(), ignore.end(), us.host) == ignore.end()) {
+    uri_split_result us;
+    if(uri_split(&us, (*i).c_str()) == 0 &&
+       std::find(ignore.begin(), ignore.end(),
+                 uri::getFieldString(us, USR_HOST, (*i).c_str()))
+       == ignore.end()) {
       if(i != insertionPoint) {
         *insertionPoint = *i;
       }
@@ -524,9 +530,8 @@ size_t FileEntry::setUris(const std::vector<std::string>& uris)
 
 bool FileEntry::addUri(const std::string& uri)
 {
-  uri::UriStruct us;
   std::string peUri = util::percentEncodeMini(uri);
-  if(uri::parse(us, peUri)) {
+  if(uri_split(NULL, peUri.c_str()) == 0) {
     uris_.push_back(peUri);
     return true;
   } else {
@@ -536,9 +541,8 @@ bool FileEntry::addUri(const std::string& uri)
 
 bool FileEntry::insertUri(const std::string& uri, size_t pos)
 {
-  uri::UriStruct us;
   std::string peUri = util::percentEncodeMini(uri);
-  if(uri::parse(us, peUri)) {
+  if(uri_split(NULL, peUri.c_str()) == 0) {
     pos = std::min(pos, uris_.size());
     uris_.insert(uris_.begin()+pos, peUri);
     return true;

src/HttpResponseCommand.cc

@@ -239,9 +239,11 @@ bool HttpResponseCommand::executeInternal()
   if(getFileEntry()->isUniqueProtocol()) {
     // Redirection should be considered here. We need to parse
     // original URI to get hostname.
-    uri::UriStruct us;
-    if(uri::parse(us, getRequest()->getUri())) {
-      getFileEntry()->removeURIWhoseHostnameIs(us.host);
+    const std::string& uri = getRequest()->getUri();
+    uri_split_result us;
+    if(uri_split(&us, uri.c_str()) == 0) {
+      std::string host = uri::getFieldString(us, USR_HOST, uri.c_str());
+      getFileEntry()->removeURIWhoseHostnameIs(host);
     }
   }
   if(!getPieceStorage()) {

src/MetalinkParserController.cc

@@ -176,11 +176,11 @@ void MetalinkParserController::setURLOfResource(const std::string& url)
     return;
   }
   std::string u = uri::joinUri(baseUri_, url);
-  uri::UriStruct us;
-  if(uri::parse(us, u)) {
+  uri_split_result us;
+  if(uri_split(&us, u.c_str()) == 0) {
     tResource_->url = u;
     if(tResource_->type == MetalinkResource::TYPE_UNKNOWN) {
-      setTypeOfResource(us.protocol);
+      setTypeOfResource(uri::getFieldString(us, USR_SCHEME, u.c_str()));
     }
   } else {
     tResource_->url = url;
@@ -579,8 +579,7 @@ void MetalinkParserController::setURLOfMetaurl(const std::string& url)
 #endif // ENABLE_BITTORRENT
     {
       std::string u = uri::joinUri(baseUri_, url);
-      uri::UriStruct us;
-      if(uri::parse(us, u)) {
+      if(uri_split(NULL, u.c_str()) == 0) {
         tMetaurl_->url = u;
       } else {
         tMetaurl_->url = url;

src/ProtocolDetector.cc

@@ -55,8 +55,7 @@ ProtocolDetector::~ProtocolDetector() {}
 
 bool ProtocolDetector::isStreamProtocol(const std::string& uri) const
 {
-  uri::UriStruct us;
-  return uri::parse(us, uri);
+  return uri_split(NULL, uri.c_str()) == 0;
 }
 
 bool ProtocolDetector::guessTorrentFile(const std::string& uri) const

src/Request.cc

@@ -172,10 +172,12 @@ const SharedHandle<PeerStat>& Request::initPeerStat()
 {
   // Use host and protocol in original URI, because URI selector
   // selects URI based on original URI, not redirected one.
-  uri::UriStruct us;
-  bool v = uri::parse(us, uri_);
-  assert(v);
-  peerStat_.reset(new PeerStat(0, us.host, us.protocol));
+  uri_split_result us;
+  int v = uri_split(&us, uri_.c_str());
+  assert(v == 0);
+  std::string host = uri::getFieldString(us, USR_HOST, uri_.c_str());
+  std::string protocol = uri::getFieldString(us, USR_SCHEME, uri_.c_str());
+  peerStat_.reset(new PeerStat(0, host, protocol));
   return peerStat_;
 }
 

src/RequestGroupMan.cc

@@ -1056,22 +1056,26 @@ void RequestGroupMan::getUsedHosts
       (*i)->getDownloadContext()->getFirstFileEntry()->getInFlightRequests();
     for(FileEntry::InFlightRequestSet::iterator j =
           inFlightReqs.begin(), eoj = inFlightReqs.end(); j != eoj; ++j) {
-      uri::UriStruct us;
-      if(uri::parse(us, (*j)->getUri())) {
+      uri_split_result us;
+      if(uri_split(&us, (*j)->getUri().c_str()) == 0) {
         std::vector<Triplet<size_t, int, std::string> >::iterator k;
         std::vector<Triplet<size_t, int, std::string> >::iterator eok =
           tempHosts.end();
+        std::string host = uri::getFieldString(us, USR_HOST,
+                                               (*j)->getUri().c_str());
         for(k =  tempHosts.begin(); k != eok; ++k) {
-          if((*k).third == us.host) {
+          if((*k).third == host) {
             ++(*k).first;
             break;
           }
         }
         if(k == eok) {
-          SharedHandle<ServerStat> ss = findServerStat(us.host, us.protocol);
+          std::string protocol = uri::getFieldString(us, USR_SCHEME,
+                                                     (*j)->getUri().c_str());
+          SharedHandle<ServerStat> ss = findServerStat(host, protocol);
           int invDlSpeed = (ss && ss->isOK()) ?
             -(static_cast<int>(ss->getDownloadSpeed())) : 0;
-          tempHosts.push_back(makeTriplet(1, invDlSpeed, us.host));
+          tempHosts.push_back(makeTriplet(1, invDlSpeed, host));
         }
       }
     }

src/uri.cc

@@ -36,7 +36,6 @@
 #include "A2STR.h"
 #include "FeatureConfig.h"
 #include "util.h"
-#include "uri_split.h"
 
 namespace aria2 {
 
@@ -167,6 +166,16 @@ bool parse(UriStruct& result, const std::string& uri)
   }
 }
 
+std::string getFieldString(const uri_split_result& res, int field,
+                           const char* base)
+{
+  if(res.field_set & (1 << field)) {
+    return std::string(base + res.fields[field].off, res.fields[field].len);
+  } else {
+    return "";
+  }
+}
+
 std::string construct(const UriStruct& us)
 {
   std::string res;

src/uri.h

@@ -39,6 +39,8 @@
 
 #include <string>
 
+#include "uri_split.h"
+
 namespace aria2 {
 
 namespace uri {
@@ -70,6 +72,12 @@ void swap(UriStruct& lhs, UriStruct& rhs);
 // undefined.
 bool parse(UriStruct& result, const std::string& uri);
 
+// Returns string specified by field in res. The base pointer in res
+// is given as base. If the given field is not stored in res, returns
+// empty string.
+std::string getFieldString(const uri_split_result& res, int field,
+                           const char* base);
+
 std::string construct(const UriStruct& us);
 
 std::string joinUri(const std::string& baseUri, const std::string& uri);