string.cpp

Go to the documentation of this file.

// Copyright (c) 2019-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#include <util/string.h>
 
#include <iterator>
#include <memory>
#include <stdexcept>
#include <string>
#include <string_view>
 
namespace util {
void ReplaceAll(std::string& in_out, std::string_view search, std::string_view substitute)
{
    if (search.empty()) return;
    auto pos{in_out.find(search)};
    if (pos == std::string::npos) return;
 
    // Build separately because repeated std::string::replace() calls move the remaining suffix when sizes differ
    std::string result;
    result.reserve(in_out.size());
    std::string::size_type start{0};
    for (; pos != std::string::npos; pos = in_out.find(search, start)) {
        result.append(in_out, start, pos - start).append(substitute);
        start = pos + search.size();
    }
    result.append(in_out, start);
    in_out.swap(result);
}
 
LineReader::LineReader(std::string_view str, size_t max_line_length)
    : m_str{str}, m_max_line_length{max_line_length}, m_it{str.begin()} {}
 
std::optional<std::string_view> LineReader::ReadLine()
{
    if (m_it == m_str.end()) {
        return std::nullopt;
    }
 
    const auto line_start = m_it;
    while (m_it != m_str.end()) {
        // Read a character from the incoming buffer and increment the iterator
        const bool new_line{*m_it == '\n'};
        ++m_it;
        // If the character we just consumed was \n, the line is terminated.
        // The \n itself does not count against max_line_length.
        if (new_line) {
            std::string_view line{line_start, m_it - 1};
            if (!line.empty() && line.back() == '\r')
                line.remove_suffix(1);
            return line;
        }
        // If the character we just consumed gives us a line length greater
        // than max_line_length, and we are not at the end of the line (or buffer) yet,
        // that means the line we are currently reading is too long, and we throw.
        if (static_cast<size_t>(std::distance(line_start, m_it)) > m_max_line_length) {
            // Reset iterator
            m_it = line_start;
            throw std::runtime_error("max_line_length exceeded by LineReader");
        }
    }
    // End of buffer reached without finding a \n or exceeding max_line_length.
    // Reset the iterator so the rest of the buffer can be read granularly
    // with ReadLength() and return null to indicate a line was not found.
    m_it = line_start;
    return std::nullopt;
}
 
// Ignores max_line_length but won't overflow
std::string_view LineReader::ReadLength(size_t len)
{
    if (len == 0) return {};
    if (Remaining() < len) throw std::runtime_error("Not enough data in buffer");
    std::string_view out(std::to_address(m_it), len);
    m_it += len;
    return out;
}
 
size_t LineReader::Remaining() const
{
    return std::distance(m_it, m_str.end());
}
 
size_t LineReader::Consumed() const
{
    return std::distance(m_str.begin(), m_it);
}
} // namespace util