small_string.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2022 deCODE Genetics
// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/biocpp/biocpp-core/blob/main/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <bio/ranges/container/small_vector.hpp>
 
namespace bio::ranges
{
 
template <size_t capacity_>
class small_string : public small_vector<char, capacity_ + 1>
{
private:
    using base_t = small_vector<char, capacity_ + 1>;
 
    // make data inherited members visible
    using base_t::data_;
    using base_t::sz;
 
public:
    using typename base_t::const_iterator;
    using typename base_t::const_reference;
    using typename base_t::difference_type;
    using typename base_t::iterator;
    using typename base_t::reference;
    using typename base_t::size_type;
    using typename base_t::value_type;
 
    using base_t::base_t;
    using base_t::assign;
 
    template <size_t N>
    constexpr small_string(char const (&_lit)[N]) noexcept : small_string{}
    {
        static_assert(N <= capacity_ + 1, "Length of string literal exceeds capacity of small_string.");
        assign(_lit);
    }
 
    template <size_t N>
    constexpr small_string & operator=(char const (&_lit)[N]) noexcept
    {
        static_assert(N <= capacity_ + 1, "Length of string literal exceeds capacity of small_string.");
        assign(_lit);
        return *this;
    }
 
    template <size_t N>
    constexpr void assign(char const (&_lit)[N]) noexcept
    {
        static_assert(N <= capacity_ + 1, "Length of string literal exceeds capacity of small_string.");
        assert(_lit[N - 1] == '\0');
        assign(&_lit[0], &_lit[N - 1]);
    }
 
    template <std::forward_iterator begin_it_type, typename end_it_type>
        requires(std::sentinel_for<end_it_type, begin_it_type> &&
                 std::constructible_from<value_type, std::iter_reference_t<begin_it_type>>)
    constexpr void assign(begin_it_type begin_it, end_it_type end_it) noexcept
    {
        base_t::assign(begin_it, end_it);
        data_[sz] = '\0';
    }
 
#ifdef __clang__
    constexpr void assign(char const * const begin_it, char const * const end_it) noexcept
    {
        base_t::assign(begin_it, end_it);
        data_[sz] = '\0';
    }
#endif
 
    static constexpr size_type max_size() noexcept { return capacity_; }
 
    static constexpr size_type capacity() noexcept { return capacity_; }
 
    constexpr void clear() noexcept
    {
        sz       = 0;
        data_[0] = '\0';
    }
 
    constexpr void push_back(char const value) noexcept
    {
        assert(sz < capacity_);
        data_[sz] = value;
        ++sz;
        data_[sz] = '\0';
    }
 
    constexpr void pop_back() noexcept
    {
        assert(sz > 0);
        --sz;
        data_[sz] = '\0';
    }
 
    constexpr void resize(size_type const count) noexcept { resize(count, '\0'); }
 
    constexpr void resize(size_type const count, char const value) noexcept
    {
        assert(count <= capacity_);
 
        for (size_t i = sz; i < count; ++i) // sz < count; add `value` in [sz, count)
            data_[i] = value;
 
        sz        = count;
        data_[sz] = '\0';
    }
 
    constexpr small_string & erase(size_type index = 0, size_type count = max_size()) noexcept
    {
        assert(index <= this->size());
 
        iterator it = this->begin() + index;
        base_t::erase(it, it + std::min<size_type>(count, this->size() - index));
        return *this;
    }
 
    template <size_t capacity2>
    constexpr friend small_string<capacity_ + capacity2> operator+(small_string const &            lhs,
                                                                   small_string<capacity2> const & rhs) noexcept
    {
        small_string<capacity_ + capacity2> tmp{lhs};
        tmp.insert(tmp.end(), rhs.begin(), rhs.end());
        return tmp;
    }
 
    std::string str() const { return std::string{this->cbegin(), this->cend()}; }
 
    constexpr std::string_view view() const { return std::string_view{data_.data(), this->size()}; }
 
    constexpr char const * c_str() const noexcept { return data_.data(); }
 
    constexpr operator std::string_view() const { return view(); }
 
    template <size_t cap2>
    friend constexpr bool operator==(small_string const & lhs, small_string<cap2> const & rhs) noexcept
    {
        return operator==(lhs.view(), rhs.view());
    }
 
    template <size_t cap2>
    friend constexpr auto operator<=>(small_string const & lhs, small_string<cap2> const & rhs) noexcept
    {
        return operator<=>(lhs.view(), rhs.view());
    }
 
    friend constexpr bool operator==(small_string const & lhs, std::string_view const & rhs) noexcept
    {
        return operator==(lhs.view(), rhs);
    }
 
    friend constexpr auto operator<=>(small_string const & lhs, std::string_view const & rhs) noexcept
    {
        return operator<=>(lhs.view(), rhs);
    }
 
    friend std::ostream & operator<<(std::ostream & os, small_string const & str)
    {
        os << str.str();
        return os;
    }
};
 
template <size_t N>
small_string(char const (&)[N]) -> small_string<N - 1>;
 
template <size_t N>
small_string(std::array<char, N> const &) -> small_string<N>;
 
template <std::same_as<char>... t>
    requires(sizeof...(t) > 0)
small_string(t const... chars) -> small_string<sizeof...(chars)>;
 
} // namespace bio::ranges
 
#if __has_include(<fmt/format.h>)
 
#    include <fmt/ranges.h>
 
template <size_t N>
struct fmt::formatter<bio::ranges::small_string<N>> : fmt::formatter<std::string_view>
{
    constexpr auto format(bio::ranges::small_string<N> const & a, auto & ctx) const
    {
        return fmt::formatter<std::string_view>::format(std::string_view{a.data(), a.size()}, ctx);
    }
};
 
#endif
 
template <size_t capacity>
    requires(capacity <= 30) // -> sizeof(small_string) <= 32
inline constexpr bool std::ranges::enable_view<bio::ranges::small_string<capacity>> = true;