/usr/include/boost/static_string
Edit: /usr/include/boost/static_string/static_string.hpp (170313B)
//
// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
// Copyright (c) 2019-2020 Krystian Stasiowski (sdkrystian at gmail dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Official repository: https://github.com/boostorg/static_string
//
#ifndef BOOST_STATIC_STRING_STATIC_STRING_HPP
#define BOOST_STATIC_STRING_STATIC_STRING_HPP
// External include guard
#ifndef BOOST_STATIC_STRING_CONFIG_HPP
#include
#endif
#include
#include
#include
#include
#include
#include
#include
#include
namespace boost {
namespace static_strings {
#ifndef BOOST_STATIC_STRING_DOCS
template
class basic_static_string;
//------------------------------------------------------------------------------
//
// Aliases
//
//------------------------------------------------------------------------------
template
using static_string =
basic_static_string>;
template
using static_wstring =
basic_static_string>;
template
using static_u16string =
basic_static_string>;
template
using static_u32string =
basic_static_string>;
#ifdef BOOST_STATIC_STRING_CPP20
template
using static_u8string =
basic_static_string>;
#endif
//--------------------------------------------------------------------------
//
// Detail
//
//--------------------------------------------------------------------------
namespace detail {
// Find the smallest width integral type that can hold a value as large as N (Glen Fernandes)
template
using smallest_width =
typename std::conditional<(N <= (std::numeric_limits::max)()), unsigned char,
typename std::conditional<(N <= (std::numeric_limits::max)()), unsigned short,
typename std::conditional<(N <= (std::numeric_limits::max)()), unsigned int,
typename std::conditional<(N <= (std::numeric_limits::max)()), unsigned long,
typename std::conditional<(N <= (std::numeric_limits::max)()), unsigned long long,
std::size_t>::type>::type>::type>::type>::type;
// std::is_nothrow_convertible is C++20
template
void is_nothrow_convertible_helper(To) noexcept;
// MSVC is unable to parse this as a single expression, so a helper is needed
template(std::declval()))>
struct is_nothrow_convertible_msvc_helper
{
static const bool value =
noexcept(is_nothrow_convertible_helper(std::declval()));
};
template
struct is_nothrow_convertible
: std::false_type { };
template
struct is_nothrow_convertible::value>::type>
: std::true_type { };
// GCC 4.8, 4.9 workaround for void_t to make the defining-type-id dependant
template
struct void_t_helper
{
using type = void;
};
// void_t for c++11
template
using void_t = typename void_t_helper::type;
// Check if a type can be used for templated
// overloads string_view_type
template
struct enable_if_viewable { };
template
struct enable_if_viewable>::value &&
!std::is_convertible::value>::type>
{
using type = void;
};
template
using enable_if_viewable_t = typename enable_if_viewable::type;
// Simplified check for if a type is an iterator
template
struct is_iterator : std::false_type { };
template
struct is_iterator::value,
void_t>::type>
: std::true_type { };
template
struct is_iterator
: std::true_type { };
template
struct is_input_iterator : std::false_type { };
template
struct is_input_iterator::value &&
std::is_convertible::iterator_category,
std::input_iterator_tag>::value>::type>
: std::true_type { };
template
struct is_forward_iterator : std::false_type { };
template
struct is_forward_iterator::value &&
std::is_convertible::iterator_category,
std::forward_iterator_tag>::value>::type>
: std::true_type { };
template
struct is_subtractable
: std::false_type { };
template
struct is_subtractable() - std::declval())>>
: std::true_type { };
// constexpr distance for c++14
template<
typename ForwardIt,
typename std::enable_if::value>::type* = nullptr>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
std::size_t
distance(ForwardIt first, ForwardIt last)
{
std::size_t dist = 0;
for (; first != last; ++first, ++dist);
return dist;
}
template<
typename RandomIt,
typename std::enable_if::value>::type* = nullptr>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
std::size_t
distance(RandomIt first, RandomIt last)
{
return last - first;
}
// Copy using traits, respecting iterator rules
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
copy_with_traits(
InputIt first,
InputIt last,
CharT* out)
{
for (; first != last; ++first, ++out)
Traits::assign(*out, *first);
}
// Optimization for using the smallest possible type
template
class static_string_base
{
private:
using size_type = smallest_width;
using value_type = typename Traits::char_type;
using pointer = value_type*;
using const_pointer = const value_type*;
public:
BOOST_STATIC_STRING_CPP11_CONSTEXPR
static_string_base() noexcept { };
BOOST_STATIC_STRING_CPP14_CONSTEXPR
pointer
data_impl() noexcept
{
return data_;
}
BOOST_STATIC_STRING_CPP14_CONSTEXPR
const_pointer
data_impl() const noexcept
{
return data_;
}
BOOST_STATIC_STRING_CPP11_CONSTEXPR
std::size_t
size_impl() const noexcept
{
return size_;
}
BOOST_STATIC_STRING_CPP14_CONSTEXPR
std::size_t
set_size(std::size_t n) noexcept
{
// Functions that set size will throw
// if the new size would exceed max_size()
// therefore we can guarantee that this will
// not lose data.
return size_ = size_type(n);
}
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
term_impl() noexcept
{
Traits::assign(data_[size_], value_type());
}
size_type size_ = 0;
#ifdef BOOST_STATIC_STRING_CPP20
value_type data_[N + 1];
#else
value_type data_[N + 1]{};
#endif
};
// Optimization for when the size is 0
template
class static_string_base<0, CharT, Traits>
{
private:
using value_type = typename Traits::char_type;
using pointer = value_type*;
public:
BOOST_STATIC_STRING_CPP11_CONSTEXPR
static_string_base() noexcept { }
// Modifying the null terminator is UB
BOOST_STATIC_STRING_CPP11_CONSTEXPR
pointer
data_impl() const noexcept
{
return const_cast(&null_);
}
BOOST_STATIC_STRING_CPP11_CONSTEXPR
std::size_t
size_impl() const noexcept
{
return 0;
}
BOOST_STATIC_STRING_CPP11_CONSTEXPR
std::size_t
set_size(std::size_t) const noexcept
{
return 0;
}
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
term_impl() const noexcept { }
private:
static constexpr const value_type null_{};
};
// This is only needed in C++14 and lower.
// see http://eel.is/c++draft/depr.static.constexpr
#ifndef BOOST_STATIC_STRING_CPP17
template
constexpr
const
typename static_string_base<0, CharT, Traits>::value_type
static_string_base<0, CharT, Traits>::
null_;
#endif
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
inline
int
lexicographical_compare(
const CharT* s1,
std::size_t n1,
const CharT* s2,
std::size_t n2) noexcept
{
if(n1 < n2)
return Traits::compare(
s1, s2, n1) <= 0 ? -1 : 1;
if(n1 > n2)
return Traits::compare(
s1, s2, n2) >= 0 ? 1 : -1;
return Traits::compare(s1, s2, n1);
}
template
inline
char*
integer_to_string(
char* str_end,
Integer value,
std::true_type) noexcept
{
if (value == 0)
{
Traits::assign(*--str_end, '0');
return str_end;
}
if (value < 0)
{
const bool is_min = value == std::numeric_limits::min();
// negation of a min value cannot be represented
if (is_min)
value = std::numeric_limits::max();
else
value = -value;
const auto last_char = str_end - 1;
for (; value > 0; value /= 10)
Traits::assign(*--str_end, "0123456789"[value % 10]);
// minimum values are powers of 2, so it will
// never terminate with a 9.
if (is_min)
Traits::assign(*last_char, Traits::to_char_type(
Traits::to_int_type(*last_char) + 1));
Traits::assign(*--str_end, '-');
return str_end;
}
for (; value > 0; value /= 10)
Traits::assign(*--str_end, "0123456789"[value % 10]);
return str_end;
}
template
inline
char*
integer_to_string(
char* str_end,
Integer value,
std::false_type) noexcept
{
if (value == 0)
{
Traits::assign(*--str_end, '0');
return str_end;
}
for (; value > 0; value /= 10)
Traits::assign(*--str_end, "0123456789"[value % 10]);
return str_end;
}
template
inline
wchar_t*
integer_to_wstring(
wchar_t* str_end,
Integer value,
std::true_type) noexcept
{
if (value == 0)
{
Traits::assign(*--str_end, L'0');
return str_end;
}
if (value < 0)
{
const bool is_min = value == std::numeric_limits::min();
// negation of a min value cannot be represented
if (is_min)
value = std::numeric_limits::max();
else
value = -value;
const auto last_char = str_end - 1;
for (; value > 0; value /= 10)
Traits::assign(*--str_end, L"0123456789"[value % 10]);
// minimum values are powers of 2, so it will
// never terminate with a 9.
if (is_min)
Traits::assign(*last_char, Traits::to_char_type(
Traits::to_int_type(*last_char) + 1));
Traits::assign(*--str_end, L'-');
return str_end;
}
for (; value > 0; value /= 10)
Traits::assign(*--str_end, L"0123456789"[value % 10]);
return str_end;
}
template
inline
wchar_t*
integer_to_wstring(
wchar_t* str_end,
Integer value,
std::false_type) noexcept
{
if (value == 0)
{
Traits::assign(*--str_end, L'0');
return str_end;
}
for (; value > 0; value /= 10)
Traits::assign(*--str_end, L"0123456789"[value % 10]);
return str_end;
}
template
inline
static_string
to_static_string_int_impl(Integer value) noexcept
{
char buffer[N];
const auto digits_end = std::end(buffer);
const auto digits_begin = integer_to_string, Integer>(
digits_end, value, std::is_signed{});
return static_string(digits_begin, std::distance(digits_begin, digits_end));
}
template
inline
static_wstring
to_static_wstring_int_impl(Integer value) noexcept
{
wchar_t buffer[N];
const auto digits_end = std::end(buffer);
const auto digits_begin = integer_to_wstring, Integer>(
digits_end, value, std::is_signed{});
return static_wstring(digits_begin, std::distance(digits_begin, digits_end));
}
BOOST_STATIC_STRING_CPP11_CONSTEXPR
inline
int
count_digits(std::size_t value)
{
return value < 10 ? 1 : count_digits(value / 10) + 1;
}
// Ignore -Wformat-truncation, we know what
// we are doing here. The version check does
// not need to be extremely precise.
#if defined(__GNUC__) && __GNUC__ >= 7
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-truncation"
#endif
template
inline
static_string
to_static_string_float_impl(double value) noexcept
{
// we have to assume here that no reasonable implementation
// will require more than 2^63 chars to represent a float value.
const long long narrow =
static_cast(N);
// extra one needed for null terminator
char buffer[N + 1];
// we know that a formatting error will not occur, so
// we assume that the result is always positive
if (std::size_t(std::snprintf(buffer, N + 1, "%f", value)) > N)
{
// the + 4 is for the decimal, 'e',
// its sign, and the sign of the integral portion
const int reserved_count =
(std::max)(2, count_digits(
std::numeric_limits::max_exponent10)) + 4;
const int precision = narrow > reserved_count ?
N - reserved_count : 0;
// switch to scientific notation
std::snprintf(buffer, N + 1, "%.*e", precision, value);
}
// this will not throw
return static_string(buffer);
}
template
inline
static_string
to_static_string_float_impl(long double value) noexcept
{
// we have to assume here that no reasonable implementation
// will require more than 2^63 chars to represent a float value.
const long long narrow =
static_cast(N);
// extra one needed for null terminator
char buffer[N + 1];
// snprintf returns the number of characters
// that would have been written
// we know that a formatting error will not occur, so
// we assume that the result is always positive
if (std::size_t(std::snprintf(buffer, N + 1, "%Lf", value)) > N)
{
// the + 4 is for the decimal, 'e',
// its sign, and the sign of the integral portion
const int reserved_count =
(std::max)(2, count_digits(
std::numeric_limits::max_exponent10)) + 4;
const int precision = narrow > reserved_count ?
N - reserved_count : 0;
// switch to scientific notation
std::snprintf(buffer, N + 1, "%.*Le", precision, value);
}
// this will not throw
return static_string(buffer);
}
template
inline
static_wstring
to_static_wstring_float_impl(double value) noexcept
{
// we have to assume here that no reasonable implementation
// will require more than 2^63 chars to represent a float value.
const long long narrow =
static_cast(N);
// extra one needed for null terminator
wchar_t buffer[N + 1];
// swprintf returns a negative number if it can't
// fit all the characters in the buffer.
// mingw has a non-standard swprintf, so
// this just covers all the bases. short
// circuit evaluation will ensure that the
// second operand is not evaluated on conforming
// implementations.
const long long num_written =
std::swprintf(buffer, N + 1, L"%f", value);
if (num_written < 0 ||
num_written > narrow)
{
// the + 4 is for the decimal, 'e',
// its sign, and the sign of the integral portion
const int reserved_count =
(std::max)(2, count_digits(
std::numeric_limits::max_exponent10)) + 4;
const int precision = narrow > reserved_count ?
N - reserved_count : 0;
// switch to scientific notation
std::swprintf(buffer, N + 1, L"%.*e", precision, value);
}
// this will not throw
return static_wstring(buffer);
}
template
inline
static_wstring
to_static_wstring_float_impl(long double value) noexcept
{
// we have to assume here that no reasonable implementation
// will require more than 2^63 chars to represent a float value.
const long long narrow =
static_cast(N);
// extra one needed for null terminator
wchar_t buffer[N + 1];
// swprintf returns a negative number if it can't
// fit all the characters in the buffer.
// mingw has a non-standard swprintf, so
// this just covers all the bases. short
// circuit evaluation will ensure that the
// second operand is not evaluated on conforming
// implementations.
const long long num_written =
std::swprintf(buffer, N + 1, L"%Lf", value);
if (num_written < 0 ||
num_written > narrow)
{
// the + 4 is for the decimal, 'e',
// its sign, and the sign of the integral portion
const int reserved_count =
(std::max)(2, count_digits(
std::numeric_limits::max_exponent10)) + 4;
const int precision = narrow > reserved_count ?
N - reserved_count : 0;
// switch to scientific notation
std::swprintf(buffer, N + 1, L"%.*Le", precision, value);
}
// this will not throw
return static_wstring(buffer);
}
#if defined(__GNUC__) && __GNUC__ >= 7
#pragma GCC diagnostic pop
#endif
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
inline
ForwardIterator
find_not_of(
ForwardIterator first,
ForwardIterator last,
const CharT* str,
std::size_t n) noexcept
{
for (; first != last; ++first)
if (!Traits::find(str, n, *first))
return first;
return last;
}
// constexpr search for C++14
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
inline
ForwardIt1
search(
ForwardIt1 first,
ForwardIt1 last,
ForwardIt2 s_first,
ForwardIt2 s_last,
BinaryPredicate p)
{
for (; ; ++first)
{
ForwardIt1 it = first;
for (ForwardIt2 s_it = s_first; ; ++it, ++s_it)
{
if (s_it == s_last)
return first;
if (it == last)
return last;
if (!p(*it, *s_it))
break;
}
}
}
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
inline
InputIt
find_first_of(
InputIt first,
InputIt last,
ForwardIt s_first,
ForwardIt s_last,
BinaryPredicate p)
{
for (; first != last; ++first)
for (ForwardIt it = s_first; it != s_last; ++it)
if (p(*first, *it))
return first;
return last;
}
// KRYSTIAN TODO: add a constexpr rotate
// Check if a pointer lies within the range {src_first, src_last)
// without unspecified behavior, allowing it to be used
// in a constant evaluation.
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
inline
bool
ptr_in_range(
const T* src_first,
const T* src_last,
const T* ptr)
{
#if defined(BOOST_STATIC_STRING_CPP14) && \
defined(BOOST_STATIC_STRING_IS_CONST_EVAL)
// Our second best option is to use is_constant_evaluated
// and a loop that checks for equality, since equality for
// pointer to object types is never unspecified in this case.
if (BOOST_STATIC_STRING_IS_CONST_EVAL)
{
for (; src_first != src_last; ++src_first)
if (ptr == src_first)
return true;
return false;
}
#endif
// We want to make this usable in constant expressions as much as possible
// while retaining the guarentee that the comparison has a strict total ordering.
// We also want this to be fast. Since different compilers have differing levels
// of conformance, we will settle for the best option that is available.
// We don't care about this in C++11, since this function would have
// no applications in constant expressions.
#if defined(BOOST_STATIC_STRING_CPP14) && \
defined(BOOST_STATIC_STRING_NO_PTR_COMP_FUNCTIONS)
// If library comparison functions don't work,
// we can use try builtin comparison operators instead.
return ptr >= src_first && ptr < src_last;
#else
// Use the library comparison functions if we can't use
// is_constant_evaluated or if we don't need to.
return std::greater_equal()(ptr, src_first) &&
std::less()(ptr, src_last);
#endif
}
// This workaround is for gcc 5,
// which prohibits throw expressions in constexpr
// functions, but for some reason permits them in
// constructors.
#ifdef BOOST_STATIC_STRING_GCC5_BAD_CONSTEXPR
template
struct throw_exception
{
BOOST_STATIC_STRING_NORETURN
BOOST_STATIC_STRING_CPP14_CONSTEXPR
throw_exception(const char* msg)
{
BOOST_STATIC_STRING_THROW(Exception(msg));
}
};
#else
template
BOOST_STATIC_STRING_NORETURN
inline
void
throw_exception(const char* msg)
{
BOOST_STATIC_STRING_THROW(Exception(msg));
}
#endif
} // detail
#endif
//--------------------------------------------------------------------------
//
// static_string
//
//--------------------------------------------------------------------------
/** A fixed-capacity string.
These objects behave like `std::string` except that the storage
is not dynamically allocated but rather fixed in size, and
stored in the object itself.
These strings offer performance advantages when an algorithm
can execute with a reasonable upper limit on the size of a value.
@par Aliases
The following alias templates are provided for convenience:
@code
template
using static_string =
basic_static_string>;
@endcode
@code
template
using static_wstring =
basic_static_string>;
@endcode
@code
template
using static_u16string =
basic_static_string>;
@endcode
@code
template
using static_u32string =
basic_static_string>;
@endcode
Addtionally, the alias template `static_u8string` is provided in C++20
@code
template
using static_u8string =
basic_static_string>;
@endcode
@see to_static_string
*/
template>
class basic_static_string
#ifndef BOOST_STATIC_STRING_DOCS
: private detail::static_string_base
#endif
{
private:
template
friend class basic_static_string;
public:
//--------------------------------------------------------------------------
//
// Member types
//
//--------------------------------------------------------------------------
/// The traits type.
using traits_type = Traits;
/// The character type.
using value_type = typename traits_type::char_type;
/// The size type.
using size_type = std::size_t;
/// The difference type.
using difference_type = std::ptrdiff_t;
/// The pointer type.
using pointer = value_type*;
/// The reference type.
using reference = value_type&;
/// The constant pointer type.
using const_pointer = const value_type*;
/// The constant reference type.
using const_reference = const value_type&;
/// The iterator type.
using iterator = value_type*;
/// The constant iterator type.
using const_iterator = const value_type*;
/// The reverse iterator type.
using reverse_iterator =
std::reverse_iterator;
/// The constant reverse iterator type.
using const_reverse_iterator =
std::reverse_iterator;
/// The string view type.
using string_view_type =
basic_string_view;
//--------------------------------------------------------------------------
//
// Constants
//
//--------------------------------------------------------------------------
/// Maximum size of the string excluding any null terminator
static constexpr size_type static_capacity = N;
/// A special index
static constexpr size_type npos = size_type(-1);
//--------------------------------------------------------------------------
//
// Construction
//
//--------------------------------------------------------------------------
/** Constructor.
Construct an empty string
*/
BOOST_STATIC_STRING_CPP11_CONSTEXPR
basic_static_string() noexcept
{
#ifdef BOOST_STATIC_STRING_CPP20
term();
#endif
}
/** Constructor.
Construct the string with `count` copies of character `ch`.
The behavior is undefined if `count >= npos`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(
size_type count,
value_type ch)
{
assign(count, ch);
}
/** Constructor.
Construct with a substring (pos, other.size()) of `other`.
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(
const basic_static_string& other,
size_type pos)
{
assign(other, pos);
}
/** Constructor.
Construct with a substring (pos, count) of `other`.
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(
const basic_static_string& other,
size_type pos,
size_type count)
{
assign(other, pos, count);
}
/** Constructor.
Construct with the first `count` characters of `s`, including nulls.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(
const_pointer s,
size_type count)
{
assign(s, count);
}
/** Constructor.
Construct from a null terminated string.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(const_pointer s)
{
assign(s);
}
/** Constructor.
Construct from a range of characters
*/
template
::value>::type* = nullptr
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(
InputIterator first,
InputIterator last)
{
// KRYSTIAN TODO: we can use a better algorithm if this is a forward iterator
assign(first, last);
}
/** Constructor.
Copy constructor.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(const basic_static_string& other) noexcept
{
assign(other);
}
/** Constructor.
Copy constructor.
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(
const basic_static_string& other)
{
assign(other);
}
/** Constructor.
Construct from an initializer list
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(std::initializer_list init)
{
assign(init.begin(), init.size());
}
/** Constructor.
Construct from a object convertible to `string_view_type`
*/
template
#endif
>
explicit
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(const T& t)
{
assign(t);
}
/** Constructor.
Construct from any object convertible to `string_view_type`.
The range (pos, n) is extracted from the value
obtained by converting `t` to `string_view_type`,
and used to construct the string.
*/
template
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(
const T& t,
size_type pos,
size_type n)
{
assign(t, pos, n);
}
//--------------------------------------------------------------------------
//
// Assignment
//
//--------------------------------------------------------------------------
/** Assign to the string.
Replaces the contents with those of
the string `s`.
@par Complexity
Linear in `s.size()`.
@par Exception Safety
Strong guarantee.
@tparam M The size of the other string.
@return `*this`
@param s The string to replace
the contents with.
@throw std::length_error `s.size() > max_size()`.
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator=(const basic_static_string& s)
{
return assign(s);
}
/** Assign to the string.
Replaces the contents with those of
`{s, s + traits_type::length(s))`.
@par Complexity
Linear in `count`.
@par Exception Safety
Strong guarantee.
@return `*this`
@param s A pointer to the string to copy from.
@throw std::length_error `traits_type::length(s) > max_size()`.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator=(const_pointer s)
{
return assign(s);
}
/** Assign to the string.
Replaces the contents with a single copy of
the character `ch`.
@par Complexity
Constant.
@par Exception Safety
Strong guarantee.
@return `*this`
@param ch The character to assign to.
@throw std::length_error `count > max_size()`.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator=(value_type ch)
{
return assign_char(ch,
std::integral_constant 0)>{});
}
/** Assign to the string.
Replaces the contents with those of the
initializer list `ilist`.
@par Complexity
Linear in `init.size()`.
@par Exception Safety
Strong guarantee.
@return `*this`
@param ilist The initializer list to copy from.
@throw std::length_error `ilist.size() > max_size()`.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator=(std::initializer_list ilist)
{
return assign(ilist);
}
/** Assign to the string.
Replaces the contents with those of
`sv`, where `sv` is `string_view_type(t)`.
@par Complexity
Linear in `sv.size()`.
@par Exception Safety
Strong guarantee.
@note
The view can contain null characters.
@tparam T A type convertible to `string_view_type`.
@par Constraints
@code
std::is_convertible::value &&
!std::is_convertible::value
@endcode
@return `*this`
@param t The object to assign from.
@throw std::length_error `sv.size() > max_size()`.
*/
template
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator=(const T& t)
{
return assign(t);
}
/** Assign to the string.
Replaces the contents with `count` copies of
character `ch`.
@par Complexity
Linear in `count`.
@par Exception Safety
Strong guarantee.
@return `*this`
@param count The size of the resulting string.
@param ch The value to initialize characters
of the string with.
@throw std::length_error `count > max_size()`.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
assign(
size_type count,
value_type ch);
/** Assign to the string.
Replaces the contents with those of
the string `s`.
@par Complexity
Linear in `s.size()`.
@par Exception Safety
Strong guarantee.
@tparam M The size of the other string.
@return `*this`
@param s The string to replace
the contents with.
@throw std::length_error `s.size() > max_size()`.
*/
template::type* = nullptr
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
assign(const basic_static_string& s)
{
return assign_unchecked(s.data(), s.size());
}
#ifndef BOOST_STATIC_STRING_DOCS
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
assign(const basic_static_string& s) noexcept
{
if (this == &s)
return *this;
return assign_unchecked(s.data(), s.size());
}
template N)>::type* = nullptr>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
assign(const basic_static_string& s)
{
return assign(s.data(), s.size());
}
#endif
/** Assign to the string.
Replaces the contents with those of the string `sub`,
where `sub` is `s.substr(pos, count)`.
@par Complexity
Linear in `sub.size()`.
@par Exception Safety
Strong guarantee.
@tparam M The capacity of the other string.
@return `*this`
@param s The string to replace
the contents with.
@param pos The index at which to begin the substring.
@param count The size of the substring. The default
argument for this parameter is @ref npos.
@throw std::length_error `sub.size() > max_size()`.
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
assign(
const basic_static_string& s,
size_type pos,
size_type count = npos)
{
return assign(s.data() + pos, s.capped_length(pos, count));
}
/** Assign to the string.
Replaces the contents with those of `{s, s + count)`.
@par Complexity
Linear in `count`.
@par Exception Safety
Strong guarantee.
@note
The range can contain null characters.
@return `*this`
@param count The number of characters to copy.
@param s A pointer to the string to copy from.
@throw std::length_error `count > max_size()`.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
assign(
const_pointer s,
size_type count);
/** Assign to the string.
Replaces the contents with those of
`{s, s + traits_type::length(s))`.
@par Complexity
Linear in `count`.
@par Exception Safety
Strong guarantee.
@return `*this`
@param s A pointer to the string to copy from.
@throw std::length_error `traits_type::length(s) > max_size()`.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
assign(const_pointer s)
{
return assign(s, traits_type::length(s));
}
/** Assign to the string.
Replaces the contents with the characters
in the range `{first, last)`.
@par Complexity
Linear in `std::distance(first, last)`.
@par Exception Safety
Strong guarantee.
@tparam InputIterator The type of the iterators.
@par Constraints
`InputIterator` satisfies __InputIterator__.
@return `*this`
@param first An iterator referring to the
first character to assign.
@param last An iterator past the end
of the range to assign from.
@throw std::length_error `std::distance(first, last) > max_size()`.
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#ifdef BOOST_STATIC_STRING_DOCS
basic_static_string&
#else
typename std::enable_if<
detail::is_input_iterator::value,
basic_static_string&>::type
#endif
assign(
InputIterator first,
InputIterator last);
/** Assign to the string.
Replaces the contents with those of the
initializer list `ilist`.
@par Complexity
Linear in `init.size()`.
@par Exception Safety
Strong guarantee.
@return `*this`
@param ilist The initializer list to copy from.
@throw std::length_error `ilist.size() > max_size()`.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
assign(
std::initializer_list ilist)
{
return assign(ilist.begin(), ilist.end());
}
/** Assign to the string.
Replaces the contents with those of
`sv`, where `sv` is `string_view_type(t)`.
@par Complexity
Linear in `sv.size()`.
@par Exception Safety
Strong guarantee.
@note
The view can contain null characters.
@tparam T A type convertible to `string_view_type`.
@par Constraints
@code
std::is_convertible::value &&
!std::is_convertible::value
@endcode
@return `*this`
@param t The object to assign from.
@throw std::length_error `sv.size() > max_size()`.
*/
template
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
assign(const T& t)
{
const string_view_type sv = t;
return assign(sv.data(), sv.size());
}
/** Assign to the string.
Replaces the contents with those of the substring `sv`,
where `sv` is `string_view_type(t).substr(pos, count)`.
@par Complexity
Linear in `sv.size()`.
@par Exception Safety
Strong guarantee.
@note
The view can contain null characters.
@tparam T A type convertible to `string_view_type`.
@par Constraints
@code
std::is_convertible::value &&
!std::is_convertible::value
@endcode
@return `*this`
@param t The object to assign from.
@param pos The index at which to begin the substring.
@param count The size of the substring. The default
argument for this parameter is @ref npos.
@throw std::length_error `sv.size() > max_size()`.
*/
template
#endif
>
basic_static_string&
assign(
const T& t,
size_type pos,
size_type count = npos)
{
const auto sv = string_view_type(t).substr(pos, count);
return assign(sv.data(), sv.size());
}
//--------------------------------------------------------------------------
//
// Element access
//
//--------------------------------------------------------------------------
/** Access a character with bounds checking.
Returns a reference to the character at
index `pos`.
@par Complexity
Constant.
@par Exception Safety
Strong guarantee.
@param pos The index to access.
@throw std::out_of_range `pos >= size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
reference
at(size_type pos)
{
if (pos >= size())
detail::throw_exception(
"pos >= size()");
return data()[pos];
}
/** Access a character with bounds checking.
Returns a reference to the character at
index `pos`.
@par Complexity
Constant.
@par Exception Safety
Strong guarantee.
@param pos The index to access.
@throw std::out_of_range `pos >= size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
const_reference
at(size_type pos) const
{
if (pos >= size())
detail::throw_exception(
"pos >= size()");
return data()[pos];
}
/** Access a character.
Returns a reference to the character at
index `pos`.
@par Complexity
Constant.
@par Precondition
`pos >= size`
@param pos The index to access.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
reference
operator[](size_type pos) noexcept
{
return data()[pos];
}
/** Access a character.
Returns a reference to the character at
index `pos`.
@par Complexity
Constant.
@par Precondition
`pos >= size`
@param pos The index to access.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
const_reference
operator[](size_type pos) const noexcept
{
return data()[pos];
}
/** Return the first character.
Returns a reference to the first character.
@par Complexity
Constant.
@par Precondition
`not empty()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
reference
front() noexcept
{
return data()[0];
}
/** Return the first character.
Returns a reference to the first character.
@par Complexity
Constant.
@par Precondition
`not empty()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
const_reference
front() const noexcept
{
return data()[0];
}
/** Return the last character.
Returns a reference to the last character.
@par Complexity
Constant.
@par Precondition
`not empty()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
reference
back() noexcept
{
return data()[size() - 1];
}
/** Return the last character.
Returns a reference to the last character.
@par Complexity
Constant.
@par Precondition
`not empty()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
const_reference
back() const noexcept
{
return data()[size() - 1];
}
/** Return a pointer to the string.
Returns a pointer to the underlying array
serving as storage. The value returned is such that
the range `{data(), data() + size())` is always a
valid range, even if the container is empty.
@par Complexity
Constant.
@note The value returned from this function
is never never a null pointer value.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
pointer
data() noexcept
{
return this->data_impl();
}
/** Return a pointer to the string.
Returns a pointer to the underlying array
serving as storage. The value returned is such that
the range `{data(), data() + size())` is always a
valid range, even if the container is empty.
@par Complexity
Constant.
@note The value returned from this function
is never never a null pointer value.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
const_pointer
data() const noexcept
{
return this->data_impl();
}
/** Return a pointer to the string.
Returns a pointer to the underlying array
serving as storage. The value returned is such that
the range `{c_str(), c_str() + size())` is always a
valid range, even if the container is empty.
@par Complexity
Constant.
@note The value returned from this function
is never never a null pointer value.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
const_pointer
c_str() const noexcept
{
return data();
}
/** Convert to a string view referring to the string.
Returns a string view referring to the
underlying character string.
@par Complexity
Constant.
*/
BOOST_STATIC_STRING_CPP11_CONSTEXPR
operator string_view_type() const noexcept
{
return string_view_type(data(), size());
}
//--------------------------------------------------------------------------
//
// Iterators
//
//--------------------------------------------------------------------------
/// Return an iterator to the beginning.
BOOST_STATIC_STRING_CPP14_CONSTEXPR
iterator
begin() noexcept
{
return data();
}
/// Return an iterator to the beginning.
BOOST_STATIC_STRING_CPP14_CONSTEXPR
const_iterator
begin() const noexcept
{
return data();
}
/// Return an iterator to the beginning.
BOOST_STATIC_STRING_CPP14_CONSTEXPR
const_iterator
cbegin() const noexcept
{
return data();
}
/// Return an iterator to the end.
BOOST_STATIC_STRING_CPP14_CONSTEXPR
iterator
end() noexcept
{
return data() + size();
}
/// Return an iterator to the end.
BOOST_STATIC_STRING_CPP14_CONSTEXPR
const_iterator
end() const noexcept
{
return data() + size();
}
/// Return an iterator to the end.
BOOST_STATIC_STRING_CPP14_CONSTEXPR
const_iterator
cend() const noexcept
{
return data() + size();
}
/// Return a reverse iterator to the beginning.
BOOST_STATIC_STRING_CPP17_CONSTEXPR
reverse_iterator
rbegin() noexcept
{
return reverse_iterator{end()};
}
/// Return a reverse iterator to the beginning.
BOOST_STATIC_STRING_CPP17_CONSTEXPR
const_reverse_iterator
rbegin() const noexcept
{
return const_reverse_iterator{cend()};
}
/// Return a reverse iterator to the beginning.
BOOST_STATIC_STRING_CPP17_CONSTEXPR
const_reverse_iterator
crbegin() const noexcept
{
return const_reverse_iterator{cend()};
}
/// Return a reverse iterator to the end.
BOOST_STATIC_STRING_CPP17_CONSTEXPR
reverse_iterator
rend() noexcept
{
return reverse_iterator{begin()};
}
/// Return a reverse iterator to the end.
BOOST_STATIC_STRING_CPP17_CONSTEXPR
const_reverse_iterator
rend() const noexcept
{
return const_reverse_iterator{cbegin()};
}
/// Return a reverse iterator to the end.
BOOST_STATIC_STRING_CPP17_CONSTEXPR
const_reverse_iterator
crend() const noexcept
{
return const_reverse_iterator{cbegin()};
}
//--------------------------------------------------------------------------
//
// Capacity
//
//--------------------------------------------------------------------------
/** Return if the string is empty.
Returns whether the string contains no characters.
@par Complexity
Constant.
@return `size() == 0`
*/
BOOST_STATIC_STRING_NODISCARD
BOOST_STATIC_STRING_CPP11_CONSTEXPR
bool
empty() const noexcept
{
return size() == 0;
}
/** Return the size of the string.
Returns the number of characters stored in the
string, excluding the null terminator.
@par Complexity
Constant.
*/
BOOST_STATIC_STRING_CPP11_CONSTEXPR
size_type
size() const noexcept
{
return this->size_impl();
}
/** Return the size of the string.
Returns the number of characters stored in the
string, excluding the null terminator.
@par Complexity
Constant.
*/
BOOST_STATIC_STRING_CPP11_CONSTEXPR
size_type
length() const noexcept
{
return size();
}
/** Return the number of characters that can be stored.
Returns the maximum size of the string, excluding the
null terminator. The returned value is always `N`.
@par Complexity
Constant.
*/
BOOST_STATIC_STRING_CPP11_CONSTEXPR
size_type
max_size() const noexcept
{
return N;
}
/** Increase the capacity.
This function has no effect.
@throw std::length_error `n > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
reserve(size_type n)
{
if (n > max_size())
detail::throw_exception(
"n > max_size()");
}
/** Return the number of characters that can be stored.
Returns the maximum size of the string, excluding the
null terminator. The returned value is always `N`.
@par Complexity
Constant.
*/
BOOST_STATIC_STRING_CPP11_CONSTEXPR
size_type
capacity() const noexcept
{
return max_size();
}
/** Request the removal of unused capacity.
This function has no effect.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
shrink_to_fit() noexcept { }
//--------------------------------------------------------------------------
//
// Operations
//
//--------------------------------------------------------------------------
/** Clear the contents.
Erases all characters from the string. After this
call, @ref size() returns zero.
@par Complexity
Linear in @ref size().
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
clear() noexcept
{
this->set_size(0);
term();
}
/** Insert into the string.
Inserts `count` copies of `ch` at the position `index`.
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return `*this`
@param index The index to insert at.
@param count The number of characters to insert.
@param ch The character to insert.
@throw std::length_error `size() + count > max_size()`
@throw std::out_of_range `index > size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
insert(
size_type index,
size_type count,
value_type ch)
{
if (index > size())
detail::throw_exception(
"index > size()");
insert(begin() + index, count, ch);
return *this;
}
/** Insert into the string.
Inserts the null-terminated character string pointed to by `s`
of length `count` at the position `index` where `count`
is `traits_type::length(s)`.
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return `*this`
@param index The index to insert at.
@param s The string to insert.
@throw std::length_error `size() + count > max_size()`
@throw std::out_of_range `index > size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
insert(
size_type index,
const_pointer s)
{
return insert(index, s, traits_type::length(s));
}
/** Insert into the string.
Inserts `count` characters of the string pointed to by `s`
at the position `index`.
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return `*this`
@param index The index to insert at.
@param s The string to insert.
@param count The length of the string to insert.
@throw std::length_error `size() + count > max_size()`
@throw std::out_of_range `index > size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
insert(
size_type index,
const_pointer s,
size_type count)
{
if (index > size())
detail::throw_exception(
"index > size()");
insert(data() + index, s, s + count);
return *this;
}
/** Insert into the string.
Inserts the string `str`
at the position `index`.
@par Exception Safety
Strong guarantee.
@note The insertion is done unchecked when
the capacity of `str` differs from that of the
string the function is called on.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@tparam M The size of the input string.
@return `*this`
@param index The index to insert at.
@param str The string to insert.
@throw std::length_error `size() + str.size() > max_size()`
@throw std::out_of_range `index > size()`
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
insert(
size_type index,
const basic_static_string& str)
{
return insert_unchecked(index, str.data(), str.size());
}
#ifndef BOOST_STATIC_STRING_DOCS
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
insert(
size_type index,
const basic_static_string& str)
{
return insert(index, str.data(), str.size());
}
#endif
/** Insert into the string.
Inserts a string, obtained by `str.substr(index_str, count)`
at the position `index`.
@par Exception Safety
Strong guarantee.
@note The insertion is done unchecked when
the capacity of `str` differs from that of the
string the function is called on.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@tparam M The size of the input string.
@return `*this`
@param index The index to insert at.
@param str The string from which to insert.
@param index_str The index in `str` to start inserting from.
@param count The number of characters to insert.
The default argument for this parameter is @ref npos.
@throw std::length_error `size() + str.substr(index_str, count).size() > max_size()`
@throw std::out_of_range `index > size()`
@throw std::out_of_range `index_str > str.size()`
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
insert(
size_type index,
const basic_static_string& str,
size_type index_str,
size_type count = npos)
{
return insert_unchecked(index, str.data() + index_str, str.capped_length(index_str, count));
}
#ifndef BOOST_STATIC_STRING_DOCS
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
insert(
size_type index,
const basic_static_string& str,
size_type index_str,
size_type count = npos)
{
return insert(index, str.data() + index_str, str.capped_length(index_str, count));
}
#endif
/** Insert into the string.
Inserts the character `ch` before the character pointed by `pos`.
@par Precondition
`pos` shall be vaild within `{data(), data() + size()}`
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return An iterator which refers to the first inserted character
or `pos` if no characters were inserted
@param pos The index to insert at.
@param ch The character to insert.
@throw std::length_error `size() + 1 > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
iterator
insert(
const_iterator pos,
value_type ch)
{
return insert(pos, 1, ch);
}
/** Insert into the string.
Inserts `count` copies of `ch` before the character pointed by `pos`.
@par Precondition
`pos` shall be valid within `{data(), data() + size()}`
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return An iterator which refers to the first inserted character
or `pos` if no characters were inserted
@param pos The position to insert at.
@param count The number of characters to insert.
@param ch The character to insert.
@throw std::length_error `size() + count > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
iterator
insert(
const_iterator pos,
size_type count,
value_type ch);
/** Insert into the string.
Inserts characters from the range `{first, last)` before the
character pointed to by `pos`.
@par Precondition
`pos` shall be valid within `{data(), data() + size()}`,
`{first, last)` shall be a valid range
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@tparam InputIterator The type of the iterators.
@par Constraints
`InputIterator` satisfies __InputIterator__ and does not
satisfy __ForwardIterator__.
@return An iterator which refers to the first inserted character
or `pos` if no characters were inserted
@param pos The position to insert at.
@param first An iterator representing the first character to insert.
@param last An iterator representing one past the last character to insert.
@throw std::length_error `size() + insert_count > max_size()`
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#ifdef BOOST_STATIC_STRING_DOCS
iterator
#else
typename std::enable_if<
detail::is_input_iterator<
InputIterator>::value &&
!detail::is_forward_iterator<
InputIterator>::value, iterator>::type
#endif
insert(
const_iterator pos,
InputIterator first,
InputIterator last);
#ifndef BOOST_STATIC_STRING_DOCS
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
typename std::enable_if<
detail::is_forward_iterator<
ForwardIterator>::value,
iterator>::type
insert(
const_iterator pos,
ForwardIterator first,
ForwardIterator last);
#endif
/** Insert into the string.
Inserts characters from `ilist` before `pos`.
@par Precondition
`pos` shall be valid within `{data(), data() + size()}`
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return An iterator which refers to the first inserted character
or `pos` if no characters were inserted
@param pos The position to insert at.
@param ilist The initializer list from which to insert.
@throw std::length_error `size() + ilist.size() > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
iterator
insert(
const_iterator pos,
std::initializer_list ilist)
{
return insert_unchecked(pos, ilist.begin(), ilist.size());
}
/** Insert into the string.
Constructs a temporary `string_view_type` object `sv` from `t` and
inserts `{sv.begin(), sv.end())` at `index`.
@par Precondition
`index` shall be valid within `{data(), data() + size()}`
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return `*this`
@tparam T The type of the object to convert.
@par Constraints
`std::is_convertible::value &&
!std::is_convertible::value`.
@param index The index to insert at.
@param t The string to insert from.
@throw std::length_error `size() + sv.size() > max_size()`
@throw std::out_of_range `index > size()`
*/
template
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
insert(
size_type index,
const T& t)
{
const string_view_type sv = t;
return insert(index, sv.data(), sv.size());
}
/** Insert into the string.
Constructs a temporary `string_view_type` object `sv` from `t`
and inserts `sv.substr(index_str, count)` at `index`.
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@tparam T The type of the object to convert.
@par Constraints
`std::is_convertible::value &&
!std::is_convertible::value`.
@return `*this`
@param index The index to insert at.
@param t The string to insert from.
@param index_str The index in the temporary `string_view_type` object
to start the substring from.
@param count The number of characters to insert.
@throw std::length_error `size() + sv.size() > max_size()`
@throw std::out_of_range `index > size()`
@throw std::out_of_range `index_str > sv.size()`
*/
template
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
insert(
size_type index,
const T& t,
size_type index_str,
size_type count = npos)
{
const auto sv = string_view_type(t).substr(index_str, count);
return insert(index, sv.data(), sv.size());
}
/** Erase from the string.
Erases `num` characters from the string, starting at `index`.
`num` is determined as the smaller of `count` and `size() - index`.
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return `*this`
@param index The index to erase at.
The default argument for this parameter is `0`.
@param count The number of characters to erase.
The default argument for this parameter is @ref npos.
@throw std::out_of_range `index > size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
erase(
size_type index = 0,
size_type count = npos)
{
erase(data() + index, data() + index + capped_length(index, count));
return *this;
}
/** Erase from the string.
Erases the character at `pos`.
@par Preconditions
`pos` shall be valid within `{data(), data() + size()}`
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return An iterator referring to character immediately following
the erased character, or @ref end() if one does not exist.
@param pos An iterator referring to the character to erase.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
iterator
erase(const_iterator pos)
{
BOOST_STATIC_STRING_ASSERT(!empty());
return erase(pos, pos + 1);
}
/** Erase from the string.
Erases the characters in the range `{first, last)`.
@par Precondition
`{first, last}` shall be valid within `{data(), data() + size()}`
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return An iterator referring to the character `last`
previously referred to, or @ref end() if one does not exist.
@param first An iterator referring to the first character to erase.
@param last An iterator past the last character to erase.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
iterator
erase(
const_iterator first,
const_iterator last);
/** Append a character.
Appends a character to the end of the string.
@par Exception Safety
Strong guarantee.
@param ch The character to append.
@throw std::length_error `size() >= max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
push_back(value_type ch);
/** Remove the last character.
Removes a character from the end of the string.
@par Precondition
`not empty()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
pop_back() noexcept
{
BOOST_STATIC_STRING_ASSERT(!empty());
this->set_size(size() - 1);
term();
}
/** Append to the string.
Appends `count` copies of `ch` to the end of the string.
@par Exception Safety
Strong guarantee.
@return `*this`
@param count The number of characters to append.
@param ch The character to append.
@throw std::length_error `size() + count > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
append(
size_type count,
value_type ch);
/** Append to the string.
Appends `s` to the end of the string.
@par Exception Safety
Strong guarantee.
@tparam M The size of the string to append.
@return `*this`
@param s The string to append.
@throw std::length_error `size() + s.size() > max_size()`
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
append(
const basic_static_string& s)
{
return append(s.data(), s.size());
}
/** Append to the string.
Appends the substring `sub` to the end of the string,
where `sub` is `s.substr(pos, count)`.
@par Exception Safety
Strong guarantee.
@tparam M The size of the string to append.
@return `*this`
@param s The string to append.
@param pos The index at which to begin the substring.
@param count The size of the substring. The default
argument for this parameter is @ref npos.
@throw std::length_error `size() + sub.size() > max_size()`
@throw std::out_of_range `pos > s.size()`
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
append(
const basic_static_string& s,
size_type pos,
size_type count = npos)
{
return append(s.data() + pos, s.capped_length(pos, count));
}
/** Append to the string.
Appends `count` characters from the string pointed
to by `s` to the end of the string.
@par Exception Safety
Strong guarantee.
@note The string can contain null characters.
@return `*this`
@param s The string to append.
@param count The number of characters to append.
@throw std::length_error `size() + count > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
append(
const_pointer s,
size_type count);
/** Append to the string.
Appends `count` characters from the string pointed
to by `s` to the end of the string, where `count`
is `traits_type::length(s)`.
@par Exception Safety
Strong guarantee.
@return `*this`
@param s The string to append.
@throw std::length_error `size() + count > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
append(const_pointer s)
{
return append(s, traits_type::length(s));
}
// KRYSTIAN TODO: change exception safety
/** Append to the string.
Appends characters from the range `{first, last)`
to the end of the string.
@par Precondition
`{first, last)` shall be a valid range
@par Exception Safety
Strong guarantee.
@tparam InputIterator The type of the iterators.
@par Constraints
`InputIterator` satisfies __InputIterator__.
@return `*this`
@param first An iterator referring to the
first character to append.
@param last An iterator past the end of
last character to append.
@throw std::length_error `size() + std::distance(first, last) > max_size()`
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#ifdef BOOST_STATIC_STRING_DOCS
basic_static_string&
#else
typename std::enable_if<
detail::is_input_iterator::value,
basic_static_string&>::type
#endif
append(
InputIterator first,
InputIterator last)
{
this->set_size(size() + read_back(true, first, last));
return term();
}
/** Append to the string.
Appends the characters from `ilist` to the
end of the string.
@par Exception Safety
Strong guarantee.
@return `*this`
@param ilist The initializer list to append.
@throw std::length_error `size() + ilist.size() > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
append(
std::initializer_list ilist)
{
return append(ilist.begin(), ilist.size());
}
/** Append to the string.
Appends `sv` to the end of the string,
where `sv` is `string_view_type(t)`.
@par Exception Safety
Strong guarantee.
@tparam T The type of the object to convert.
@par Constraints
@code
std::is_convertible::value &&
!std::is_convertible::value
@endcode
@return `*this`
@param t The string to append.
@throw std::length_error `size() + sv.size() > max_size()`
*/
template
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
append(const T& t)
{
const string_view_type sv = t;
return append(sv.data(), sv.size());
}
/** Append to the string.
Appends the substring `sv` to the end of the string,
where `sv` is `string_view_type(t).substr(pos, count)`.
@par Exception Safety
Strong guarantee.
@tparam T The type of the object to convert.
@par Constraints
@code
std::is_convertible::value &&
!std::is_convertible::value
@endcode
@return `*this`
@param t The object to append.
@param pos The index at which to begin the substring.
@param count The size of the substring. The default
argument for this parameter is @ref npos.
@throw std::length_error `size() + sv.size() > max_size()`
*/
template
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
append(
const T& t,
size_type pos,
size_type count = npos)
{
const auto sv = string_view_type(t).substr(pos, count);
return append(sv.data(), sv.size());
}
/** Append to the string.
Appends `s` to the end of the string.
@par Exception Safety
Strong guarantee.
@tparam M The size of the string to append.
@return `*this`
@param s The string to append.
@throw std::length_error `size() + s.size() > max_size()`
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator+=(
const basic_static_string& s)
{
return append(s);
}
/** Append to the string.
Appends a character to the end of the string.
@par Exception Safety
Strong guarantee.
@param ch The character to append.
@throw std::length_error `size() >= max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator+=(value_type ch)
{
push_back(ch);
return *this;
}
/** Append to the string.
Appends `count` characters from the string pointed
to by `s` to the end of the string, where `count`
is `traits_type::length(s)`.
@par Exception Safety
Strong guarantee.
@return `*this`
@param s The string to append.
@throw std::length_error `size() + count > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator+=(const_pointer s)
{
return append(s);
}
/** Append to the string.
Appends the characters from `ilist` to the
end of the string.
@par Exception Safety
Strong guarantee.
@return `*this`
@param ilist The initializer list to append.
@throw std::length_error `size() + ilist.size() > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator+=(
std::initializer_list ilist)
{
return append(ilist);
}
/** Append to the string.
Appends `sv` to the end of the string,
where `sv` is `string_view_type(t)`.
@par Exception Safety
Strong guarantee.
@tparam T The type of the object to convert.
@par Constraints
@code
std::is_convertible::value &&
!std::is_convertible::value
@endcode
@return `*this`
@param t The string to append.
@throw std::length_error `size() + sv.size() > max_size()`
*/
template
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator+=(const T& t)
{
return append(t);
}
/** Compare a string with the string.
Let `comp` be `traits_type::compare(data(), s.data(), std::min(size(), s.size())`.
If `comp != 0`, then the result is `comp`. Otherwise, the result is
`0` if `size() == s.size()`, `-1` if `size() < s.size()`, and `1`
otherwise.
@par Complexity
Linear.
@return The result of lexicographically comparing `s` and the string.
@tparam M The size of the string to compare with.
@param s The string to compare.
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
int
compare(
const basic_static_string& s) const noexcept
{
return detail::lexicographical_compare(
data(), size(), s.data(), s.size());
}
/** Compare a string with the string.
Let `sub` be `substr(pos1, count1)` and `comp` be
`traits_type::compare(sub.data(), s.data(), std::min(sub.size(), s.size())`.
If `comp != 0`, then the result is `comp`. Otherwise, the result is
`0` if `sub.size() == s.size()`, `-1` if `sub.size() < s.size()`, and `1`
otherwise.
@par Complexity
Linear.
@par Exception Safety
Strong guarantee.
@return The result of lexicographically comparing `sub` and `s`.
@tparam M The size of the string to compare with.
@param pos1 The index at which to begin the substring.
@param count1 The size of the substring.
@param s The string to compare.
@throw std::out_of_range `pos1 > size()`
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
int
compare(
size_type pos1,
size_type count1,
const basic_static_string& s) const
{
return detail::lexicographical_compare(
data() + pos1, capped_length(pos1, count1), s.data(), s.size());
}
/** Compare a string with the string.
Let `sub1` be `substr(pos1, count1)`, `sub2` be
`s.substr(pos2, count2)`, and `comp` be
`traits_type::compare(sub1.data(), sub2.data(), std::min(sub1.size(), sub2.size())`.
If `comp != 0`, then the result is `comp`. Otherwise, the result is
`0` if `sub1.size() == sub2.size()`, `-1` if `sub1.size() < sub2.size()`, and `1`
otherwise.
@par Complexity
Linear.
@par Exception Safety
Strong guarantee.
@return The result of lexicographically comparing `sub1` and `sub2`.
@param pos1 The index at which to begin the substring.
@param count1 The size of the substring.
@param s The string to compare.
@param pos2 The index at which to begin the substring to compare.
@param count2 The size of the substring to compare.
@throw std::out_of_range `pos1 > size()`
@throw std::out_of_range `pos2 > s.size()`
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
int
compare(
size_type pos1,
size_type count1,
const basic_static_string& s,
size_type pos2,
size_type count2 = npos) const
{
return detail::lexicographical_compare(
data() + pos1, capped_length(pos1, count1),
s.data() + pos2, s.capped_length(pos2, count2));
}
/** Compare a string with the string.
Let `len` be `traits_type::length(s)` and `comp` be
`traits_type::compare(data(), s, std::min(size(), len)`.
If `comp != 0`, then the result is `comp`. Otherwise, the result is
`0` if `size() == len`, `-1` if `size() < len`, and `1`
otherwise.
@par Complexity
Linear.
@return The result of lexicographically comparing `s` and the string.
@param s The string to compare.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
int
compare(const_pointer s) const noexcept
{
return detail::lexicographical_compare(
data(), size(), s, traits_type::length(s));
}
/** Compare a string with the string.
Let `sub` be `substr(pos1, count1)`, `len` be
`traits_type::length(s)`, and `comp` be
`traits_type::compare(sub.data(), s, std::min(size(), len)`.
If `comp != 0`, then the result is `comp`. Otherwise, the result is
`0` if `sub.size() == len`, `-1` if `sub.size() < len`, and `1`
otherwise.
@par Complexity
Linear.
@par Exception Safety
Strong guarantee.
@return The result of lexicographically comparing `s` and `sub`.
@param pos1 The index at which to begin the substring.
@param count1 The size of the substring.
@param s The string to compare.
@throw std::out_of_range `pos1 > size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
int
compare(
size_type pos1,
size_type count1,
const_pointer s) const
{
return detail::lexicographical_compare(
data() + pos1, capped_length(pos1, count1), s, traits_type::length(s));
}
/** Compare a string with the string.
Let `sub` be `substr(pos1, count1)`, and `comp` be
`traits_type::compare(sub.data(), s, std::min(size(), count2)`.
If `comp != 0`, then the result is `comp`. Otherwise, the result is
`0` if `sub.size() == count2`, `-1` if `sub.size() < count2`, and `1`
otherwise.
@par Complexity
Linear.
@par Exception Safety
Strong guarantee.
@return The result of lexicographically comparing `s` and `sub`.
@param pos1 The index at which to begin the substring.
@param count1 The size of the substring.
@param s The string to compare.
@param count2 The length of the string to compare.
@throw std::out_of_range `pos1 > size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
int
compare(
size_type pos1,
size_type count1,
const_pointer s,
size_type count2) const
{
return detail::lexicographical_compare(
data() + pos1, capped_length(pos1, count1), s, count2);
}
/** Compare a string with the string.
Let `s` be `string_view_type(t)` and `comp` be
`traits_type::compare(data(), s.data(), std::min(size(), s.size())`.
If `comp != 0`, then the result is `comp`. Otherwise, the result is
`0` if `size() == s.size()`, `-1` if `size() < s.size()`, and `1`
otherwise.
@par Complexity
Linear.
@par Exception Safety
Strong guarantee.
@tparam T The type of the object to convert.
@par Constraints
@code
std::is_convertible::value &&
!std::is_convertible::value.
@endcode
@return The result of lexicographically comparing `s` and the string.
@param t The string to compare.
*/
template
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
int
compare(const T& t) const noexcept
{
const string_view_type sv = t;
return detail::lexicographical_compare(
data(), size(), sv.data(), sv.size());
}
/** Compare a string with the string.
Let `s` be `string_view_type(t)`, `sub` be
`substr(pos1, count1)`, and `comp` be
`traits_type::compare(sub.data(), s.data(), std::min(sub.size(), s.size())`.
If `comp != 0`, then the result is `comp`. Otherwise, the result is
`0` if `sub.size() == s.size()`, `-1` if `sub.size() < s.size()`, and `1`
otherwise.
@par Complexity
Linear.
@par Exception Safety
Strong guarantee.
@tparam T The type of the object to convert.
@par Constraints
@code
std::is_convertible::value &&
!std::is_convertible::value.
@endcode
@return The result of lexicographically comparing `s` and `sub`.
@param pos1 The index at which to begin the substring.
@param count1 The length of the substring.
@param t The string to compare.
*/
template
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
int
compare(
size_type pos1,
size_type count1,
const T& t) const
{
const string_view_type sv = t;
return detail::lexicographical_compare(
data() + pos1, capped_length(pos1, count1), sv.data(), sv.size());
}
/** Compare a string with the string.
Let `sub1` be `substr(pos1, count1)`, `sub2` be
`string_view_type(t).substr(pos2, count2)`, and `comp` be
`traits_type::compare(sub1.data(), sub2.data(), std::min(sub1.size(), sub2.size())`.
If `comp != 0`, then the result is `comp`. Otherwise, the result is
`0` if `sub1.size() == sub2.size()`, `-1` if `sub1.size() < sub2.size()`, and `1`
otherwise.
@par Complexity
Linear.
@par Exception Safety
Strong guarantee.
@tparam T The type of the object to convert.
@par Constraints
@code
std::is_convertible::value &&
!std::is_convertible::value.
@endcode
@return The result of lexicographically comparing `sub1` and `sub2`.
@param pos1 The index at which to begin the substring in the string.
@param count1 The length of the substring in the string.
@param t The string to compare.
@param pos2 The index at which to begin the substring in the string view.
@param count2 The length of the substring in the string view.
*/
template
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
int
compare(
size_type pos1,
size_type count1,
const T& t,
size_type pos2,
size_type count2 = npos) const
{
const auto sv = string_view_type(t).substr(pos2, count2);
return compare(pos1, count1,
sv.data(), sv.size());
}
/** Return a substring.
Returns a substring of the string.
@par Exception Safety
Strong guarantee.
@return A string object containing the characters
`{data() + pos, std::min(count, size() - pos))`.
@param pos The index to being the substring at. The
default arugment for this parameter is `0`.
@param count The length of the substring. The default arugment
for this parameter is @ref npos.
@throw std::out_of_range `pos > size()`
*/
#ifndef BOOST_STATIC_STRING_GCC5_BAD_CONSTEXPR
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#endif
basic_static_string
substr(
size_type pos = 0,
size_type count = npos) const
{
return basic_static_string(
data() + pos, capped_length(pos, count));
}
/** Return a string view of a substring.
Returns a view of a substring.
@par Exception Safety
Strong guarantee.
@return A `string_view_type` object referring
to `{data() + pos, std::min(count, size() - pos))`.
@param pos The index to being the substring at. The
default arugment for this parameter is `0`.
@param count The length of the substring. The default arugment
for this parameter is @ref npos.
@throw std::out_of_range `pos > size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
string_view_type
subview(
size_type pos = 0,
size_type count = npos) const
{
return string_view_type(
data() + pos, capped_length(pos, count));
}
/** Copy a substring to another string.
Copies `std::min(count, size() - pos)` characters starting at
index `pos` to the string pointed to by `dest`.
@note The resulting string is not null terminated.
@return The number of characters copied.
@param count The number of characters to copy.
@param dest The string to copy to.
@param pos The index to begin copying from. The
default argument for this parameter is `0`.
@throw std::out_of_range `pos > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
copy(
pointer dest,
size_type count,
size_type pos = 0) const
{
const auto num_copied = capped_length(pos, count);
traits_type::copy(dest, data() + pos, num_copied);
return num_copied;
}
/** Change the size of the string.
Resizes the string to contain `n` characters. If
`n > size()`, characters with the value `CharT()` are
appended. Otherwise, `size()` is reduced to `n`.
@param n The size to resize the string to.
@throw std::out_of_range `n > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
resize(size_type n)
{
resize(n, value_type());
}
/** Change the size of the string.
Resizes the string to contain `n` characters. If
`n > size()`, copies of `c` are
appended. Otherwise, `size()` is reduced to `n`.
@param n The size to resize the string to.
@param c The characters to append if the size
increases.
@throw std::out_of_range `n > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
resize(
size_type n,
value_type c);
/** Swap two strings.
Swaps the contents of the string and `s`.
@par Exception Safety
Strong guarantee.
@note
All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@param s The string to swap with.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
swap(basic_static_string& s) noexcept;
/** Swap two strings.
Swaps the contents of the string and `s`.
@par Exception Safety
Strong guarantee.
@note
All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@tparam M The size of the string to swap with.
@param s The string to swap with.
@throw std::length_error `s.size() > max_size() || size() > s.max_size()`
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
swap(basic_static_string& s);
/** Replace a part of the string.
Replaces `rcount` characters starting at index `pos1` with those
of `str`, where `rcount` is `std::min(n1, size() - pos1)`.
@par Exception Safety
Strong guarantee.
@note The replacement is done unchecked when
the capacity of `str` differs from that of the
string the function is called on.
All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@tparam M The size of the input string.
@return `*this`
@param pos1 The index to replace at.
@param n1 The number of characters to replace.
@param str The string to replace with.
@throw std::length_error `size() + (str.size() - rcount) > max_size()`
@throw std::out_of_range `pos1 > size()`
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
size_type pos1,
size_type n1,
const basic_static_string& str)
{
return replace_unchecked(pos1, n1, str.data(), str.size());
}
#ifndef BOOST_STATIC_STRING_DOCS
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
size_type pos1,
size_type n1,
const basic_static_string& str)
{
return replace(pos1, n1, str.data(), str.size());
}
#endif
/** Replace a part of the string.
Replaces `rcount` characters starting at index `pos1` with those of
`str.subview(pos2, n2)`, where `rcount` is `std::min(n1, size() - pos1)`.
@par Exception Safety
Strong guarantee.
@note The replacement is done unchecked when
the capacity of `str` differs from that of the
string the function is called on.
All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return `*this`
@param pos1 The index to replace at.
@param n1 The number of characters to replace.
@param str The string to replace with.
@param pos2 The index to begin the substring.
@param n2 The length of the substring.
The default argument for this parameter is @ref npos.
@throw std::length_error `size() + (std::min(str.size(), n2) - rcount) > max_size()`
@throw std::out_of_range `pos1 > size()`
@throw std::out_of_range `pos2 > str.size()`
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
size_type pos1,
size_type n1,
const basic_static_string& str,
size_type pos2,
size_type n2 = npos)
{
return replace_unchecked(pos1, n1, str.data() + pos2, str.capped_length(pos2, n2));
}
#ifndef BOOST_STATIC_STRING_DOCS
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
size_type pos1,
size_type n1,
const basic_static_string& str,
size_type pos2,
size_type n2 = npos)
{
return replace(pos1, n1, str.data() + pos2, str.capped_length(pos2, n2));
}
#endif
/** Replace a part of the string.
Constructs a temporary `string_view_type` object `sv` from `t`, and
replaces `rcount` characters starting at index `pos1` with those
of `sv`, where `rcount` is `std::min(n1, size() - pos1)`.
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@tparam T The type of the object to convert.
@par Constraints
`std::is_convertible::value &&
!std::is_convertible::value`.
@return `*this`
@param pos1 The index to replace at.
@param n1 The number of characters to replace.
@param t The object to replace with.
@throw std::length_error `size() + (sv.size() - rcount) > max_size()`
@throw std::out_of_range `pos1 > size()`
*/
template
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
size_type pos1,
size_type n1,
const T& t)
{
const string_view_type sv = t;
return replace(pos1, n1, sv.data(), sv.size());
}
/** Replace a part of the string.
Constructs a temporary `string_view_type` object `sv` from `t`, and
replaces `rcount` characters starting at index `pos1` with those
of `sv.substr(pos2, n2)`, where `rcount` is `std::min(n1, size() - pos)`.
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@tparam T The type of the object to convert.
@par Constraints
`std::is_convertible::value &&
!std::is_convertible::value`.
@return `*this`
@param pos1 The index to replace at.
@param n1 The number of characters to replace.
@param t The object to replace with.
@param pos2 The index to begin the substring.
@param n2 The length of the substring.
The default argument for this parameter is @ref npos.
@throw std::length_error `size() + (std::min(n2, sv.size()) - rcount) > max_size()`
@throw std::out_of_range `pos1 > size()`
@throw std::out_of_range `pos2 > sv.size()`
*/
template
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
size_type pos1,
size_type n1,
const T& t,
size_type pos2,
size_type n2 = npos)
{
const string_view_type sv = t;
return replace(pos1, n1, sv.substr(pos2, n2));
}
/** Replace a part of the string.
Replaces `rcount` characters starting at index `pos` with those of
`{s, s + n2)`, where `rcount` is `std::min(n1, size() - pos)`.
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return `*this`
@param pos The index to replace at.
@param n1 The number of characters to replace.
@param s The string to replace with.
@param n2 The length of the string to replace with.
@throw std::length_error `size() + (n2 - rcount) > max_size()`
@throw std::out_of_range `pos > size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
size_type pos,
size_type n1,
const_pointer s,
size_type n2)
{
return replace(data() + pos, data() + pos + capped_length(pos, n1), s, n2);
}
/** Replace a part of the string.
Replaces `rcount` characters starting at index `pos` with those of
`{s, s + len)`, where the length of the string `len` is `traits_type::length(s)` and `rcount`
is `std::min(n1, size() - pos)`.
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return `*this`
@param pos The index to replace at.
@param n1 The number of characters to replace.
@param s The string to replace with.
@throw std::length_error `size() + (len - rcount) > max_size()`
@throw std::out_of_range `pos > size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
size_type pos,
size_type n1,
const_pointer s)
{
return replace(pos, n1, s, traits_type::length(s));
}
/** Replace a part of the string.
Replaces `rcount` characters starting at index `pos` with `n2` copies
of `c`, where `rcount` is `std::min(n1, size() - pos)`.
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return `*this`
@param pos The index to replace at.
@param n1 The number of characters to replace.
@param n2 The number of characters to replace with.
@param c The character to replace with.
@throw std::length_error `size() + (n2 - rcount) > max_size()`
@throw std::out_of_range `pos > size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
size_type pos,
size_type n1,
size_type n2,
value_type c)
{
return replace(data() + pos, data() + pos + capped_length(pos, n1), n2, c);
}
/** Replace a part of the string.
Replaces the characters in the range `{i1, i2)`
with those of `str`.
@par Precondition
`{i1, i2)` is a valid range.
@par Exception Safety
Strong guarantee.
@note The replacement is done unchecked when
the capacity of `str` differs from that of the
string the function is called on.
All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@tparam M The size of the input string.
@return `*this`
@param i1 An iterator referring to the first character to replace.
@param i2 An iterator referring past the end of
the last character to replace.
@param str The string to replace with.
@throw std::length_error `size() + (str.size() - std::distance(i1, i2)) > max_size()`
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
const_iterator i1,
const_iterator i2,
const basic_static_string& str)
{
return replace_unchecked(i1, i2, str.data(), str.size());
}
#ifndef BOOST_STATIC_STRING_DOCS
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
const_iterator i1,
const_iterator i2,
const basic_static_string& str)
{
return replace(i1, i2, str.data(), str.size());
}
#endif
/** Replace a part of the string.
Constructs a temporary `string_view_type` object `sv` from `t`, and
replaces the characters in the range `{i1, i2)` with those
of `sv`.
@par Precondition
`{i1, i2)` is a valid range.
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@tparam T The type of the object to convert.
@par Constraints
`std::is_convertible::value &&
!std::is_convertible::value`.
@return `*this`
@param i1 An iterator referring to the first character to replace.
@param i2 An iterator referring past the end of
the last character to replace.
@param t The object to replace with.
@throw std::length_error `size() + (sv.size() - std::distance(i1, i2)) > max_size()`
*/
template
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
const_iterator i1,
const_iterator i2,
const T& t)
{
const string_view_type sv = t;
return replace(i1, i2, sv.begin(), sv.end());
}
/** Replace a part of the string.
Replaces the characters in the range `{i1, i2)` with those of
`{s, s + n)`.
@par Precondition
`{i1, i2)` is a valid range.
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return `*this`
@param i1 An iterator referring to the first character to replace.
@param i2 An iterator referring past the end of
the last character to replace.
@param s The string to replace with.
@param n The length of the string to replace with.
@throw std::length_error `size() + (n - std::distance(i1, i2)) > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
const_iterator i1,
const_iterator i2,
const_pointer s,
size_type n)
{
return replace(i1, i2, s, s + n);
}
/** Replace a part of the string.
Replaces the characters in the range `{i1, i2)` with those of
`{s, s + len)`, where the length of the string `len` is `traits_type::length(s)`.
@par Precondition
`{i1, i2)` shall be a valid range.
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return `*this`
@param i1 An iterator referring to the first character to replace.
@param i2 An iterator referring past the end of
the last character to replace.
@param s The string to replace with.
@throw std::length_error `size() + (len - std::distance(i1, i2)) > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
const_iterator i1,
const_iterator i2,
const_pointer s)
{
return replace(i1, i2, s, traits_type::length(s));
}
/** Replace a part of the string.
Replaces the characters in the range `{i1, i2)` with
`n` copies of `c`.
@par Precondition
`{i1, i2)` is a valid range.
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return `*this`
@param i1 An iterator referring to the first character to replace.
@param i2 An iterator past the end of
the last character to replace.
@param n The number of characters to replace with.
@param c The character to replace with.
@throw std::length_error `size() + (n - std::distance(i1, i2)) > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
const_iterator i1,
const_iterator i2,
size_type n,
value_type c);
/** Replace a part of the string.
Replaces the characters in the range `{i1, i2)`
with those of `{j1, j2)`.
@par Precondition
`{i1, i2)` is a valid range.
`{j1, j2)` is a valid range.
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@tparam InputIterator The type of the iterators.
@par Constraints
`InputIterator` satisfies __InputIterator__ and does not
satisfy __ForwardIterator__.
@return `*this`
@param i1 An iterator referring to the first character to replace.
@param i2 An iterator referring past the end of
the last character to replace.
@param j1 An iterator referring to the first character to replace with.
@param j2 An iterator referring past the end of
the last character to replace with.
@throw std::length_error `size() + (inserted - std::distance(i1, i2)) > max_size()`
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#ifdef BOOST_STATIC_STRING_DOCS
basic_static_string&
#else
typename std::enable_if<
detail::is_input_iterator<
InputIterator>::value &&
!detail::is_forward_iterator<
InputIterator>::value,
basic_static_string&>::type
#endif
replace(
const_iterator i1,
const_iterator i2,
InputIterator j1,
InputIterator j2);
#ifndef BOOST_STATIC_STRING_DOCS
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
typename std::enable_if<
detail::is_forward_iterator<
ForwardIterator>::value,
basic_static_string&>::type
replace(
const_iterator i1,
const_iterator i2,
ForwardIterator j1,
ForwardIterator j2);
#endif
/** Replace a part of the string.
Replaces the characters in the range `{i1, i2)`
with those of contained in the initializer list `il`.
@par Precondition
`{i1, i2)` is a valid range.
@par Exception Safety
Strong guarantee.
@note All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
@return `*this`
@param i1 An iterator referring to the first character to replace.
@param i2 An iterator past the end of
the last character to replace.
@param il The initializer list to replace with.
@throw std::length_error `size() + (il.size() - std::distance(i1, i2)) > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
const_iterator i1,
const_iterator i2,
std::initializer_list il)
{
return replace_unchecked(i1, i2, il.begin(), il.size());
}
//--------------------------------------------------------------------------
//
// Search
//
//--------------------------------------------------------------------------
/** Find the first occurrence of a string within the string.
Constructs a temporary `string_view_type` object `sv` from `t`, and finds
the first occurrence of `sv` within the string starting at the index `pos`.
@par Complexity
Linear.
@note An empty string is always found.
@tparam T The type of the object to convert.
@par Constraints
`std::is_convertible::value &&
!std::is_convertible::value`.
@return The lowest index `idx` greater than or equal to `pos`
where each element of `{sv.begin(), sv.end())` is equal to
that of `{begin() + idx, begin() + idx + count)` if one exists,
and @ref npos otherwise.
@param t The string to search for.
@param pos The index to start searching at. The default argument
for this parameter is `0`.
*/
template
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find(
const T& t,
size_type pos = 0) const
noexcept(detail::is_nothrow_convertible::value)
{
const string_view_type sv = t;
return find(sv.data(), pos, sv.size());
}
/** Find the first occurrence of a string within the string.
Finds the first occurrence of `str` within the
string starting at the index `pos`.
@par Complexity
Linear.
@return The lowest index `idx` greater than or equal to `pos`
where each element of `str` is equal to that of
`{begin() + idx, begin() + idx + str.size())`
if one exists, and @ref npos otherwise.
@param str The string to search for.
@param pos The index to start searching at. The default argument for
this parameter is `0`.
*/
template
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find(
const basic_static_string& str,
size_type pos = 0) const noexcept
{
return find(str.data(), pos, str.size());
}
/** Find the first occurrence of a string within the string.
Finds the first occurrence of the string pointed to
by `s` within the string starting at the index `pos`.
@par Complexity
Linear.
@note An empty string is always found.
@return The lowest index `idx` greater than or equal to `pos`
where each element of `{s, s + n)` is equal to that of
`{begin() + idx, begin() + idx + n)` if one exists,
and @ref npos otherwise.
@param s The string to search for.
@param pos The index to start searching at.
@param n The length of the string to search for.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find(
const_pointer s,
size_type pos,
size_type n) const noexcept;
/** Find the first occurrence of a string within the string.
Finds the first occurrence of the string pointed to by `s`
of length `count` within the string starting at the index `pos`,
where `count` is `traits_type::length(s)`.
@par Complexity
Linear.
@note An empty string is always found.
@return The lowest index `idx` greater than or equal to `pos`
where each element of `{s, s + count)` is equal to that of
`{begin() + idx, begin() + idx + count)` if one exists,
and @ref npos otherwise.
@param s The string to search for.
@param pos The index to start searching at. The default argument
for this parameter is `0`.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find(
const_pointer s,
size_type pos = 0) const noexcept
{
return find(s, pos, traits_type::length(s));
}
/** Find the first occurrence of a character within the string.
Finds the first occurrence of `c` within the string
starting at the index `pos`.
@par Complexity
Linear.
@return The index corrosponding to the first occurrence of `c` within
`{begin() + pos, end())` if it exists, and @ref npos otherwise.
@param c The character to search for.
@param pos The index to start searching at. The default argument
for this parameter is `0`.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find(
value_type c,
size_type pos = 0) const noexcept
{
return find(&c, pos, 1);
}
/** Find the last occurrence of a string within the string.
Constructs a temporary `string_view_type` object `sv` from `t`, and finds
the last occurrence of `sv` within the string starting before or at
the index `pos`.
@par Complexity
Linear.
@tparam T The type of the object to convert.
@par Constraints
`std::is_convertible::value &&
!std::is_convertible