Branch data     Line data    Source code

       1                 :             : // Copyright (c) 2019-present The Bitcoin Core developers
       2                 :             : // Distributed under the MIT software license, see the accompanying
       3                 :             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4                 :             : 
       5                 :             : #include <util/string.h>
       6                 :             : 
       7                 :             : #include <regex>
       8                 :             : #include <string>
       9                 :             : 
      10                 :             : namespace util {
      11                 :          10 : void ReplaceAll(std::string& in_out, const std::string& search, const std::string& substitute)
      12                 :             : {
      13         [ +  + ]:          10 :     if (search.empty()) return;
      14         [ +  - ]:           8 :     in_out = std::regex_replace(in_out, std::regex(search), substitute);
      15                 :             : }
      16                 :             : 
      17                 :          10 : LineReader::LineReader(std::span<const std::byte> buffer, size_t max_line_length)
      18                 :          10 :     : start(buffer.begin()), end(buffer.end()), max_line_length(max_line_length), it(buffer.begin()) {}
      19                 :             : 
      20                 :          22 : std::optional<std::string> LineReader::ReadLine()
      21                 :             : {
      22         [ +  + ]:          22 :     if (it == end) {
      23                 :           6 :         return std::nullopt;
      24                 :             :     }
      25                 :             : 
      26                 :          16 :     auto line_start = it;
      27                 :          16 :     size_t count = 0;
      28         [ +  + ]:         182 :     while (it != end) {
      29                 :             :         // Read a character from the incoming buffer and increment the iterator
      30                 :         181 :         auto c = static_cast<char>(*it);
      31         [ +  + ]:         181 :         ++it;
      32                 :         181 :         ++count;
      33                 :             :         // If the character we just consumed was \n, the line is terminated.
      34                 :             :         // The \n itself does not count against max_line_length.
      35         [ +  + ]:         181 :         if (c == '\n') {
      36                 :          11 :             const std::string_view untrimmed_line(reinterpret_cast<const char*>(std::to_address(line_start)), count);
      37                 :          11 :             const std::string_view line = TrimStringView(untrimmed_line); // delete leading and trailing whitespace including \r and \n
      38                 :          22 :             return std::string(line);
      39                 :             :         }
      40                 :             :         // If the character we just consumed gives us a line length greater
      41                 :             :         // than max_line_length, and we are not at the end of the line (or buffer) yet,
      42                 :             :         // that means the line we are currently reading is too long, and we throw.
      43         [ +  + ]:         170 :         if (count > max_line_length) {
      44                 :             :             // Reset iterator
      45                 :           4 :             it = line_start;
      46         [ +  - ]:           4 :             throw std::runtime_error("max_line_length exceeded by LineReader");
      47                 :             :         }
      48                 :             :     }
      49                 :             :     // End of buffer reached without finding a \n or exceeding max_line_length.
      50                 :             :     // Reset the iterator so the rest of the buffer can be read granularly
      51                 :             :     // with ReadLength() and return null to indicate a line was not found.
      52                 :           1 :     it = line_start;
      53                 :           1 :     return std::nullopt;
      54                 :             : }
      55                 :             : 
      56                 :             : // Ignores max_line_length but won't overflow
      57                 :          11 : std::string LineReader::ReadLength(size_t len)
      58                 :             : {
      59         [ +  + ]:          11 :     if (len == 0) return "";
      60   [ +  +  +  - ]:          10 :     if (Remaining() < len) throw std::runtime_error("Not enough data in buffer");
      61                 :           9 :     std::string out(reinterpret_cast<const char*>(std::to_address(it)), len);
      62                 :           9 :     it += len;
      63                 :           9 :     return out;
      64                 :           9 : }
      65                 :             : 
      66                 :          14 : size_t LineReader::Remaining() const
      67                 :             : {
      68                 :          14 :     return std::distance(it, end);
      69                 :             : }
      70                 :             : } // namespace util