Update codebase from boost::string_view into std::string_view

src/ripple/app/misc/ValidatorList.h

@@ -622,7 +622,7 @@ class ValidatorList
     */
     std::optional<Json::Value>
     getAvailable(
-        boost::beast::string_view const& pubKey,
+        std::string_view pubKey,
         std::optional<std::uint32_t> forceVersion = {});
 
     /** Return the number of configured validator list sites. */

src/ripple/app/misc/impl/ValidatorList.cpp

@@ -1676,7 +1676,7 @@ ValidatorList::for_each_available(
 
 std::optional<Json::Value>
 ValidatorList::getAvailable(
-    boost::beast::string_view const& pubKey,
+    std::string_view pubKey,
     std::optional<std::uint32_t> forceVersion /* = {} */)
 {
     std::shared_lock read_lock{mutex_};

src/ripple/basics/StringUtilities.h

@@ -108,7 +108,7 @@ strUnHex(std::string const& strSrc)
 }
 
 inline std::optional<Blob>
-strViewUnHex(boost::string_view const& strSrc)
+strViewUnHex(std::string_view strSrc)
 {
     return strUnHex(strSrc.size(), strSrc.cbegin(), strSrc.cend());
 }

src/ripple/overlay/impl/OverlayImpl.cpp

@@ -997,9 +997,13 @@ OverlayImpl::processValidatorList(
         return true;
     };
 
-    auto key = req.target().substr(prefix.size());
+    // Explicitly construct a std::string_view until http_request_type is
+    // migrated from boost
+    std::string_view key{
+        req.target().substr(prefix.size()).data(),
+        req.target().substr(prefix.size()).length()};
 
-    if (auto slash = key.find('/'); slash != boost::string_view::npos)
+    if (auto slash = key.find('/'); slash != std::string_view::npos)
     {
         auto verString = key.substr(0, slash);
         if (!boost::conversion::try_lexical_convert(verString, version))

src/ripple/resource/ResourceManager.h

@@ -49,7 +49,7 @@ class Manager : public beast::PropertyStream::Source
     newInboundEndpoint(
         beast::IP::Endpoint const& address,
         bool const proxy,
-        boost::string_view const& forwardedFor) = 0;
+        std::string_view forwardedFor) = 0;
 
     /** Create a new endpoint keyed by outbound IP address and port. */
     virtual Consumer

src/ripple/resource/impl/ResourceManager.cpp

@@ -77,14 +77,13 @@ class ManagerImp : public Manager
     newInboundEndpoint(
         beast::IP::Endpoint const& address,
         bool const proxy,
-        boost::string_view const& forwardedFor) override
+        std::string_view forwardedFor) override
     {
         if (!proxy)
             return newInboundEndpoint(address);
 
         boost::system::error_code ec;
-        auto const proxiedIp =
-            boost::asio::ip::make_address(forwardedFor.to_string(), ec);
+        auto const proxiedIp = boost::asio::ip::make_address(forwardedFor, ec);
         if (ec)
         {
             journal_.warn()

src/ripple/rpc/Context.h

@@ -57,8 +57,8 @@ struct JsonContext : public Context
      */
     struct Headers
     {
-        boost::string_view user;
-        boost::string_view forwardedFor;
+        std::string_view user;
+        std::string_view forwardedFor;
     };
 
     Json::Value params;

src/ripple/rpc/Role.h

@@ -56,15 +56,15 @@ requestRole(
     Port const& port,
     Json::Value const& params,
     beast::IP::Endpoint const& remoteIp,
-    boost::string_view const& user);
+    std::string_view user);
 
 Resource::Consumer
 requestInboundEndpoint(
     Resource::Manager& manager,
     beast::IP::Endpoint const& remoteAddress,
     Role const& role,
-    boost::string_view const& user,
-    boost::string_view const& forwardedFor);
+    std::string_view user,
+    std::string_view forwardedFor);
 
 /**
  * Check if the role entitles the user to unlimited resources.
@@ -85,7 +85,7 @@ ipAllowed(
     std::vector<boost::asio::ip::network_v4> const& nets4,
     std::vector<boost::asio::ip::network_v6> const& nets6);
 
-boost::string_view
+std::string_view
 forwardedFor(http_request_type const& request);
 
 }  // namespace ripple

src/ripple/rpc/handlers/Ping.cpp

@@ -39,13 +39,14 @@ doPing(RPC::JsonContext& context)
             break;
         case Role::IDENTIFIED:
             ret[jss::role] = "identified";
-            ret[jss::username] = context.headers.user.to_string();
+            // Can I avoid making expensive copies for std::string?
+            ret[jss::username] = std::string{context.headers.user};
             if (context.headers.forwardedFor.size())
-                ret[jss::ip] = context.headers.forwardedFor.to_string();
+                ret[jss::ip] = std::string{context.headers.forwardedFor};
             break;
         case Role::PROXY:
             ret[jss::role] = "proxied";
-            ret[jss::ip] = context.headers.forwardedFor.to_string();
+            ret[jss::ip] = std::string{context.headers.forwardedFor};
         default:;
     }
 

src/ripple/rpc/impl/Role.cpp

@@ -96,7 +96,7 @@ requestRole(
     Port const& port,
     Json::Value const& params,
     beast::IP::Endpoint const& remoteIp,
-    boost::string_view const& user)
+    std::string_view user)
 {
     if (isAdmin(port, params, remoteIp.address()))
         return Role::ADMIN;
@@ -142,8 +142,8 @@ requestInboundEndpoint(
     Resource::Manager& manager,
     beast::IP::Endpoint const& remoteAddress,
     Role const& role,
-    boost::string_view const& user,
-    boost::string_view const& forwardedFor)
+    std::string_view user,
+    std::string_view forwardedFor)
 {
     if (isUnlimited(role))
         return manager.newUnlimitedEndpoint(remoteAddress);
@@ -152,18 +152,18 @@ requestInboundEndpoint(
         remoteAddress, role == Role::PROXY, forwardedFor);
 }
 
-static boost::string_view
-extractIpAddrFromField(boost::string_view field)
+static std::string_view
+extractIpAddrFromField(std::string_view field)
 {
     // Lambda to trim leading and trailing spaces on the field.
-    auto trim = [](boost::string_view str) -> boost::string_view {
-        boost::string_view ret = str;
+    auto trim = [](std::string_view str) -> std::string_view {
+        std::string_view ret = str;
 
         // Only do the work if there's at least one leading space.
         if (!ret.empty() && ret.front() == ' ')
         {
             std::size_t const firstNonSpace = ret.find_first_not_of(' ');
-            if (firstNonSpace == boost::string_view::npos)
+            if (firstNonSpace == std::string_view::npos)
                 // We know there's at least one leading space.  So if we got
                 // npos, then it must be all spaces.  Return empty string_view.
                 return {};
@@ -178,7 +178,7 @@ extractIpAddrFromField(boost::string_view field)
                 c == ' ' || c == '\r' || c == '\n')
             {
                 std::size_t const lastNonSpace = ret.find_last_not_of(" \r\n");
-                if (lastNonSpace == boost::string_view::npos)
+                if (lastNonSpace == std::string_view::npos)
                     // We know there's at least one leading space.  So if we
                     // got npos, then it must be all spaces.
                     return {};
@@ -189,7 +189,7 @@ extractIpAddrFromField(boost::string_view field)
         return ret;
     };
 
-    boost::string_view ret = trim(field);
+    std::string_view ret = trim(field);
     if (ret.empty())
         return {};
 
@@ -251,13 +251,13 @@ extractIpAddrFromField(boost::string_view field)
 
     // If there's a port appended to the IP address, strip that by
     // terminating at the colon.
-    if (std::size_t colon = ret.find(':'); colon != boost::string_view::npos)
+    if (std::size_t colon = ret.find(':'); colon != std::string_view::npos)
         ret = ret.substr(0, colon);
 
     return ret;
 }
 
-boost::string_view
+std::string_view
 forwardedFor(http_request_type const& request)
 {
     // Look for the Forwarded field in the request.
@@ -286,10 +286,9 @@ forwardedFor(http_request_type const& request)
 
         // We found a "for=".  Scan for the end of the IP address.
         std::size_t const pos = [&found, &it]() {
-            std::size_t pos =
-                boost::string_view(found, it->value().end() - found)
-                    .find_first_of(",;");
-            if (pos != boost::string_view::npos)
+            std::size_t pos = std::string_view(found, it->value().end() - found)
+                                  .find_first_of(",;");
+            if (pos != std::string_view::npos)
                 return pos;
 
             return it->value().size() - forStr.size();
@@ -305,7 +304,10 @@ forwardedFor(http_request_type const& request)
         std::size_t found = it->value().find(',');
         if (found == boost::string_view::npos)
             found = it->value().length();
-        return extractIpAddrFromField(it->value().substr(0, found));
+        // http_request_type has a dependency on boost. Explicitly convert such
+        // boost::string_view into std::string_view
+        return extractIpAddrFromField(
+            std::string_view{it->value().substr(0, found).data(), found});
     }
 
     return {};

src/ripple/rpc/impl/ServerHandlerImp.cpp

@@ -559,8 +559,9 @@ ServerHandlerImp::processSession(
         [&] {
             auto const iter = session->request().find("X-User");
             if (iter != session->request().end())
-                return iter->value();
-            return boost::beast::string_view{};
+                return std::string_view{
+                    iter->value().data(), iter->value().length()};
+            return std::string_view{};
         }());
 
     if (beast::rfc2616::is_keep_alive(session->request()))
@@ -592,8 +593,8 @@ ServerHandlerImp::processRequest(
     beast::IP::Endpoint const& remoteIPAddress,
     Output&& output,
     std::shared_ptr<JobQueue::Coro> coro,
-    boost::string_view forwardedFor,
-    boost::string_view user)
+    std::string_view forwardedFor,
+    std::string_view user)
 {
     auto rpcJ = app_.journal("RPC");
 
@@ -847,8 +848,14 @@ ServerHandlerImp::processRequest(
          */
         if (role != Role::IDENTIFIED && role != Role::PROXY)
         {
-            forwardedFor.clear();
-            user.clear();
+            // Simulate the clearing of string_view through a swap. Is this a
+            // good candidate for std::string_view? This is due to a discrepency
+            // between boost::string_view versus std::string_view's APIs
+            //            forwardedFor.clear();
+            std::string_view empty_str;
+            forwardedFor.swap(empty_str);
+            //            user.clear();
+            user.swap(empty_str);
         }
 
         JLOG(m_journal.debug()) << "Query: " << strMethod << params;

src/ripple/rpc/impl/ServerHandlerImp.h

@@ -189,8 +189,8 @@ class ServerHandlerImp
         beast::IP::Endpoint const& remoteIPAddress,
         Output&&,
         std::shared_ptr<JobQueue::Coro> coro,
-        boost::string_view forwardedFor,
-        boost::string_view user);
+        std::string_view forwardedFor,
+        std::string_view user);
 
     Handoff
     statusResponse(http_request_type const& request) const;

src/ripple/rpc/impl/WSInfoSub.h

@@ -55,13 +55,13 @@ class WSInfoSub : public InfoSub
         }
     }
 
-    boost::string_view
+    std::string_view
     user() const
     {
         return user_;
     }
 
-    boost::string_view
+    std::string_view
     forwarded_for() const
     {
         return fwdfor_;