small_string.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/utils/small_string.hpp
/// @brief @copybrief utils::SmallString
 
#include <cstddef>
#include <functional>
#include <stdexcept>
#include <string>
 
#include <boost/container/small_vector.hpp>
 
#include <userver/utils/assert.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace utils {
 
/// @ingroup userver_universal userver_containers
///
/// @brief An alternative to std::string with a custom SSO (small string
/// optimization) container size. Unlike std::string, SmallString is not
/// null-terminated thus it has no c_str(), data() returns a not null-terminated
/// buffer.
template <std::size_t N>
class SmallString final {
    using Container = boost::container::small_vector<char, N>;
 
public:
    using value_type = char;
 
    /// @brief Create empty string.
    SmallString() = default;
 
    /// @brief Create a string from another one.
    SmallString(const SmallString<N>&) = default;
 
    /// @brief Create a string from another one.
    explicit SmallString(SmallString<N>&&) noexcept = default;
 
    /// @brief Create a string from std::string_view.
    explicit SmallString(std::string_view sv);
 
    /// @brief Assign the value of other string_view to this string.
    SmallString& operator=(std::string_view sv);
 
    /// @brief Assign the value of other string to this string.
    SmallString& operator=(const SmallString&) = default;
 
    /// @brief Assign the value of other string to this string.
    SmallString& operator=(SmallString&&) noexcept = default;
 
    SmallString& operator+=(std::string_view sv) {
        append(sv);
        return *this;
    }
 
    SmallString& operator+=(char c) {
        push_back(c);
        return *this;
    }
 
    /// @brief Convert string to a std::string_view.
    operator std::string_view() const;
 
    /// @brief Read-only subscript access to the data contained in the string.
    const char& operator[](std::size_t pos) const;
 
    /// @brief Subscript access to the data contained in the string.
    char& operator[](std::size_t pos);
 
    /// @brief Provides access to the data contained in the string.
    const char& at(std::size_t pos) const;
 
    /// @brief Provides access to the data contained in the string.
    char& at(std::size_t pos);
 
    using iterator = typename Container::iterator;
 
    using const_iterator = typename Container::const_iterator;
 
    iterator begin() noexcept;
    const_iterator begin() const noexcept;
 
    iterator end() noexcept;
    const_iterator end() const noexcept;
 
    /// @brief Get string size.
    std::size_t size() const noexcept;
 
    /// @brief Get pointer to data.
    /// @warning The buffer is not null-terminated.
    const char* data() const noexcept;
 
    /// @brief Get pointer to data.
    /// @warning The buffer is not null-terminated.
    char* data() noexcept;
 
    /// @brief Resize the string. If its length is increased,
    /// fill new chars with %c.
    void resize(std::size_t n, char c);
 
    /// @brief Resize the string. If its length is increased,
    /// fill new chars with \0.
    void resize(std::size_t n);
 
    /// @brief Resize the string. Use op to write into the string and replace a
    /// sequence of characters
    template <class Operation>
    void resize_and_overwrite(std::size_t size, Operation op);
 
    /// @brief Shrink the string's size to fit all contents
    void shrink_to_fit();
 
    /// @brief Get current capacity.
    std::size_t capacity() const noexcept;
 
    /// @brief Reserve to %n bytes.
    void reserve(std::size_t n);
 
    /// @brief Clear the string.
    void clear() noexcept;
 
    /// @brief Is the string empty?
    bool empty() const noexcept;
 
    /// @brief Get a reference to the first character.
    char& front();
 
    /// @brief Get a reference to the first character.
    const char& front() const;
 
    /// @brief Get a reference to the last character.
    char& back();
 
    /// @brief Get a reference to the last character.
    const char& back() const;
 
    /// @brief Append a character to the string.
    void push_back(char c);
 
    /// @brief Append contents of a string_view to the string.
    void append(std::string_view str);
 
    /// @brief Append contents of a begin...end to the string.
    void append(const char* begin, const char* end);
 
    /// @brief Inserts elements from range [begin, end) before pos.
    template <class InputIt>
    void insert(const_iterator pos, InputIt begin, InputIt end);
 
    /// @brief Remove the last character from the string.
    void pop_back();
 
private:
    boost::container::small_vector<char, N> data_;
};
class SmallString final {…};
 
template <std::size_t N>
SmallString<N>::SmallString(std::string_view sv) : data_(sv.begin(), sv.end()) {}
 
template <std::size_t N>
SmallString<N>::operator std::string_view() const {
    return std::string_view{data_.data(), data_.size()};
}
SmallString<N>::operator std::string_view() const {…}
 
template <std::size_t N>
SmallString<N>& SmallString<N>::operator=(std::string_view sv) {
    data_ = {sv.begin(), sv.end()};
    return *this;
}
SmallString<N>& SmallString<N>::operator=(std::string_view sv) {…}
 
template <std::size_t N>
bool operator==(const SmallString<N>& str, std::string_view sv) {
    return std::string_view{str} == sv;
}
 
template <std::size_t N>
bool operator==(std::string_view sv, const SmallString<N>& str) {
    return std::string_view{str} == sv;
}
 
template <std::size_t N>
bool operator==(const SmallString<N>& str1, const SmallString<N>& str2) {
    return std::string_view{str1} == std::string_view{str2};
}
 
template <std::size_t N>
bool operator!=(const SmallString<N>& str1, const SmallString<N>& str2) {
    return !(str1 == str2);
}
 
