proxygen: folly::BasicFixedString< Char, N

proxygen

A class for holding up to N characters of type Char that is amenable to constexpr string manipulation. It is guaranteed to not perform any dynamic allocation. More...

#include <FixedString.h>

Inheritance diagram for folly::BasicFixedString< Char, N >:

Public Types
using	size_type = std::size_t

using	difference_type = std::ptrdiff_t

using	reference = Char &

using	const_reference = const Char &

using	pointer = Char *

using	const_pointer = const Char *

using	iterator = Char *

using	const_iterator = const Char *

using	reverse_iterator = detail::fixedstring::ReverseIterator< Char >

using	const_reverse_iterator = detail::fixedstring::ReverseIterator< const Char >

Public Member Functions
constexpr	BasicFixedString ()

constexpr	BasicFixedString (const BasicFixedString &)=default

template<std::size_t M>
constexpr	BasicFixedString (const BasicFixedString< Char, M > &that) noexcept(M<=N)

template<std::size_t M>
constexpr	BasicFixedString (const BasicFixedString< Char, M > &that, std::size_t pos) noexcept(false)=delete

template<std::size_t M>
constexpr	BasicFixedString (const BasicFixedString< Char, M > &that, std::size_t pos, std::size_t count) noexcept(false)

template<std::size_t M>
constexpr	BasicFixedString (const Char(&that)[M]) noexcept

constexpr	BasicFixedString (const Char *that, std::size_t count) noexcept(false)

constexpr	BasicFixedString (std::size_t count, Char ch) noexcept(false)

constexpr	BasicFixedString (std::initializer_list< Char > il) noexcept(false)

FOLLY_CPP14_CONSTEXPR BasicFixedString &	operator= (const BasicFixedString &) noexcept=default

template<std::size_t M>
FOLLY_CPP14_CONSTEXPR BasicFixedString &	operator= (const BasicFixedString< Char, M > &that) noexcept(M<=N)

template<std::size_t M>
FOLLY_CPP14_CONSTEXPR BasicFixedString &	operator= (const Char(&that)[M]) noexcept

FOLLY_CPP14_CONSTEXPR BasicFixedString &	operator= (std::initializer_list< Char > il) noexcept(false)

FOLLY_CPP14_CONSTEXPR Range< Char * >	toRange () noexcept

constexpr Range< const Char * >	toRange () const noexcept

	operator std::basic_string< Char > () const noexcept(false)

std::basic_string< Char >	toStdString () const noexcept(false)

FOLLY_CPP14_CONSTEXPR BasicFixedString &	assign (std::size_t count, Char ch) noexcept(false)

template<std::size_t M>
FOLLY_CPP14_CONSTEXPR BasicFixedString &	assign (const BasicFixedString< Char, M > &that) noexcept(M<=N)

template<std::size_t M>
FOLLY_CPP14_CONSTEXPR BasicFixedString &	assign (const BasicFixedString< Char, M > &that, std::size_t pos) noexcept(false)=delete

template<std::size_t M>
FOLLY_CPP14_CONSTEXPR BasicFixedString &	assign (const BasicFixedString< Char, M > &that, std::size_t pos, std::size_t count) noexcept(false)

template<std::size_t M>
FOLLY_CPP14_CONSTEXPR BasicFixedString &	assign (const Char(&that)[M]) noexcept

FOLLY_CPP14_CONSTEXPR BasicFixedString &	assign (const Char *that, std::size_t count) noexcept(false)

FOLLY_CPP14_CONSTEXPR void	swap (BasicFixedString &that) noexcept

FOLLY_CPP14_CONSTEXPR Char *	data () noexcept

constexpr const Char *	data () const noexcept

constexpr const Char *	c_str () const noexcept

FOLLY_CPP14_CONSTEXPR Char *	begin () noexcept

constexpr const Char *	begin () const noexcept

constexpr const Char *	cbegin () const noexcept

FOLLY_CPP14_CONSTEXPR Char *	end () noexcept

constexpr const Char *	end () const noexcept

constexpr const Char *	cend () const noexcept

FOLLY_CPP14_CONSTEXPR reverse_iterator	rbegin () noexcept

constexpr const_reverse_iterator	rbegin () const noexcept

constexpr const_reverse_iterator	crbegin () const noexcept

FOLLY_CPP14_CONSTEXPR reverse_iterator	rend () noexcept

constexpr const_reverse_iterator	rend () const noexcept

constexpr const_reverse_iterator	crend () const noexcept

constexpr std::size_t	size () const noexcept

constexpr std::size_t	length () const noexcept

constexpr bool	empty () const noexcept

std::uint32_t	hash () const noexcept

FOLLY_CPP14_CONSTEXPR Char &	at (std::size_t i) noexcept(false)

constexpr const Char &	at (std::size_t i) const noexcept(false)

FOLLY_CPP14_CONSTEXPR Char &	operator[] (std::size_t i) noexcept

constexpr const Char &	operator[] (std::size_t i) const noexcept

FOLLY_CPP14_CONSTEXPR Char &	front () noexcept

constexpr const Char &	front () const noexcept

FOLLY_CPP14_CONSTEXPR Char &	back () noexcept

constexpr const Char &	back () const noexcept

FOLLY_CPP14_CONSTEXPR void	clear () noexcept

FOLLY_CPP14_CONSTEXPR void	push_back (Char ch) noexcept(false)

constexpr BasicFixedString< Char, N+1u >	cpush_back (Char ch) const noexcept

FOLLY_CPP14_CONSTEXPR void	pop_back () noexcept(false)

constexpr BasicFixedString< Char, N-1u >	cpop_back () const noexcept(false)

FOLLY_CPP14_CONSTEXPR BasicFixedString &	append (std::size_t count, Char ch) noexcept(false)

template<std::size_t M>
FOLLY_CPP14_CONSTEXPR BasicFixedString &	append (const BasicFixedString< Char, M > &that) noexcept(false)

template<std::size_t M>
FOLLY_CPP14_CONSTEXPR BasicFixedString &	append (const BasicFixedString< Char, M > &that, std::size_t pos) noexcept(false)=delete

template<std::size_t M>
FOLLY_CPP14_CONSTEXPR BasicFixedString &	append (const BasicFixedString< Char, M > &that, std::size_t pos, std::size_t count) noexcept(false)

FOLLY_CPP14_CONSTEXPR BasicFixedString &	append (const Char *that) noexcept(false)

FOLLY_CPP14_CONSTEXPR BasicFixedString &	append (const Char *that, std::size_t count) noexcept(false)

constexpr BasicFixedString< Char, N+1u >	cappend (Char ch) const noexcept

template<std::size_t M>
constexpr BasicFixedString< Char, N+M >	cappend (const BasicFixedString< Char, M > &that) const noexcept

template<std::size_t M>
constexpr BasicFixedString< Char, N+M >	cappend (const BasicFixedString< Char, M > &that, std::size_t pos) const noexcept(false)=delete

template<std::size_t M>
constexpr BasicFixedString< Char, N+M >	cappend (const BasicFixedString< Char, M > &that, std::size_t pos, std::size_t count) const noexcept(false)

template<std::size_t M>
constexpr BasicFixedString< Char, N+M-1u >	cappend (const Char(&that)[M]) const noexcept

template<std::size_t M>
constexpr BasicFixedString< Char, N+M-1u >	cappend (const Char(&that)[M], std::size_t pos) const noexcept(false)=delete

template<std::size_t M>
constexpr BasicFixedString< Char, N+M-1u >	cappend (const Char(&that)[M], std::size_t pos, std::size_t count) const noexcept(false)

FOLLY_CPP14_CONSTEXPR BasicFixedString &	operator+= (const Char *that) noexcept(false)

template<std::size_t M>
FOLLY_CPP14_CONSTEXPR BasicFixedString &	operator+= (const BasicFixedString< Char, M > &that) noexcept(false)

FOLLY_CPP14_CONSTEXPR BasicFixedString &	operator+= (Char ch) noexcept(false)

FOLLY_CPP14_CONSTEXPR BasicFixedString &	operator+= (std::initializer_list< Char > il) noexcept(false)

FOLLY_CPP14_CONSTEXPR BasicFixedString &	erase () noexcept

FOLLY_CPP14_CONSTEXPR BasicFixedString &	erase (std::size_t pos, std::size_t count=npos) noexcept(false)

FOLLY_CPP14_CONSTEXPR Char *	erase (const Char *first) noexcept(false)

FOLLY_CPP14_CONSTEXPR Char *	erase (const Char first, const Char last) noexcept(false)

constexpr BasicFixedString< Char, 0u >	cerase () const noexcept

constexpr BasicFixedString	cerase (std::size_t pos, std::size_t count=npos) const noexcept(false)

template<std::size_t M>
constexpr int	compare (const BasicFixedString< Char, M > &that) const noexcept

template<std::size_t M>
constexpr int	compare (std::size_t this_pos, std::size_t this_count, const BasicFixedString< Char, M > &that) const noexcept(false)

template<std::size_t M>
constexpr int	compare (std::size_t this_pos, std::size_t this_count, const BasicFixedString< Char, M > &that, std::size_t that_pos, std::size_t that_count) const noexcept(false)

constexpr int	compare (const Char *that) const noexcept

constexpr int	compare (Range< const Char * > that) const noexcept

constexpr int	compare (std::size_t this_pos, std::size_t this_count, const Char *that) const noexcept(false)

constexpr int	compare (std::size_t this_pos, std::size_t this_count, Range< const Char * > that) const noexcept(false)

constexpr int	compare (std::size_t this_pos, std::size_t this_count, const Char *that, std::size_t that_count) const noexcept(false)

constexpr int	compare (std::size_t this_pos, std::size_t this_count, Range< const Char * > that, std::size_t that_count) const noexcept(false)

constexpr BasicFixedString	substr (std::size_t pos) const noexcept(false)

constexpr BasicFixedString	substr (std::size_t pos, std::size_t count) const noexcept(false)

template<std::size_t M>
FOLLY_CPP14_CONSTEXPR BasicFixedString &	replace (const Char first, const Char last, const BasicFixedString< Char, M > &that) noexcept(false)

template<std::size_t M>
FOLLY_CPP14_CONSTEXPR BasicFixedString &	replace (std::size_t this_pos, std::size_t this_count, const BasicFixedString< Char, M > &that, std::size_t that_pos=0u) noexcept(false)

template<std::size_t M>
FOLLY_CPP14_CONSTEXPR BasicFixedString &	replace (std::size_t this_pos, std::size_t this_count, const BasicFixedString< Char, M > &that, std::size_t that_pos, std::size_t that_count) noexcept(false)

FOLLY_CPP14_CONSTEXPR BasicFixedString &	replace (std::size_t this_pos, std::size_t this_count, const Char *that) noexcept(false)

FOLLY_CPP14_CONSTEXPR BasicFixedString &	replace (const Char first, const Char last, const Char *that) noexcept(false)

FOLLY_CPP14_CONSTEXPR BasicFixedString &	replace (std::size_t this_pos, std::size_t this_count, const Char *that, std::size_t that_count) noexcept(false)

FOLLY_CPP14_CONSTEXPR BasicFixedString &	replace (std::size_t this_pos, std::size_t this_count, std::size_t that_count, Char ch) noexcept(false)

FOLLY_CPP14_CONSTEXPR BasicFixedString &	replace (const Char first, const Char last, std::size_t that_count, Char ch) noexcept(false)

FOLLY_CPP14_CONSTEXPR BasicFixedString &	replace (const Char first, const Char last, std::initializer_list< Char > il) noexcept(false)

template<std::size_t M>
constexpr BasicFixedString< Char, N+M >	creplace (std::size_t this_pos, std::size_t this_count, const BasicFixedString< Char, M > &that, std::size_t that_pos=0u) const noexcept(false)

template<std::size_t M>
constexpr BasicFixedString< Char, N+M >	creplace (std::size_t this_pos, std::size_t this_count, const BasicFixedString< Char, M > &that, std::size_t that_pos, std::size_t that_count) const noexcept(false)

template<std::size_t M>
constexpr BasicFixedString< Char, N+M >	creplace (const Char first, const Char last, const BasicFixedString< Char, M > &that, std::size_t that_pos=0u) const noexcept(false)

template<std::size_t M>
constexpr BasicFixedString< Char, N+M >	creplace (const Char first, const Char last, const BasicFixedString< Char, M > &that, std::size_t that_pos, std::size_t that_count) const noexcept(false)

template<std::size_t M>
constexpr BasicFixedString< Char, N+M-1u >	creplace (std::size_t this_pos, std::size_t this_count, const Char(&that)[M]) const noexcept(false)

template<std::size_t M>
constexpr BasicFixedString< Char, N+M-1u >	creplace (std::size_t this_pos, std::size_t this_count, const Char(&that)[M], std::size_t that_pos, std::size_t that_count) const noexcept(false)

template<std::size_t M>
constexpr BasicFixedString< Char, N+M-1u >	creplace (const Char first, const Char last, const Char(&that)[M]) const noexcept(false)

template<std::size_t M>
constexpr BasicFixedString< Char, N+M-1u >	creplace (const Char first, const Char last, const Char(&that)[M], std::size_t that_pos, std::size_t that_count) const noexcept(false)

FOLLY_CPP14_CONSTEXPR std::size_t	copy (Char *dest, std::size_t count) const noexcept

FOLLY_CPP14_CONSTEXPR std::size_t	copy (Char *dest, std::size_t count, std::size_t pos) const noexcept(false)

FOLLY_CPP14_CONSTEXPR void	resize (std::size_t count) noexcept(false)

FOLLY_CPP14_CONSTEXPR void	resize (std::size_t count, Char ch) noexcept(false)

template<std::size_t M>
constexpr std::size_t	find (const BasicFixedString< Char, M > &that) const noexcept

template<std::size_t M>
constexpr std::size_t	find (const BasicFixedString< Char, M > &that, std::size_t pos) const noexcept(false)

constexpr std::size_t	find (const Char *that) const noexcept

constexpr std::size_t	find (const Char *that, std::size_t pos) const noexcept(false)

constexpr std::size_t	find (const Char *that, std::size_t pos, std::size_t count) const noexcept(false)

constexpr std::size_t	find (Char ch) const noexcept

constexpr std::size_t	find (Char ch, std::size_t pos) const noexcept(false)

template<std::size_t M>
constexpr std::size_t	rfind (const BasicFixedString< Char, M > &that) const noexcept

template<std::size_t M>
constexpr std::size_t	rfind (const BasicFixedString< Char, M > &that, std::size_t pos) const noexcept(false)

constexpr std::size_t	rfind (const Char *that) const noexcept

