Use a string view.

Author: gbrail

WORKSPACE

@@ -37,3 +37,10 @@ git_repository(
     remote = "https://boringssl.googlesource.com/boringssl",
     shallow_since = "1566966435 +0000",
 )
+
+http_archive(
+    name = "absl",
+    sha256 = "8100085dada279bf3ee00cd064d43b5f55e5d913be0dfe2906f06f8f28d5b37e",
+    strip_prefix = "abseil-cpp-20190808",
+    urls = ["https://github.com/abseil/abseil-cpp/archive/20190808.tar.gz"],
+)

src/BUILD

@@ -49,6 +49,7 @@ cc_library(
     	"-lm",
     ],
     deps = [
+        "@absl//absl/strings",
         "@httpparser",
     ],
 )
@@ -90,6 +91,7 @@ cc_library(
     ],
     deps = [
         ":common",
+        "@absl//absl/strings",
         "@libev",
     ],
     linkopts = [

src/apib_cpu_proc.cc

@@ -21,6 +21,7 @@ limitations under the License.
 #include <cstring>
 #include <fstream>
 
+#include "absl/strings/numbers.h"
 #include "src/apib_cpu.h"
 #include "src/apib_lines.h"
 #include "src/apib_time.h"
@@ -116,13 +117,21 @@ double cpu_GetMemoryUsage() {
     const auto v = line.nextToken(" ");
 
     if ("MemTotal:" == n) {
-      totalMem = std::stol(v);
+      if (!absl::SimpleAtoi(v, &totalMem)) {
+        return 0.0;
+      }
     } else if ("MemFree:" == n) {
-      freeMem = std::stol(v);
+      if (!absl::SimpleAtoi(v, &freeMem)) {
+        return 0.0;
+      }
     } else if ("Buffers:" == n) {
-      buffers = std::stol(v);
+      if (!absl::SimpleAtoi(v, &buffers)) {
+        return 0.0;
+      }
     } else if ("Cached:" == n) {
-      cache = std::stol(v);
+      if (!absl::SimpleAtoi(v, &cache)) {
+        return 0.0;
+      }
     }
   }
 
@@ -153,7 +162,7 @@ static int getTicks(CPUUsage* cpu) {
       int64_t idleCount = 0LL;
       int64_t nonIdleCount = 0LL;
       int i = 0;
-      std::string tok;
+      absl::string_view tok;
 
       line.nextToken(" \t");
       do {
@@ -164,9 +173,13 @@ static int getTicks(CPUUsage* cpu) {
                  We consider both to be idle CPU.
                The eigth is "steal", which is time lost to virtualization
                as a client -- that's idle two in our estimation */
-            idleCount += std::stoll(tok);
+            if (!absl::SimpleAtoi(tok, &idleCount)) {
+              return 0;
+            }
           } else {
-            nonIdleCount += std::stoll(tok);
+            if (!absl::SimpleAtoi(tok, &nonIdleCount)) {
+              return 0;
+            }
           }
           i++;
         }

src/apib_lines.cc

@@ -120,14 +120,14 @@ bool LineState::next() {
   return true;
 }
 
-std::string LineState::line() {
+absl::string_view LineState::line() {
   if (!lineComplete_) {
     return "";
   }
-  return std::string(buf_ + lineStart_);
+  return absl::string_view(buf_ + lineStart_);
 }
 
-std::string LineState::nextToken(const std::string& toks) {
+absl::string_view LineState::nextToken(const std::string& toks) {
   if (!lineComplete_) {
     return "";
   }
@@ -147,7 +147,7 @@ std::string LineState::nextToken(const std::string& toks) {
     }
   }
 
-  return std::string(buf_ + tokStart_);
+  return absl::string_view(buf_ + tokStart_);
 }
 
 void LineState::skipMatches(const std::string& toks) {

src/apib_lines.h

@@ -21,6 +21,8 @@ limitations under the License.
 #include <ostream>
 #include <string>
 
+#include "absl/strings/string_view.h"
+
 namespace apib {
 
 /*
@@ -49,11 +51,11 @@ class LineState {
    * present. */
   bool next();
   /* If NextLine returned non-zero, return a pointer to the entire line */
-  std::string line();
+  absl::string_view line();
   /* If NextLine returned non-zero, return the next token delimited by "toks"
    * like strtok. If "toks" is zn empty string, return everything until the end
    * of the current line. */
-  std::string nextToken(const std::string& toks);
+  absl::string_view nextToken(const std::string& toks);
   /* Move the token position to skip anything that's not whitespace */
   void skipMatches(const std::string& toks);
   /* Move any data remaining in the line to the start. Used if we didn't

src/apib_message.cc

@@ -20,6 +20,7 @@ limitations under the License.
 #include <iostream>
 #include <regex>
 
+#include "absl/strings/numbers.h"
 #include "src/apib_util.h"
 
 using std::cerr;
@@ -74,9 +75,10 @@ int HttpMessage::parseStatus(LineState* buf) {
     return 1;
   }
 
-  const std::string line = buf->line();
+  const auto line = buf->line();
   std::smatch matches;
-  if (!std::regex_match(line, matches, statusLineRegex)) {
+  const std::string lines(line);
+  if (!std::regex_match(lines, matches, statusLineRegex)) {
     return -1;
   }
   assert(matches.size() == kStatusLineParts);
@@ -94,9 +96,10 @@ int HttpMessage::parseRequestLine(LineState* buf) {
     return 1;
   }
 
-  const std::string line = buf->line();
+  const auto line = buf->line();
   std::smatch matches;
-  if (!std::regex_match(line, matches, requestLineRegex)) {
+  const std::string lines(line);
+  if (!std::regex_match(lines, matches, requestLineRegex)) {
     return -1;
   }
   assert(matches.size() == kRequestLineParts);
@@ -128,10 +131,13 @@ void HttpMessage::finishHeaders() {
   }
 }
 
-void HttpMessage::examineHeader(const std::string& name,
-                                const std::string& value) {
+void HttpMessage::examineHeader(const absl::string_view name,
+                                const absl::string_view value) {
   if (eqcase("Content-Length", name)) {
-    contentLength = std::stol(value);
+    int32_t newLength;
+    if (absl::SimpleAtoi(value, &newLength)) {
+      contentLength = newLength;
+    }
   } else if (eqcase("Transfer-Encoding", name)) {
     chunked = eqcase("chunked", value) ? 1 : 0;
   } else if (eqcase("Connection", name)) {
@@ -144,7 +150,7 @@ int HttpMessage::parseHeaderLine(LineState* buf) {
     return 1;
   }
 
-  const std::string hl = buf->line();
+  const auto hl = buf->line();
   if (hl.empty()) {
     // Empty line -- means end of headers!
     finishHeaders();
@@ -165,9 +171,9 @@ int HttpMessage::parseHeaderLine(LineState* buf) {
     examineHeader(matches[1], matches[3]);
     */
 
-  const std::string name = buf->nextToken(":");
+  const auto name = buf->nextToken(":");
   buf->skipMatches(" \t");
-  const std::string value = buf->nextToken("");
+  const auto value = buf->nextToken("");
   examineHeader(name, value);
 
   return 0;
@@ -205,7 +211,7 @@ int HttpMessage::parseChunkHeader(LineState* buf) {
   }
 
   // TODO regular expression for extra chunk header stuff like encoding!
-  const long len = std::stol(buf->line(), 0, 16);
+  const long len = std::stol(std::string(buf->line()), 0, 16);
   if (len == 0) {
     chunkState_ = kChunkEnd;
   } else {
@@ -256,7 +262,7 @@ int HttpMessage::parseTrailerLine(LineState* buf) {
     return 1;
   }
 
-  const std::string hl = buf->line();
+  const auto hl = buf->line();
   if (hl.empty()) {
     // Empty line -- means end of everything!
     state = kMessageDone;
@@ -268,7 +274,8 @@ int HttpMessage::parseTrailerLine(LineState* buf) {
   }
 
   std::smatch matches;
-  if (!std::regex_match(hl, matches, headerLineRegex)) {
+  const std::string hls(hl);
+  if (!std::regex_match(hls, matches, headerLineRegex)) {
     cerr << "Invalid trailer line: \"" << hl << '\"' << endl;
     return -2;
   }

src/apib_message.h

@@ -20,6 +20,7 @@ limitations under the License.
 #include <cstdint>
 #include <string>
 
+#include "absl/strings/string_view.h"
 #include "src/apib_lines.h"
 
 namespace apib {
@@ -90,7 +91,8 @@ class HttpMessage {
   int parseRequestLine(LineState* buf);
   void finishHeaders();
   int parseHeaderLine(LineState* buf);
-  void examineHeader(const std::string& name, const std::string& value);
+  void examineHeader(const absl::string_view name,
+                     const absl::string_view value);
   int parseLengthBody(LineState* buf);
   int parseChunkHeader(LineState* buf);
   int parseChunkBody(LineState* buf);

src/apib_mon.cc

@@ -49,11 +49,11 @@ namespace apib {
 
 MonServerConnection::MonServerConnection(int fd) : fd_(fd) {}
 
-size_t MonServerConnection::sendBack(const std::string& msg) {
+size_t MonServerConnection::sendBack(const absl::string_view msg) {
   return write(fd_, msg.data(), msg.size());
 }
 
-bool MonServerConnection::processCommand(const std::string& cmd,
+bool MonServerConnection::processCommand(const absl::string_view cmd,
                                          CPUUsage* lastUsage) {
   if (eqcase(cmd, "HELLO")) {
     sendBack("Hi!\n");

src/apib_mon.h

@@ -21,6 +21,7 @@ limitations under the License.
 #include <string>
 #include <thread>
 
+#include "absl/strings/string_view.h"
 #include "ev.h"
 #include "src/apib_cpu.h"
 
@@ -49,8 +50,8 @@ class MonServerConnection {
  public:
   MonServerConnection(int fd);
   void socketLoop();
-  bool processCommand(const std::string& cmd, CPUUsage* lastUsage);
-  size_t sendBack(const std::string& msg);
+  bool processCommand(const absl::string_view msg, CPUUsage* lastUsage);
+  size_t sendBack(const absl::string_view msg);
 
  private:
   int fd_;

src/apib_url.cc

@@ -72,7 +72,7 @@ URLInfo::~URLInfo() {
   }
 }
 
-int URLInfo::initHost(const std::string& hostname) {
+int URLInfo::initHost(const absl::string_view hostname) {
   struct addrinfo hints;
   struct addrinfo* results;
 
@@ -83,7 +83,8 @@ int URLInfo::initHost(const std::string& hostname) {
   hints.ai_protocol = 0;
   hints.ai_flags = 0;
 
-  const int addrerr = getaddrinfo(hostname.c_str(), NULL, &hints, &results);
+  std::string tmpHost(hostname);
+  const int addrerr = getaddrinfo(tmpHost.c_str(), NULL, &hints, &results);
   if (addrerr) {
     return -1;
   }
@@ -104,12 +105,12 @@ int URLInfo::initHost(const std::string& hostname) {
   return 0;
 }
 
-static std::string urlPart(const struct http_parser_url* pu,
-                           const std::string& urlstr, int part) {
+static absl::string_view urlPart(const struct http_parser_url* pu,
+                                 const absl::string_view urlstr, int part) {
   return urlstr.substr(pu->field_data[part].off, pu->field_data[part].len);
 }
 
-int URLInfo::init(const std::string& urlstr) {
+int URLInfo::init(const absl::string_view urlstr) {
   struct http_parser_url pu;
 
   http_parser_url_init(&pu);
@@ -133,7 +134,7 @@ int URLInfo::init(const std::string& urlstr) {
     return -3;
   }
 
-  hostName_ = urlPart(&pu, urlstr, UF_HOST);
+  hostName_ = std::string(urlPart(&pu, urlstr, UF_HOST));
 
   if (pu.field_set & (1 << UF_PORT)) {
     port_ = pu.port;
@@ -148,7 +149,7 @@ int URLInfo::init(const std::string& urlstr) {
   if (pu.field_set & (1 << UF_PATH)) {
     const auto p = urlPart(&pu, urlstr, UF_PATH);
     path << p;
-    pathOnly_ = p;
+    pathOnly_ = std::string(p);
   } else {
     path << '/';
     pathOnly_ = "/";
@@ -157,7 +158,7 @@ int URLInfo::init(const std::string& urlstr) {
   if (pu.field_set & (1 << UF_QUERY)) {
     const auto q = urlPart(&pu, urlstr, UF_QUERY);
     path << '?' << q;
-    query_ = q;
+    query_ = std::string(q);
   }
 
   if (pu.field_set & (1 << UF_FRAGMENT)) {

src/apib_url.h

@@ -24,6 +24,7 @@ limitations under the License.
 #include <string>
 #include <vector>
 
+#include "absl/strings/string_view.h"
 #include "src/apib_rand.h"
 
 namespace apib {
@@ -91,8 +92,8 @@ class URLInfo {
   size_t addressCount() const { return addresses_.size(); }
 
  private:
-  int init(const std::string& urlStr);
-  int initHost(const std::string& hostName);
+  int init(const absl::string_view urlStr);
+  int initHost(const absl::string_view hostName);
 
   std::vector<struct sockaddr*> addresses_;
   std::vector<socklen_t> addressLengths_;

src/apib_util.cc

@@ -21,7 +21,7 @@ limitations under the License.
 
 namespace apib {
 
-bool eqcase(const std::string& s1, const std::string& s2) {
+bool eqcase(const absl::string_view s1, const absl::string_view s2) {
   if (s1.size() != s2.size()) {
     return false;
   }

src/apib_util.h

@@ -21,6 +21,8 @@ limitations under the License.
 #include <iostream>
 #include <string>
 
+#include "absl/strings/string_view.h"
+
 namespace apib {
 
 #define mandatoryAssert(e)                                           \
@@ -30,7 +32,7 @@ namespace apib {
     abort();                                                         \
   }
 
-extern bool eqcase(const std::string& s1, const std::string& s2);
+extern bool eqcase(const absl::string_view s1, const absl::string_view s2);
 
 }  // namespace apib