small_string.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// 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/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <seqan3/range/container/small_vector.hpp>
 
namespace seqan3
{
 
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::value_type;
    using typename base_t::reference;
    using typename base_t::const_reference;
    using typename base_t::iterator;
    using typename base_t::const_iterator;
    using typename base_t::difference_type;
    using typename base_t::size_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);
    }
 
    explicit constexpr small_string(char const c) noexcept : small_string{}
    {
        assign(1, c);
    }
 
    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, /*ranges::iter_reference_t*/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';
    }
 
    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 char const * c_str() const noexcept
    {
        return data_.data();
    }
 
    operator std::string() const
    {
        return str();
    }
 
    friend std::ostream & operator<<(std::ostream & os, small_string const & str)
    {
        os << str.str();
        return os;
    }
 
    friend std::istream & operator>>(std::istream & is, small_string & str)
    {
        // Check if stream is ok and skip leading whitespaces.
        std::istream::sentry s(is);
        if (s)
        {
            str.erase(); // clear the string
            std::streamsize num_char = (is.width() > 0)
                ? std::min<std::streamsize>(is.width(), str.max_size())
                : str.max_size();
            assert(num_char > 0);
            for (std::streamsize n = num_char; n > 0 && !std::isspace(static_cast<char>(is.peek()), is.getloc()); --n)
            {
                char c = is.get();
                if (is.eof())
                    break;
                str.push_back(c);
            }
 
            if (str.size() == 0) // nothing extracted so we set the fail bit.
                is.setstate(std::ios_base::failbit);
 
            is.width(0); // cancel the effects of std::setw, if any.
        }
 
        return is;
    }
};
 
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>;
 
small_string(char const) -> small_string<1>;
 
} // namespace seqan3