template <std::size_t N>
const char& SmallString<N>::operator[](std::size_t pos) const {
    return data_[pos];
}
const char& SmallString<N>::operator[](std::size_t pos) const {…}
 
template <std::size_t N>
char& SmallString<N>::operator[](std::size_t pos) {
    return data_[pos];
}
char& SmallString<N>::operator[](std::size_t pos) {…}
 
template <std::size_t N>
const char& SmallString<N>::at(std::size_t pos) const {
    if (size() <= pos) throw std::out_of_range("at");
    return data_[pos];
}
const char& SmallString<N>::at(std::size_t pos) const {…}
 
template <std::size_t N>
char& SmallString<N>::at(std::size_t pos) {
    if (size() <= pos) throw std::out_of_range("at");
    return data_[pos];
}
char& SmallString<N>::at(std::size_t pos) {…}
 
template <std::size_t N>
typename SmallString<N>::iterator SmallString<N>::begin() noexcept {
    return {data_.begin()};
}
 
template <std::size_t N>
typename SmallString<N>::const_iterator SmallString<N>::begin() const noexcept {
    return {data_.begin()};
}
 
template <std::size_t N>
typename SmallString<N>::iterator SmallString<N>::end() noexcept {
    return {data_.end()};
}
 
template <std::size_t N>
typename SmallString<N>::const_iterator SmallString<N>::end() const noexcept {
    return {data_.end()};
}
 
template <std::size_t N>
std::size_t SmallString<N>::size() const noexcept {
    return data_.size();
}
std::size_t SmallString<N>::size() const noexcept {…}
 
template <std::size_t N>
const char* SmallString<N>::data() const noexcept {
    return data_.data();
}
const char* SmallString<N>::data() const noexcept {…}
 
template <std::size_t N>
char* SmallString<N>::data() noexcept {
    return data_.data();
}
char* SmallString<N>::data() noexcept {…}
 
template <std::size_t N>
bool SmallString<N>::empty() const noexcept {
    return data_.empty();
}
bool SmallString<N>::empty() const noexcept {…}
 
template <std::size_t N>
char& SmallString<N>::front() {
    return data_.front();
}
char& SmallString<N>::front() {…}
 
template <std::size_t N>
const char& SmallString<N>::front() const {
    return data_.front();
}
const char& SmallString<N>::front() const {…}
 
template <std::size_t N>
char& SmallString<N>::back() {
    return data_.back();
}
char& SmallString<N>::back() {…}
 
template <std::size_t N>
const char& SmallString<N>::back() const {
    return data_.back();
}
const char& SmallString<N>::back() const {…}
 
template <std::size_t N>
void SmallString<N>::push_back(char c) {
    data_.push_back(c);
}
void SmallString<N>::push_back(char c) {…}
 
template <std::size_t N>
void SmallString<N>::append(std::string_view str) {
    std::size_t old_size = data_.size();
    data_.insert(data_.begin() + old_size, str.begin(), str.end());
}
void SmallString<N>::append(std::string_view str) {…}
 
template <std::size_t N>
void SmallString<N>::append(const char* begin, const char* end) {
    append(std::string_view{begin, static_cast<std::size_t>(end - begin)});
}
void SmallString<N>::append(const char* begin, const char* end) {…}
 
template <std::size_t N>
template <class InputIt>
void SmallString<N>::insert(SmallString::const_iterator pos, InputIt begin, InputIt end) {
    data_.insert(pos, begin, end);
}
void SmallString<N>::insert(SmallString::const_iterator pos, InputIt begin, InputIt end) {…}
 
template <std::size_t N>
void SmallString<N>::pop_back() {
    data_.pop_back();
}
void SmallString<N>::pop_back() {…}
 
template <std::size_t N>
void SmallString<N>::resize(std::size_t n, char c) {
    data_.resize(n, c);
}
void SmallString<N>::resize(std::size_t n, char c) {…}
 
template <std::size_t N>
void SmallString<N>::resize(std::size_t n) {
    resize(n, '\0');
}
void SmallString<N>::resize(std::size_t n) {…}
 
template <std::size_t N>
template <class Operation>
void SmallString<N>::resize_and_overwrite(std::size_t size, Operation op) {
    data_.resize(size, boost::container::default_init);
    data_.resize(std::move(op)(data_.data(), size), boost::container::default_init);
    UASSERT(data_.size() <= size);
}
void SmallString<N>::resize_and_overwrite(std::size_t size, Operation op) {…}
 
template <std::size_t N>
void SmallString<N>::shrink_to_fit() {
    data_.shrink_to_fit();
}
void SmallString<N>::shrink_to_fit() {…}
 
template <std::size_t N>
std::size_t SmallString<N>::capacity() const noexcept {
    return data_.capacity();
}
std::size_t SmallString<N>::capacity() const noexcept {…}
 
template <std::size_t N>
void SmallString<N>::reserve(std::size_t n) {
    return data_.reserve(n);
}
void SmallString<N>::reserve(std::size_t n) {…}
 
template <std::size_t N>
void SmallString<N>::clear() noexcept {
    data_.clear();
}
void SmallString<N>::clear() noexcept {…}
 
}  // namespace utils
 
USERVER_NAMESPACE_END
 
template <std::size_t N>
struct std::hash<USERVER_NAMESPACE::utils::SmallString<N>> {
    std::size_t operator()(const USERVER_NAMESPACE::utils::SmallString<N>& s) const noexcept {
        return std::hash<std::string_view>{}(std::string_view{s});
    }
};
struct std::hash<USERVER_NAMESPACE::utils::SmallString<N>> {…};