constexpr std::size_t	rfind (const Char *that, std::size_t pos) const noexcept(false)

constexpr std::size_t	rfind (const Char *that, std::size_t pos, std::size_t count) const noexcept(false)

constexpr std::size_t	rfind (Char ch) const noexcept

constexpr std::size_t	rfind (Char ch, std::size_t pos) const noexcept(false)

template<std::size_t M>
constexpr std::size_t	find_first_of (const BasicFixedString< Char, M > &that) const noexcept

template<std::size_t M>
constexpr std::size_t	find_first_of (const BasicFixedString< Char, M > &that, std::size_t pos) const noexcept(false)

constexpr std::size_t	find_first_of (const Char *that) const noexcept

constexpr std::size_t	find_first_of (const Char *that, std::size_t pos) const noexcept(false)

constexpr std::size_t	find_first_of (const Char *that, std::size_t pos, std::size_t count) const noexcept(false)

constexpr std::size_t	find_first_of (Char ch) const noexcept

constexpr std::size_t	find_first_of (Char ch, std::size_t pos) const noexcept(false)

template<std::size_t M>
constexpr std::size_t	find_first_not_of (const BasicFixedString< Char, M > &that) const noexcept

template<std::size_t M>
constexpr std::size_t	find_first_not_of (const BasicFixedString< Char, M > &that, std::size_t pos) const noexcept(false)

constexpr std::size_t	find_first_not_of (const Char *that) const noexcept

constexpr std::size_t	find_first_not_of (const Char *that, std::size_t pos) const noexcept(false)

constexpr std::size_t	find_first_not_of (const Char *that, std::size_t pos, std::size_t count) const noexcept(false)

constexpr std::size_t	find_first_not_of (Char ch) const noexcept

constexpr std::size_t	find_first_not_of (Char ch, std::size_t pos) const noexcept(false)

template<std::size_t M>
constexpr std::size_t	find_last_of (const BasicFixedString< Char, M > &that) const noexcept

template<std::size_t M>
constexpr std::size_t	find_last_of (const BasicFixedString< Char, M > &that, std::size_t pos) const noexcept(false)

constexpr std::size_t	find_last_of (const Char *that) const noexcept

constexpr std::size_t	find_last_of (const Char *that, std::size_t pos) const noexcept(false)

constexpr std::size_t	find_last_of (const Char *that, std::size_t pos, std::size_t count) const noexcept(false)

constexpr std::size_t	find_last_of (Char ch) const noexcept

constexpr std::size_t	find_last_of (Char ch, std::size_t pos) const noexcept(false)

template<std::size_t M>
constexpr std::size_t	find_last_not_of (const BasicFixedString< Char, M > &that) const noexcept

template<std::size_t M>
constexpr std::size_t	find_last_not_of (const BasicFixedString< Char, M > &that, std::size_t pos) const noexcept(false)

constexpr std::size_t	find_last_not_of (const Char *that) const noexcept

constexpr std::size_t	find_last_not_of (const Char *that, std::size_t pos) const noexcept(false)

constexpr std::size_t	find_last_not_of (const Char *that, std::size_t pos, std::size_t count) const noexcept(false)

constexpr std::size_t	find_last_not_of (Char ch) const noexcept

constexpr std::size_t	find_last_not_of (Char ch, std::size_t pos) const noexcept(false)

Static Public Member Functions
static constexpr std::size_t	capacity () noexcept

static constexpr std::size_t	max_size () noexcept

Private Types
using	Indices = folly::make_index_sequence< N >

Private Member Functions
template<class That , std::size_t... Is>
constexpr	BasicFixedString (const That &that, std::size_t size, folly::index_sequence< Is... >, std::size_t pos=0, std::size_t count=npos) noexcept

template<std::size_t... Is>
constexpr	BasicFixedString (std::size_t count, Char ch, folly::index_sequence< Is... >) noexcept

template<class Left , class Right , std::size_t... Is>
constexpr	BasicFixedString (const Left &left, std::size_t left_size, const Right &right, std::size_t right_size, folly::index_sequence< Is... >) noexcept

template<class Left , class Right , std::size_t... Is>
constexpr	BasicFixedString (const Left &left, std::size_t left_size, std::size_t left_pos, std::size_t left_count, const Right &right, std::size_t right_pos, std::size_t right_count, folly::index_sequence< Is... >) noexcept

Private Attributes
Char	data_ [N+1u]

std::size_t	size_

Friends
template<class , std::size_t >
class	BasicFixedString

struct	detail::fixedstring::Helper

constexpr bool	operator== (const Char *a, const BasicFixedString &b) noexcept

constexpr bool	operator== (const BasicFixedString &a, const Char *b) noexcept

constexpr bool	operator== (Range< const Char * > a, const BasicFixedString &b) noexcept

constexpr bool	operator== (const BasicFixedString &a, Range< const Char * > b) noexcept

constexpr bool	operator!= (const Char *a, const BasicFixedString &b) noexcept

constexpr bool	operator!= (const BasicFixedString &a, const Char *b) noexcept

constexpr bool	operator!= (Range< const Char * > a, const BasicFixedString &b) noexcept

constexpr bool	operator!= (const BasicFixedString &a, Range< const Char * > b) noexcept

constexpr bool	operator< (const Char *a, const BasicFixedString &b) noexcept

constexpr bool	operator< (const BasicFixedString &a, const Char *b) noexcept

constexpr bool	operator< (Range< const Char * > a, const BasicFixedString &b) noexcept

constexpr bool	operator< (const BasicFixedString &a, Range< const Char * > b) noexcept

constexpr bool	operator> (const Char *a, const BasicFixedString &b) noexcept

constexpr bool	operator> (const BasicFixedString &a, const Char *b) noexcept

constexpr bool	operator> (Range< const Char * > a, const BasicFixedString &b) noexcept

constexpr bool	operator> (const BasicFixedString &a, Range< const Char * > b) noexcept

constexpr bool	operator<= (const Char *a, const BasicFixedString &b) noexcept

constexpr bool	operator<= (const BasicFixedString &a, const Char *b) noexcept

constexpr bool	operator<= (Range< const Char * > const &a, const BasicFixedString &b) noexcept

constexpr bool	operator<= (const BasicFixedString &a, Range< const Char * > b) noexcept

constexpr bool	operator>= (const Char *a, const BasicFixedString &b) noexcept

constexpr bool	operator>= (const BasicFixedString &a, const Char *b) noexcept

constexpr bool	operator>= (Range< const Char * > a, const BasicFixedString &b) noexcept

constexpr bool	operator>= (const BasicFixedString &a, Range< const Char * > const &b) noexcept

template<std::size_t M>
constexpr BasicFixedString< Char, N+M-1u >	operator+ (const Char(&a)[M], const BasicFixedString &b) noexcept

template<std::size_t M>
constexpr BasicFixedString< Char, N+M-1u >	operator+ (const BasicFixedString &a, const Char(&b)[M]) noexcept

constexpr BasicFixedString< Char, N+1u >	operator+ (Char a, const BasicFixedString &b) noexcept

constexpr BasicFixedString< Char, N+1u >	operator+ (const BasicFixedString &a, Char b) noexcept

Additional Inherited Members
Static Private Attributes inherited from folly::detail::fixedstring::FixedStringBase_< class >
static constexpr std::size_t	npos = static_cast<std::size_t>(-1)

Detailed Description

template<class Char, std::size_t N>
class folly::BasicFixedString< Char, N >

A class for holding up to N characters of type Char that is amenable to constexpr string manipulation. It is guaranteed to not perform any dynamic allocation.

Template Parameters

Char	The character type. Must be a scalar type.
N	The capacity and max size of string instances of this type.

BasicFixedString is a std::string work-alike that stores characters in an internal buffer. It has minor interface differences that make it easy to work with strings in a constexpr context.

Example:

: constexpr auto hello = makeFixedString("hello"); // a FixedString<5>
constexpr auto world = makeFixedString("world"); // a FixedString<5>
constexpr auto hello_world = hello + ' ' + world + '!'; // a FixedString<12>
static_assert(hello_world == "hello world!", "neato!");

: FixedString<N> is an alias for BasicFixedString<char, N>.

Constexpr and In-place Mutation

: On a C++14 compiler, BasicFixedString supports the full std::string interface as constexpr member functions. On a C++11 compiler, the mutating members are not constexpr, but non-mutating alternatives, which create a new string, can be used instead. For example, instead of this:

: constexpr FixedString<10> replace_example_cpp14() {
FixedString<10> test{"****"};
test.replace(1, 2, "!!!!");
return test; // returns "*!!!!*"
}

: You might write this instead:

: constexpr FixedString<10> replace_example_cpp11() {
// GNU compilers have an extension that make it possible to create
// FixedString objects with a `""_fs` user-defined literal.
using namespace folly;
return makeFixedString("****").creplace(1, 2, "!!!!"); // "*!!!!*"
}

User-defined Literals: Instead of using the folly::makeFixedString helper function, you can use a user-defined literal to make FixedString instances. The UDL feature of C++ has some limitations that make this less than ideal; you must tell the compiler roughly how many characters are in the string. The suffixes _fs4, _fs8, _fs16, _fs32, _fs64, and _fs128 exist to create instances of types FixedString<4>, FixedString<8>, etc. For example:

: using namespace folly::string_literals;
constexpr auto hello = "hello"_fs8; // A FixedString<8> containing "hello"

: See Error Handling below for what to expect when you try to exceed the capacity of a FixedString by storing too many characters in it.

: If your compiler supports GNU extensions, there is one additional suffix you can use: _fs. This suffix always creates FixedString objects of exactly the right size. For example:

: using namespace folly::string_literals;
// NOTE: Only works on compilers with GNU extensions enabled. Clang and
// gcc support this (-Wgnu-string-literal-operator-template):
constexpr auto hello = "hello"_fs; // A FixedString<5> containing "hello"

Error Handling:: The capacity of a BasicFixedString is set at compile time. When the user asks the string to exceed its capacity, one of three things will happen, depending on the context:

If the attempt is made while evaluating a constant expression, the program will fail to compile.
Otherwise, if the program is being run in debug mode, it will assert.
Otherwise, the failed operation will throw a std::out_of_range exception.

: This is also the case if an invalid offset is passed to any member function, or if pop_back or cpop_back is called on an empty BasicFixedString.

Member functions documented as having preconditions will assert in Debug mode (!defined(NDEBUG)) on precondition failures. Those documented with Throws clauses will throw the specified exception on failure. Those with both a precondition and a Throws clause will assert in Debug and throw in Release mode.

Definition at line 42 of file FixedString.h.

Member Typedef Documentation

template<class Char, std::size_t N>

using folly::BasicFixedString< Char, N >::const_iterator = const Char*

Definition at line 599 of file FixedString.h.

template<class Char, std::size_t N>

using folly::BasicFixedString< Char, N >::const_pointer = const Char*

Definition at line 597 of file FixedString.h.

template<class Char, std::size_t N>

using folly::BasicFixedString< Char, N >::const_reference = const Char&

Definition at line 595 of file FixedString.h.

template<class Char, std::size_t N>

using folly::BasicFixedString< Char, N >::const_reverse_iterator = detail::fixedstring::ReverseIterator<const Char>

Definition at line 602 of file FixedString.h.

template<class Char, std::size_t N>

using folly::BasicFixedString< Char, N >::difference_type = std::ptrdiff_t

Definition at line 593 of file FixedString.h.

template<class Char, std::size_t N>

using folly::BasicFixedString< Char, N >::Indices = folly::make_index_sequence<N>

private

Definition at line 531 of file FixedString.h.

template<class Char, std::size_t N>

using folly::BasicFixedString< Char, N >::iterator = Char*

Definition at line 598 of file FixedString.h.

template<class Char, std::size_t N>

using folly::BasicFixedString< Char, N >::pointer = Char*

Definition at line 596 of file FixedString.h.

template<class Char, std::size_t N>

using folly::BasicFixedString< Char, N >::reference = Char&

Definition at line 594 of file FixedString.h.

template<class Char, std::size_t N>

using folly::BasicFixedString< Char, N >::reverse_iterator = detail::fixedstring::ReverseIterator<Char>

Definition at line 600 of file FixedString.h.

template<class Char, std::size_t N>

using folly::BasicFixedString< Char, N >::size_type = std::size_t

Definition at line 592 of file FixedString.h.

Constructor & Destructor Documentation

template<class Char, std::size_t N>

template<class That , std::size_t... Is>

constexpr folly::BasicFixedString< Char, N >::BasicFixedString	(	const That &	that,
		std::size_t	size,
		folly::index_sequence< Is... >	,
		std::size_t	pos = `0`,
		std::size_t	count = `npos`
	)

inlineprivatenoexcept

Definition at line 534 of file FixedString.h.

References testing::gmock_generated_actions_test::Char(), folly::constexpr_min(), count, and folly::size().

       : data_{(Is < (size - pos) && Is < count ? that[Is + pos] : Char(0))...,
               Char(0)},
         size_{folly::constexpr_min(size - pos, count)} {}

template<class Char, std::size_t N>

template<std::size_t... Is>

constexpr folly::BasicFixedString< Char, N >::BasicFixedString	(	std::size_t	count,
		Char	ch,
		folly::index_sequence< Is... >
	)

inlineprivatenoexcept

Definition at line 545 of file FixedString.h.

References testing::gmock_generated_actions_test::Char(), and count.

549 : data_{((Is < count) ? ch : Char(0))..., Char(0)}, size_{count} {}

auto ch

Definition: ParallelBenchmark.cpp:103

folly::BasicFixedString::data_

Char data_[N+1u]

Definition: FixedString.h:528

count

int * count

Definition: gmock_stress_test.cc:176

testing::gmock_generated_actions_test::Char

char Char(char ch)

Definition: gmock-generated-actions_test.cc:68

folly::BasicFixedString::size_

std::size_t size_

Definition: FixedString.h:529

template<class Char, std::size_t N>

template<class Left , class Right , std::size_t... Is>

constexpr folly::BasicFixedString< Char, N >::BasicFixedString	(	const Left &	left,
		std::size_t	left_size,
		const Right &	right,
		std::size_t	right_size,
		folly::index_sequence< Is... >
	)

inlineprivatenoexcept

Definition at line 553 of file FixedString.h.

References testing::gmock_generated_actions_test::Char().

       : data_{detail::fixedstring::char_at_<Char>(
                   left,
                   left_size,
                   right,
                   right_size,
                   Is)...,
               Char(0)},
         size_{left_size + right_size} {}

template<class Char, std::size_t N>

template<class Left , class Right , std::size_t... Is>

