feedc0de/boost_static_string
1
0
Fork 0
forked from boostorg/static_string
Code Pull Requests Activity
Files
2561beb7fb1fd4ae137a27e153d6970b7271bc55
boost_static_string/include/boost/static_string/static_string.hpp
T

5611 lines
156 KiB
C++
Raw Normal View History

Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
//
// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
Update copyright, add throw condition to replace/insert
2020-02-01 13:51:40 -05:00
// Copyright (c) 2019-2020 Krystian Stasiowski (sdkrystian at gmail dot com)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
//
// 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
#include <boost/static_string/config.hpp>
#include <algorithm>
#include <cstdint>
Add missing includes
2020-02-01 16:47:19 -05:00
#include <cstdio>
Add missing include, debug for travis
2020-02-01 17:29:57 -05:00
#include <cwchar>
Add missing includes
2020-02-01 16:47:19 -05:00
#include <functional>
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
#include <initializer_list>
#include <iosfwd>
#include <type_traits>
namespace boost {
namespace static_string {
Move to single header
2020-02-01 16:30:23 -05:00
template<std::size_t, typename, typename>
class basic_static_string;
//------------------------------------------------------------------------------
//
// Aliases
//
//------------------------------------------------------------------------------
template<std::size_t N>
using static_string = basic_static_string<N, char, std::char_traits<char>>;
template<std::size_t N>
using static_wstring = basic_static_string<N, wchar_t, std::char_traits<wchar_t>>;
template<std::size_t N>
using static_u16string = basic_static_string<N, char16_t, std::char_traits<char16_t>>;
template<std::size_t N>
using static_u32string = basic_static_string<N, char32_t, std::char_traits<char32_t>>;
//--------------------------------------------------------------------------
//
// Detail
//
//--------------------------------------------------------------------------
#ifndef GENERATING_DOCUMENTATION
namespace detail {
// Find the smallest width integral type that can hold a value as large as N (Glen Fernandes)
template<std::size_t N>
using smallest_width =
typename std::conditional<(N <= (std::numeric_limits<unsigned char>::max)()), unsigned char,
typename std::conditional<(N <= (std::numeric_limits<unsigned short>::max)()), unsigned short,
typename std::conditional<(N <= (std::numeric_limits<unsigned int>::max)()), unsigned int,
typename std::conditional<(N <= (std::numeric_limits<unsigned long>::max)()), unsigned long,
typename std::conditional<(N <= (std::numeric_limits<unsigned long long>::max)()), unsigned long long,
void>::type>::type>::type>::type>::type;
// std::is_nothrow_convertible is C++20
template<typename To>
void is_nothrow_convertible_helper(To) noexcept;
// MSVC is unable to parse this as a single expression, so a helper is needed
template<typename From, typename To, typename =
decltype(is_nothrow_convertible_helper<To>(std::declval<From>()))>
struct is_nothrow_convertible_msvc_helper
{
static const bool value =
noexcept(is_nothrow_convertible_helper<To>(std::declval<From>()));
};
template<typename From, typename To, typename = void>
struct is_nothrow_convertible
: std::false_type { };
template<typename From, typename To>
struct is_nothrow_convertible<From, To, typename std::enable_if<
is_nothrow_convertible_msvc_helper<From, To>::value>::type>
: std::true_type { };
// GCC 4.8, 4.9 workaround for void_t to make the defining-type-id dependant
template<typename...>
struct void_t_helper
{
using type = void;
};
// void_t for c++11
template<typename... Ts>
using void_t = typename void_t_helper<Ts...>::type;
// Simplified check for if a type is an iterator
template<class T, typename = void>
struct is_iterator : std::false_type { };
template<class T>
struct is_iterator<T,
typename std::enable_if<std::is_class<T>::value,
void_t<typename T::iterator_category>>::type>
: std::true_type { };
template<class T>
struct is_iterator<T*, void>
: std::true_type { };
template<class T, typename = void>
struct is_input_iterator : std::false_type { };
template<class T>
struct is_input_iterator<T, typename std::enable_if<is_iterator<T>::value &&
std::is_convertible<typename std::iterator_traits<T>::iterator_category,
std::input_iterator_tag>::value>::type>
: std::true_type { };
template<class T, typename = void>
struct is_forward_iterator : std::false_type { };
template<class T>
struct is_forward_iterator<T, typename std::enable_if<is_iterator<T>::value &&
std::is_convertible<typename std::iterator_traits<T>::iterator_category,
std::forward_iterator_tag>::value>::type>
: std::true_type { };
template<typename T, typename = void>
struct is_subtractable
: std::false_type { };
template<typename T>
struct is_subtractable<T, void_t<decltype(std::declval<T&>() - std::declval<T&>())>>
: std::true_type { };
// constexpr distance for c++14
template<typename InputIt, typename std::enable_if<!is_subtractable<InputIt>::value>::type* = nullptr>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
typename std::iterator_traits<InputIt>::difference_type
distance(InputIt first, InputIt last)
{
std::size_t dist = 0;
for (; first != last; ++first, ++dist);
return dist;
}
template<typename RandomIt, typename std::enable_if<is_subtractable<RandomIt>::value>::type* = nullptr>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
typename std::iterator_traits<RandomIt>::difference_type
distance(RandomIt first, RandomIt last)
{
return last - first;
}
// Copy using traits, respecting iterator rules
template<typename Traits, typename InputIt, typename CharT>
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<std::size_t N, typename CharT, typename Traits>
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
class static_string_base
Move to single header
2020-02-01 16:30:23 -05:00
{
public:
BOOST_STATIC_STRING_CPP11_CONSTEXPR
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
static_string_base() noexcept { };
Move to single header
2020-02-01 16:30:23 -05:00
BOOST_STATIC_STRING_CPP11_CONSTEXPR
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
static_string_base(std::size_t n) noexcept : size_(n) { }
Move to single header
2020-02-01 16:30:23 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
CharT*
data_impl() noexcept
{
return data_;
}
BOOST_STATIC_STRING_CPP14_CONSTEXPR
CharT const*
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
{
return size_ = n;
}
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
term_impl() noexcept
{
Traits::assign(data_[size_], CharT());
}
smallest_width<N> size_{0};
Update config, fix checks
2020-02-01 21:19:29 -05:00
#ifdef BOOST_STATIC_STRING_CPP20
Move to single header
2020-02-01 16:30:23 -05:00
CharT data_[N + 1];
#else
CharT data_[N + 1]{};
#endif
};
// Optimization for when the size is 0
template<typename CharT, typename Traits>
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
class static_string_base<0, CharT, Traits>
Move to single header
2020-02-01 16:30:23 -05:00
{
public:
BOOST_STATIC_STRING_CPP11_CONSTEXPR
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
static_string_base() noexcept { }
Move to single header
2020-02-01 16:30:23 -05:00
BOOST_STATIC_STRING_CPP11_CONSTEXPR
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
static_string_base(std::size_t) noexcept { }
Move to single header
2020-02-01 16:30:23 -05:00
// Modifying the null terminator is UB
BOOST_STATIC_STRING_CPP11_CONSTEXPR
CharT*
data_impl() const noexcept
{
return const_cast<CharT*>(&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) noexcept
{
return 0;
}
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
term_impl() noexcept { }
private:
Fix floating point conversions
2020-02-02 22:35:14 -05:00
static constexpr const CharT null_{};
Move to single header
2020-02-01 16:30:23 -05:00
};
template<typename CharT, typename Traits>
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
constexpr const CharT static_string_base<0, CharT, Traits>::null_;
Move to single header
2020-02-01 16:30:23 -05:00
template<typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
inline
int
lexicographical_compare(
CharT const* s1, std::size_t n1,
CharT const* 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<typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
inline
int
lexicographical_compare(
basic_string_view<CharT, Traits> s1,
CharT const* s2, std::size_t n2) noexcept
{
return detail::lexicographical_compare<
CharT, Traits>(s1.data(), s1.size(), s2, n2);
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
inline
int
lexicographical_compare(
const basic_static_string<N, CharT, Traits>& s1,
CharT const* s2, std::size_t n2) noexcept
{
return detail::lexicographical_compare<
CharT, Traits>(s1.data(), s1.size(), s2, n2);
}
template<typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
inline
int
lexicographical_compare(
basic_string_view<CharT, Traits> s1,
basic_string_view<CharT, Traits> s2) noexcept
{
return detail::lexicographical_compare<CharT, Traits>(
s1.data(), s1.size(), s2.data(), s2.size());
}
template<std::size_t N, std::size_t M, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
inline
int
lexicographical_compare(
const basic_static_string<N, CharT, Traits>& s1,
const basic_static_string<M, CharT, Traits>& s2) noexcept
{
return detail::lexicographical_compare<CharT, Traits>(
s1.data(), s1.size(), s2.data(), s2.size());
}
template<typename Traits, typename Integer>
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)
{
value = -value;
for (; value > 0; value /= 10)
Traits::assign(*--str_end, "0123456789"[value % 10]);
Traits::assign(*--str_end, '-');
return str_end;
}
for (; value > 0; value /= 10)
Traits::assign(*--str_end, "0123456789"[value % 10]);
return str_end;
}
template<typename Traits, typename Integer>
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<typename Traits, typename Integer>
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)
{
value = -value;
for (; value > 0; value /= 10)
Traits::assign(*--str_end, L"0123456789"[value % 10]);
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<typename Traits, typename Integer>
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<std::size_t N, typename Integer>
inline
static_string<N>
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<std::char_traits<char>, Integer>(
digits_end, value, std::is_signed<Integer>{});
return static_string<N>(digits_begin, std::distance(digits_begin, digits_end));
}
template<std::size_t N, typename Integer>
inline
static_wstring<N>
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<std::char_traits<wchar_t>, Integer>(
digits_end, value, std::is_signed<Integer>{});
return static_wstring<N>(digits_begin, std::distance(digits_begin, digits_end));
}
Fix floating point conversions
2020-02-02 22:35:14 -05:00
template<std::size_t N>
Move to single header
2020-02-01 16:30:23 -05:00
inline
static_string<N>
Fix floating point conversions
2020-02-02 22:35:14 -05:00
to_static_string_float_impl(double value) noexcept
{
// extra one needed for null terminator
char buffer[N + 1];
std::sprintf(buffer, "%f", value);
// this will not throw
return static_string<N>(buffer);
}
template<std::size_t N>
inline
static_string<N>
to_static_string_float_impl(long double value) noexcept
Move to single header
2020-02-01 16:30:23 -05:00
{
// extra one needed for null terminator
char buffer[N + 1];
Fix constexpr when using libstdc++
2020-02-01 23:18:20 -05:00
std::sprintf(buffer, "%Lf", value);
Move to single header
2020-02-01 16:30:23 -05:00
// this will not throw
return static_string<N>(buffer);
}
Fix floating point conversions
2020-02-02 22:35:14 -05:00
template<std::size_t N>
Move to single header
2020-02-01 16:30:23 -05:00
inline
static_wstring<N>
Fix floating point conversions
2020-02-02 22:35:14 -05:00
to_static_wstring_float_impl(double value) noexcept
{
// extra one needed for null terminator
wchar_t buffer[N + 1];
std::swprintf(buffer, N + 1, L"%f", value);
// this will not throw
return static_wstring<N>(buffer);
}
template<std::size_t N>
inline
static_wstring<N>
to_static_wstring_float_impl(long double value) noexcept
Move to single header
2020-02-01 16:30:23 -05:00
{
// extra one needed for null terminator
wchar_t buffer[N + 1];
Fix constexpr when using libstdc++
2020-02-01 23:18:20 -05:00
std::swprintf(buffer, N + 1, L"%Lf", value);
Move to single header
2020-02-01 16:30:23 -05:00
// this will not throw
return static_wstring<N>(buffer);
}
template<
typename Traits,
typename CharT,
typename ForwardIterator>
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<
typename ForwardIt1,
typename ForwardIt2,
typename BinaryPredicate>
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<
typename InputIt,
typename ForwardIt,
typename BinaryPredicate>
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;
}
Fix more constexpr
2020-02-02 11:43:17 -05:00
// Check if a pointer lies within the range [src_first, src_last)
// without unspecified behavior, allowing it to be used
// in a constant evaluation.
Move to single header
2020-02-01 16:30:23 -05:00
template<typename T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
inline
bool
Clean up replace
2020-02-06 16:48:02 -05:00
ptr_in_range(
Move to single header
2020-02-01 16:30:23 -05:00
const T* src_first,
const T* src_last,
const T* ptr)
{
Update config, fix checks
2020-02-01 21:19:29 -05:00
// 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.
Fix constexpr when using libstdc++
2020-02-01 23:18:20 -05:00
// We don't care about this in C++11, since this function would have
// no applications in constant expressions.
Update travis
2020-02-02 12:49:30 -05:00
#if defined(BOOST_STATIC_STRING_CPP14) && defined(BOOST_STATIC_STRING_NO_PTR_COMP_FUNCTIONS)
Fix more constexpr
2020-02-02 11:43:17 -05:00
#ifdef BOOST_STATIC_STRING_IS_CONST_EVAL
Update config, fix checks
2020-02-01 21:19:29 -05:00
// 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)
Adjust travis
2020-02-02 13:36:18 -05:00
if (ptr == src_first)
Update config, fix checks
2020-02-01 21:19:29 -05:00
return true;
return false;
}
#else
Fix constexpr when using libstdc++
2020-02-01 23:18:20 -05:00
// If library comparison functions don't work, and
Fix more constexpr
2020-02-02 11:43:17 -05:00
// we cannot use any of the above, we can use
// try builtin comparison operators instead.
return ptr >= src_first && ptr < src_last;
Update config, fix checks
2020-02-01 21:19:29 -05:00
#endif
#endif
// Use the library comparison functions if we can't use
// is_constant_evaluated or if we don't need to.
return std::greater_equal<const T*>()(ptr, src_first) &&
Fix more constexpr
2020-02-02 11:43:17 -05:00
std::less<const T*>()(ptr, src_last);
Move to single header
2020-02-01 16:30:23 -05:00
}
} // detail
#endif
//--------------------------------------------------------------------------
//
// static_string
//
//--------------------------------------------------------------------------
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** 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.
@see to_static_string
*/
template<
std::size_t N,
typename CharT,
typename Traits = std::char_traits<CharT>>
class basic_static_string
#ifndef GENERATING_DOCUMENTATION
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
: private detail::static_string_base<N, CharT, Traits>
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
#endif
Inlined free functions for ODR
2019-10-27 21:01:44 -04:00
{
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
private:
template<std::size_t, class, class>
friend class basic_static_string;
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
term() noexcept
{
this->term_impl();
}
public:
//--------------------------------------------------------------------------
//
// Member types
//
//--------------------------------------------------------------------------
using traits_type = Traits;
using value_type = typename Traits::char_type;
using size_type = std::size_t;
using difference_type = std::ptrdiff_t;
using pointer = value_type*;
using reference = value_type&;
using const_pointer = value_type const*;
using const_reference = value_type const&;
using iterator = value_type*;
using const_iterator = value_type const*;
using reverse_iterator =
std::reverse_iterator<iterator>;
using const_reverse_iterator =
std::reverse_iterator<const_iterator>;
Chunked docs
2020-01-31 15:30:17 -05:00
/// The type of `string_view_type` returned by the interface
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
using string_view_type =
Fix test and standalone support
2019-12-16 18:19:01 -05:00
basic_string_view<CharT, Traits>;
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
//--------------------------------------------------------------------------
//
// 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
//
//--------------------------------------------------------------------------
/** Construct a `basic_static_string`.
Construct an empty string
*/
BOOST_STATIC_STRING_CPP11_CONSTEXPR
basic_static_string() noexcept;
/** Construct a `basic_static_string`.
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,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT ch);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Construct a `basic_static_string`.
Construct with a substring (pos, other.size()) of `other`.
*/
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(
basic_static_string<M, CharT, Traits> const& other,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type pos);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Construct a `basic_static_string`.
Construct with a substring (pos, count) of `other`.
*/
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(
basic_static_string<M, CharT, Traits> const& other,
size_type pos,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Construct a `basic_static_string`.
Construct with the first `count` characters of `s`, including nulls.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(
CharT const* s,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Construct a `basic_static_string`.
Construct from a null terminated string.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT const* s);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Construct a `basic_static_string`.
Construct from a range of characters
*/
More noexcept, remove dummy parameter from constructor.
2020-01-15 16:23:12 -05:00
template<class InputIterator
#ifndef GENERATING_DOCUMENTATION
, typename std::enable_if<
detail::is_input_iterator<InputIterator>
::value>::type* = nullptr
#endif
>
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(
InputIterator first,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
InputIterator last);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Construct a `basic_static_string`.
Copy constructor.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(
basic_static_string const& other) noexcept;
/** Construct a `basic_static_string`.
Copy constructor.
*/
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<M, CharT, Traits> const& other);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Construct a `basic_static_string`.
Construct from an initializer list
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
std::initializer_list<CharT> init);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Construct a `basic_static_string`.
Chunked docs
2020-01-31 15:30:17 -05:00
Construct from a `string_view_type`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
explicit
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
string_view_type sv);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Construct a `basic_static_string`.
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<typename T
#ifndef GENERATING_DOCUMENTATION
, class = typename std::enable_if<
std::is_convertible<T, string_view_type>::value>::type
#endif
>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string(
T const& t,
size_type pos,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type n);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
//--------------------------------------------------------------------------
//
// Assignment
//
//--------------------------------------------------------------------------
/** Assign to the string.
If `*this` and `s` are the same object,
this function has no effect.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator=(
basic_static_string const& s) noexcept
{
return assign(s);
}
/** Assign to the string.
Replace the contents with a copy of `s`
@throw std::length_error if `s.size() > max_size()`
*/
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator=(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<M, CharT, Traits> const& s)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return assign(s);
}
/** Assign to the string.
Replace the contents with those of the null-terminated string `s`
@throw std::length_error if `Traits::length(s) > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator=(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT const* s)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return assign(s);
}
/** Assign to the string.
Assign from single character.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator=(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT ch)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return assign_char(ch,
Add macro to disable exceptions
2019-12-16 17:36:12 -05:00
std::integral_constant<bool, (N > 0)>{});
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
}
/** Assign to the string.
Assign from initializer list.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator=(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
std::initializer_list<CharT> ilist)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return assign(ilist);
}
/** Assign to the string.
Assign from `string_view_type`.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator=(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
string_view_type sv)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return assign(sv);
}
/** Replace the contents.
Replace the contents with `count` copies of character `ch`
@throw std::length_error if `count > max_size()`
@return `*this`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
assign(
size_type count,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT ch);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Replace the contents.
Replace the contents with a copy of another `basic_static_string`
@return `*this`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
assign(
basic_static_string const& s) noexcept;
/** Replace the contents.
Replace the contents with a copy of another `basic_static_string`
@throw std::length_error if `s.size() > max_size()`
@return `*this`
*/
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
assign(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<M, CharT, Traits> const& s)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
// VFALCO this could come in two flavors,
// N>M and N<M, and skip the exception
// check when N>M
return assign(s.data(), s.size());
}
/** Replace the contents.
Replace the contents with a copy of `count` characters starting at `npos` from `s`.
@throw std::length_error if `count > max_size()`
@return `*this`
*/
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
assign(
basic_static_string<M, CharT, Traits> const& s,
size_type pos,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count = npos);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Replace the contents.
Replace the contents with the first `count` characters of `s`, including nulls.
@throw std::length_error if `count > max_size()`
@return `*this`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
assign(
CharT const* s,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Replace the contents.
Replace the contents with a copy of a null terminated string `s`
@throw std::length_error if `Traits::length(s) > max_size()`
@return `*this`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
assign(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT const* s)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return assign(s, Traits::length(s));
}
/** Replace the contents.
Replace the contents with a copy of characters from the range `(first, last)`
@throw std::length_error if `std::distance(first, last) > max_size()`
@return `*this`
*/
template<typename InputIterator>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#ifdef GENERATING_DOCUMENTATION
basic_static_string&
#else
typename std::enable_if<
detail::is_input_iterator<InputIterator>::value,
basic_static_string&>::type
#endif
assign(
InputIterator first,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
InputIterator last);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Replace the contents.
Replace the contents with the characters in an initializer list
@throw std::length_error if `ilist.size() > max_size()`
@return `*this`
*/
Better constexpr support for insert and replace, fixed range overloads for insert and replace.
2019-12-30 16:44:17 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
basic_static_string&
assign(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
std::initializer_list<CharT> ilist)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return assign(ilist.begin(), ilist.end());
}
/** Replace the contents.
Replace the contents with a copy of the characters from `string_view_type{t}`
@throw std::length_error if `string_view_type{t}.size() > max_size()`
*/
template<typename T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
basic_static_string&
#else
typename std::enable_if<
std::is_convertible<T, string_view_type>::value &&
! std::is_convertible<T, CharT const*>::value,
basic_static_string&>::type
#endif
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
assign(T const& t)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
string_view_type ss{t};
return assign(ss.data(), ss.size());
}
/** Replace the contents.
Replace the contents with a copy of the characters from `string_view_type{t}.substr(pos, count)`
The range `[pos, count)` is extracted from the value
obtained by converting `t` to `string_view_type`,
and used to assign the string.
@throw std::out_of_range if `pos > string_view_type{t}.size()`
@throw std::length_error if `string_view_type{t}.substr(pos, count).size() > max_size()`
*/
template<typename T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
basic_static_string&
#else
typename std::enable_if<
std::is_convertible<T, string_view_type>::value &&
! std::is_convertible<T, CharT const*>::value,
basic_static_string&>::type
#endif
assign(
T const& t,
size_type pos,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count = npos)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return assign(string_view_type{t}.substr(pos, count));
}
//--------------------------------------------------------------------------
//
// Element access
//
//--------------------------------------------------------------------------
/** Access specified character with bounds checking.
@throw std::out_of_range if `pos >= size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
reference
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
at(size_type pos);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Access specified character with bounds checking.
@throw std::out_of_range if `pos >= size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
const_reference
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
at(size_type pos) const;
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Access specified character
Undefined behavior if `pos > size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
reference
operator[](size_type pos) noexcept
{
return data()[pos];
}
/** Access specified character.
Undefined behavior if `pos > size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
const_reference
operator[](size_type pos) const noexcept
{
return data()[pos];
}
/** Accesses the first character.
Undefined behavior if `empty() == true`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
CharT&
front() noexcept
{
return data()[0];
}
/** Accesses the first character.
Undefined behavior if `empty() == true`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
CharT const&
front() const noexcept
{
return data()[0];
}
/** Accesses the last character.
Undefined behavior if `empty() == true`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
CharT&
back() noexcept
{
Chunked docs
2020-01-31 15:30:17 -05:00
return data()[size() - 1];
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
}
/** Accesses the last character.
Undefined behavior if `empty() == true`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
CharT const&
back() const noexcept
{
Chunked docs
2020-01-31 15:30:17 -05:00
return data()[size() - 1];
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
}
/// Returns a pointer to the first character of the string.
BOOST_STATIC_STRING_CPP14_CONSTEXPR
CharT*
data() noexcept
{
return this->data_impl();
}
/// Returns a pointer to the first character of a string.
BOOST_STATIC_STRING_CPP14_CONSTEXPR
CharT const*
data() const noexcept
{
return this->data_impl();
}
/// Returns a non-modifiable standard C character array version of the string.
BOOST_STATIC_STRING_CPP14_CONSTEXPR
CharT const*
c_str() const noexcept
{
return data();
}
/// Convert a static string to a `string_view_type`
BOOST_STATIC_STRING_CPP11_CONSTEXPR
operator string_view_type() const noexcept
{
return string_view_type{data(), size()};
}
//--------------------------------------------------------------------------
//
// Iterators
//
//--------------------------------------------------------------------------
/// Returns an iterator to the beginning.
BOOST_STATIC_STRING_CPP14_CONSTEXPR
iterator
begin() noexcept
{
return data();
}
/// Returns an iterator to the beginning.
BOOST_STATIC_STRING_CPP14_CONSTEXPR
const_iterator
begin() const noexcept
{
return data();
}
/// Returns an iterator to the beginning.
BOOST_STATIC_STRING_CPP14_CONSTEXPR
const_iterator
cbegin() const noexcept
{
return data();
}
/// Returns an iterator to the end.
BOOST_STATIC_STRING_CPP14_CONSTEXPR
iterator
end() noexcept
{
return &data()[size()];
}
/// Returns an iterator to the end.
BOOST_STATIC_STRING_CPP14_CONSTEXPR
const_iterator
end() const noexcept
{
return &data()[size()];
}
/// Returns an iterator to the end.
BOOST_STATIC_STRING_CPP14_CONSTEXPR
const_iterator
cend() const noexcept
{
return &data()[size()];
}
/// Returns a reverse iterator to the beginning.
constexpr reverse iterators
2019-12-16 13:56:16 -05:00
BOOST_STATIC_STRING_CPP17_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
reverse_iterator
rbegin() noexcept
{
return reverse_iterator{end()};
}
/// Returns a reverse iterator to the beginning.
constexpr reverse iterators
2019-12-16 13:56:16 -05:00
BOOST_STATIC_STRING_CPP17_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
const_reverse_iterator
rbegin() const noexcept
{
return const_reverse_iterator{cend()};
}
/// Returns a reverse iterator to the beginning.
constexpr reverse iterators
2019-12-16 13:56:16 -05:00
BOOST_STATIC_STRING_CPP17_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
const_reverse_iterator
crbegin() const noexcept
{
return const_reverse_iterator{cend()};
}
/// Returns a reverse iterator to the end.
constexpr reverse iterators
2019-12-16 13:56:16 -05:00
BOOST_STATIC_STRING_CPP17_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
reverse_iterator
rend() noexcept
{
return reverse_iterator{begin()};
}
/// Returns a reverse iterator to the end.
constexpr reverse iterators
2019-12-16 13:56:16 -05:00
BOOST_STATIC_STRING_CPP17_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
const_reverse_iterator
rend() const noexcept
{
return const_reverse_iterator{cbegin()};
}
/// Returns a reverse iterator to the end.
constexpr reverse iterators
2019-12-16 13:56:16 -05:00
BOOST_STATIC_STRING_CPP17_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
const_reverse_iterator
crend() const noexcept
{
return const_reverse_iterator{cbegin()};
}
//--------------------------------------------------------------------------
//
// Capacity
//
//--------------------------------------------------------------------------
/// Returns `true` if the string is empty.
BOOST_STATIC_STRING_NODISCARD
BOOST_STATIC_STRING_CPP11_CONSTEXPR
bool
empty() const noexcept
{
return size() == 0;
}
/// Returns the number of characters, excluding the null terminator.
BOOST_STATIC_STRING_CPP11_CONSTEXPR
size_type
size() const noexcept
{
return this->size_impl();
}
/** Returns the number of characters, excluding the null terminator
Equivalent to calling `size()`.
*/
BOOST_STATIC_STRING_CPP11_CONSTEXPR
size_type
length() const noexcept
{
return size();
}
/// Returns the maximum number of characters that can be stored, excluding the null terminator.
BOOST_STATIC_STRING_CPP11_CONSTEXPR
size_type
max_size() const noexcept
{
return N;
}
/** Reserve space for `n` characters, excluding the null terminator
This function has no effect when `n <= max_size()`.
@throw std::length_error if `n > max_size()`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
reserve(std::size_t n);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Returns the number of characters that can be held in currently allocated storage.
This function always returns `max_size()`.
*/
BOOST_STATIC_STRING_CPP11_CONSTEXPR
size_type
capacity() const noexcept
{
return max_size();
}
/** Reduces memory usage by freeing unused memory.
This function call has no effect.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
shrink_to_fit() noexcept
{
}
//--------------------------------------------------------------------------
//
// Operations
//
//--------------------------------------------------------------------------
/// Clears the contents
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
clear() noexcept;
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
/** Insert a character.
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.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
insert(
size_type index,
size_type count,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT ch)
Better constexpr support for insert and replace, fixed range overloads for insert and replace.
2019-12-30 16:44:17 -05:00
{
BOOST_STATIC_STRING_THROW_IF(
index > size(), std::out_of_range{"index > size()"});
insert(begin() + index, count, ch);
return *this;
}
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
/** Insert a string.
Inserts the null-terminated character string pointed to by `s`
of length `count` at the position `index` where `count`
is `Traits::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.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
insert(
size_type index,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT const* s)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return insert(index, s, Traits::length(s));
}
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
/** Insert a string.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
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.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
insert(
size_type index,
CharT const* s,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
/** Insert a string.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
Inserts the string `str`
at the position `index`.
@par Exception Safety
Strong guarantee.
Used library comparison functions to compare pointers
2020-02-01 15:22:50 -05:00
@note The insertion is done unchecked when
the capacity of `str` differs from that of the
string the function is called on.
Added unchecked insertion
2020-02-01 14:40:30 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
@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.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
Modify insert overloads
2020-01-30 00:06:33 -05:00
template<std::size_t M>
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
insert(
size_type index,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
const basic_static_string<M, CharT, Traits>& str)
Added unchecked insertion
2020-02-01 14:40:30 -05:00
{
return insert_unchecked(index, str.data(), str.size());
}
Used library comparison functions to compare pointers
2020-02-01 15:22:50 -05:00
#ifndef GENERATING_DOCUMENTATION
Added unchecked insertion
2020-02-01 14:40:30 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
insert(
size_type index,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
const basic_static_string& str)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
Modify insert overloads
2020-01-30 00:06:33 -05:00
return insert(index, str.data(), str.size());
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
}
Used library comparison functions to compare pointers
2020-02-01 15:22:50 -05:00
#endif
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
/** Insert a string.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
Inserts a string, obtained by `str.substr(index_str, count)`
at the position `index`.
@par Exception Safety
Strong guarantee.
Used library comparison functions to compare pointers
2020-02-01 15:22:50 -05:00
@note The insertion is done unchecked when
the capacity of `str` differs from that of the
string the function is called on.
Added unchecked insertion
2020-02-01 14:40:30 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
@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.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
@param index The index to insert at.
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
@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()`
Update copyright, add throw condition to replace/insert
2020-02-01 13:51:40 -05:00
@throw std::out_of_range `index_str > str.size()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
Modify insert overloads
2020-01-30 00:06:33 -05:00
template<std::size_t M>
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
insert(
size_type index,
Modify insert overloads
2020-01-30 00:06:33 -05:00
const basic_static_string<M, CharT, Traits>& str,
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
size_type index_str,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count = npos)
Added unchecked insertion
2020-02-01 14:40:30 -05:00
{
BOOST_STATIC_STRING_THROW_IF(
index_str > str.size(), std::out_of_range{"index_str > str.size()"}
);
return insert_unchecked(index, str.data() + index_str, (std::min)(count, str.size() - index_str));
}
Used library comparison functions to compare pointers
2020-02-01 15:22:50 -05:00
#ifndef GENERATING_DOCUMENTATION
Added unchecked insertion
2020-02-01 14:40:30 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
insert(
size_type index,
const basic_static_string& str,
size_type index_str,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count = npos)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
Throw when pos2 is out of range
2020-02-01 13:59:06 -05:00
BOOST_STATIC_STRING_THROW_IF(
index_str > str.size(), std::out_of_range{"index_str > str.size()"}
);
Modify insert overloads
2020-01-30 00:06:33 -05:00
return insert(index, str.data() + index_str, (std::min)(count, str.size() - index_str));
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
}
Used library comparison functions to compare pointers
2020-02-01 15:22:50 -05:00
#endif
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
/** Insert a character.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
Inserts the character `ch` before the character pointed by `pos`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
iterator
insert(
const_iterator pos,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT ch)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return insert(pos, 1, ch);
}
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
/** Insert characters.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
Inserts `count` copies of `ch` before the character pointed by `pos`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
@par Precondition
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
`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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
iterator
insert(
const_iterator pos,
size_type count,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT ch);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
/** Insert a range of characters.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
Inserts characters from the range `[first, last)` before the
character pointed to by `pos`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<typename InputIterator>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
iterator
#else
typename std::enable_if<
Fix InputIterator overloads
2019-12-30 21:12:20 -05:00
detail::is_input_iterator<
InputIterator>::value &&
! detail::is_forward_iterator<
InputIterator>::value, iterator>::type
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
#endif
insert(
const_iterator pos,
InputIterator first,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
InputIterator last);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
/** Insert a range of characters.
Fix InputIterator overloads
2019-12-30 21:12:20 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
Inserts characters from the range `[first, last)` before the
character pointed to by `pos`.
Fix InputIterator overloads
2019-12-30 21:12:20 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
@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 ForwardIterator The type of the iterators.
@par Constraints
`InputIterator` satisfies __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()`
*/
Fix InputIterator overloads
2019-12-30 21:12:20 -05:00
template<typename ForwardIterator>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
iterator
#else
typename std::enable_if<
detail::is_forward_iterator<
ForwardIterator>::value,
iterator>::type
#endif
insert(
const_iterator pos,
ForwardIterator first,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
ForwardIterator last);
Fix InputIterator overloads
2019-12-30 21:12:20 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
/** Insert characters from an initializer list.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
Inserts characters from `ilist` before `pos`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Fix InputIterator overloads
2019-12-30 21:12:20 -05:00
iterator
insert(
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
const_iterator pos,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
std::initializer_list<CharT> ilist)
Added unchecked insertion
2020-02-01 14:40:30 -05:00
{
const auto offset = pos - begin();
return insert_unchecked(offset, ilist.begin(), ilist.size()).begin() + offset;
}
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
/** Insert characters from an object convertible to `string_view_type`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
Constructs a temporary `string_view_type` object `sv` from `t` and
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
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.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
@tparam T The type of the object to convert.
@par Constraints
`std::is_convertible<T const&, string_view>::value &&
!std::is_convertible<T const&, char CharT*>::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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<typename T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
basic_static_string&
#else
typename std::enable_if<
std::is_convertible<
T const&, string_view_type>::value &&
! std::is_convertible<
T const&, CharT const*>::value,
basic_static_string&>::type
#endif
insert(
size_type index,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
T const& t)
Better constexpr support for insert and replace, fixed range overloads for insert and replace.
2019-12-30 16:44:17 -05:00
{
return insert(index, t, 0, npos);
}
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
/** Insert characters from an object convertible to `string_view_type`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
Constructs a temporary `string_view_type` object `sv` from `t`
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
and inserts `sv.substr(index_str, count)` at `index`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
@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<T const&, string_view>::value &&
!std::is_convertible<T const&, CharT const*>::value`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
@param index The index to insert at.
@param t The string to insert from.
Chunked docs
2020-01-31 15:30:17 -05:00
@param index_str The index in the temporary `string_view_type` object
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
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()`
Update copyright, add throw condition to replace/insert
2020-02-01 13:51:40 -05:00
@throw std::out_of_range `index_str > sv.size()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<typename T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
basic_static_string&
#else
typename std::enable_if<
std::is_convertible<T const&, string_view_type>::value &&
! std::is_convertible<T const&, CharT const*>::value,
basic_static_string&>::type
#endif
insert(
size_type index,
T const& t,
size_type index_str,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count = npos)
Better constexpr support for insert and replace, fixed range overloads for insert and replace.
2019-12-30 16:44:17 -05:00
{
auto const s = string_view_type(t).substr(index_str, count);
return insert(index, s.data(), s.size());
}
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Removes `min(count, size() - index)` characters starting at `index`
@throw std::out_of_range if `index > size()`
@return `*this`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
erase(
size_type index = 0,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count = npos);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Removes the character at `pos`
@return iterator pointing to the character immediately following the character erased, or `end()` if no such character exists
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
iterator
erase(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
const_iterator pos);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Removes the characters in the range `(first, last)`
@return iterator pointing to the character last pointed to before the erase, or `end()` if no such character exists
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
iterator
erase(
const_iterator first,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
const_iterator last);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Appends the given character `ch` to the end of the string.
Fixed overflow checks
2019-12-16 16:56:19 -05:00
@throw std::length_error if `1 > max_size() - size()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
push_back(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT ch);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Removes the last character from the string
The behavior is undefined if the string is empty.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
pop_back() noexcept
{
BOOST_STATIC_STRING_ASSERT(size() > 0);
this->set_size(size() - 1);
term();
}
/** Appends `count` copies of character `ch`
The appended characters may be null.
Fixed overflow checks
2019-12-16 16:56:19 -05:00
@throw std::length_error if `count > max_size() - size()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
append(
size_type count,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT ch)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return insert(size(), count, ch);
}
/** Append to the string.
Appends the contents of string view `sv`
The appended string can contain null characters.
Fixed overflow checks
2019-12-16 16:56:19 -05:00
@throw std::length_error if `sv.size() > max_size() - size()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
append(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
string_view_type sv)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return append(sv.data(), sv.size());
}
/** Append to the string.
Appends the contents of `sv.substr(pos, count)`
The appended string can contain null characters.
@throw std::out_of_range if `pos > sv.size()`
Fixed overflow checks
2019-12-16 16:56:19 -05:00
@throw std::length_error if `sv.substr(pos, count).size() > max_size() - size()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
append(
string_view_type sv,
size_type pos,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count = npos)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return append(sv.substr(pos, count));
}
/** Append to the string.
Appends characters in the range `(s, s + count)`
The appended string can contain null characters.
Fixed overflow checks
2019-12-16 16:56:19 -05:00
@throw std::length_error if `count > max_size() - size()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
append(
CharT const* s,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/** Append to the string.
Appends the null-terminated character string pointed to by `s`
The length of the string is determined by the first
null character using `Traits::length(s)`.
Fixed overflow checks
2019-12-16 16:56:19 -05:00
@throw std::length_error if `Traits::length(s) > max_size() - size()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
append(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT const* s)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return append(s, Traits::length(s));
}
/** Append to the string.
Appends characters from the range `(first, last)`
The inserted string can contain null characters.
This function does not participate in overload resolution if
`InputIterator` does not satisfy <em>LegacyInputIterator</em>
Fixed overflow checks
2019-12-16 16:56:19 -05:00
@throw std::length_error if `std::distance(first, last) > max_size() - size()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
*/
template<typename InputIterator>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
basic_static_string&
#else
typename std::enable_if<
detail::is_input_iterator<InputIterator>::value,
basic_static_string&>::type
#endif
append(
InputIterator first,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
InputIterator last)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
insert(end(), first, last);
return *this;
}
/** Append to the string.
Appends characters from initializer list `ilist`
The appended string can contain null characters.
Fixed overflow checks
2019-12-16 16:56:19 -05:00
@throw std::length_error if `ilist.size() > max_size() - size()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
append(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
std::initializer_list<CharT> ilist)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
insert(end(), ilist);
return *this;
}
/** Append to the string.
Fix test and standalone support
2019-12-16 18:19:01 -05:00
Appends characters from `string_view_type{t}`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
The appended string can contain null characters.
This function participates in overload resolution if
Chunked docs
2020-01-31 15:30:17 -05:00
`T` is convertible to `string_view_type` and `T` is not
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
convertible to `CharT const*`.
Fix test and standalone support
2019-12-16 18:19:01 -05:00
@throw std::length_error if `string_view_type{t}.size() > max_size() - size()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
*/
template<typename T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
basic_static_string&
#else
typename std::enable_if<
std::is_convertible<
T const&, string_view_type>::value &&
! std::is_convertible<
T const&, CharT const*>::value,
basic_static_string&>::type
#endif
append(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
T const& t)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
Fix test and standalone support
2019-12-16 18:19:01 -05:00
return append(string_view_type{t});
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
}
/** Append to the string.
Fix test and standalone support
2019-12-16 18:19:01 -05:00
Appends characters from `string_view_type{t}.substr{pos, count}`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
The appended string can contain null characters.
This function participates in overload resolution if
Fix test and standalone support
2019-12-16 18:19:01 -05:00
`T` is convertible to `string_view_type` and `T` is not
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
convertible to `CharT const*`.
Fix test and standalone support
2019-12-16 18:19:01 -05:00
@throw std::out_of_range if `pos > string_view_type{t}.size()`
@throw std::length_error if `string_view_type{t}.substr(pos, count).size() > max_size() - size()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
*/
template<typename T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
basic_static_string&
#else
typename std::enable_if<
std::is_convertible<
T const&, string_view_type>::value &&
! std::is_convertible<
T const&, CharT const*>::value,
basic_static_string&>::type
#endif
append(
T const& t,
size_type pos,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count = npos)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
Fix test and standalone support
2019-12-16 18:19:01 -05:00
return append(string_view_type{t}.substr(pos, count));
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
}
/** Append to the string.
Fixed overflow checks
2019-12-16 16:56:19 -05:00
@throw std::length_error if `s.size() > max_size() - size()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator+=(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<M, CharT, Traits> const& s)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return append(s.data(), s.size());
}
/** Append to the string.
Appends the given character `ch` to the end of the string.
Fixed overflow checks
2019-12-16 16:56:19 -05:00
@throw std::length_error if `1 > max_size() - size()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator+=(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT ch)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
push_back(ch);
return *this;
}
/** Append to the string.
Appends the null-terminated character string pointed to by `s`
The length of the string is determined by the first
null character using `Traits::length(s)`.
Fixed overflow checks
2019-12-16 16:56:19 -05:00
@throw std::length_error if `Traits::length(s) > max_size() - size()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator+=(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT const* s)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return append(s);
}
/** Append to the string.
Appends characters from initializer list `ilist`
The appended string can contain null characters.
Fixed overflow checks
2019-12-16 16:56:19 -05:00
@throw std::length_error if `ilist.size() > max_size() - size()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
operator+=(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
std::initializer_list<CharT> ilist)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return append(ilist);
}
/** Append to the string.
Appends a copy of the characters from `string_view_type{t}`
The appended string can contain null characters.
This function participates in overload resolution if
Fix test and standalone support
2019-12-16 18:19:01 -05:00
`T` is convertible to `string_view_type` and `T` is not
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
convertible to `CharT const*`.
@throw std::length_error if `string_view_type{t}.size() > max_size()`
*/
template<typename T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
basic_static_string&
#else
typename std::enable_if<
std::is_convertible<T, string_view_type>::value &&
! std::is_convertible<T, CharT const*>::value,
basic_static_string&>::type
#endif
operator+=(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
T const& t)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return append(t);
}
/** Compare the string with another.
Compares this string to `s`.
*/
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
int
compare(
basic_static_string<M, CharT, Traits> const& s) const noexcept
{
return detail::lexicographical_compare<CharT, Traits>(
data(), size(), s.data(), s.size());
}
/** Compare the string with another.
Compares a `[pos1, pos1+count1)` substring of this string to `s`. If `count1 > size() - pos1` the substring is `[pos1, size())`.
*/
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
int
compare(
size_type pos1,
size_type count1,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<M, CharT, Traits> const& s) const
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return detail::lexicographical_compare<CharT, Traits>(
subview(pos1, count1), s.data(), s.size());
}
/** Compare the string with another.
Compares a `[pos1, pos1+count1)` substring of this string to a substring `[pos2, pos2+count2)` of `s`.
If `count1 > size() - pos1` the first substring is `[pos1, size())`. Likewise, if `count2 > s.size() - pos2` the
second substring is `[pos2, s.size())`.
*/
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
int
compare(
size_type pos1,
size_type count1,
basic_static_string<M, CharT, Traits> const& s,
size_type pos2,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count2 = npos) const
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return detail::lexicographical_compare(
subview(pos1, count1), s.subview(pos2, count2));
}
/** Compare the string with another.
Compares this string to the null-terminated character sequence beginning at the character pointed to by `s` with length `Traits::length(s)`.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
int
compare(
CharT const* s) const noexcept
{
return detail::lexicographical_compare<CharT, Traits>(
data(), size(), s, Traits::length(s));
}
/** Compare the string with another.
Compares a `[pos1, pos1+count1)` substring of this string to the null-terminated character sequence beginning at the character pointed to by `s` with
length `Traits::length(s)`. If `count1 > size() - pos1` the substring is `[pos1, size())`.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
int
compare(
size_type pos1,
size_type count1,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT const* s) const
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return detail::lexicographical_compare<CharT, Traits>(
subview(pos1, count1), s, Traits::length(s));
}
/** Compare the string with another.
Compares a `[pos1, pos1+count1)` substring of this string to the characters in the range `[s, s + count2)`. If `count1 > size() - pos1` the substring is `[pos1, size())`.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
int
compare(
size_type pos1,
size_type count1,
CharT const* s,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count2) const
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return detail::lexicographical_compare<CharT, Traits>(
subview(pos1, count1), s, count2);
}
/** Compare the string with another.
Compares this string to `s`.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
int
compare(
string_view_type s) const noexcept
{
return detail::lexicographical_compare<CharT, Traits>(
data(), size(), s.data(), s.size());
}
/** Compare the string with another.
Compares a `[pos1, pos1+count1)` substring of this string to `s`. If `count1 > size() - pos1` the substring is `[pos1, size())`.
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
int
compare(
size_type pos1,
size_type count1,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
string_view_type s) const
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return detail::lexicographical_compare<CharT, Traits>(
subview(pos1, count1), s);
}
/** Compare the string with another.
Replaces the part of the string indicated by `[pos1, pos1 + count1)` with a substring `[pos2, pos2 + count2)` of `t` after converting to `string_view_type`.
This function participates in overload resolution if
Chunked docs
2020-01-31 15:30:17 -05:00
`T` is convertible to `string_view_type` and `T` is not
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
convertible to `CharT const*`.
*/
template<typename T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
int
#else
typename std::enable_if<
std::is_convertible<T const&, string_view_type>::value &&
! std::is_convertible<T const&, CharT const*>::value,
int>::type
#endif
compare(
size_type pos1,
size_type count1,
T const& t,
size_type pos2,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count2 = npos) const
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return compare(pos1, count1,
string_view_type(t).substr(pos2, count2));
}
Chunked docs
2020-01-31 15:30:17 -05:00
/** Return a substring.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string
substr(
size_type pos = 0,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count = npos) const;
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
/** Return a view of a substring.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
Returns a view of a substring.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
string_view_type
subview(
size_type pos = 0,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count = npos) const;
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
/** Copy a substring to another string.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
copy(
CharT* dest,
size_type count,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type pos = 0) const;
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
/** Change the size of the string.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
resize(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
std::size_t n);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
/** Change the size of the string.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
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()`
*/
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
resize(
std::size_t n,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT c);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
/// Exchange the contents of this string with another.
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
swap(
basic_static_string& s) noexcept;
/// Exchange the contents of this string with another.
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
swap(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<M, CharT, Traits>& s);
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
/** Replace a substring with a 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.
Used library comparison functions to compare pointers
2020-02-01 15:22:50 -05:00
@note The replacement is done unchecked when
the capacity of `str` differs from that of the
string the function is called on.
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
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.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
size_type pos1,
size_type n1,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
const basic_static_string<M, CharT, Traits>& str)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
Fixed exception checks for ranges, less repetition
2020-01-01 15:01:39 -05:00
return replace_unchecked(pos1, n1, str.data(), str.size());
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
}
Used library comparison functions to compare pointers
2020-02-01 15:22:50 -05:00
#ifndef GENERATING_DOCUMENTATION
Fix unchecked replacement.
2020-01-01 15:38:41 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
basic_static_string&
replace(
Fix unchecked replacement.
2020-01-01 15:38:41 -05:00
size_type pos1,
size_type n1,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
const basic_static_string& str)
Fix unchecked replacement.
2020-01-01 15:38:41 -05:00
{
return replace(pos1, n1, str.data(), str.size());
}
Used library comparison functions to compare pointers
2020-02-01 15:22:50 -05:00
#endif
Fix unchecked replacement.
2020-01-01 15:38:41 -05:00
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
/** Replace a substring with a substring.
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.
Used library comparison functions to compare pointers
2020-02-01 15:22:50 -05:00
@note The replacement is done unchecked when
the capacity of `str` differs from that of the
string the function is called on.
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
All references, pointers, or iterators
referring to contained elements are invalidated. Any
past-the-end iterators are also invalidated.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
@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()`
Update copyright, add throw condition to replace/insert
2020-02-01 13:51:40 -05:00
@throw std::out_of_range `pos2 > str.size()`
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
*/
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
size_type pos1,
size_type n1,
const basic_static_string<M, CharT, Traits>& str,
size_type pos2,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type n2 = npos)
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
{
Throw when pos2 is out of range
2020-02-01 13:59:06 -05:00
BOOST_STATIC_STRING_THROW_IF(
pos2 > str.size(), std::out_of_range{"pos2 > str.size()"}
);
Fix unchecked replacement
2020-02-01 13:50:50 -05:00
return replace_unchecked(pos1, n1, str.data() + pos2, (std::min)(n2, str.size() - pos2));
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
}
Used library comparison functions to compare pointers
2020-02-01 15:22:50 -05:00
#ifndef GENERATING_DOCUMENTATION
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
size_type pos1,
size_type n1,
const basic_static_string& str,
size_type pos2,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type n2 = npos)
Used library comparison functions to compare pointers
2020-02-01 15:22:50 -05:00
{
BOOST_STATIC_STRING_THROW_IF(
pos2 > str.size(), std::out_of_range{"pos2 > str.size()"}
);
return replace(pos1, n1, str.data() + pos2, (std::min)(n2, str.size() - pos2));
}
#endif
Chunked docs
2020-01-31 15:30:17 -05:00
/** Replace a substring with an object convertible to `string_view_type`.
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
Constructs a temporary `string_view_type` object `sv` from `t`, and
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
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<T const&, string_view>::value &&
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
!std::is_convertible<T const&, char CharT*>::value`.
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<typename T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
basic_static_string&
#else
typename std::enable_if<
std::is_convertible<T, string_view_type>::value &&
! std::is_convertible<T, CharT const*>::value,
basic_static_string&>::type
#endif
replace(
size_type pos1,
size_type n1,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
const T& t)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
string_view_type sv = t;
return replace(pos1, n1, sv.data(), sv.size());
}
Chunked docs
2020-01-31 15:30:17 -05:00
/** Replace a substring with a substring of an object convertible to `string_view_type`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
Constructs a temporary `string_view_type` object `sv` from `t`, and
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
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<T const&, string_view>::value &&
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
!std::is_convertible<T const&, char CharT*>::value`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
@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()`
Update copyright, add throw condition to replace/insert
2020-02-01 13:51:40 -05:00
@throw std::out_of_range `pos2 > sv.size()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<typename T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
basic_static_string&
#else
typename std::enable_if<
std::is_convertible<T, string_view_type>::value &&
! std::is_convertible<T, CharT const*>::value,
basic_static_string&>::type
#endif
replace(
size_type pos1,
size_type n1,
const T& t,
size_type pos2,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type n2 = npos)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
string_view_type sv = t;
return replace(pos1, n1, sv.substr(pos2, n2));
}
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
/** Replace a substring with a 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.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
size_type pos,
size_type n1,
const CharT* s,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type n2);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
/** Replace a substring with a string.
Replaces `rcount` characters starting at index `pos` with those of
`[s, s + len)`, where the length of the string `len` is `Traits::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.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
size_type pos,
size_type n1,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
const CharT* s)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return replace(pos, n1, s, Traits::length(s));
}
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
/** Replace a substring with copies of a character.
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.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
size_type pos,
size_type n1,
size_type n2,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT c);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
/** Replace a range with a 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 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.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
template<std::size_t M>
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
const_iterator i1,
const_iterator i2,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
const basic_static_string<M, CharT, Traits>& str)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return replace(i1, i2, str.data(), str.size());
}
Chunked docs
2020-01-31 15:30:17 -05:00
/** Replace a range with an object convertible to `string_view_type`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
Constructs a temporary `string_view_type` object `sv` from `t`, and
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
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<T const&, string_view>::value &&
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
!std::is_convertible<T const&, char CharT*>::value`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<typename T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
basic_static_string&
#else
typename std::enable_if<
std::is_convertible<T, string_view_type>::value &&
! std::is_convertible<T, CharT const*>::value,
basic_static_string&>::type
#endif
replace(
const_iterator i1,
const_iterator i2,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
const T& t)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
string_view_type sv = t;
return replace(i1 - begin(), i2 - i1, sv.data(), sv.size());
}
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
/** Replace a range with a 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.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
const_iterator i1,
const_iterator i2,
const CharT* s,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type n)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return replace(i1 - begin(), i2 - i1, s, n);
}
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
/** Replace a range with a string.
Replaces the characters in the range `[i1, i2)` with those of
`[s, s + len)`, where the length of the string `len` is `Traits::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.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
const_iterator i1,
const_iterator i2,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
const CharT* s)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return replace(i1, i2, s, Traits::length(s));
}
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
/** Replace a range with copies of a character.
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.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace(
const_iterator i1,
const_iterator i2,
size_type n,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT c)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return replace(i1 - begin(), i2 - i1, n, c);
}
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
/** Replace a range with a range.
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.
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
@tparam InputIterator The type of the iterators.
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
@par Constraints
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
`InputIterator` satisfies __InputIterator__ and does not
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
satisfy __ForwardIterator__.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<typename InputIterator>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
basic_static_string&
#else
typename std::enable_if<
Fix InputIterator overloads
2019-12-30 21:12:20 -05:00
detail::is_input_iterator<
InputIterator>::value &&
! detail::is_forward_iterator<
InputIterator>::value,
basic_static_string<N, CharT, Traits>&>::type
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
#endif
replace(
const_iterator i1,
const_iterator i2,
InputIterator j1,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
InputIterator j2);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
/** Replace a range with a range.
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.
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
@tparam ForwardIterator The type of the iterators.
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
@par Constraints
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
`ForwardIterator` satisfies __ForwardIterator__.
Fix InputIterator overloads
2019-12-30 21:12:20 -05:00
@return `*this`
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
@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() + (std::distance(j1, j2) - std::distance(i1, i2)) > max_size()`
Fix InputIterator overloads
2019-12-30 21:12:20 -05:00
*/
template<typename ForwardIterator>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
basic_static_string&
#else
typename std::enable_if<
detail::is_forward_iterator<
ForwardIterator>::value,
basic_static_string<N, CharT, Traits>&>::type
#endif
replace(
const_iterator i1,
const_iterator i2,
ForwardIterator j1,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
ForwardIterator j2);
Fix InputIterator overloads
2019-12-30 21:12:20 -05:00
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
/** Replace a range with an initializer list.
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.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
@return `*this`
Improved docs for replace, added unchecked variant for overload
2020-01-29 23:35:31 -05:00
@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()`
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Fixed exception checks for ranges, less repetition
2020-01-01 15:01:39 -05:00
basic_static_string&
replace(
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
const_iterator i1,
const_iterator i2,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
std::initializer_list<CharT> il)
Fixed exception checks for ranges, less repetition
2020-01-01 15:01:39 -05:00
{
return replace_unchecked(i1 - begin(), i2 - i1, il.begin(), il.size());
}
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
//--------------------------------------------------------------------------
//
// Search
//
//--------------------------------------------------------------------------
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the first occurrence of a string within the string.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
Constructs a temporary `string_view_type` object `sv` from `t`, and finds
Better docs for find functions
2020-01-29 21:15:27 -05:00
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<T const&, string_view>::value &&
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
!std::is_convertible<T const&, char CharT*>::value`.
Better docs for find functions
2020-01-29 21:15:27 -05:00
@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`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<class T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
size_type
#else
typename std::enable_if<
std::is_convertible<T, string_view_type>::value &&
! std::is_convertible<T, CharT const*>::value,
size_type>::type
#endif
find(
const T& t,
Finish more complex exception specifications
2019-12-16 13:52:55 -05:00
size_type pos = 0) const noexcept(detail::is_nothrow_convertible<const T&,
string_view_type>::value)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
string_view_type sv = t;
return find(sv.data(), pos, sv.size());
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the first occurrence of a string within the string.
Finds the first occurrence of `str` within the
string starting at the index `pos`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Better docs for find functions
2020-01-29 21:15:27 -05:00
@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`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
Better docs for find functions
2020-01-29 21:15:27 -05:00
find(
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
const basic_static_string<M, CharT, Traits>& str,
size_type pos = 0) const noexcept
{
return find(str.data(), pos, str.size());
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** 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.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find(
const CharT* s,
size_type pos,
size_type n) const noexcept;
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** 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::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`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find(
const CharT* s,
size_type pos = 0) const noexcept
{
return find(s, pos, Traits::length(s));
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** 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`.
*/
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find(
CharT c,
size_type pos = 0) const noexcept
{
return find(&c, pos, 1);
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the last occurrence of a string within the string.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
Constructs a temporary `string_view_type` object `sv` from `t`, and finds
Better docs for find functions
2020-01-29 21:15:27 -05:00
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<T const&, string_view>::value &&
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
!std::is_convertible<T const&, char CharT*>::value`.
Better docs for find functions
2020-01-29 21:15:27 -05:00
@return The highest index `idx` less 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 @ref npos.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<class T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
size_type
#else
typename std::enable_if<
std::is_convertible<T, string_view_type>::value &&
! std::is_convertible<T, CharT const*>::value,
size_type>::type
#endif
rfind(
const T& t,
Finish more complex exception specifications
2019-12-16 13:52:55 -05:00
size_type pos = npos) const noexcept(detail::is_nothrow_convertible<const T&,
string_view_type>::value)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
string_view_type sv = t;
return rfind(sv.data(), pos, sv.size());
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the last occurrence of a string within the string.
Finds the last occurrence of `str` within the string
starting before or at the index `pos`.
@par Complexity
Linear.
@return The highest index `idx` less 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 @ref npos.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
rfind(
const basic_static_string<M, CharT, Traits>& str,
size_type pos = npos) const noexcept
{
return rfind(str.data(), pos, str.size());
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the last occurrence of a string within the string.
Finds the last occurrence of the string pointed to
by `s` within the string starting before or at
the index `pos`.
@par Complexity
Linear.
@return The highest index `idx` less 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.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
rfind(
const CharT* s,
size_type pos,
size_type n) const noexcept;
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the last occurrence of a string within the string.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Better docs for find functions
2020-01-29 21:15:27 -05:00
Finds the last occurrence of the string pointed to by `s`
of length `count` within the string starting before or at the
index `pos`, where `count` is `Traits::length(s)`.
@par Complexity
Linear.
@return The highest index `idx` less 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 stop searching at. The default argument
for this parameter is @ref npos.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
rfind(
const CharT* s,
size_type pos = npos) const noexcept
{
return rfind(s, pos, Traits::length(s));
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the last occurrence of a character within the string.
Finds the last occurrence of `c` within the string
starting before or at the index `pos`.
@par Complexity
Linear.
@return The index corrosponding to the last occurrence of `c` within
`[begin(), begin() + pos]` if it exists, and @ref npos otherwise.
@param c The character to search for.
@param pos The index to stop searching at. The default argument
for this parameter is @ref npos.
*/
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
rfind(
CharT c,
size_type pos = npos) const noexcept
{
return rfind(&c, pos, 1);
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the first occurrence of any of the characters within the string.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
Constructs a temporary `string_view_type` object `sv` from `t`, and finds
Better docs for find functions
2020-01-29 21:15:27 -05:00
the first occurrence of any of the characters in `sv`
within the string starting at the index `pos`.
@par Complexity
Linear.
@tparam T The type of the object to convert.
@par Constraints
`std::is_convertible<T const&, string_view>::value &&
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
!std::is_convertible<T const&, char CharT*>::value`.
Better docs for find functions
2020-01-29 21:15:27 -05:00
@return The index corrosponding to the first occurrence of
any of the characters in `[sv.begin(), sv.end())` within
`[begin() + pos, end())` if it exists, and @ref npos otherwise.
@param t The characters to search for.
@param pos The index to start searching at. The default argument
for this parameter is `0`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<class T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
size_type
#else
typename std::enable_if<
std::is_convertible<T, string_view_type>::value &&
! std::is_convertible<T, CharT const*>::value,
size_type>::type
#endif
find_first_of(
const T& t,
Finish more complex exception specifications
2019-12-16 13:52:55 -05:00
size_type pos = 0) const noexcept(detail::is_nothrow_convertible<const T&,
string_view_type>::value)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
string_view_type sv = t;
return find_first_of(sv.data(), pos, sv.size());
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the first occurrence of any of the characters within the string.
Finds the first occurrence of any of the characters within `str` within the
string starting at the index `pos`.
@par Complexity
Linear.
@return The index corrosponding to the first occurrence of any of the characters
of `str` within `[begin() + pos, end())` if it exists, and @ref npos otherwise.
@param str The characters to search for.
@param pos The index to start searching at. The default argument for
this parameter is `0`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find_first_of(
const basic_static_string<M, CharT, Traits>& str,
size_type pos = 0) const noexcept
{
return find_first_of(str.data(), pos, str.size());
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the first occurrence of any of the characters within the string.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Better docs for find functions
2020-01-29 21:15:27 -05:00
Finds the first occurrence of any of the characters within the string pointed to
by `s` within the string starting at the index `pos`.
@par Complexity
Linear.
@return The index corrosponding to the first occurrence
of any of the characters in `[s, s + n)` within `[begin() + pos, end())`
if it exists, and @ref npos otherwise.
@param s The characters to search for.
@param pos The index to start searching at.
@param n The length of the string to search for.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find_first_of(
const CharT* s,
size_type pos,
size_type n) const noexcept;
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the first occurrence of any of the characters within the string.
Finds the first occurrence of the any of the characters within string
pointed to by `s` of length `count` within the string starting at the
index `pos`, where `count` is `Traits::length(s)`.
@par Complexity
Linear.
@return The index corrosponding to the first occurrence of any of
the characters in `[s, s + count)` within
`[begin() + pos, end())` if it exists, and @ref npos otherwise.
@param s The characters to search for.
@param pos The index to start searching at. The default argument
for this parameter is `0`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find_first_of(
const CharT* s,
size_type pos = 0) const noexcept
{
return find_first_of(s, pos, Traits::length(s));
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** 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`.
*/
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find_first_of(
CharT c,
size_type pos = 0) const noexcept
{
return find_first_of(&c, pos, 1);
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the last occurrence of any of the characters within the string.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
Constructs a temporary `string_view_type` object `sv` from `t`, and finds
Better docs for find functions
2020-01-29 21:15:27 -05:00
the last occurrence of any of the characters in `sv`
within the string before or at the index `pos`.
@par Complexity
Linear.
@tparam T The type of the object to convert.
@par Constraints
`std::is_convertible<T const&, string_view>::value &&
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
!std::is_convertible<T const&, char CharT*>::value`.
Better docs for find functions
2020-01-29 21:15:27 -05:00
@return The index corrosponding to the last occurrence of
any of the characters in `[sv.begin(), sv.end())` within
`[begin(), begin() + pos]` if it exists, and @ref npos otherwise.
@param t The characters to search for.
@param pos The index to stop searching at. The default argument
for this parameter is @ref npos.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<class T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
size_type
#else
typename std::enable_if<
std::is_convertible<T, string_view_type>::value &&
! std::is_convertible<T, CharT const*>::value,
size_type>::type
#endif
find_last_of(
const T& t,
Finish more complex exception specifications
2019-12-16 13:52:55 -05:00
size_type pos = npos) const noexcept(detail::is_nothrow_convertible<const T&,
string_view_type>::value)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
string_view_type sv = t;
return find_last_of(sv.data(), pos, sv.size());
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the last occurrence of any of the characters within the string.
Finds the last occurrence of any of the characters within `str` within the
string starting before or at the index `pos`.
@par Complexity
Linear.
@return The index corrosponding to the last occurrence of any of the characters
of `str` within `[begin(), begin() + pos]` if it exists, and @ref npos otherwise.
@param str The characters to search for.
@param pos The index to stop searching at. The default argument for
this parameter is @ref npos.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find_last_of(
const basic_static_string<M, CharT, Traits>& str,
size_type pos = npos) const noexcept
{
return find_last_of(str.data(), pos, str.size());
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the last occurrence of any of the characters within the string.
Finds the last occurrence of any of the characters within the string pointed to
by `s` within the string before or at the index `pos`.
@par Complexity
Linear.
@return The index corrosponding to the last occurrence
of any of the characters in `[s, s + n)` within `[begin(), begin() + pos]`
if it exists, and @ref npos otherwise.
@param s The characters to search for.
@param pos The index to stop searching at.
@param n The length of the string to search for.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find_last_of(
const CharT* s,
size_type pos,
size_type n) const noexcept;
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the last occurrence of any of the characters within the string.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Better docs for find functions
2020-01-29 21:15:27 -05:00
Finds the last occurrence of any of the characters within the string pointed to
by `s` of length `count` within the string before or at the index `pos`,
where `count` is `Traits::length(s)`.
@par Complexity
Linear.
@return The index corrosponding to the last occurrence
of any of the characters in `[s, s + count)` within `[begin(), begin() + pos]`
if it exists, and @ref npos otherwise.
@param s The characters to search for.
@param pos The index to stop searching at. The default argument for
this parameter is @ref npos.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find_last_of(
const CharT* s,
size_type pos = npos) const noexcept
{
return find_last_of(s, pos, Traits::length(s));
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the last occurrence of a character within the string.
Finds the last occurrence of `c` within the string
before or at the index `pos`.
@par Complexity
Linear.
@return The index corrosponding to the last occurrence of `c` within
`[begin(), begin() + pos]` if it exists, and @ref npos otherwise.
@param c The character to search for.
@param pos The index to stop searching at. The default argument
for this parameter is @ref npos.
*/
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find_last_of(
CharT c,
size_type pos = npos) const noexcept
{
return find_last_of(&c, pos, 1);
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the first occurrence of a character not within the string.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
Constructs a temporary `string_view_type` object `sv` from `t`, and finds
Better docs for find functions
2020-01-29 21:15:27 -05:00
the first character that is not within `sv`, starting at the index `pos`.
@par Complexity
Linear.
@tparam T The type of the object to convert.
@par Constraints
`std::is_convertible<T const&, string_view>::value &&
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
!std::is_convertible<T const&, char CharT*>::value`.
Better docs for find functions
2020-01-29 21:15:27 -05:00
@return The index corrosponding to the first occurrence of
a character that is not in `[sv.begin(), sv.end())` within
`[begin() + pos, end())` if it exists, and @ref npos otherwise.
@param t The characters to ignore.
@param pos The index to start searching at. The default argument
for this parameter is `0`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<class T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
size_type
#else
typename std::enable_if<
std::is_convertible<T, string_view_type>::value &&
! std::is_convertible<T, CharT const*>::value,
size_type>::type
#endif
find_first_not_of(
const T& t,
Finish more complex exception specifications
2019-12-16 13:52:55 -05:00
size_type pos = 0) const noexcept(detail::is_nothrow_convertible<const T&,
string_view_type>::value)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
string_view_type sv = t;
return find_first_not_of(sv.data(), pos, sv.size());
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the first occurrence of any of the characters not within the string.
Finds the first occurrence of a character that is not within `str`
within the string starting at the index `pos`.
@par Complexity
Linear.
@return The index corrosponding to the first character of `[begin() + pos, end())`
that is not within `str` if it exists, and @ref npos otherwise.
@param str The characters to ignore.
@param pos The index to start searching at. The default argument for
this parameter is `0`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find_first_not_of(
const basic_static_string<M, CharT, Traits>& str,
size_type pos = 0) const noexcept
{
return find_first_not_of(str.data(), pos, str.size());
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the first occurrence of any of the characters not within the string.
Finds the first occurrence of a character that is not within the string
pointed to by `s` within the string starting at the index `pos`.
@par Complexity
Linear.
@return The index corrosponding to the first character of `[begin() + pos, end())`
that is not within `[s, s + n)` if it exists, and @ref npos otherwise.
@param s The characters to ignore.
@param pos The index to start searching at. The default argument for
this parameter is `0`.
@param n The length of the characters to ignore.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find_first_not_of(
const CharT* s,
size_type pos,
size_type n) const noexcept;
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the first occurrence of any of the characters not within the string.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Better docs for find functions
2020-01-29 21:15:27 -05:00
Finds the first occurrence of a character that is not within the string
pointed to by `s` of length `count` within the string starting
at the index `pos`, where `count` is `Traits::length(s)`.
@par Complexity
Linear.
@return The index corrosponding to the first character of `[begin() + pos, end())`
that is not within `[s, s + count)` if it exists, and @ref npos otherwise.
@param s The characters to ignore.
@param pos The index to start searching at. The default argument for
this parameter is `0`.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find_first_not_of(
const CharT* s,
size_type pos = 0) const noexcept
{
return find_first_not_of(s, pos, Traits::length(s));
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the first occurrence of a character not equal to `c`.
Finds the first occurrence of a character that is not equal
to `c`.
@par Complexity
Linear.
@return The index corrosponding to the first character of `[begin() + pos, end())`
that is not equal to `c` if it exists, and @ref npos otherwise.
@param c The character to ignore.
@param pos The index to start searching at. The default argument for
this parameter is `0`.
*/
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find_first_not_of(
CharT c,
size_type pos = 0) const noexcept
{
return find_first_not_of(&c, pos, 1);
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the last occurrence of a character not within the string.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Chunked docs
2020-01-31 15:30:17 -05:00
Constructs a temporary `string_view_type` object `sv` from `t`, and finds
Better docs for find functions
2020-01-29 21:15:27 -05:00
the last character that is not within `sv`, starting at the index `pos`.
@par Complexity
Linear.
@tparam T The type of the object to convert.
@par Constraints
`std::is_convertible<T const&, string_view>::value &&
Update docs for insert, fixed exception specification for copy
2020-01-30 19:25:56 -05:00
!std::is_convertible<T const&, char CharT*>::value`.
Better docs for find functions
2020-01-29 21:15:27 -05:00
@return The index corrosponding to the last occurrence of
a character that is not in `[sv.begin(), sv.end())` within
`[begin(), begin() + pos]` if it exists, and @ref npos otherwise.
@param t The characters to ignore.
@param pos The index to start searching at. The default argument
for this parameter is @ref npos.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<class T>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
#if GENERATING_DOCUMENTATION
size_type
#else
typename std::enable_if<
std::is_convertible<T, string_view_type>::value &&
! std::is_convertible<T, CharT const*>::value,
size_type>::type
#endif
find_last_not_of(
const T& t,
Finish more complex exception specifications
2019-12-16 13:52:55 -05:00
size_type pos = npos) const noexcept(detail::is_nothrow_convertible<const T&,
string_view_type>::value)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
string_view_type sv = t;
return find_last_not_of(sv.data(), pos, sv.size());
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the last occurrence of a character not within the string.
Finds the last occurrence of a character that is not within `str`
within the string before or at the index `pos`.
@par Complexity
Linear.
@return The index corrosponding to the last character of `[begin(), begin() + pos]`
that is not within `str` if it exists, and @ref npos otherwise.
@param str The characters to ignore.
@param pos The index to stop searching at. The default argument for
this parameter is @ref npos.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
template<size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find_last_not_of(
const basic_static_string<M, CharT, Traits>& str,
size_type pos = npos) const noexcept
{
return find_last_not_of(str.data(), pos, str.size());
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the last occurrence of a character not within the string.
Finds the last occurrence of a character that is not within the
string pointed to by `s` within the string before or at the index `pos`.
@par Complexity
Linear.
@return The index corrosponding to the last character of `[begin(), begin() + pos]`
that is not within `[s, s + n)` if it exists, and @ref npos otherwise.
@param s The characters to ignore.
@param pos The index to stop searching at. The default argument for
this parameter is @ref npos.
@param n The length of the characters to ignore.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find_last_not_of(
const CharT* s,
size_type pos,
size_type n) const noexcept;
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the last occurrence of a character not within the string.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
Better docs for find functions
2020-01-29 21:15:27 -05:00
Finds the last occurrence of a character that is not within the
string pointed to by `s` of length `count` within the string
before or at the index `pos`, where `count` is `Traits::length(s)`.
@par Complexity
Linear.
@return The index corrosponding to the last character of `[begin(), begin() + pos]`
that is not within `[s, s + count)` if it exists, and @ref npos otherwise.
@param s The characters to ignore.
@param pos The index to stop searching at. The default argument for
this parameter is @ref npos.
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
*/
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find_last_not_of(
const CharT* s,
size_type pos = npos) const noexcept
{
return find_last_not_of(s, pos, Traits::length(s));
}
Better docs for find functions
2020-01-29 21:15:27 -05:00
/** Find the last occurrence of a character not equal to `c`.
Finds the last occurrence of a character that is not equal
to `c` before or at the index `pos`.
@par Complexity
Linear.
@return The index corrosponding to the last character of `[begin(), begin() + pos]`
that is not equal to `c` if it exists, and @ref npos otherwise.
@param c The character to ignore.
@param pos The index to start searching at. The default argument for
this parameter is @ref npos.
*/
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
size_type
find_last_not_of(
CharT c,
size_type pos = npos) const noexcept
{
return find_last_not_of(&c, pos, 1);
}
/// Returns whether the string begins with `s`
BOOST_STATIC_STRING_CPP14_CONSTEXPR
bool
starts_with(
string_view_type s) const noexcept
{
const size_type len = s.size();
return size() >= len && !Traits::compare(data(), s.data(), len);
}
/// Returns whether the string begins with `c`
BOOST_STATIC_STRING_CPP14_CONSTEXPR
bool
starts_with(
CharT c) const noexcept
{
return !empty() && Traits::eq(front(), c);
}
/// Returns whether the string begins with `s`
BOOST_STATIC_STRING_CPP14_CONSTEXPR
bool
starts_with(
const CharT* s) const noexcept
{
const size_type len = Traits::length(s);
return size() >= len && !Traits::compare(data(), s, len);
}
/// Returns whether the string ends with `s`
BOOST_STATIC_STRING_CPP14_CONSTEXPR
bool
ends_with(
string_view_type s) const noexcept
{
const size_type len = s.size();
return size() >= len && !Traits::compare(data() + (size() - len), s.data(), len);
}
/// Returns whether the string ends with `c`
BOOST_STATIC_STRING_CPP14_CONSTEXPR
bool
ends_with(
CharT c) const noexcept
{
return !empty() && Traits::eq(back(), c);
}
/// Returns whether the string begins with `s`
BOOST_STATIC_STRING_CPP14_CONSTEXPR
bool
ends_with(
const CharT* s) const noexcept
{
const size_type len = Traits::length(s);
return size() >= len && !Traits::compare(data() + (size() - len), s, len);
}
private:
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
assign_char(CharT ch, std::true_type) noexcept;
basic_static_string&
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
assign_char(CharT ch, std::false_type);
Fix InputIterator overloads
2019-12-30 21:12:20 -05:00
// Returns the size of data read from input iterator. Read data begins at data() + size() + 1.
template<typename InputIterator>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
std::size_t
read_back(
InputIterator first,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
InputIterator last);
Fixed exception checks for ranges, less repetition
2020-01-01 15:01:39 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
replace_unchecked(
size_type pos,
size_type n1,
const CharT* s,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type n2);
Added unchecked insertion
2020-02-01 14:40:30 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string&
insert_unchecked(
size_type index,
const CharT* s,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count);
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
};
//------------------------------------------------------------------------------
//
// Non-member functions
//
//------------------------------------------------------------------------------
template<
std::size_t N, std::size_t M,
typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator==(
basic_static_string<N, CharT, Traits> const& lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<M, CharT, Traits> const& rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return lhs.compare(rhs) == 0;
}
template<
std::size_t N, std::size_t M,
typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator!=(
basic_static_string<N, CharT, Traits> const& lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<M, CharT, Traits> const& rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return lhs.compare(rhs) != 0;
}
template<
std::size_t N, std::size_t M,
typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator<(
basic_static_string<N, CharT, Traits> const& lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<M, CharT, Traits> const& rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return lhs.compare(rhs) < 0;
}
template<
std::size_t N, std::size_t M,
typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator<=(
basic_static_string<N, CharT, Traits> const& lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<M, CharT, Traits> const& rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return lhs.compare(rhs) <= 0;
}
template<
std::size_t N, std::size_t M,
typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator>(
basic_static_string<N, CharT, Traits> const& lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<M, CharT, Traits> const& rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return lhs.compare(rhs) > 0;
}
template<
std::size_t N, std::size_t M,
typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator>=(
basic_static_string<N, CharT, Traits> const& lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<M, CharT, Traits> const& rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return lhs.compare(rhs) >= 0;
}
template<std::size_t N, typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator==(
CharT const* lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<N, CharT, Traits> const& rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return detail::lexicographical_compare<CharT, Traits>(
lhs, Traits::length(lhs),
rhs.data(), rhs.size()) == 0;
}
template<std::size_t N, typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator==(
basic_static_string<N, CharT, Traits> const& lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT const* rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return detail::lexicographical_compare<CharT, Traits>(
lhs.data(), lhs.size(),
rhs, Traits::length(rhs)) == 0;
}
template<std::size_t N, typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator!=(
CharT const* lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<N, CharT, Traits> const& rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return detail::lexicographical_compare<CharT, Traits>(
lhs, Traits::length(lhs),
rhs.data(), rhs.size()) != 0;
}
template<std::size_t N, typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator!=(
basic_static_string<N, CharT, Traits> const& lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT const* rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return detail::lexicographical_compare<CharT, Traits>(
lhs.data(), lhs.size(),
rhs, Traits::length(rhs)) != 0;
}
template<std::size_t N, typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator<(
CharT const* lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<N, CharT, Traits> const& rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return detail::lexicographical_compare<CharT, Traits>(
lhs, Traits::length(lhs),
rhs.data(), rhs.size()) < 0;
}
template<std::size_t N, typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator<(
basic_static_string<N, CharT, Traits> const& lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT const* rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return detail::lexicographical_compare<CharT, Traits>(
lhs.data(), lhs.size(),
rhs, Traits::length(rhs)) < 0;
}
template<std::size_t N, typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator<=(
CharT const* lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<N, CharT, Traits> const& rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return detail::lexicographical_compare<CharT, Traits>(
lhs, Traits::length(lhs),
rhs.data(), rhs.size()) <= 0;
}
template<std::size_t N, typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator<=(
basic_static_string<N, CharT, Traits> const& lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT const* rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return detail::lexicographical_compare<CharT, Traits>(
lhs.data(), lhs.size(),
rhs, Traits::length(rhs)) <= 0;
}
template<std::size_t N, typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator>(
CharT const* lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<N, CharT, Traits> const& rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return detail::lexicographical_compare<CharT, Traits>(
lhs, Traits::length(lhs),
rhs.data(), rhs.size()) > 0;
}
template<std::size_t N, typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator>(
basic_static_string<N, CharT, Traits> const& lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT const* rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return detail::lexicographical_compare<CharT, Traits>(
lhs.data(), lhs.size(),
rhs, Traits::length(rhs)) > 0;
}
template<std::size_t N, typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator>=(
CharT const* lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<N, CharT, Traits> const& rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return detail::lexicographical_compare<CharT, Traits>(
lhs, Traits::length(lhs),
rhs.data(), rhs.size()) >= 0;
}
template<std::size_t N, typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
bool
operator>=(
basic_static_string<N, CharT, Traits> const& lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT const* rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
return detail::lexicographical_compare<CharT, Traits>(
lhs.data(), lhs.size(),
rhs, Traits::length(rhs)) >= 0;
}
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
template<
std::size_t N, std::size_t M,
typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
inline
basic_static_string<N + M, CharT, Traits>
operator+(
basic_static_string<N, CharT, Traits>const& lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<M, CharT, Traits>const& rhs)
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
{
return basic_static_string<N + M, CharT, Traits>(lhs) += rhs;
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
inline
basic_static_string<N + 1, CharT, Traits>
operator+(
basic_static_string<N, CharT, Traits> const& lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT rhs)
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
{
return basic_static_string<N + 1, CharT, Traits>(lhs) += rhs;
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
inline
basic_static_string<N + 1, CharT, Traits>
operator+(
CharT lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<N, CharT, Traits> const& rhs)
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
{
return basic_static_string<N + 1, CharT, Traits>(rhs).insert(0, lhs);
}
template<
std::size_t N, std::size_t M,
typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
inline
basic_static_string<N + M, CharT, Traits>
operator+(
basic_static_string<N, CharT, Traits>const& lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
const CharT(&rhs)[M])
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
{
return basic_static_string<N + M, CharT, Traits>(lhs).append(+rhs, M);
}
template<
std::size_t N, std::size_t M,
typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
inline
basic_static_string<N + M, CharT, Traits>
operator+(
const CharT(&lhs)[N],
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<M, CharT, Traits>const& rhs)
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
{
return basic_static_string<N + M, CharT, Traits>(rhs).insert(0, +rhs, N);
}
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
//------------------------------------------------------------------------------
//
// swap
//
//------------------------------------------------------------------------------
template<
std::size_t N,
typename CharT,
typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
void
swap(
basic_static_string<N, CharT, Traits>& lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<N, CharT, Traits>& rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
lhs.swap(rhs);
}
template<
std::size_t N, std::size_t M,
typename CharT, typename Traits>
Added operator+ for operands of known size, more constexpr
2019-12-16 16:42:53 -05:00
BOOST_STATIC_STRING_CPP14_CONSTEXPR
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
void
swap(
basic_static_string<N, CharT, Traits>& lhs,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<M, CharT, Traits>& rhs)
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
lhs.swap(rhs);
}
//------------------------------------------------------------------------------
//
// Input/Output
//
//------------------------------------------------------------------------------
template<std::size_t N, typename CharT, typename Traits>
inline
std::basic_ostream<CharT, Traits>&
operator<<(std::basic_ostream<CharT, Traits>& os,
basic_static_string<N, CharT, Traits> const& s)
{
Fix test and standalone support
2019-12-16 18:19:01 -05:00
return os << basic_string_view<CharT, Traits>(s.data(), s.size());
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
}
//------------------------------------------------------------------------------
//
// Numeric conversions
//
//------------------------------------------------------------------------------
Added docs for to_static_string
2020-01-15 16:41:51 -05:00
/// Converts `value` to a `static_string`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_string<std::numeric_limits<int>::digits10 + 1>
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_string(int value) noexcept
{
return detail::to_static_string_int_impl<
std::numeric_limits<int>::digits10 + 1>(value);
}
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
Added docs for to_static_string
2020-01-15 16:41:51 -05:00
/// Converts `value` to a `static_string`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_string<std::numeric_limits<long>::digits10 + 1>
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_string(long value) noexcept
{
return detail::to_static_string_int_impl<
std::numeric_limits<long>::digits10 + 1>(value);
}
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
Added docs for to_static_string
2020-01-15 16:41:51 -05:00
/// Converts `value` to a `static_string`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_string<std::numeric_limits<long long>::digits10 + 1>
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_string(long long value) noexcept
{
return detail::to_static_string_int_impl<
std::numeric_limits<long long>::digits10 + 1>(value);
}
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
Added docs for to_static_string
2020-01-15 16:41:51 -05:00
/// Converts `value` to a `static_string`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_string<std::numeric_limits<unsigned int>::digits10 + 1>
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_string(unsigned int value) noexcept
{
return detail::to_static_string_int_impl<
std::numeric_limits<unsigned int>::digits10 + 1>(value);
}
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
Added docs for to_static_string
2020-01-15 16:41:51 -05:00
/// Converts `value` to a `static_string`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_string<std::numeric_limits<unsigned long>::digits10 + 1>
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_string(unsigned long value) noexcept
{
return detail::to_static_string_int_impl<
std::numeric_limits<unsigned long>::digits10 + 1>(value);
}
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
Move to single header
2020-02-01 16:30:23 -05:00
/// Converts `value` to a `static_string`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_string<std::numeric_limits<unsigned long long>::digits10 + 1>
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_string(unsigned long long value) noexcept
{
return detail::to_static_string_int_impl<
std::numeric_limits<unsigned long long>::digits10 + 1>(value);
}
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
Move to single header
2020-02-01 16:30:23 -05:00
/// Converts `value` to a `static_string`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_string<std::numeric_limits<float>::max_digits10 + 1>
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_string(float value) noexcept
{
return detail::to_static_string_float_impl<
std::numeric_limits<float>::max_digits10 + 1>(value);
}
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
Move to single header
2020-02-01 16:30:23 -05:00
/// Converts `value` to a `static_string`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_string<std::numeric_limits<double>::max_digits10 + 1>
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_string(double value) noexcept
{
return detail::to_static_string_float_impl<
std::numeric_limits<double>::max_digits10 + 1>(value);
}
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
Added docs for to_static_string
2020-01-15 16:41:51 -05:00
/// Converts `value` to a `static_string`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_string<std::numeric_limits<long double>::max_digits10 + 1>
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_string(long double value) noexcept
{
return detail::to_static_string_float_impl<
std::numeric_limits<long double>::max_digits10 + 1>(value);
}
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
Move to single header
2020-02-01 16:30:23 -05:00
/// Converts `value` to a `static_wstring`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_wstring<std::numeric_limits<int>::digits10 + 1>
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_wstring(int value) noexcept
{
return detail::to_static_wstring_int_impl<
std::numeric_limits<int>::digits10 + 1>(value);
}
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
Move to single header
2020-02-01 16:30:23 -05:00
/// Converts `value` to a `static_wstring`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_wstring<std::numeric_limits<long>::digits10 + 1>
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_wstring(long value) noexcept
{
return detail::to_static_wstring_int_impl<
std::numeric_limits<long>::digits10 + 1>(value);
}
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
Move to single header
2020-02-01 16:30:23 -05:00
/// Converts `value` to a `static_wstring`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_wstring<std::numeric_limits<long long>::digits10 + 1>
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_wstring(long long value) noexcept
{
return detail::to_static_wstring_int_impl<
std::numeric_limits<long long>::digits10 + 1>(value);
}
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
Move to single header
2020-02-01 16:30:23 -05:00
/// Converts `value` to a `static_wstring`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_wstring<std::numeric_limits<unsigned int>::digits10 + 1>
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_wstring(unsigned int value) noexcept
{
return detail::to_static_wstring_int_impl<
std::numeric_limits<unsigned int>::digits10 + 1>(value);
}
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
Move to single header
2020-02-01 16:30:23 -05:00
/// Converts `value` to a `static_wstring`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_wstring<std::numeric_limits<unsigned long>::digits10 + 1>
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_wstring(unsigned long value) noexcept
{
return detail::to_static_wstring_int_impl<
std::numeric_limits<unsigned long>::digits10 + 1>(value);
}
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
Move to single header
2020-02-01 16:30:23 -05:00
/// Converts `value` to a `static_wstring`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_wstring<std::numeric_limits<unsigned long long>::digits10 + 1>
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_wstring(unsigned long long value) noexcept
{
return detail::to_static_wstring_int_impl<
std::numeric_limits<unsigned long long>::digits10 + 1>(value);
}
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
Move to single header
2020-02-01 16:30:23 -05:00
/// Converts `value` to a `static_wstring`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_wstring<std::numeric_limits<float>::max_digits10 + 1>
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_wstring(float value) noexcept
{
return detail::to_static_wstring_float_impl<
std::numeric_limits<float>::max_digits10 + 1>(value);
}
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
Move to single header
2020-02-01 16:30:23 -05:00
/// Converts `value` to a `static_wstring`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_wstring<std::numeric_limits<double>::max_digits10 + 1>
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_wstring(double value) noexcept
{
return detail::to_static_wstring_float_impl<
std::numeric_limits<double>::max_digits10 + 1>(value);
}
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
Move to single header
2020-02-01 16:30:23 -05:00
/// Converts `value` to a `static_wstring`
to_static_string and to_static_wstring overloads
2019-12-20 02:34:04 -05:00
static_wstring<std::numeric_limits<long double>::max_digits10 + 1>
inline
Move to single header
2020-02-01 16:30:23 -05:00
to_static_wstring(long double value) noexcept
{
return detail::to_static_wstring_float_impl<
std::numeric_limits<long double>::max_digits10 + 1>(value);
}
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
//------------------------------------------------------------------------------
//
// Deduction Guides
//
//------------------------------------------------------------------------------
#ifdef BOOST_STATIC_STRING_USE_DEDUCT
template<std::size_t N, typename CharT>
basic_static_string(CharT(&)[N]) ->
basic_static_string<N, CharT, std::char_traits<CharT>>;
#endif
//------------------------------------------------------------------------------
//
// Hashing
//
//------------------------------------------------------------------------------
#ifndef BOOST_STATIC_STRING_STANDALONE
Fix doc generation for hash specialization
2020-01-15 13:23:44 -05:00
/// hash_value overload for Boost.Container_Hash
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
template <std::size_t N,
typename CharT,
typename Traits>
std::size_t
hash_value(
const basic_static_string<N, CharT, Traits>& str)
{
return boost::hash_range(str.begin(), str.end());
}
#endif
Unconditional noexcept when exceptions are disabled
2019-12-26 17:22:57 -05:00
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
} // static_string
} // boost
Fix doc generation for hash specialization
2020-01-15 13:23:44 -05:00
/// std::hash partial specialization for basic_static_string
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
namespace std
{
Move to single header
2020-02-01 16:30:23 -05:00
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
template <std::size_t N, typename CharT, typename Traits>
Fix doc generation for hash specialization
2020-01-15 13:23:44 -05:00
struct hash<
#if GENERATING_DOCUMENTATION
basic_static_string
#else
boost::static_string::basic_static_string<N, CharT, Traits>
#endif
>
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
std::size_t
operator()(
More noexcept, remove dummy parameter from constructor.
2020-01-15 16:23:12 -05:00
const boost::static_string::basic_static_string<N, CharT, Traits>& str) const noexcept
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
{
#ifndef BOOST_STATIC_STRING_STANDALONE
return boost::hash_range(str.begin(), str.end());
#else
using sv = boost::static_string::basic_string_view<CharT, Traits>;
return std::hash<sv>()(sv(str.data(), str.size()));
#endif
}
};
} // std
Move to single header
2020-02-01 16:30:23 -05:00
//--------------------------------------------------------------------------
//
// Implementation
//
//--------------------------------------------------------------------------
#ifndef GENERATING_DOCUMENTATION
namespace boost {
namespace static_string {
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP11_CONSTEXPR
basic_static_string<N, CharT, Traits>::
basic_static_string() noexcept
{
Update config, fix checks
2020-02-01 21:19:29 -05:00
#ifdef BOOST_STATIC_STRING_CPP20
Move to single header
2020-02-01 16:30:23 -05:00
term();
Renamed from fixed_string to static_string, added aliases
2019-12-16 12:23:46 -05:00
#endif
Move to single header
2020-02-01 16:30:23 -05:00
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string<N, CharT, Traits>::
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string(size_type count, CharT ch)
Move to single header
2020-02-01 16:30:23 -05:00
{
assign(count, ch);
}
template<std::size_t N, typename CharT, typename Traits>
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string<N, CharT, Traits>::
basic_static_string(basic_static_string<M, CharT, Traits> const& other,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type pos)
Move to single header
2020-02-01 16:30:23 -05:00
{
assign(other, pos);
}
template<std::size_t N, typename CharT, typename Traits>
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string<N, CharT, Traits>::
basic_static_string(
basic_static_string<M, CharT, Traits> const& other,
size_type pos,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count)
Move to single header
2020-02-01 16:30:23 -05:00
{
assign(other, pos, count);
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string<N, CharT, Traits>::
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string(CharT const* s, size_type count)
Move to single header
2020-02-01 16:30:23 -05:00
{
assign(s, count);
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string<N, CharT, Traits>::
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string(CharT const* s)
Move to single header
2020-02-01 16:30:23 -05:00
{
auto const count = Traits::length(s);
BOOST_STATIC_STRING_THROW_IF(count > max_size(),
std::length_error{"count > max_size()"});
Traits::copy(data(), s, count + 1);
this->set_size(count);
}
template<std::size_t N, typename CharT, typename Traits>
template<class InputIterator,
typename std::enable_if<
detail::is_input_iterator<InputIterator>
::value>::type*>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string<N, CharT, Traits>::
basic_static_string(
InputIterator first,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
InputIterator last)
Move to single header
2020-02-01 16:30:23 -05:00
{
assign(first, last);
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string<N, CharT, Traits>::
basic_static_string(
basic_static_string const& s) noexcept
{
assign(s);
}
template<std::size_t N, typename CharT, typename Traits>
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string<N, CharT, Traits>::
basic_static_string(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string<M, CharT, Traits> const& s)
Move to single header
2020-02-01 16:30:23 -05:00
{
assign(s);
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string<N, CharT, Traits>::
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string(std::initializer_list<CharT> init)
Move to single header
2020-02-01 16:30:23 -05:00
{
assign(init.begin(), init.end());
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string<N, CharT, Traits>::
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string(string_view_type sv)
Move to single header
2020-02-01 16:30:23 -05:00
{
assign(sv);
}
template<std::size_t N, typename CharT, typename Traits>
template<class T, class>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
basic_static_string<N, CharT, Traits>::
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
basic_static_string(T const& t, size_type pos, size_type n)
Move to single header
2020-02-01 16:30:23 -05:00
{
assign(t, pos, n);
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
assign(
size_type count,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT ch) ->
Move to single header
2020-02-01 16:30:23 -05:00
basic_static_string&
{
BOOST_STATIC_STRING_THROW_IF(count > max_size(),
std::length_error{"count > max_size()"});
this->set_size(count);
Traits::assign(data(), size(), ch);
term();
return *this;
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
assign(
basic_static_string const& s) noexcept ->
basic_static_string&
{
if(this == &s)
return *this;
this->set_size(s.size());
auto const n = size() + 1;
Traits::copy(data(), &s.data()[0], n);
return *this;
}
template<std::size_t N, typename CharT, typename Traits>
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
assign(
basic_static_string<M, CharT, Traits> const& s,
size_type pos,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count) ->
Move to single header
2020-02-01 16:30:23 -05:00
basic_static_string&
{
auto const ss = s.subview(pos, count);
return assign(ss.data(), ss.size());
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
assign(
CharT const* s,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count) ->
Move to single header
2020-02-01 16:30:23 -05:00
basic_static_string&
{
BOOST_STATIC_STRING_THROW_IF(count > max_size(),
std::length_error{"count > max_size()"});
this->set_size(count);
Traits::move(data(), s, size());
term();
return *this;
}
template<std::size_t N, typename CharT, typename Traits>
template<class InputIterator>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
assign(
InputIterator first,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
InputIterator last) ->
Move to single header
2020-02-01 16:30:23 -05:00
typename std::enable_if<
detail::is_input_iterator<InputIterator>::value,
basic_static_string&>::type
{
auto ptr = data();
for (std::size_t i = 0; first != last; ++first, ++ptr, ++i)
{
if (1 > max_size() - i)
{
this->set_size(i);
BOOST_STATIC_STRING_THROW(std::length_error{"n > max_size()"});
}
Traits::assign(*ptr, *first);
}
this->set_size(ptr - data());
term();
return *this;
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
at(size_type pos) ->
Move to single header
2020-02-01 16:30:23 -05:00
reference
{
BOOST_STATIC_STRING_THROW_IF(
pos >= size(), std::out_of_range{"pos >= size()"});
return data()[pos];
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
at(size_type pos) const ->
Move to single header
2020-02-01 16:30:23 -05:00
const_reference
{
BOOST_STATIC_STRING_THROW_IF(
pos >= size(), std::out_of_range{"pos >= size()"});
return data()[pos];
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
basic_static_string<N, CharT, Traits>::
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
reserve(std::size_t n)
Move to single header
2020-02-01 16:30:23 -05:00
{
BOOST_STATIC_STRING_THROW_IF(
n > max_size(), std::length_error{"n > max_size()"});
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
basic_static_string<N, CharT, Traits>::
clear() noexcept
{
this->set_size(0);
term();
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
insert(
size_type index,
CharT const* s,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count) ->
Move to single header
2020-02-01 16:30:23 -05:00
basic_static_string&
{
const auto curr_size = size();
const auto curr_data = data();
BOOST_STATIC_STRING_THROW_IF(
index > curr_size, std::out_of_range{"index > size()"});
insert(curr_data + index, s, s + count);
return *this;
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
insert(
const_iterator pos,
size_type count,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT ch) ->
Move to single header
2020-02-01 16:30:23 -05:00
iterator
{
const auto curr_size = size();
const auto curr_data = data();
BOOST_STATIC_STRING_THROW_IF(
count > max_size() - curr_size, std::length_error{"count() > max_size() - size()"});
auto const index = pos - curr_data;
Traits::move(&curr_data[index + count], &curr_data[index], curr_size - index);
Traits::assign(&curr_data[index], count, ch);
this->set_size(curr_size + count);
term();
return &curr_data[index];
}
template<std::size_t N, typename CharT, typename Traits>
template<class ForwardIterator>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
insert(
const_iterator pos,
ForwardIterator first,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
ForwardIterator last) ->
Move to single header
2020-02-01 16:30:23 -05:00
typename std::enable_if<
detail::is_forward_iterator<
ForwardIterator>::value, iterator>::type
{
const auto curr_size = size();
const auto curr_data = data();
const auto count = detail::distance(first, last);
const auto index = pos - curr_data;
const auto s = &*first;
BOOST_STATIC_STRING_THROW_IF(
count > max_size() - curr_size, std::length_error{"count > max_size() - size()"});
Clean up replace
2020-02-06 16:48:02 -05:00
const bool inside = detail::ptr_in_range(curr_data, curr_data + curr_size, s);
Move to single header
2020-02-01 16:30:23 -05:00
if (!inside || (inside && ((s - curr_data) + count <= index)))
{
Traits::move(&curr_data[index + count], &curr_data[index], curr_size - index + 1);
detail::copy_with_traits<Traits>(first, last, &curr_data[index]);
}
else
{
const size_type offset = s - curr_data;
Traits::move(&curr_data[index + count], &curr_data[index], curr_size - index + 1);
if (offset < index)
{
const size_type diff = index - offset;
Traits::copy(&curr_data[index], &curr_data[offset], diff);
Traits::copy(&curr_data[index + diff], &curr_data[index + count], count - diff);
}
else
{
Traits::copy(&curr_data[index], &curr_data[offset + count], count);
}
}
this->set_size(curr_size + count);
return curr_data + index;
}
template<std::size_t N, typename CharT, typename Traits>
template<class InputIterator>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
insert(
const_iterator pos,
InputIterator first,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
InputIterator last) ->
Move to single header
2020-02-01 16:30:23 -05:00
typename std::enable_if<
detail::is_input_iterator<
InputIterator>::value &&
! detail::is_forward_iterator<
InputIterator>::value, iterator>::type
{
const auto curr_size = size();
const auto curr_data = data();
const auto count = read_back(first, last);
const auto index = pos - curr_data;
const auto s = curr_data + curr_size + 1;
BOOST_STATIC_STRING_THROW_IF(
index > curr_size, std::out_of_range{"index > size()"});
std::rotate(&curr_data[index], &curr_data[curr_size + 1], &curr_data[curr_size + count + 1]);
this->set_size(curr_size + count);
return curr_data + index;
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
erase(
size_type index,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count) ->
Move to single header
2020-02-01 16:30:23 -05:00
basic_static_string&
{
const auto curr_size = size();
const auto curr_data = data();
BOOST_STATIC_STRING_THROW_IF(
index > curr_size, std::out_of_range{"index > size()"});
auto const n = (std::min)(count, curr_size - index);
Traits::move(&curr_data[index], &curr_data[index + n], curr_size - (index + n) + 1);
this->set_size(curr_size - n);
return *this;
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
erase(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
const_iterator pos) ->
Move to single header
2020-02-01 16:30:23 -05:00
iterator
{
erase(pos - begin(), 1);
return begin() + (pos - begin());
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
erase(
const_iterator first,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
const_iterator last) ->
Move to single header
2020-02-01 16:30:23 -05:00
iterator
{
erase(first - begin(),
detail::distance(first, last));
return begin() + (first - begin());
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
basic_static_string<N, CharT, Traits>::
push_back(
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT ch)
Move to single header
2020-02-01 16:30:23 -05:00
{
const auto curr_size = size();
BOOST_STATIC_STRING_THROW_IF(
curr_size >= max_size(), std::length_error{"size() >= max_size()"});
Traits::assign(data()[curr_size], ch);
this->set_size(curr_size + 1);
term();
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
append(
CharT const* s,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count) ->
Move to single header
2020-02-01 16:30:23 -05:00
basic_static_string&
{
const auto curr_size = size();
BOOST_STATIC_STRING_THROW_IF(
count > max_size() - curr_size, std::length_error{"count > max_size() - size()"});
Traits::copy(&data()[curr_size], s, count);
this->set_size(curr_size + count);
term();
return *this;
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
substr(size_type pos, size_type count) const ->
Move to single header
2020-02-01 16:30:23 -05:00
basic_static_string
{
BOOST_STATIC_STRING_THROW_IF(
pos > size(), std::out_of_range{"pos > size()"});
return {&data()[pos], (std::min)(count, size() - pos)};
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
subview(size_type pos, size_type count) const ->
Move to single header
2020-02-01 16:30:23 -05:00
string_view_type
{
BOOST_STATIC_STRING_THROW_IF(
pos > size(), std::out_of_range{"pos > size()"});
return {&data()[pos], (std::min)(count, size() - pos)};
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
copy(CharT* dest, size_type count, size_type pos) const ->
Move to single header
2020-02-01 16:30:23 -05:00
size_type
{
auto const s = subview(pos, count);
Traits::copy(dest, s.data(), s.size());
return s.size();
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
basic_static_string<N, CharT, Traits>::
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
resize(std::size_t n)
Move to single header
2020-02-01 16:30:23 -05:00
{
const auto curr_size = size();
BOOST_STATIC_STRING_THROW_IF(
n > max_size(), std::length_error{"n > max_size()"});
if(n > curr_size)
Traits::assign(&data()[curr_size], n - curr_size, CharT{});
this->set_size(n);
term();
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
basic_static_string<N, CharT, Traits>::
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
resize(std::size_t n, CharT c)
Move to single header
2020-02-01 16:30:23 -05:00
{
const auto curr_size = size();
BOOST_STATIC_STRING_THROW_IF(
n > max_size(), std::length_error{"n > max_size()"});
if(n > curr_size)
Traits::assign(&data()[curr_size], n - curr_size, c);
this->set_size(n);
term();
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
basic_static_string<N, CharT, Traits>::
swap(basic_static_string& s) noexcept
{
const auto curr_size = size();
basic_static_string tmp(s);
s.set_size(curr_size);
Traits::copy(&s.data()[0], data(), curr_size + 1);
this->set_size(tmp.size());
Traits::copy(data(), tmp.data(), size() + 1);
}
template<std::size_t N, typename CharT, typename Traits>
template<std::size_t M>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
void
basic_static_string<N, CharT, Traits>::
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
swap(basic_static_string<M, CharT, Traits>& s)
Move to single header
2020-02-01 16:30:23 -05:00
{
const auto curr_size = size();
BOOST_STATIC_STRING_THROW_IF(
curr_size > s.max_size(), std::length_error{"size() > s.max_size()"});
BOOST_STATIC_STRING_THROW_IF(
s.size() > max_size(), std::length_error{"s.size() > max_size()"});
basic_static_string tmp(s);
s.set_size(curr_size);
Traits::copy(&s.data()[0], data(), curr_size + 1);
this->set_size(tmp.size());
Traits::copy(data(), &tmp.data()[0], size() + 1);
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
replace(
size_type pos,
size_type n1,
const CharT* s,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type n2) ->
Move to single header
2020-02-01 16:30:23 -05:00
basic_static_string<N, CharT, Traits>&
{
BOOST_STATIC_STRING_THROW_IF(
Clean up replace
2020-02-06 16:48:02 -05:00
pos > size(), std::out_of_range{"pos > size()"});
return replace(data() + pos, data() + pos + n1, s, s + n2);
Move to single header
2020-02-01 16:30:23 -05:00
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
replace(
size_type pos,
size_type n1,
size_type n2,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
CharT c) -> basic_static_string<N, CharT, Traits> &
Move to single header
2020-02-01 16:30:23 -05:00
{
const auto curr_size = size();
const auto curr_data = data();
BOOST_STATIC_STRING_THROW_IF(
pos > curr_size, std::out_of_range{"pos > size()"});
BOOST_STATIC_STRING_THROW_IF(
curr_size - (std::min)(n1, curr_size - pos) >= max_size() - n2,
std::length_error{"replaced string exceeds max_size()"});
n1 = (std::min)(n1, curr_size - pos);
Traits::move(&curr_data[pos + n2], &curr_data[pos + n1], curr_size - pos - n1 + 1);
Traits::assign(&curr_data[pos], n2, c);
Fix potential overflows
2020-02-03 22:34:08 -05:00
this->set_size((curr_size - n1) + n2);
Move to single header
2020-02-01 16:30:23 -05:00
return *this;
}
template<std::size_t N, typename CharT, typename Traits>
template<typename ForwardIterator>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
replace(
const_iterator i1,
const_iterator i2,
ForwardIterator j1,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
ForwardIterator j2) ->
Move to single header
2020-02-01 16:30:23 -05:00
typename std::enable_if<
detail::is_forward_iterator<ForwardIterator>::value,
basic_static_string<N, CharT, Traits>&>::type
{
const auto curr_size = size();
const auto curr_data = data();
std::size_t n1 = detail::distance(i1, i2);
const std::size_t n2 = detail::distance(j1, j2);
const std::size_t pos = i1 - curr_data;
const auto s = &*j1;
BOOST_STATIC_STRING_THROW_IF(
curr_size - (std::min)(n1, curr_size - pos) >= max_size() - n2,
std::length_error{"replaced string exceeds max_size()"});
n1 = (std::min)(n1, curr_size - pos);
Clean up replace
2020-02-06 16:48:02 -05:00
const bool inside = detail::ptr_in_range(curr_data, curr_data + curr_size, s);
if (inside && s - curr_data == pos && n1 == n2)
Move to single header
2020-02-01 16:30:23 -05:00
return *this;
if (!inside || (inside && ((s - curr_data) + n2 <= pos)))
{
// source outside
Traits::move(&curr_data[pos + n2], &curr_data[pos + n1], curr_size - pos - n1 + 1);
detail::copy_with_traits<Traits>(j1, j2, &curr_data[pos]);
}
else
{
// source inside
const size_type offset = s - curr_data;
if (n2 >= n1)
{
Clean up replace
2020-02-06 16:48:02 -05:00
const size_type diff = offset <= pos + n1 ? (std::min)((pos + n1) - offset, n2) : 0;
Move to single header
2020-02-01 16:30:23 -05:00
// grow/unchanged
// shift all right of splice point by n2 - n1 to the right
Traits::move(&curr_data[pos + n2], &curr_data[pos + n1], curr_size - pos - n1 + 1);
// copy all before splice point
Traits::move(&curr_data[pos], &curr_data[offset], diff);
// copy all after splice point
Fix potential overflows
2020-02-03 22:34:08 -05:00
Traits::move(&curr_data[pos + diff], &curr_data[(offset - n1) + n2 + diff], n2 - diff);
Move to single header
2020-02-01 16:30:23 -05:00
}
else
{
// shrink
// copy all elements into place
Traits::move(&curr_data[pos], &curr_data[offset], n2);
// shift all elements after splice point left
Traits::move(&curr_data[pos + n2], &curr_data[pos + n1], curr_size - pos - n1 + 1);
}
}
Fix potential overflows
2020-02-03 22:34:08 -05:00
this->set_size((curr_size - n1) + n2);
Move to single header
2020-02-01 16:30:23 -05:00
return *this;
}
template<std::size_t N, typename CharT, typename Traits>
template<typename InputIterator>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
replace(
const_iterator i1,
const_iterator i2,
InputIterator j1,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
InputIterator j2) ->
Move to single header
2020-02-01 16:30:23 -05:00
typename std::enable_if<
detail::is_input_iterator<
InputIterator>::value &&
! detail::is_forward_iterator<
InputIterator>::value,
basic_static_string<N, CharT, Traits>&>::type
{
const auto curr_size = size();
const auto curr_data = data();
std::size_t n1 = detail::distance(i1, i2);
const std::size_t n2 = read_back(j1, j2);
const std::size_t pos = i1 - curr_data;
BOOST_STATIC_STRING_THROW_IF(
pos > curr_size, std::out_of_range{"pos > size()"});
BOOST_STATIC_STRING_THROW_IF(
curr_size - (std::min)(n1, curr_size - pos) >= max_size() - n2,
std::length_error{"replaced string exceeds max_size()"});
// Rotate to the correct order. [i2, end] will now start with the replaced string, continue to the existing string not being replaced, and end with a null terminator
std::rotate(&curr_data[pos], &curr_data[curr_size + 1], &curr_data[curr_size + n2 + 1]);
// Cap the size
n1 = (std::min)(n1, curr_size - pos);
// Move everything from the end of the splice point to the end of the rotated string to the begining of the splice point
Fix potential overflows
2020-02-03 22:34:08 -05:00
Traits::move(&curr_data[pos + n2], &curr_data[pos + n2 + n1], ((curr_size - n1) + n2) - pos);
this->set_size((curr_size - n1) + n2);
Move to single header
2020-02-01 16:30:23 -05:00
return *this;
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
find(
const CharT* s,
size_type pos,
size_type n) const noexcept ->
size_type
{
const auto curr_size = size();
if (pos > curr_size || n > curr_size - pos)
return npos;
if (!n)
return pos;
const auto res = detail::search(&data()[pos], &data()[curr_size], s, &s[n], Traits::eq);
return res == end() ? npos : detail::distance(data(), res);
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
rfind(
const CharT* s,
size_type pos,
size_type n) const noexcept ->
size_type
{
const auto curr_size = size();
const auto curr_data = data();
if (curr_size < n)
return npos;
if (pos > curr_size - n)
pos = curr_size - n;
if (!n)
return pos;
for (auto sub = &curr_data[pos]; sub >= curr_data; --sub)
if (!Traits::compare(sub, s, n))
return detail::distance(curr_data, sub);
return npos;
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
find_first_of(
const CharT* s,
size_type pos,
size_type n) const noexcept ->
size_type
{
const auto curr_data = data();
if (pos >= size() || !n)
return npos;
const auto res = detail::find_first_of(&curr_data[pos], &curr_data[size()], s, &s[n], Traits::eq);
return res == end() ? npos : detail::distance(curr_data, res);
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
find_last_of(
const CharT* s,
size_type pos,
size_type n) const noexcept ->
size_type
{
const auto curr_size = size();
if (!n)
return npos;
if (pos >= curr_size)
pos = 0;
else
pos = curr_size - (pos + 1);
const auto res = detail::find_first_of(rbegin() + pos, rend(), s, &s[n], Traits::eq);
return res == rend() ? npos : curr_size - 1 - detail::distance(rbegin(), res);
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
find_first_not_of(
const CharT* s,
size_type pos,
size_type n) const noexcept ->
size_type
{
if (pos >= size())
return npos;
if (!n)
return pos;
const auto res = detail::find_not_of<Traits>(&data()[pos], &data()[size()], s, n);
return res == end() ? npos : detail::distance(data(), res);
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
find_last_not_of(
const CharT* s,
size_type pos,
size_type n) const noexcept ->
size_type
{
const auto curr_size = size();
if (pos >= curr_size)
pos = curr_size - 1;
if (!n)
return pos;
pos = curr_size - (pos + 1);
const auto res = detail::find_not_of<Traits>(rbegin() + pos, rend(), s, n);
return res == rend() ? npos : curr_size - 1 - detail::distance(rbegin(), res);
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
assign_char(CharT ch, std::true_type) noexcept ->
basic_static_string&
{
this->set_size(1);
Traits::assign(data()[0], ch);
term();
return *this;
}
template<std::size_t N, typename CharT, typename Traits>
auto
basic_static_string<N, CharT, Traits>::
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
assign_char(CharT, std::false_type) ->
Move to single header
2020-02-01 16:30:23 -05:00
basic_static_string&
{
BOOST_STATIC_STRING_THROW(std::length_error{"max_size() == 0"});
return *this;
}
template<std::size_t N, typename CharT, typename Traits>
template<typename InputIterator>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
read_back(
InputIterator first,
InputIterator last) ->
std::size_t
{
const auto curr_data = data();
auto new_size = size();
for (; first != last; ++first)
{
BOOST_STATIC_STRING_THROW_IF(
1 > max_size() - new_size, std::length_error{"count > max_size() - size()"});
Traits::assign(curr_data[++new_size], *first);
}
return new_size - size();
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
replace_unchecked(
size_type pos,
size_type n1,
const CharT* s,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type n2) ->
Move to single header
2020-02-01 16:30:23 -05:00
basic_static_string&
{
const auto curr_data = data();
const auto curr_size = size();
BOOST_STATIC_STRING_THROW_IF(
pos > curr_size, std::out_of_range{"pos > size()"});
BOOST_STATIC_STRING_THROW_IF(
curr_size - (std::min)(n1, curr_size - pos) >= max_size() - n2,
std::length_error{"replaced string exceeds max_size()"});
if (pos + n1 >= curr_size)
n1 = curr_size - pos;
Traits::move(&curr_data[pos + n2], &curr_data[pos + n1], curr_size - pos - n1 + 1);
Traits::copy(&curr_data[pos], s, n2);
Fix potential overflows
2020-02-03 22:34:08 -05:00
this->set_size((curr_size - n1) + n2);
Move to single header
2020-02-01 16:30:23 -05:00
return *this;
}
template<std::size_t N, typename CharT, typename Traits>
BOOST_STATIC_STRING_CPP14_CONSTEXPR
auto
basic_static_string<N, CharT, Traits>::
insert_unchecked(
size_type index,
const CharT* s,
Removed the ability to disable exceptions in config and the null terminator optimization from master
2020-02-07 13:50:14 -05:00
size_type count) ->
Move to single header
2020-02-01 16:30:23 -05:00
basic_static_string<N, CharT, Traits>&
{
const auto curr_data = data();
const auto curr_size = size();
BOOST_STATIC_STRING_THROW_IF(
index > curr_size, std::out_of_range{"index > size()"});
BOOST_STATIC_STRING_THROW_IF(
count > max_size() - size(),
std::length_error{"count > max_size() - size()"});
Traits::move(&curr_data[index + count], &curr_data[index], curr_size - index + 1);
Traits::copy(&curr_data[index], s, count);
this->set_size(curr_size + count);
return *this;
}
} // static_string
} // boost
#endif
#endif
Copy Permalink