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                 :        1395 : void ReplaceAll(std::string& in_out, const std::string& search, const std::string& substitute)
      12                 :             : {
      13         [ +  - ]:        1395 :     if (search.empty()) return;
      14         [ +  - ]:        1395 :     in_out = std::regex_replace(in_out, std::regex(search), substitute);
      15                 :             : }
      16                 :             : 
      17                 :           0 : LineReader::LineReader(std::span<const std::byte> buffer, size_t max_line_length)
      18                 :           0 :     : start(buffer.begin()), end(buffer.end()), max_line_length(max_line_length), it(buffer.begin()) {}
      19                 :             : 
      20                 :           0 : std::optional<std::string> LineReader::ReadLine()
      21                 :             : {
      22         [ #  # ]:           0 :     if (it == end) {
      23                 :           0 :         return std::nullopt;
      24                 :             :     }
      25                 :             : 
      26                 :           0 :     auto line_start = it;
      27                 :           0 :     size_t count = 0;
      28         [ #  # ]:           0 :     while (it != end) {
      29                 :             :         // Read a character from the incoming buffer and increment the iterator
      30                 :           0 :         auto c = static_cast<char>(*it);
      31         [ #  # ]:           0 :         ++it;
      32                 :           0 :         ++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         [ #  # ]:           0 :         if (c == '\n') {
      36                 :           0 :             const std::string_view untrimmed_line(reinterpret_cast<const char*>(std::to_address(line_start)), count);
      37                 :           0 :             const std::string_view line = TrimStringView(untrimmed_line); // delete leading and trailing whitespace including \r and \n
      38                 :           0 :             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         [ #  # ]:           0 :         if (count > max_line_length) {
      44                 :             :             // Reset iterator
      45                 :           0 :             it = line_start;
      46         [ #  # ]:           0 :             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                 :           0 :     it = line_start;
      53                 :           0 :     return std::nullopt;
      54                 :             : }
      55                 :             : 
      56                 :             : // Ignores max_line_length but won't overflow
      57                 :           0 : std::string LineReader::ReadLength(size_t len)
      58                 :             : {
      59         [ #  # ]:           0 :     if (len == 0) return "";
      60   [ #  #  #  # ]:           0 :     if (Remaining() < len) throw std::runtime_error("Not enough data in buffer");
      61                 :           0 :     std::string out(reinterpret_cast<const char*>(std::to_address(it)), len);
      62                 :           0 :     it += len;
      63                 :           0 :     return out;
      64                 :           0 : }
      65                 :             : 
      66                 :           0 : size_t LineReader::Remaining() const
      67                 :             : {
      68                 :           0 :     return std::distance(it, end);
      69                 :             : }
      70                 :             : } // namespace util