constexpr folly::BasicFixedString< Char, N >::BasicFixedString	(	const Left &	left,
		std::size_t	left_size,
		std::size_t	left_pos,
		std::size_t	left_count,
		const Right &	right,
		std::size_t	right_pos,
		std::size_t	right_count,
		folly::index_sequence< Is... >
	)

inlineprivatenoexcept

Definition at line 570 of file FixedString.h.

References testing::gmock_generated_actions_test::Char().

       : data_{detail::fixedstring::char_at_<Char>(
                   left,
                   left_size,
                   left_pos,
                   left_count,
                   right,
                   right_pos,
                   right_count,
                   Is)...,
               Char(0)},
         size_{left_size - left_count + right_count} {}

template<class Char, std::size_t N>

constexpr folly::BasicFixedString< Char, N >::BasicFixedString ( )

inline

Default construct

Postcondition: size() == 0; at(0) == Char(0)

Definition at line 611 of file FixedString.h.

611 : data_{}, size_{} {}

folly::BasicFixedString::data_

Char data_[N+1u]

Definition: FixedString.h:528

folly::BasicFixedString::size_

std::size_t size_

Definition: FixedString.h:529

template<class Char, std::size_t N>

constexpr folly::BasicFixedString< Char, N >::BasicFixedString ( const BasicFixedString< Char, N > & )

default

Copy construct

Postcondition: size() == that.size(); 0 == strncmp(data(), that.data(), size()); at(size()) == Char(0)

template<class Char, std::size_t N>

template<std::size_t M>

constexpr folly::BasicFixedString< Char, N >::BasicFixedString ( const BasicFixedString< Char, M > & that )

inlinenoexcept

Construct from a differently-sized BasicFixedString

Precondition: that.size() <= N

Postcondition: size() == that.size(); 0 == strncmp(data(), that.data(), size()); at(size()) == Char(0)

Exceptions

std::out_of_range when that.size() > N. When M <= N, this constructor will never throw.

Note: Conversions from larger-capacity BasicFixedString objects to smaller ones (M > N) are allowed as long as the size() of the source string is small enough.

Definition at line 634 of file FixedString.h.

References folly::pushmi::__adl::noexcept(), and folly::BasicFixedString< Char, N >::size_.

636 : BasicFixedString{that, 0u, that.size_} {}

folly::BasicFixedString::BasicFixedString

constexpr BasicFixedString()

Definition: FixedString.h:611

template<class Char, std::size_t N>

template<std::size_t M>

constexpr folly::BasicFixedString< Char, N >::BasicFixedString	(	const BasicFixedString< Char, M > &	that,
		std::size_t	pos
	)

deletenoexcept

template<class Char, std::size_t N>

template<std::size_t M>

constexpr folly::BasicFixedString< Char, N >::BasicFixedString	(	const BasicFixedString< Char, M > &	that,
		std::size_t	pos,
		std::size_t	count
	)

inlinenoexcept

Construct from an BasicFixedString, an offset, and a count

Parameters

that	The source string
pos	The starting position in `that`
count	The number of characters to copy. If `npos`, `count` is taken to be `that.size()-pos`.

Precondition: pos <= that.size(); count <= that.size()-pos && count <= N

Postcondition: size() == count; 0 == strncmp(data(), that.data()+pos, size()); at(size()) == Char(0)

Exceptions

std::out_of_range when pos+count > that.size(), or when count > N

Definition at line 660 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), folly::detail::fixedstring::checkOverflowOrNpos(), count, folly::BasicFixedString< Char, N >::data_, M, folly::BasicFixedString< Char, N >::size_, and type.

       : BasicFixedString{
             that.data_,
             that.size_,
             folly::make_index_sequence<(M < N ? M : N)>{},
             pos,
             detail::fixedstring::checkOverflow(
                 detail::fixedstring::checkOverflowOrNpos(
                     count,
                     that.size_ -
                         detail::fixedstring::checkOverflow(pos, that.size_)),
                 N)} {}

template<class Char, std::size_t N>

template<std::size_t M>

constexpr folly::BasicFixedString< Char, N >::BasicFixedString ( const Char(&) that[M] )

inlinenoexcept

Construct from a string literal

Precondition: M-1 <= N; that[M-1] == Char(0)

Postcondition: 0 == strncmp(data(), that, M-1); size() == M-1; at(size()) == Char(0)

Definition at line 685 of file FixedString.h.

References folly::detail::fixedstring::checkNullTerminated().

       : BasicFixedString{detail::fixedstring::checkNullTerminated(that),
                          M - 1u,
                          folly::make_index_sequence<M - 1u>{}} {}

template<class Char, std::size_t N>

constexpr folly::BasicFixedString< Char, N >::BasicFixedString	(	const Char *	that,
		std::size_t	count
	)

inlinenoexcept

Construct from a const Char* and count

Precondition: that points to an array of at least count characters.; count <= N

Postcondition: size() == count; 0 == strncmp(data(), that, size()); at(size()) == Char(0)

Exceptions

std::out_of_range when count > N

Definition at line 699 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), and count.

       : BasicFixedString{that,
                          detail::fixedstring::checkOverflow(count, N),
                          Indices{}} {}

template<class Char, std::size_t N>

constexpr folly::BasicFixedString< Char, N >::BasicFixedString	(	std::size_t	count,
		Char	ch
	)

inlinenoexcept

Construct an BasicFixedString that contains count characters, all of which are ch.

Precondition: count <= N

Postcondition: size() == count; npos == find_first_not_of(ch); at(size()) == Char(0)

Exceptions

std::out_of_range when count > N

Definition at line 714 of file FixedString.h.

References ch, folly::detail::fixedstring::checkOverflow(), and count.

       : BasicFixedString{detail::fixedstring::checkOverflow(count, N),
                          ch,
                          Indices{}} {}

template<class Char, std::size_t N>

constexpr folly::BasicFixedString< Char, N >::BasicFixedString ( std::initializer_list< Char > il )

inlinenoexcept

Construct an BasicFixedString from a std::initializer_list of characters.

Precondition: il.size() <= N

Postcondition: size() == count; 0 == strncmp(data(), il.begin(), size()); at(size()) == Char(0)

Exceptions

std::out_of_range when il.size() > N

Definition at line 728 of file FixedString.h.

References folly::BasicFixedString< Char, N >::begin(), FOLLY_CPP14_CONSTEXPR, and folly::pushmi::__adl::noexcept().

729 : BasicFixedString{il.begin(), il.size()} {}

folly::BasicFixedString::BasicFixedString

constexpr BasicFixedString()

Definition: FixedString.h:611

Member Function Documentation

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::append	(	std::size_t	count,
		Char	ch
	)

inlinenoexcept

Appends count copies of ch to this string.

Precondition: count + old_size <= N

Postcondition: The first old_size characters of the string are unmodified.; size() == old_size + count

Exceptions

std::out_of_range if count > N - size().

Definition at line 1240 of file FixedString.h.

References ch, testing::gmock_generated_actions_test::Char(), folly::detail::fixedstring::checkOverflow(), count, and i.

                                {
     detail::fixedstring::checkOverflow(count, N - size_);
     for (std::size_t i = 0u; i < count; ++i) {
       data_[size_ + i] = ch;
     }
     size_ += count;
     data_[size_] = Char(0);
     return *this;
   }

template<class Char, std::size_t N>

template<std::size_t M>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::append ( const BasicFixedString< Char, M > & that )

inlinenoexcept

Note: Equivalent to append(*this, 0, that.size()).

Definition at line 1256 of file FixedString.h.

References append(), FOLLY_CPP14_CONSTEXPR, folly::pushmi::__adl::noexcept(), and folly::BasicFixedString< Char, N >::size_.

                                                              {
     return append(that, 0u, that.size_);
   }

template<class Char, std::size_t N>

template<std::size_t M>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::append	(	const BasicFixedString< Char, M > &	that,
		std::size_t	pos
	)

deletenoexcept

template<class Char, std::size_t N>

template<std::size_t M>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::append	(	const BasicFixedString< Char, M > &	that,
		std::size_t	pos,
		std::size_t	count
	)

inlinenoexcept

Appends count characters from another string to this one, starting at a given offset, pos.

Parameters

that	The source string.
pos	The starting position in the source string.
count	The number of characters to append. If `npos`, `count` is taken to be `that.size()-pos`.

Precondition: pos <= that.size(); count <= that.size() - pos; old_size + count <= N

Postcondition: The first old_size characters of the string are unmodified.; size() == old_size + count; at(size()) == Char(0)

Exceptions

std::out_of_range if pos + count > that.size() or if old_size + count > N.

Definition at line 1286 of file FixedString.h.

References testing::gmock_generated_actions_test::Char(), folly::detail::fixedstring::checkOverflow(), folly::detail::fixedstring::checkOverflowOrNpos(), count, folly::BasicFixedString< Char, N >::data_, i, and folly::BasicFixedString< Char, N >::size_.

                                        {
     detail::fixedstring::checkOverflow(pos, that.size_);
     count = detail::fixedstring::checkOverflowOrNpos(count, that.size_ - pos);
     detail::fixedstring::checkOverflow(count, N - size_);
     for (std::size_t i = 0u; i < count; ++i) {
       data_[size_ + i] = that.data_[pos + i];
     }
     size_ += count;
     data_[size_] = Char(0);
     return *this;
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::append ( const Char * that )

inlinenoexcept

Note: Equivalent to append(that, strlen(that)).

Definition at line 1304 of file FixedString.h.

References append(), and folly::constexpr_strlen().

              {
     return append(that, folly::constexpr_strlen(that));
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::append	(	const Char *	that,
		std::size_t	count
	)

inlinenoexcept

Appends count characters from the specified character array.

Precondition: that points to a range of at least count characters.; count + old_size <= N

Postcondition: The first old_size characters of the string are unmodified.; size() == old_size + count; at(size()) == Char(0)

Exceptions

std::out_of_range if old_size + count > N.

Definition at line 1318 of file FixedString.h.

References testing::gmock_generated_actions_test::Char(), folly::detail::fixedstring::checkOverflow(), count, and i.

                                        {
     detail::fixedstring::checkOverflow(count, N - size_);
     for (std::size_t i = 0u; i < count; ++i) {
       data_[size_ + i] = that[i];
     }
     size_ += count;
     data_[size_] = Char(0);
     return *this;
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::assign	(	std::size_t	count,
		Char	ch
	)

inlinenoexcept

Assigns a sequence of count characters of value ch.

Parameters

count	The count of characters.
ch

Precondition: count <= N

Postcondition: size() == count; npos == find_first_not_of(ch); at(size()) == Char(0)

Exceptions

std::out_of_range when count > N

Returns: *this

Definition at line 844 of file FixedString.h.

References ch, testing::gmock_generated_actions_test::Char(), folly::detail::fixedstring::checkOverflow(), count, and i.

Referenced by TEST().

                                {
     detail::fixedstring::checkOverflow(count, N);
     for (std::size_t i = 0u; i < count; ++i) {
       data_[i] = ch;
     }
     size_ = count;
     data_[size_] = Char(0);
     return *this;
   }

template<class Char, std::size_t N>

template<std::size_t M>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::assign ( const BasicFixedString< Char, M > & that )

inlinenoexcept

Assigns characters from an BasicFixedString to this object.

Note: Equivalent to assign(that, 0, that.size())

Definition at line 861 of file FixedString.h.

References FOLLY_CPP14_CONSTEXPR, and folly::pushmi::__adl::noexcept().

                                                               {
     return *this = that;
   }

template<class Char, std::size_t N>

template<std::size_t M>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::assign	(	const BasicFixedString< Char, M > &	that,
		std::size_t	pos
	)

deletenoexcept

template<class Char, std::size_t N>

template<std::size_t M>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::assign	(	const BasicFixedString< Char, M > &	that,
		std::size_t	pos,
		std::size_t	count
	)

inlinenoexcept

Assigns count characters from an BasicFixedString to this object, starting at position pos in the source object.

Parameters

that	The source string.
pos	The starting position in the source string.
count	The number of characters to copy. If `npos`, `count` is taken to be `that.size()-pos`.

Precondition: pos <= that.size(); count <= that.size()-pos; count <= N

Postcondition: size() == count; 0 == strncmp(data(), that.begin() + pos, count); at(size()) == Char(0)

Exceptions

std::out_of_range when pos > that.size() or count > that.size()-pos or count > N.

Returns: *this

Definition at line 893 of file FixedString.h.

                                        {
     detail::fixedstring::checkOverflow(pos, that.size_);
     return assign(
         that.data_ + pos,
         detail::fixedstring::checkOverflowOrNpos(count, that.size_ - pos));
   }

template<class Char, std::size_t N>

template<std::size_t M>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::assign ( const Char(&) that[M] )

inlinenoexcept

Assigns characters from an BasicFixedString to this object.

Precondition: that contains no embedded nulls.; that[M-1] == Char(0)

Note: Equivalent to assign(that, M - 1)

Definition at line 910 of file FixedString.h.

References folly::detail::fixedstring::checkNullTerminated().

                                       {
     return assign(detail::fixedstring::checkNullTerminated(that), M - 1u);
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::assign	(	const Char *	that,
		std::size_t	count
	)

inlinenoexcept

Assigns count characters from a range of characters to this object.

Parameters

that	A pointer to a range of characters.
count	The number of characters to copy.

Precondition: that points to at least count characters.; count <= N

Postcondition: size() == count; 0 == strncmp(data(), that, count); at(size()) == Char(0)

Exceptions

std::out_of_range when count > N

Returns: *this

Definition at line 927 of file FixedString.h.

References testing::gmock_generated_actions_test::Char(), folly::detail::fixedstring::checkOverflow(), count, and i.

                                        {
     detail::fixedstring::checkOverflow(count, N);
     for (std::size_t i = 0u; i < count; ++i) {
       data_[i] = that[i];
     }
     size_ = count;
     data_[size_] = Char(0);
     return *this;
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR Char& folly::BasicFixedString< Char, N >::at ( std::size_t i )

inlinenoexcept

Note: at(size()) is allowed will return Char(0).

Returns: *(data() + i)

Exceptions

std::out_of_range when i > size()

Definition at line 1105 of file FixedString.h.

References i.

                                                               {
     return i <= size_ ? data_[i]
                       : (throw_exception<std::out_of_range>(
                              "Out of range in BasicFixedString::at"),
                          data_[size_]);
   }

template<class Char, std::size_t N>

constexpr const Char& folly::BasicFixedString< Char, N >::at ( std::size_t i ) const

inlinenoexcept

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 1115 of file FixedString.h.

References i.

                                                               {
     return i <= size_ ? data_[i]
                       : (throw_exception<std::out_of_range>(
                              "Out of range in BasicFixedString::at"),
                          data_[size_]);
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR Char& folly::BasicFixedString< Char, N >::back ( )

inlinenoexcept

Note: Equivalent to at(size()-1)

Precondition: !empty()

Definition at line 1164 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow().

                                               {
 #ifdef NDEBUG
     return data_[size_ - 1u];
 #else
     return data_[size_ - detail::fixedstring::checkOverflow(1u, size_)];
 #endif
   }

template<class Char, std::size_t N>

constexpr const Char& folly::BasicFixedString< Char, N >::back ( ) const

inlinenoexcept

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 1175 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow().

                                               {
 #ifdef NDEBUG
     return data_[size_ - 1u];
 #else
     return data_[size_ - detail::fixedstring::checkOverflow(1u, size_)];
 #endif
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR Char* folly::BasicFixedString< Char, N >::begin ( )

inlinenoexcept

Returns: data().

Definition at line 976 of file FixedString.h.

References data_.

Referenced by folly::BasicFixedString< Char, N >::BasicFixedString(), and folly::BasicFixedString< Char, N >::compare().

                                                {
     return data_;
   }

template<class Char, std::size_t N>

constexpr const Char* folly::BasicFixedString< Char, N >::begin ( ) const

inlinenoexcept

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 983 of file FixedString.h.

References data_.

                                                {
     return data_;
   }

template<class Char, std::size_t N>

constexpr const Char* folly::BasicFixedString< Char, N >::c_str ( ) const

inlinenoexcept

Returns: data().

Definition at line 969 of file FixedString.h.

References data_.

Referenced by TEST().

                                                {
     return data_;
   }

template<class Char, std::size_t N>

static constexpr std::size_t folly::BasicFixedString< Char, N >::capacity ( )

inlinestaticnoexcept

Returns: N.

Definition at line 1083 of file FixedString.h.

                                                  {
     return N;
   }

template<class Char, std::size_t N>

constexpr BasicFixedString<Char, N + 1u> folly::BasicFixedString< Char, N >::cappend ( Char ch ) const

inlinenoexcept

Creates a new string by appending a character to an existing string, which is left unmodified.

Note: Equivalent to *this + ch

Definition at line 1335 of file FixedString.h.

References ch.

                                                                            {
     return *this + ch;
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr BasicFixedString<Char, N + M> folly::BasicFixedString< Char, N >::cappend ( const BasicFixedString< Char, M > & that ) const

inlinenoexcept

Creates a new string by appending a string to an existing string, which is left unmodified.

Note: Equivalent to *this + ch

Definition at line 1345 of file FixedString.h.

References folly::pushmi::__adl::noexcept().

                                                             {
     return *this + that;
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr BasicFixedString<Char, N + M> folly::BasicFixedString< Char, N >::cappend	(	const BasicFixedString< Char, M > &	that,
		std::size_t	pos
	)		const

deletenoexcept

template<class Char, std::size_t N>

template<std::size_t M>

constexpr BasicFixedString<Char, N + M> folly::BasicFixedString< Char, N >::cappend	(	const BasicFixedString< Char, M > &	that,
		std::size_t	pos,
		std::size_t	count
	)		const

inlinenoexcept

Creates a new string by appending characters from one string to another, which is left unmodified.

Note: Equivalent to *this + that.substr(pos, count)

Definition at line 1363 of file FixedString.h.

References count.

                                              {
     return creplace(size_, 0u, that, pos, count);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr BasicFixedString<Char, N + M - 1u> folly::BasicFixedString< Char, N >::cappend ( const Char(&) that[M] ) const

inlinenoexcept

Creates a new string by appending a string literal to a string, which is left unmodified.

Note: Equivalent to *this + that

Definition at line 1376 of file FixedString.h.

References testing::gmock_generated_actions_test::Char(), and folly::pushmi::__adl::noexcept().

                                             {
     return creplace(size_, 0u, that);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr BasicFixedString<Char, N + M - 1u> folly::BasicFixedString< Char, N >::cappend	(	const Char(&)	that[M],
		std::size_t	pos
	)		const

deletenoexcept

template<class Char, std::size_t N>

template<std::size_t M>

constexpr BasicFixedString<Char, N + M - 1u> folly::BasicFixedString< Char, N >::cappend	(	const Char(&)	that[M],
		std::size_t	pos,
		std::size_t	count
	)		const

inlinenoexcept

Creates a new string by appending characters from one string to another, which is left unmodified.

Note: Equivalent to *this + makeFixedString(that).substr(pos, count)

Definition at line 1395 of file FixedString.h.

References count.

                       {
     return creplace(size_, 0u, that, pos, count);
   }

template<class Char, std::size_t N>

constexpr const Char* folly::BasicFixedString< Char, N >::cbegin ( ) const

inlinenoexcept

Returns: data().

Definition at line 990 of file FixedString.h.

References folly::test::begin().

                                                 {
     return begin();
   }

template<class Char, std::size_t N>

constexpr const Char* folly::BasicFixedString< Char, N >::cend ( ) const

inlinenoexcept

Returns: data() + size().

Definition at line 1011 of file FixedString.h.

References folly::test::end().

                                               {
     return end();
   }

template<class Char, std::size_t N>

constexpr BasicFixedString<Char, 0u> folly::BasicFixedString< Char, N >::cerase ( ) const

inlinenoexcept

Create a new string by erasing all the characters from this string.

Note: Equivalent to BasicFixedString<Char, 0>{}

Definition at line 1493 of file FixedString.h.

                                                                {
     return {};
   }

template<class Char, std::size_t N>

constexpr BasicFixedString folly::BasicFixedString< Char, N >::cerase	(	std::size_t	pos,
		std::size_t	count = `npos`
	)		const

inlinenoexcept

Create a new string by erasing all the characters after position pos from this string.

Note: Equivalent to creplace(pos, min(count, pos - size()), "")

Definition at line 1502 of file FixedString.h.

References testing::gmock_generated_actions_test::Char(), folly::detail::fixedstring::checkOverflow(), folly::detail::fixedstring::checkOverflowOrNpos(), and count.

                             {
     using A = const Char[1];
     return creplace(
         pos,
         detail::fixedstring::checkOverflowOrNpos(
             count, size_ - detail::fixedstring::checkOverflow(pos, size_)),
         A{Char(0)});
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR void folly::BasicFixedString< Char, N >::clear ( )

inlinenoexcept

Clears the contents of this string.

Postcondition: size() == 0u; at(size()) == Char(0)

Definition at line 1188 of file FixedString.h.

References testing::gmock_generated_actions_test::Char().

                                               {
     data_[0u] = Char(0);
     size_ = 0u;
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr int folly::BasicFixedString< Char, N >::compare ( const BasicFixedString< Char, M > & that ) const

inlinenoexcept

Compare two strings for lexicographical ordering.

Note: Equivalent to compare(0, size(), that.data(), that.size())

Definition at line 1518 of file FixedString.h.

References folly::BasicFixedString< Char, N >::size_.

                                                                               {
     return compare(0u, size_, that, 0u, that.size_);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr int folly::BasicFixedString< Char, N >::compare	(	std::size_t	this_pos,
		std::size_t	this_count,
		const BasicFixedString< Char, M > &	that
	)		const

inlinenoexcept

Compare two strings for lexicographical ordering.

Note: Equivalent to compare(this_pos, this_count, that.data(), that.size())

Definition at line 1528 of file FixedString.h.

References folly::BasicFixedString< Char, N >::size_.

                                                                    {
     return compare(this_pos, this_count, that, 0u, that.size_);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr int folly::BasicFixedString< Char, N >::compare	(	std::size_t	this_pos,
		std::size_t	this_count,
		const BasicFixedString< Char, M > &	that,
		std::size_t	that_pos,
		std::size_t	that_count
	)		const

inlinenoexcept

Compare two strings for lexicographical ordering.

Note: Equivalent to compare(this_pos, this_count, that.data() + that_pos, that_count)

Definition at line 1541 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), folly::detail::fixedstring::compare_(), folly::BasicFixedString< Char, N >::data_, and folly::BasicFixedString< Char, N >::size_.

                                                   {
     return static_cast<int>(detail::fixedstring::compare_(
         data_,
         detail::fixedstring::checkOverflow(this_pos, size_),
         detail::fixedstring::checkOverflow(this_count, size_ - this_pos) +
             this_pos,
         that.data_,
         detail::fixedstring::checkOverflow(that_pos, that.size_),
         detail::fixedstring::checkOverflow(that_count, that.size_ - that_pos) +
             that_pos));
   }

template<class Char, std::size_t N>

constexpr int folly::BasicFixedString< Char, N >::compare ( const Char * that ) const

inlinenoexcept

Compare two strings for lexicographical ordering.

Note: Equivalent to compare(0, size(), that, strlen(that))

Definition at line 1562 of file FixedString.h.

References folly::constexpr_strlen().

                                                          {
     return compare(0u, size_, that, folly::constexpr_strlen(that));
   }

template<class Char, std::size_t N>

constexpr int folly::BasicFixedString< Char, N >::compare ( Range< const Char * > that ) const

inlinenoexcept

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 1569 of file FixedString.h.

References folly::BasicFixedString< Char, N >::begin(), and folly::BasicFixedString< Char, N >::size().

                                                                 {
     return compare(0u, size_, that.begin(), that.size());
   }

template<class Char, std::size_t N>

constexpr int folly::BasicFixedString< Char, N >::compare	(	std::size_t	this_pos,
		std::size_t	this_count,
		const Char *	that
	)		const

inlinenoexcept

Compare two strings for lexicographical ordering.

Note: Equivalent to compare(this_pos, this_count, that, strlen(that))

Definition at line 1578 of file FixedString.h.

References folly::constexpr_strlen().

                                               {
     return compare(this_pos, this_count, that, folly::constexpr_strlen(that));
   }

template<class Char, std::size_t N>

constexpr int folly::BasicFixedString< Char, N >::compare	(	std::size_t	this_pos,
		std::size_t	this_count,
		Range< const Char * >	that
	)		const

inlinenoexcept

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 1588 of file FixedString.h.

References folly::BasicFixedString< Char, N >::begin(), and folly::BasicFixedString< Char, N >::size().

                                                      {
     return compare(this_pos, this_count, that.begin(), that.size());
   }

template<class Char, std::size_t N>

constexpr int folly::BasicFixedString< Char, N >::compare	(	std::size_t	this_pos,
		std::size_t	this_count,
		const Char *	that,
		std::size_t	that_count
	)		const

inlinenoexcept

Compare two strings for lexicographical ordering.

Let A be the the character sequence {(*this)[this_pos], ... (*this)[this_pos + this_count - 1]}. Let B be the character sequence {that[0], ...that[count - 1]}. Then...

Returns

< 0 if A is ordered before the B
> 0 if B is ordered before A
0 if A equals B.

Exceptions

std::out_of_range if this_pos + this_count > size().

Definition at line 1610 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), folly::detail::fixedstring::checkOverflowOrNpos(), and folly::detail::fixedstring::compare_().

                                                   {
     return static_cast<int>(detail::fixedstring::compare_(
         data_,
         detail::fixedstring::checkOverflow(this_pos, size_),
         detail::fixedstring::checkOverflowOrNpos(this_count, size_ - this_pos) +
             this_pos,
         that,
         0u,
         that_count));
   }

template<class Char, std::size_t N>

constexpr int folly::BasicFixedString< Char, N >::compare	(	std::size_t	this_pos,
		std::size_t	this_count,
		Range< const Char * >	that,
		std::size_t	that_count
	)		const

inlinenoexcept

Definition at line 1625 of file FixedString.h.

References folly::BasicFixedString< Char, N >::begin(), folly::detail::fixedstring::checkOverflow(), and folly::BasicFixedString< Char, N >::size().

                                                   {
     return compare(
         this_pos,
         this_count,
         that.begin(),
         detail::fixedstring::checkOverflow(that_count, that.size()));
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR std::size_t folly::BasicFixedString< Char, N >::copy	(	Char *	dest,
		std::size_t	count
	)		const

inlinenoexcept

Copies min(count, size()) characters starting from offset 0 from this string into the buffer pointed to by dest.

Returns: The number of characters copied.

Definition at line 2016 of file FixedString.h.

References folly::copy(), count, upload::dest, and FOLLY_CPP14_CONSTEXPR.

Referenced by folly::BasicFixedString< Char, N >::operator=().

                {
     return copy(dest, count, 0u);
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR std::size_t folly::BasicFixedString< Char, N >::copy	(	Char *	dest,
		std::size_t	count,
		std::size_t	pos
	)		const

inlinenoexcept

Copies min(count, size() - pos) characters starting from offset pos from this string into the buffer pointed to by dest.

Precondition: pos <= size()

Returns: The number of characters copied.

Exceptions

std::out_of_range if pos > size()

Definition at line 2029 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), count, upload::dest, and i.

                                                                          {
     detail::fixedstring::checkOverflow(pos, size_);
     for (std::size_t i = 0u; i < count; ++i) {
       if (i + pos == size_) {
         return size_;
       }
       dest[i] = data_[i + pos];
     }
     return count;
   }

template<class Char, std::size_t N>

constexpr BasicFixedString<Char, N - 1u> folly::BasicFixedString< Char, N >::cpop_back ( ) const

inlinenoexcept

Returns a new string with the first size()-1 characters from this string.

Precondition: !empty()

Note: Equivalent to BasicFixedString<Char, N-1u>{*this, 0u, size()-1u}

Exceptions

std::out_of_range if empty().

Definition at line 1229 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow().

                                                                              {
     return {*this, 0u, size_ - detail::fixedstring::checkOverflow(1u, size_)};
   }

template<class Char, std::size_t N>

constexpr BasicFixedString<Char, N + 1u> folly::BasicFixedString< Char, N >::cpush_back ( Char ch ) const

inlinenoexcept

Note: Equivalent to cappend(1u, ch).

Definition at line 1205 of file FixedString.h.

References ch.

                                                                               {
     return cappend(ch);
   }

template<class Char, std::size_t N>

constexpr const_reverse_iterator folly::BasicFixedString< Char, N >::crbegin ( ) const

inlinenoexcept

Note: Equivalent to rbegin() on a const-qualified reference to *this.

Definition at line 1033 of file FixedString.h.

                                                             {
     return rbegin();
   }

template<class Char, std::size_t N>

constexpr const_reverse_iterator folly::BasicFixedString< Char, N >::crend ( ) const

inlinenoexcept

Note: Equivalent to rend() on a const-qualified reference to *this.

Definition at line 1055 of file FixedString.h.

                                                           {
     return rend();
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr BasicFixedString<Char, N + M> folly::BasicFixedString< Char, N >::creplace	(	std::size_t	this_pos,
		std::size_t	this_count,
		const BasicFixedString< Char, M > &	that,
		std::size_t	that_pos = `0u`
	)		const

inlinenoexcept

Construct a new string by replacing this_count characters starting from position this_pos within this string with the characters from string that starting at position that_pos.

Precondition: that_pos <= that.size()

Note: Equivalent to creplace(this_pos, this_count, that, that_pos, that.size() - that_pos)

Definition at line 1822 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), and folly::BasicFixedString< Char, N >::size_.

                                                      {
     return creplace(
         this_pos,
         this_count,
         that,
         that_pos,
         that.size_ - detail::fixedstring::checkOverflow(that_pos, that.size_));
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr BasicFixedString<Char, N + M> folly::BasicFixedString< Char, N >::creplace	(	std::size_t	this_pos,
		std::size_t	this_count,
		const BasicFixedString< Char, M > &	that,
		std::size_t	that_pos,
		std::size_t	that_count
	)		const

inlinenoexcept

Construct a new string by replacing this_count characters starting from position this_pos within this string with that_count characters from string that starting at position that_pos.

Parameters

this_pos	The starting offset within `*this` of the first character to be replaced.
this_count	The number of characters to be replaced. If `npos`, it is treated as if `this_count` were `size() - this_pos`.
that	A string that contains the replacement string.
that_pos	The offset to the first character in the replacement string.
that_count	The number of characters in the replacement string.

Precondition: this_pos <= size() && this_count <= size() - this_pos; that_pos <= that.size() && that_count <= that.size() - that_pos

Postcondition: The size of the returned string is size() - this_count + that_count

Note: Equivalent to BasicFixedString<Char, N + M>{substr(0, this_pos) + that.substr(that_pos, that_count) + substr(this_pos + this_count)}

Exceptions

std::out_of_range

on any of the following conditions:

this_pos > size()
this_count > size() - this_pos
that_pos > that.size()
that_count > that.size() - that_pos

Definition at line 1859 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), folly::detail::fixedstring::checkOverflowOrNpos(), data_, folly::BasicFixedString< Char, N >::data_, and folly::BasicFixedString< Char, N >::size_.

                                                   {
     return detail::fixedstring::Helper::replace_<Char>(
         data_,
         size_,
         detail::fixedstring::checkOverflow(this_pos, size_),
         detail::fixedstring::checkOverflowOrNpos(this_count, size_ - this_pos),
         that.data_,
         detail::fixedstring::checkOverflow(that_pos, that.size_),
         detail::fixedstring::checkOverflowOrNpos(
             that_count, that.size_ - that_pos),
         folly::make_index_sequence<N + M>{});
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr BasicFixedString<Char, N + M> folly::BasicFixedString< Char, N >::creplace	(	const Char *	first,
		const Char *	last,
		const BasicFixedString< Char, M > &	that,
		std::size_t	that_pos = `0u`
	)		const

inlinenoexcept

Construct a new string by replacing the characters denoted by the half-open range [first,last) within this string with the characters from string that starting at position that_pos.

Precondition: that_pos <= that.size()

Note: Equivalent to creplace(first - data(), last - first, that, that_pos, that.size() - that_pos)

Definition at line 1887 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), and folly::BasicFixedString< Char, N >::size_.

                                                      {
     return creplace(
         first - data_,
         last - first,
         that,
         that_pos,
         that.size_ - detail::fixedstring::checkOverflow(that_pos, that.size_));
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr BasicFixedString<Char, N + M> folly::BasicFixedString< Char, N >::creplace	(	const Char *	first,
		const Char *	last,
		const BasicFixedString< Char, M > &	that,
		std::size_t	that_pos,
		std::size_t	that_count
	)		const

inlinenoexcept

Construct a new string by replacing the characters denoted by the half-open range [first,last) within this string with the that_count characters from string that starting at position that_pos.

Note: Equivalent to creplace(first - data(), last - first, that, that_pos, that_count)

Definition at line 1909 of file FixedString.h.

References folly::gen::first.

                                                   {
     return creplace(first - data_, last - first, that, that_pos, that_count);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr BasicFixedString<Char, N + M - 1u> folly::BasicFixedString< Char, N >::creplace	(	std::size_t	this_pos,
		std::size_t	this_count,
		const Char(&)	that[M]
	)		const

inlinenoexcept

Construct a new string by replacing this_count characters starting from position this_pos within this string with M-1 characters from character array that.

Precondition: strlen(that) == M-1

Note: Equivalent to creplace(this_pos, this_count, that, 0, M - 1)

Definition at line 1927 of file FixedString.h.

                                                    {
     return creplace(this_pos, this_count, that, 0u, M - 1u);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr BasicFixedString<Char, N + M - 1u> folly::BasicFixedString< Char, N >::creplace	(	std::size_t	this_pos,
		std::size_t	this_count,
		const Char(&)	that[M],
		std::size_t	that_pos,
		std::size_t	that_count
	)		const

inlinenoexcept

Replace this_count characters starting from position this_pos with that_count characters from the character array that starting at position that_pos.

Parameters

this_pos	The starting offset within `*this` of the first character to be replaced.
this_count	The number of characters to be replaced. If `npos`, it is treated as if `this_count` were `size() - this_pos`.
that	An array of characters containing the replacement string.
that_pos	The starting offset of the replacement string.
that_count	The number of characters in the replacement string. If `npos`, it is treated as if `that_count` were `M - 1 - that_pos`

Precondition: this_pos <= size() && this_count <= size() - this_pos; that_pos <= M - 1 && that_count <= M - 1 - that_pos

Postcondition: The size of the returned string is size() - this_count + that_count

Note: Equivalent to BasicFixedString<Char, N + M - 1>{ substr(0, this_pos) + makeFixedString(that).substr(that_pos, that_count) + substr(this_pos + this_count)}

Exceptions

std::out_of_range

on any of the following conditions:

this_pos > size()
this_count > size() - this_pos
that_pos >= M
that_count >= M - that_pos

Definition at line 1960 of file FixedString.h.

References testing::gmock_generated_actions_test::Char(), folly::detail::fixedstring::checkNullTerminated(), folly::detail::fixedstring::checkOverflow(), folly::detail::fixedstring::checkOverflowOrNpos(), and data_.

                                                   {
     return detail::fixedstring::Helper::replace_<Char>(
         data_,
         size_,
         detail::fixedstring::checkOverflow(this_pos, size_),
         detail::fixedstring::checkOverflowOrNpos(this_count, size_ - this_pos),
         detail::fixedstring::checkNullTerminated(that),
         detail::fixedstring::checkOverflow(that_pos, M - 1u),
         detail::fixedstring::checkOverflowOrNpos(that_count, M - 1u - that_pos),
         folly::make_index_sequence<N + M - 1u>{});
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr BasicFixedString<Char, N + M - 1u> folly::BasicFixedString< Char, N >::creplace	(	const Char *	first,
		const Char *	last,
		const Char(&)	that[M]
	)		const

inlinenoexcept

Construct a new string by replacing the characters denoted by the half-open range [first,last) within this string with the first M-1 characters from the character array that.

Precondition: strlen(that) == M-1

Note: Equivalent to creplace(first - data(), last - first, that, 0, M-1)

Definition at line 1987 of file FixedString.h.

                       {
     return creplace(first - data_, last - first, that, 0u, M - 1u);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr BasicFixedString<Char, N + M - 1u> folly::BasicFixedString< Char, N >::creplace	(	const Char *	first,
		const Char *	last,
		const Char(&)	that[M],
		std::size_t	that_pos,
		std::size_t	that_count
	)		const

inlinenoexcept

Construct a new string by replacing the characters denoted by the half-open range [first,last) within this string with the that_count characters from the character array that starting at position that_pos.

Precondition: strlen(that) == M-1

Note: Equivalent to creplace(first - data(), last - first, that, that_pos, that_count)

Definition at line 2002 of file FixedString.h.

                                                   {
     return creplace(first - data_, last - first, that, that_pos, that_count);
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR Char* folly::BasicFixedString< Char, N >::data ( )

inlinenoexcept

Return a pointer to a range of size()+1 characters, the last of which is Char(0).

Definition at line 955 of file FixedString.h.

References data_.

                                               {
     return data_;
   }

template<class Char, std::size_t N>

constexpr const Char* folly::BasicFixedString< Char, N >::data ( ) const

inlinenoexcept

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 962 of file FixedString.h.

References data_.

                                               {
     return data_;
   }

template<class Char, std::size_t N>

constexpr bool folly::BasicFixedString< Char, N >::empty ( ) const

inlinenoexcept

Returns: True if and only if size() == 0.

Definition at line 1076 of file FixedString.h.

                                         {
     return 0u == size_;
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR Char* folly::BasicFixedString< Char, N >::end ( )

inlinenoexcept

Returns: data() + size().

Definition at line 997 of file FixedString.h.

                                              {
     return data_ + size_;
   }

template<class Char, std::size_t N>

constexpr const Char* folly::BasicFixedString< Char, N >::end ( ) const

inlinenoexcept

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 1004 of file FixedString.h.

                                              {
     return data_ + size_;
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::erase ( )

inlinenoexcept

Erase all characters from this string.

Note: Equivalent to clear()

Returns: *this;

Definition at line 1442 of file FixedString.h.

                                                            {
     clear();
     return *this;
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::erase	(	std::size_t	pos,
		std::size_t	count = `npos`
	)

inlinenoexcept

Erases count characters from position pos. If count is npos, erases from pos to the end of the string.

Precondition: pos <= size(); count <= size() - pos || count == npos

Postcondition: size() == old_size - min(count, old_size - pos); at(size()) == Char(0)

Returns: *this;

Exceptions

std::out_of_range when pos > size().

Definition at line 1457 of file FixedString.h.

References testing::gmock_generated_actions_test::Char(), folly::detail::fixedstring::checkOverflow(), folly::detail::fixedstring::checkOverflowOrNpos(), count, and replace().

                                               {
     using A = const Char[1];
     return replace(
         pos,
         detail::fixedstring::checkOverflowOrNpos(
             count, size_ - detail::fixedstring::checkOverflow(pos, size_)),
         A{Char(0)},
         0u);
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR Char* folly::BasicFixedString< Char, N >::erase ( const Char * first )

inlinenoexcept

Note: Equivalent to erase(first - data(), 1)

Returns: A pointer to the first character after the erased character.

Definition at line 1473 of file FixedString.h.

References data_, and folly::gen::first.

                                                                        {
     erase(first - data_, 1u);
     return data_ + (first - data_);
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR Char* folly::BasicFixedString< Char, N >::erase	(	const Char *	first,
		const Char *	last
	)

inlinenoexcept

Note: Equivalent to erase(first - data(), last - first)

Returns: A pointer to the first character after the erased characters.

Definition at line 1482 of file FixedString.h.

References data_, and folly::gen::first.

                                         {
     erase(first - data_, last - first);
     return data_ + (first - data_);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr std::size_t folly::BasicFixedString< Char, N >::find ( const BasicFixedString< Char, M > & that ) const

inlinenoexcept

Finds the first occurrence of the character sequence that in this string.

Note: Equivalent to find(that.data(), 0, that.size())

Definition at line 2073 of file FixedString.h.

                {
     return find(that, 0u);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr std::size_t folly::BasicFixedString< Char, N >::find	(	const BasicFixedString< Char, M > &	that,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the first occurrence of the character sequence that in this string, starting at offset pos.

Precondition: pos <= size()

Note: Equivalent to find(that.data(), pos, that.size())

Definition at line 2085 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), folly::BasicFixedString< Char, N >::data_, folly::detail::fixedstring::find_(), folly::detail::fixedstring::FixedStringBase_< class >::npos, and folly::BasicFixedString< Char, N >::size_.

                                            {
     return that.size_ <= size_ - detail::fixedstring::checkOverflow(pos, size_)
         ? detail::fixedstring::find_(data_, size_, that.data_, pos, that.size_)
         : npos;
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find ( const Char * that ) const

inlinenoexcept

Finds the first occurrence of the character sequence that in this string.

Note: Equivalent to find(that.data(), 0, strlen(that))

Definition at line 2097 of file FixedString.h.

References folly::constexpr_strlen().

                                                             {
     return find(that, 0u, folly::constexpr_strlen(that));
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find	(	const Char *	that,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the first occurrence of the character sequence that in this string, starting at offset pos.

Precondition: pos <= size()

Note: Equivalent to find(that.data(), pos, strlen(that))

Definition at line 2107 of file FixedString.h.

References folly::constexpr_strlen().

                       {
     return find(that, pos, folly::constexpr_strlen(that));
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find	(	const Char *	that,
		std::size_t	pos,
		std::size_t	count
	)		const

inlinenoexcept

Finds the first occurrence of the first count characters in the buffer pointed to by that in this string, starting at offset pos.

Precondition: pos <= size(); that points to a buffer containing at least count contiguous characters.

Returns: The lowest offset i such that i >= pos and 0 == strncmp(data() + i, that, count); or npos if there is no such offset i.

Exceptions

std::out_of_range when pos > size()

Definition at line 2123 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), count, folly::detail::fixedstring::find_(), and folly::detail::fixedstring::FixedStringBase_< class >::npos.

                                              {
     return count <= size_ - detail::fixedstring::checkOverflow(pos, size_)
         ? detail::fixedstring::find_(data_, size_, that, pos, count)
         : npos;
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find ( Char ch ) const

inlinenoexcept

Finds the first occurrence of the character ch in this string.

Note: Equivalent to find(&ch, 0, 1)

Definition at line 2136 of file FixedString.h.

References ch.

                                                    {
     return find(ch, 0u);
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find	(	Char	ch,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the first occurrence of the character character c in this string, starting at offset pos.

Precondition: pos <= size()

Note: Equivalent to find(&ch, pos, 1)

Definition at line 2146 of file FixedString.h.

References ch, folly::detail::fixedstring::checkOverflow(), folly::detail::fixedstring::find_(), and folly::detail::fixedstring::FixedStringBase_< class >::npos.

                                                                          {
     using A = const Char[1u];
     return 0u == size_ - detail::fixedstring::checkOverflow(pos, size_)
         ? npos
         : detail::fixedstring::find_(data_, size_, A{ch}, pos, 1u);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_first_not_of ( const BasicFixedString< Char, M > & that ) const

inlinenoexcept

Finds the first occurrence of any character not in that in this string.

Note: Equivalent to find_first_not_of(that.data(), 0, that.size())

Definition at line 2347 of file FixedString.h.

                                                             {
     return find_first_not_of(that, 0u);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_first_not_of	(	const BasicFixedString< Char, M > &	that,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the first occurrence of any character not in that in this string.

Note: Equivalent to find_first_not_of(that.data(), 0, that.size())

Definition at line 2357 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), folly::BasicFixedString< Char, N >::data_, folly::detail::fixedstring::find_first_not_of_(), folly::detail::fixedstring::FixedStringBase_< class >::npos, and folly::BasicFixedString< Char, N >::size_.

                                            {
     return size_ == detail::fixedstring::checkOverflow(pos, size_)
         ? npos
         : detail::fixedstring::find_first_not_of_(
               data_, size_, that.data_, pos, that.size_);
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_first_not_of ( const Char * that ) const

inlinenoexcept

Finds the first occurrence of any character not in the null-terminated character sequence pointed to by that in this string.

Note: Equivalent to find_first_not_of(that, 0, strlen(that))

Definition at line 2371 of file FixedString.h.

References folly::constexpr_strlen().

                                                                          {
     return find_first_not_of(that, 0u, folly::constexpr_strlen(that));
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_first_not_of	(	const Char *	that,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the first occurrence of any character not in the null-terminated character sequence pointed to by that in this string, starting at offset pos

Note: Equivalent to find_first_not_of(that, pos, strlen(that))

Definition at line 2381 of file FixedString.h.

References folly::constexpr_strlen().

                             {
     return find_first_not_of(that, pos, folly::constexpr_strlen(that));
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_first_not_of	(	const Char *	that,
		std::size_t	pos,
		std::size_t	count
	)		const

inlinenoexcept

Finds the first occurrence of any character not in the first count characters in the buffer pointed to by that in this string, starting at offset pos.

Precondition: pos <= size(); that points to a buffer containing at least count contiguous characters.

Returns: The smallest offset i such that i >= pos and std::find(that, that+count, at(i)) == that+count; or npos if there is no such offset i.

Exceptions

std::out_of_range when pos > size()

Definition at line 2398 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), count, folly::detail::fixedstring::find_first_not_of_(), and folly::detail::fixedstring::FixedStringBase_< class >::npos.

                                              {
     return size_ == detail::fixedstring::checkOverflow(pos, size_)
         ? npos
         : detail::fixedstring::find_first_not_of_(
               data_, size_, that, pos, count);
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_first_not_of ( Char ch ) const

inlinenoexcept

Finds the first occurrence of any character other than ch in this string.

Note: Equivalent to find_first_not_of(&ch, 0, 1)

Definition at line 2412 of file FixedString.h.

References ch.

                                                                 {
     return find_first_not_of(ch, 0u);
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_first_not_of	(	Char	ch,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the first occurrence of any character other than ch in this string, starting at offset pos.

Note: Equivalent to find_first_not_of(&ch, pos, 1)

Definition at line 2421 of file FixedString.h.

References ch, folly::detail::fixedstring::checkOverflow(), folly::detail::fixedstring::find_first_not_of_(), and folly::detail::fixedstring::FixedStringBase_< class >::npos.

                       {
     using A = const Char[1u];
     return 1u <= size_ - detail::fixedstring::checkOverflow(pos, size_)
         ? detail::fixedstring::find_first_not_of_(data_, size_, A{ch}, pos, 1u)
         : npos;
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_first_of ( const BasicFixedString< Char, M > & that ) const

inlinenoexcept

Finds the first occurrence of any character in that in this string.

Note: Equivalent to find_first_of(that.data(), 0, that.size())

Definition at line 2260 of file FixedString.h.

                                                             {
     return find_first_of(that, 0u);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_first_of	(	const BasicFixedString< Char, M > &	that,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the first occurrence of any character in that in this string, starting at offset pos

Note: Equivalent to find_first_of(that.data(), pos, that.size())

Definition at line 2271 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), folly::BasicFixedString< Char, N >::data_, folly::detail::fixedstring::find_first_of_(), folly::detail::fixedstring::FixedStringBase_< class >::npos, and folly::BasicFixedString< Char, N >::size_.

                                            {
     return size_ == detail::fixedstring::checkOverflow(pos, size_)
         ? npos
         : detail::fixedstring::find_first_of_(
               data_, size_, that.data_, pos, that.size_);
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_first_of ( const Char * that ) const

inlinenoexcept

Finds the first occurrence of any character in the null-terminated character sequence pointed to by that in this string.

Note: Equivalent to find_first_of(that, 0, strlen(that))

Definition at line 2285 of file FixedString.h.

References folly::constexpr_strlen().

                                                                      {
     return find_first_of(that, 0u, folly::constexpr_strlen(that));
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_first_of	(	const Char *	that,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the first occurrence of any character in the null-terminated character sequence pointed to by that in this string, starting at offset pos

Note: Equivalent to find_first_of(that, pos, strlen(that))

Definition at line 2295 of file FixedString.h.

References folly::constexpr_strlen().

                       {
     return find_first_of(that, pos, folly::constexpr_strlen(that));
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_first_of	(	const Char *	that,
		std::size_t	pos,
		std::size_t	count
	)		const

inlinenoexcept

Finds the first occurrence of any character in the first count characters in the buffer pointed to by that in this string, starting at offset pos.

Precondition: pos <= size(); that points to a buffer containing at least count contiguous characters.

Returns: The smallest offset i such that i >= pos and std::find(that, that+count, at(i)) != that+count; or npos if there is no such offset i.

Exceptions

std::out_of_range when pos > size()

Definition at line 2312 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), count, folly::detail::fixedstring::find_first_of_(), and folly::detail::fixedstring::FixedStringBase_< class >::npos.

                                              {
     return size_ == detail::fixedstring::checkOverflow(pos, size_)
         ? npos
         : detail::fixedstring::find_first_of_(data_, size_, that, pos, count);
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_first_of ( Char ch ) const

inlinenoexcept

Finds the first occurrence of ch in this string.

Note: Equivalent to find_first_of(&ch, 0, 1)

Definition at line 2325 of file FixedString.h.

References ch.

                                                             {
     return find_first_of(ch, 0u);
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_first_of	(	Char	ch,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the first occurrence of ch in this string, starting at offset pos.

Note: Equivalent to find_first_of(&ch, pos, 1)

Definition at line 2334 of file FixedString.h.

References ch, folly::detail::fixedstring::checkOverflow(), folly::detail::fixedstring::find_first_of_(), and folly::detail::fixedstring::FixedStringBase_< class >::npos.

                       {
     using A = const Char[1u];
     return size_ == detail::fixedstring::checkOverflow(pos, size_)
         ? npos
         : detail::fixedstring::find_first_of_(data_, size_, A{ch}, pos, 1u);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_last_not_of ( const BasicFixedString< Char, M > & that ) const

inlinenoexcept

Finds the last occurrence of any character not in that in this string.

Note: Equivalent to find_last_not_of(that.data(), size(), that.size())

Definition at line 2535 of file FixedString.h.

                                                             {
     return find_last_not_of(that, size_);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_last_not_of	(	const BasicFixedString< Char, M > &	that,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the last occurrence of any character not in that in this string, starting at offset pos

Note: Equivalent to find_last_not_of(that.data(), pos, that.size())

Definition at line 2546 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), folly::constexpr_min(), folly::BasicFixedString< Char, N >::data_, folly::detail::fixedstring::find_last_not_of_(), folly::detail::fixedstring::FixedStringBase_< class >::npos, and folly::BasicFixedString< Char, N >::size_.

                                            {
     return 0u == size_
         ? npos
         : detail::fixedstring::find_last_not_of_(
               data_,
               that.data_,
               folly::constexpr_min(
                   detail::fixedstring::checkOverflow(pos, size_), size_ - 1u),
               that.size_);
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_last_not_of ( const Char * that ) const

inlinenoexcept

Finds the last occurrence of any character not in the null-terminated character sequence pointed to by that in this string.

Note: Equivalent to find_last_not_of(that, size(), strlen(that))

Definition at line 2564 of file FixedString.h.

References folly::constexpr_strlen().

                                                                         {
     return find_last_not_of(that, size_, folly::constexpr_strlen(that));
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_last_not_of	(	const Char *	that,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the last occurrence of any character not in the null-terminated character sequence pointed to by that in this string, starting at offset pos

Note: Equivalent to find_last_not_of(that, pos, strlen(that))

Definition at line 2574 of file FixedString.h.

References folly::constexpr_strlen().

                             {
     return find_last_not_of(that, pos, folly::constexpr_strlen(that));
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_last_not_of	(	const Char *	that,
		std::size_t	pos,
		std::size_t	count
	)		const

inlinenoexcept

Finds the last occurrence of any character not in the first count characters in the buffer pointed to by that in this string, starting at offset pos.

Precondition: pos <= size(); that points to a buffer containing at least count contiguous characters.

Returns: The largest offset i such that i <= pos and i < size() and std::find(that, that+count, at(i)) == that+count; or npos if there is no such offset i.

Exceptions

std::out_of_range when pos > size()

Definition at line 2591 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), folly::constexpr_min(), count, folly::detail::fixedstring::find_last_not_of_(), and folly::detail::fixedstring::FixedStringBase_< class >::npos.

                                              {
     return 0u == size_
         ? npos
         : detail::fixedstring::find_last_not_of_(
               data_,
               that,
               folly::constexpr_min(
                   detail::fixedstring::checkOverflow(pos, size_), size_ - 1u),
               count);
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_last_not_of ( Char ch ) const

inlinenoexcept

Finds the last occurrence of any character other than ch in this string.

Note: Equivalent to find_last_not_of(&ch, size(), 1)

Definition at line 2609 of file FixedString.h.

References ch.

                                                                {
     return find_last_not_of(ch, size_);
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_last_not_of	(	Char	ch,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the last occurrence of any character other than ch in this string, starting at offset pos.

Note: Equivalent to find_last_not_of(&ch, pos, 1)

Definition at line 2618 of file FixedString.h.

References ch, folly::detail::fixedstring::checkOverflow(), folly::constexpr_min(), folly::detail::fixedstring::find_last_not_of_(), and folly::detail::fixedstring::FixedStringBase_< class >::npos.

                       {
     using A = const Char[1u];
     return 0u == size_
         ? npos
         : detail::fixedstring::find_last_not_of_(
               data_,
               A{ch},
               folly::constexpr_min(
                   detail::fixedstring::checkOverflow(pos, size_), size_ - 1u),
               1u);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_last_of ( const BasicFixedString< Char, M > & that ) const

inlinenoexcept

Finds the last occurrence of any character in that in this string.

Note: Equivalent to find_last_of(that.data(), size(), that.size())

Definition at line 2434 of file FixedString.h.

                                                             {
     return find_last_of(that, size_);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_last_of	(	const BasicFixedString< Char, M > &	that,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the last occurrence of any character in that in this string, starting at offset pos

Note: Equivalent to find_last_of(that.data(), pos, that.size())

Definition at line 2445 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), folly::constexpr_min(), folly::BasicFixedString< Char, N >::data_, folly::detail::fixedstring::find_last_of_(), folly::detail::fixedstring::FixedStringBase_< class >::npos, and folly::BasicFixedString< Char, N >::size_.

                                            {
     return 0u == size_
         ? npos
         : detail::fixedstring::find_last_of_(
               data_,
               that.data_,
               folly::constexpr_min(
                   detail::fixedstring::checkOverflow(pos, size_), size_ - 1u),
               that.size_);
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_last_of ( const Char * that ) const

inlinenoexcept

Finds the last occurrence of any character in the null-terminated character sequence pointed to by that in this string.

Note: Equivalent to find_last_of(that, size(), strlen(that))

Definition at line 2463 of file FixedString.h.

References folly::constexpr_strlen().

                                                                     {
     return find_last_of(that, size_, folly::constexpr_strlen(that));
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_last_of	(	const Char *	that,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the last occurrence of any character in the null-terminated character sequence pointed to by that in this string, starting at offset pos

Note: Equivalent to find_last_of(that, pos, strlen(that))

Definition at line 2473 of file FixedString.h.

References folly::constexpr_strlen().

                       {
     return find_last_of(that, pos, folly::constexpr_strlen(that));
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_last_of	(	const Char *	that,
		std::size_t	pos,
		std::size_t	count
	)		const

inlinenoexcept

Finds the last occurrence of any character in the first count characters in the buffer pointed to by that in this string, starting at offset pos.

Precondition: pos <= size(); that points to a buffer containing at least count contiguous characters.

Returns: The largest offset i such that i <= pos and i < size() and std::find(that, that+count, at(i)) != that+count; or npos if there is no such offset i.

Exceptions

std::out_of_range when pos > size()

Definition at line 2490 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), folly::constexpr_min(), count, folly::detail::fixedstring::find_last_of_(), and folly::detail::fixedstring::FixedStringBase_< class >::npos.

                                              {
     return 0u == size_
         ? npos
         : detail::fixedstring::find_last_of_(
               data_,
               that,
               folly::constexpr_min(
                   detail::fixedstring::checkOverflow(pos, size_), size_ - 1u),
               count);
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_last_of ( Char ch ) const

inlinenoexcept

Finds the last occurrence of ch in this string.

Note: Equivalent to find_last_of(&ch, size(), 1)

Definition at line 2508 of file FixedString.h.

References ch.

                                                            {
     return find_last_of(ch, size_);
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::find_last_of	(	Char	ch,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the last occurrence of ch in this string, starting at offset pos.

Note: Equivalent to find_last_of(&ch, pos, 1)

Definition at line 2517 of file FixedString.h.

References ch, folly::detail::fixedstring::checkOverflow(), folly::constexpr_min(), folly::detail::fixedstring::find_last_of_(), and folly::detail::fixedstring::FixedStringBase_< class >::npos.

                       {
     using A = const Char[1u];
     return 0u == size_
         ? npos
         : detail::fixedstring::find_last_of_(
               data_,
               A{ch},
               folly::constexpr_min(
                   detail::fixedstring::checkOverflow(pos, size_), size_ - 1u),
               1u);
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR Char& folly::BasicFixedString< Char, N >::front ( )

inlinenoexcept

Note: Equivalent to (*this)[0]

Definition at line 1149 of file FixedString.h.

                                                {
     return (*this)[0u];
   }

template<class Char, std::size_t N>

constexpr const Char& folly::BasicFixedString< Char, N >::front ( ) const

inlinenoexcept

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 1156 of file FixedString.h.

                                                {
     return (*this)[0u];
   }

template<class Char, std::size_t N>

std::uint32_t folly::BasicFixedString< Char, N >::hash ( ) const

inlinenoexcept

Definition at line 1096 of file FixedString.h.

References folly::hsieh_hash32_buf().

                                     {
     return folly::hsieh_hash32_buf(data_, size_);
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::length ( ) const

inlinenoexcept

Returns: The number of Char elements in the string.

Definition at line 1069 of file FixedString.h.

                                               {
     return size_;
   }

template<class Char, std::size_t N>

static constexpr std::size_t folly::BasicFixedString< Char, N >::max_size ( )

inlinestaticnoexcept

Returns: N.

Definition at line 1090 of file FixedString.h.

                                                  {
     return N;
   }

template<class Char, std::size_t N>

folly::BasicFixedString< Char, N >::operator std::basic_string< Char > ( ) const

inlinenoexcept

Conversion to std::basic_string<Char>

Returns: std::basic_string<Char>{begin(), end()}

Definition at line 811 of file FixedString.h.

References folly::test::begin(), and folly::test::end().

                                                            {
     return std::basic_string<Char>{begin(), end()};
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::operator+= ( const Char * that )

inlinenoexcept

Appends characters from a null-terminated string literal to this string.

Note: Equivalent to append(that).

Definition at line 1404 of file FixedString.h.

References append().

              {
     return append(that);
   }

template<class Char, std::size_t N>

template<std::size_t M>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::operator+= ( const BasicFixedString< Char, M > & that )

inlinenoexcept

Appends characters from another string to this one.

Note: Equivalent to append(that).

Definition at line 1414 of file FixedString.h.

References append(), and folly::BasicFixedString< Char, N >::size_.

                                                              {
     return append(that, 0u, that.size_);
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::operator+= ( Char ch )

inlinenoexcept

Appends a character to this string.

Note: Equivalent to push_back(ch).

Definition at line 1423 of file FixedString.h.

References ch, and push_back().

                                                                               {
     push_back(ch);
     return *this;
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::operator+= ( std::initializer_list< Char > il )

inlinenoexcept

Appends characters from an initializer_list to this string.

Note: Equivalent to append(il.begin(), il.size()).

Definition at line 1432 of file FixedString.h.

References append().

                                                     {
     return append(il.begin(), il.size());
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::operator= ( const BasicFixedString< Char, N > & )

defaultnoexcept

template<class Char, std::size_t N>

template<std::size_t M>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::operator= ( const BasicFixedString< Char, M > & that )

inlinenoexcept

Assign from a BasicFixedString<Char, M>.

Precondition: that.size() <= N

Postcondition: size() == that.size(); 0 == strncmp(data(), that.begin(), size()); at(size()) == Char(0)

Exceptions

std::out_of_range when that.size() > N. When M <= N, this assignment operator will never throw.

Note: Assignments from larger-capacity BasicFixedString objects to smaller ones (M > N) are allowed as long as the size of the source string is small enough.

Returns: *this

Definition at line 748 of file FixedString.h.

References testing::gmock_generated_actions_test::Char(), folly::detail::fixedstring::checkOverflow(), folly::BasicFixedString< Char, N >::copy(), M, folly::BasicFixedString< Char, N >::size_, and type.

                                                               {
     detail::fixedstring::checkOverflow(that.size_, N);
     size_ = that.copy(data_, that.size_);
     data_[size_] = Char(0);
     return *this;
   }

template<class Char, std::size_t N>

template<std::size_t M>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::operator= ( const Char(&) that[M] )

inlinenoexcept

Assign from a null-terminated array of characters.

Precondition: M < N; that has no embedded null characters; that[M-1]==Char(0)

Postcondition: size() == M-1; 0 == strncmp(data(), that, size()); at(size()) == Char(0)

Returns: *this

Definition at line 767 of file FixedString.h.

References folly::detail::fixedstring::checkNullTerminated().

                                       {
     return assign(detail::fixedstring::checkNullTerminated(that), M - 1u);
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::operator= ( std::initializer_list< Char > il )

inlinenoexcept

Assign from an initializer_list of characters.

Precondition: il.size() <= N

Postcondition: size() == il.size(); 0 == strncmp(data(), il.begin(), size()); at(size()) == Char(0)

Exceptions

std::out_of_range when il.size() > N

Returns: *this

Definition at line 781 of file FixedString.h.

References testing::gmock_generated_actions_test::Char(), folly::detail::fixedstring::checkOverflow(), and i.

                                                     {
     detail::fixedstring::checkOverflow(il.size(), N);
     for (std::size_t i = 0u; i < il.size(); ++i) {
       data_[i] = il.begin()[i];
     }
     size_ = il.size();
     data_[size_] = Char(0);
     return *this;
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR Char& folly::BasicFixedString< Char, N >::operator[] ( std::size_t i )

inlinenoexcept

Precondition: i <= size()

Note: (*this)[size()] is allowed will return Char(0).

Returns: *(data() + i)

Definition at line 1127 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), and i.

                                                                {
 #ifdef NDEBUG
     return data_[i];
 #else
     return data_[detail::fixedstring::checkOverflow(i, size_)];
 #endif
   }

template<class Char, std::size_t N>

constexpr const Char& folly::BasicFixedString< Char, N >::operator[] ( std::size_t i ) const

inlinenoexcept

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 1138 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), and i.

                                                                {
 #ifdef NDEBUG
     return data_[i];
 #else
     return data_[detail::fixedstring::checkOverflow(i, size_)];
 #endif
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR void folly::BasicFixedString< Char, N >::pop_back ( )

inlinenoexcept

Removes the last character from the string.

Precondition: !empty()

Postcondition: size() is one fewer than before calling pop_back().; at(size()) == Char(0); The characters in the half-open range [0,size()-1) are unmodified.

Exceptions

std::out_of_range if empty().

Definition at line 1217 of file FixedString.h.

References testing::gmock_generated_actions_test::Char(), and folly::detail::fixedstring::checkOverflow().

                                                         {
     detail::fixedstring::checkOverflow(1u, size_);
     --size_;
     data_[size_] = Char(0);
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR void folly::BasicFixedString< Char, N >::push_back ( Char ch )

inlinenoexcept

Note: Equivalent to append(1u, ch).

Definition at line 1196 of file FixedString.h.

References ch, testing::gmock_generated_actions_test::Char(), and folly::detail::fixedstring::checkOverflow().

                                                                 {
     detail::fixedstring::checkOverflow(1u, N - size_);
     data_[size_] = ch;
     data_[++size_] = Char(0);
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR reverse_iterator folly::BasicFixedString< Char, N >::rbegin ( )

inlinenoexcept

Returns a reverse iterator to the first character of the reversed string. It corresponds to the last + 1 character of the non-reversed string.

Definition at line 1019 of file FixedString.h.

Referenced by TEST().

                                                            {
     return reverse_iterator{data_ + size_};
   }

template<class Char, std::size_t N>

constexpr const_reverse_iterator folly::BasicFixedString< Char, N >::rbegin ( ) const

inlinenoexcept

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 1026 of file FixedString.h.

                                                            {
     return const_reverse_iterator{data_ + size_};
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR reverse_iterator folly::BasicFixedString< Char, N >::rend ( )

inlinenoexcept

Returns a reverse iterator to the last + 1 character of the reversed string. It corresponds to the first character of the non-reversed string.

Definition at line 1041 of file FixedString.h.

Referenced by TEST().

                                                          {
     return reverse_iterator{data_};
   }

template<class Char, std::size_t N>

constexpr const_reverse_iterator folly::BasicFixedString< Char, N >::rend ( ) const

inlinenoexcept

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 1048 of file FixedString.h.

                                                          {
     return const_reverse_iterator{data_};
   }

template<class Char, std::size_t N>

template<std::size_t M>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::replace	(	const Char *	first,
		const Char *	last,
		const BasicFixedString< Char, M > &	that
	)

inlinenoexcept

Replace the characters in the range denoted by the half-open range [first, last) with the string that.

Precondition: first and last point to characters within this string (including the terminating null).

Note: Equivalent to replace(first - data(), last - first, that.data(), that.size())

Definition at line 1663 of file FixedString.h.

References folly::gen::first, replace(), and folly::BasicFixedString< Char, N >::size_.

Referenced by TEST().

                                                              {
     return replace(first - data_, last - first, that, 0u, that.size_);
   }

template<class Char, std::size_t N>

template<std::size_t M>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::replace	(	std::size_t	this_pos,
		std::size_t	this_count,
		const BasicFixedString< Char, M > &	that,
		std::size_t	that_pos = `0u`
	)

inlinenoexcept

Replace this_count characters starting from position this_pos with the characters from string that starting at position that_pos.

Precondition: that_pos <= that.size()

Note: Equivalent to replace(this_pos, this_count, that.data() + that_pos, that.size() - that_pos)

Definition at line 1679 of file FixedString.h.

References replace(), and folly::BasicFixedString< Char, N >::size_.

                                                {
     return replace(this_pos, this_count, that, that_pos, that.size_ - that_pos);
   }

template<class Char, std::size_t N>

template<std::size_t M>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::replace	(	std::size_t	this_pos,
		std::size_t	this_count,
		const BasicFixedString< Char, M > &	that,
		std::size_t	that_pos,
		std::size_t	that_count
	)

inlinenoexcept

Replace this_count characters starting from position this_pos with that_count characters from string that starting at position that_pos.

Precondition: that_pos <= that.size() && that_count <= that.size() - that_pos

Note: Equivalent to replace(this_pos, this_count, that.data() + that_pos, that_count)

Definition at line 1696 of file FixedString.h.

                                             {
     return *this = creplace(this_pos, this_count, that, that_pos, that_count);
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::replace	(	std::size_t	this_pos,
		std::size_t	this_count,
		const Char *	that
	)

inlinenoexcept

Replace this_count characters starting from position this_pos with the characters from the string literal that.

Note: Equivalent to replace(this_pos, this_count, that, strlen(that))

Definition at line 1711 of file FixedString.h.

References folly::constexpr_strlen(), and replace().

                                         {
     return replace(this_pos, this_count, that, folly::constexpr_strlen(that));
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::replace	(	const Char *	first,
		const Char *	last,
		const Char *	that
	)

inlinenoexcept

Replace the characters denoted by the half-open range [first,last) with the characters from the string literal that.

Precondition: first and last point to characters within this string (including the terminating null).

Note: Equivalent to replace(first - data(), last - first, that, strlen(that))

Definition at line 1726 of file FixedString.h.

References folly::constexpr_strlen(), folly::gen::first, and replace().

                                         {
     return replace(
         first - data_, last - first, that, folly::constexpr_strlen(that));
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::replace	(	std::size_t	this_pos,
		std::size_t	this_count,
		const Char *	that,
		std::size_t	that_count
	)

inlinenoexcept

Replace this_count characters starting from position this_pos with that_count characters from the character sequence pointed to by that.

Parameters

this_pos	The starting offset within `*this` of the first character to be replaced.
this_count	The number of characters to be replaced. If `npos`, it is treated as if `this_count` were `size() - this_pos`.
that	A pointer to the replacement string.
that_count	The number of characters in the replacement string.

Precondition: this_pos <= size() && this_count <= size() - this_pos; that points to a contiguous sequence of at least that_count characters

Exceptions

std::out_of_range

on any of the following conditions:

this_pos > size()
this_count > size() - this_pos
size() - this_count + that_count > N

Definition at line 1751 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), folly::detail::fixedstring::checkOverflowOrNpos(), and data_.

                                             {
     return *this = detail::fixedstring::Helper::replace_<Char>(
                data_,
                size_,
                detail::fixedstring::checkOverflow(this_pos, size_),
                detail::fixedstring::checkOverflowOrNpos(
                    this_count, size_ - this_pos),
                that,
                0u,
                that_count,
                Indices{});
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::replace	(	std::size_t	this_pos,
		std::size_t	this_count,
		std::size_t	that_count,
		Char	ch
	)

inlinenoexcept

Replace this_count characters starting from position this_pos with that_count characters ch.

Note: Equivalent to replace(this_pos, this_count, BasicFixedString{that_count, ch})

Definition at line 1774 of file FixedString.h.

References ch, and replace().

                                {
     return replace(this_pos, this_count, BasicFixedString{that_count, ch});
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::replace	(	const Char *	first,
		const Char *	last,
		std::size_t	that_count,
		Char	ch
	)

inlinenoexcept

Replace the characters denoted by the half-open range [first,last) with that_count characters ch.

Note: Equivalent to replace(first - data(), last - first, BasicFixedString{that_count, ch})

Definition at line 1788 of file FixedString.h.

References ch, folly::gen::first, and replace().

                                {
     return replace(
         first - data_, last - first, BasicFixedString{that_count, ch});
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR BasicFixedString& folly::BasicFixedString< Char, N >::replace	(	const Char *	first,
		const Char *	last,
		std::initializer_list< Char >	il
	)

inlinenoexcept

Replace the characters denoted by the half-open range [first,last) with the characters from the string literal that.

Precondition: first and last point to characters within this string (including the terminating null).

Note: Equivalent to replace(this_pos, this_count, il.begin(), il.size())

Definition at line 1805 of file FixedString.h.

References folly::gen::first, and replace().

                                                     {
     return replace(first - data_, last - first, il.begin(), il.size());
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR void folly::BasicFixedString< Char, N >::resize ( std::size_t count )

inlinenoexcept

Resizes the current string.

Note: Equivalent to resize(count, Char(0))

Definition at line 2044 of file FixedString.h.

References testing::gmock_generated_actions_test::Char(), count, and resize().

                                                                      {
     resize(count, Char(0));
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR void folly::BasicFixedString< Char, N >::resize	(	std::size_t	count,
		Char	ch
	)

inlinenoexcept

Resizes the current string by setting the size to count and setting data()[count] to Char(0). If count > old_size, the characters in the range [old_size,count) are set to ch.

Definition at line 2053 of file FixedString.h.

References ch, testing::gmock_generated_actions_test::Char(), folly::detail::fixedstring::checkOverflow(), and count.

              {
     detail::fixedstring::checkOverflow(count, N);
     if (count == size_) {
     } else if (count < size_) {
       size_ = count;
       data_[size_] = Char(0);
     } else {
       for (; size_ < count; ++size_) {
         data_[size_] = ch;
       }
       data_[size_] = Char(0);
     }
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr std::size_t folly::BasicFixedString< Char, N >::rfind ( const BasicFixedString< Char, M > & that ) const

inlinenoexcept

Finds the last occurrence of characters in the string that in this string.

Note: Equivalent to rfind(that.data(), size(), that.size())

Definition at line 2159 of file FixedString.h.

References folly::rfind().

                {
     return rfind(that, size_);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr std::size_t folly::BasicFixedString< Char, N >::rfind	(	const BasicFixedString< Char, M > &	that,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the last occurrence of characters in the string that in this string, starting at offset pos.

Note: Equivalent to rfind(that.data(), pos, that.size())

Definition at line 2170 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), folly::constexpr_min(), folly::BasicFixedString< Char, N >::data_, folly::detail::fixedstring::FixedStringBase_< class >::npos, folly::detail::fixedstring::rfind_(), and folly::BasicFixedString< Char, N >::size_.

                                            {
     return that.size_ <= size_
         ? detail::fixedstring::rfind_(
               data_,
               that.data_,
               folly::constexpr_min(
                   detail::fixedstring::checkOverflow(pos, size_),
                   size_ - that.size_),
               that.size_)
         : npos;
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::rfind ( const Char * that ) const

inlinenoexcept

Finds the last occurrence of characters in the buffer pointed to by that in this string.

Note: Equivalent to rfind(that, size(), strlen(that))

Definition at line 2189 of file FixedString.h.

References folly::constexpr_strlen(), and folly::rfind().

                                                              {
     return rfind(that, size_, folly::constexpr_strlen(that));
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::rfind	(	const Char *	that,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the last occurrence of characters in the buffer pointed to by that in this string, starting at offset pos.

Note: Equivalent to rfind(that, pos, strlen(that))

Definition at line 2198 of file FixedString.h.

References folly::constexpr_strlen(), and folly::rfind().

                       {
     return rfind(that, pos, folly::constexpr_strlen(that));
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::rfind	(	const Char *	that,
		std::size_t	pos,
		std::size_t	count
	)		const

inlinenoexcept

Finds the last occurrence of the first count characters in the buffer pointed to by that in this string, starting at offset pos.

Precondition: pos <= size(); that points to a buffer containing at least count contiguous characters.

Returns: The largest offset i such that i <= pos and i + count <= size() and 0 == strncmp(data() + i, that, count); or npos if there is no such offset i.

Exceptions

std::out_of_range when pos > size()

Definition at line 2214 of file FixedString.h.

References folly::detail::fixedstring::checkOverflow(), folly::constexpr_min(), count, folly::detail::fixedstring::FixedStringBase_< class >::npos, and folly::detail::fixedstring::rfind_().

                                              {
     return count <= size_
         ? detail::fixedstring::rfind_(
               data_,
               that,
               folly::constexpr_min(
                   detail::fixedstring::checkOverflow(pos, size_),
                   size_ - count),
               count)
         : npos;
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::rfind ( Char ch ) const

inlinenoexcept

Finds the last occurrence of the character character ch in this string.

Note: Equivalent to rfind(&ch, size(), 1)

Definition at line 2233 of file FixedString.h.

References ch, and folly::rfind().

                                                     {
     return rfind(ch, size_);
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::rfind	(	Char	ch,
		std::size_t	pos
	)		const

inlinenoexcept

Finds the last occurrence of the character character ch in this string, starting at offset pos.

Precondition: pos <= size()

Note: Equivalent to rfind(&ch, pos, 1)

Definition at line 2243 of file FixedString.h.

References ch, folly::detail::fixedstring::checkOverflow(), folly::constexpr_min(), folly::detail::fixedstring::FixedStringBase_< class >::npos, and folly::detail::fixedstring::rfind_().

                                                                           {
     using A = const Char[1u];
     return 0u == size_
         ? npos
         : detail::fixedstring::rfind_(
               data_,
               A{ch},
               folly::constexpr_min(
                   detail::fixedstring::checkOverflow(pos, size_), size_ - 1u),
               1u);
   }

template<class Char, std::size_t N>

constexpr std::size_t folly::BasicFixedString< Char, N >::size ( ) const

inlinenoexcept

Returns: The number of Char elements in the string.

Definition at line 1062 of file FixedString.h.

Referenced by folly::BasicFixedString< Char, N >::compare().

                                             {
     return size_;
   }

template<class Char, std::size_t N>

constexpr BasicFixedString folly::BasicFixedString< Char, N >::substr ( std::size_t pos ) const

inlinenoexcept

Return a substring from pos to the end of the string.

Note: Equivalent to BasicFixedString{*this, pos}

Definition at line 1641 of file FixedString.h.

                                                                          {
     return {*this, pos};
   }

template<class Char, std::size_t N>

constexpr BasicFixedString folly::BasicFixedString< Char, N >::substr	(	std::size_t	pos,
		std::size_t	count
	)		const

inlinenoexcept

Return a substring from pos to the end of the string.

Note: Equivalent to BasicFixedString{*this, pos, count}

Definition at line 1649 of file FixedString.h.

References count.

                       {
     return {*this, pos, count};
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR void folly::BasicFixedString< Char, N >::swap ( BasicFixedString< Char, N > & that )

inlinenoexcept

Swap the contents of this string with that.

Definition at line 942 of file FixedString.h.

References folly::constexpr_max(), folly::detail::fixedstring::constexpr_swap(), folly::BasicFixedString< Char, N >::data_, i, and folly::BasicFixedString< Char, N >::size_.

Referenced by TEST().

                                                                    {
     // less-than-or-equal here to copy the null terminator:
     for (std::size_t i = 0u; i <= folly::constexpr_max(size_, that.size_);
          ++i) {
       detail::fixedstring::constexpr_swap(data_[i], that.data_[i]);
     }
     detail::fixedstring::constexpr_swap(size_, that.size_);
   }

template<class Char, std::size_t N>

FOLLY_CPP14_CONSTEXPR Range<Char*> folly::BasicFixedString< Char, N >::toRange ( )

inlinenoexcept

Conversion to folly::Range

Returns: Range<Char*>{begin(), end()}

Definition at line 796 of file FixedString.h.

References folly::test::begin(), and folly::test::end().

                                                         {
     return {begin(), end()};
   }

template<class Char, std::size_t N>

constexpr Range<const Char*> folly::BasicFixedString< Char, N >::toRange ( ) const

inlinenoexcept

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 803 of file FixedString.h.

References folly::test::begin(), and folly::test::end().

                                                         {
     return {begin(), end()};
   }

template<class Char, std::size_t N>

std::basic_string<Char> folly::BasicFixedString< Char, N >::toStdString ( ) const

inlinenoexcept

Definition at line 815 of file FixedString.h.

References folly::test::begin(), and folly::test::end().

                                                             {
     return std::basic_string<Char>{begin(), end()};
   }

Friends And Related Function Documentation

template<class Char, std::size_t N>

template<class , std::size_t >

friend class BasicFixedString

friend

Definition at line 516 of file FixedString.h.

template<class Char, std::size_t N>

friend struct detail::fixedstring::Helper

friend

Definition at line 517 of file FixedString.h.

template<class Char, std::size_t N>

constexpr bool operator!=	(	const Char *	a,
		const BasicFixedString< Char, N > &	b
	)

friend

Definition at line 2668 of file FixedString.h.

                                           {
     return !(a == b);
   }

template<class Char, std::size_t N>

constexpr bool operator!=	(	const BasicFixedString< Char, N > &	a,
		const Char *	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2677 of file FixedString.h.

                               {
     return !(b == a);
   }

template<class Char, std::size_t N>

constexpr bool operator!=	(	Range< const Char * >	a,
		const BasicFixedString< Char, N > &	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2686 of file FixedString.h.

                                           {
     return !(a == b);
   }

template<class Char, std::size_t N>

constexpr bool operator!=	(	const BasicFixedString< Char, N > &	a,
		Range< const Char * >	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2695 of file FixedString.h.

                                      {
     return !(a == b);
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr BasicFixedString<Char, N + M - 1u> operator+	(	const Char(&)	a[M],
		const BasicFixedString< Char, N > &	b
	)

friend

Asymmetric concatenation

Definition at line 2845 of file FixedString.h.

                                           {
     return detail::fixedstring::Helper::concat_<Char>(
         detail::fixedstring::checkNullTerminated(a),
         M - 1u,
         b.data_,
         b.size_,
         folly::make_index_sequence<N + M - 1u>{});
   }

template<class Char, std::size_t N>

template<std::size_t M>

constexpr BasicFixedString<Char, N + M - 1u> operator+	(	const BasicFixedString< Char, N > &	a,
		const Char(&)	b[M]
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2860 of file FixedString.h.

                                    {
     return detail::fixedstring::Helper::concat_<Char>(
         a.data_,
         a.size_,
         detail::fixedstring::checkNullTerminated(b),
         M - 1u,
         folly::make_index_sequence<N + M - 1u>{});
   }

template<class Char, std::size_t N>

constexpr BasicFixedString<Char, N + 1u> operator+	(	Char	a,
		const BasicFixedString< Char, N > &	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2874 of file FixedString.h.

                                           {
     using A = const Char[2u];
     return detail::fixedstring::Helper::concat_<Char>(
         A{a, Char(0)},
         1u,
         b.data_,
         b.size_,
         folly::make_index_sequence<N + 1u>{});
   }

template<class Char, std::size_t N>

constexpr BasicFixedString<Char, N + 1u> operator+	(	const BasicFixedString< Char, N > &	a,
		Char	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2889 of file FixedString.h.

                        {
     using A = const Char[2u];
     return detail::fixedstring::Helper::concat_<Char>(
         a.data_,
         a.size_,
         A{b, Char(0)},
         1u,
         folly::make_index_sequence<N + 1u>{});
   }

template<class Char, std::size_t N>

constexpr bool operator<	(	const Char *	a,
		const BasicFixedString< Char, N > &	b
	)

friend

Definition at line 2701 of file FixedString.h.

                                           {
     return ordering::lt ==
         detail::fixedstring::compare_(
                a, 0u, folly::constexpr_strlen(a), b.data_, 0u, b.size_);
   }

template<class Char, std::size_t N>

constexpr bool operator<	(	const BasicFixedString< Char, N > &	a,
		const Char *	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2712 of file FixedString.h.

                               {
     return ordering::lt ==
         detail::fixedstring::compare_(
                a.data_, 0u, a.size_, b, 0u, folly::constexpr_strlen(b));
   }

template<class Char, std::size_t N>

constexpr bool operator<	(	Range< const Char * >	a,
		const BasicFixedString< Char, N > &	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2723 of file FixedString.h.

                                           {
     return ordering::lt ==
         detail::fixedstring::compare_(
                a.begin(), 0u, a.size(), b.data_, 0u, b.size_);
   }

template<class Char, std::size_t N>

constexpr bool operator<	(	const BasicFixedString< Char, N > &	a,
		Range< const Char * >	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2734 of file FixedString.h.

                                      {
     return ordering::lt ==
         detail::fixedstring::compare_(
                a.data_, 0u, a.size_, b.begin(), 0u, b.size());
   }

template<class Char, std::size_t N>

constexpr bool operator<=	(	const Char *	a,
		const BasicFixedString< Char, N > &	b
	)

friend

Definition at line 2775 of file FixedString.h.

                                           {
     return !(b < a);
   }

template<class Char, std::size_t N>

constexpr bool operator<=	(	const BasicFixedString< Char, N > &	a,
		const Char *	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2784 of file FixedString.h.

                               {
     return !(b < a);
   }

template<class Char, std::size_t N>

constexpr bool operator<=	(	Range< const Char * > const &	a,
		const BasicFixedString< Char, N > &	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2793 of file FixedString.h.

                                           {
     return !(b < a);
   }

template<class Char, std::size_t N>

constexpr bool operator<=	(	const BasicFixedString< Char, N > &	a,
		Range< const Char * >	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2802 of file FixedString.h.

                                      {
     return !(b < a);
   }

template<class Char, std::size_t N>

constexpr bool operator==	(	const Char *	a,
		const BasicFixedString< Char, N > &	b
	)

friend

Asymmetric relational operators

Definition at line 2634 of file FixedString.h.

                                           {
     return detail::fixedstring::equal_(
         a, folly::constexpr_strlen(a), b.data_, b.size_);
   }

template<class Char, std::size_t N>

constexpr bool operator==	(	const BasicFixedString< Char, N > &	a,
		const Char *	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2644 of file FixedString.h.

                               {
     return b == a;
   }

template<class Char, std::size_t N>

constexpr bool operator==	(	Range< const Char * >	a,
		const BasicFixedString< Char, N > &	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2653 of file FixedString.h.

                                           {
     return detail::fixedstring::equal_(a.begin(), a.size(), b.data_, b.size_);
   }

template<class Char, std::size_t N>

constexpr bool operator==	(	const BasicFixedString< Char, N > &	a,
		Range< const Char * >	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2662 of file FixedString.h.

                                      {
     return b == a;
   }

template<class Char, std::size_t N>

constexpr bool operator>	(	const Char *	a,
		const BasicFixedString< Char, N > &	b
	)

friend

Definition at line 2742 of file FixedString.h.

                                           {
     return b < a;
   }

template<class Char, std::size_t N>

constexpr bool operator>	(	const BasicFixedString< Char, N > &	a,
		const Char *	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2751 of file FixedString.h.

                               {
     return b < a;
   }

template<class Char, std::size_t N>

constexpr bool operator>	(	Range< const Char * >	a,
		const BasicFixedString< Char, N > &	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2760 of file FixedString.h.

                                           {
     return b < a;
   }

template<class Char, std::size_t N>

constexpr bool operator>	(	const BasicFixedString< Char, N > &	a,
		Range< const Char * >	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2769 of file FixedString.h.

                                      {
     return b < a;
   }

template<class Char, std::size_t N>

constexpr bool operator>=	(	const Char *	a,
		const BasicFixedString< Char, N > &	b
	)

friend

Definition at line 2808 of file FixedString.h.

                                           {
     return !(a < b);
   }

template<class Char, std::size_t N>

constexpr bool operator>=	(	const BasicFixedString< Char, N > &	a,
		const Char *	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2817 of file FixedString.h.

                               {
     return !(a < b);
   }

template<class Char, std::size_t N>

constexpr bool operator>=	(	Range< const Char * >	a,
		const BasicFixedString< Char, N > &	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2826 of file FixedString.h.

                                           {
     return !(a < b);
   }

template<class Char, std::size_t N>

constexpr bool operator>=	(	const BasicFixedString< Char, N > &	a,
		Range< const Char * > const &	b
	)

friend

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 2835 of file FixedString.h.

                                             {
     return !(a < b);
   }

Member Data Documentation

template<class Char, std::size_t N>

Char folly::BasicFixedString< Char, N >::data_[N+1u]

private

Definition at line 528 of file FixedString.h.

template<class Char, std::size_t N>

std::size_t folly::BasicFixedString< Char, N >::size_

private

Definition at line 529 of file FixedString.h.

The documentation for this class was generated from the following file:

proxygen/folly/folly/FixedString.h

folly
BasicFixedString
Generated by 1.8.11

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

template<class Char, std::size_t N> class folly::BasicFixedString< Char, N >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

template<class Char, std::size_t N>
class folly::BasicFixedString< Char, N >