proxygen: folly::basic_fbstring< E, T, A, Storage

#include <FBString.h>

Classes
struct	Invariant

Public Types
typedef T	traits_type

typedef traits_type::char_type	value_type

typedef A	allocator_type

typedef A::size_type	size_type

typedef A::difference_type	difference_type

typedef A::reference	reference

typedef A::const_reference	const_reference

typedef A::pointer	pointer

typedef A::const_pointer	const_pointer

typedef E *	iterator

typedef const E *	const_iterator

typedef std::reverse_iterator< iterator >	reverse_iterator

typedef std::reverse_iterator< const_iterator >	const_reverse_iterator

typedef std::true_type	IsRelocatable

Public Member Functions
	basic_fbstring () noexcept

	basic_fbstring (const A &) noexcept

	basic_fbstring (const basic_fbstring &str)

	basic_fbstring (basic_fbstring &&goner) noexcept

template<typename A2 >
	basic_fbstring (const std::basic_string< E, T, A2 > &str)

	basic_fbstring (const basic_fbstring &str, size_type pos, size_type n=npos, const A &=A())

FOLLY_MALLOC_NOINLINE	basic_fbstring (const value_type *s, const A &=A())

FOLLY_MALLOC_NOINLINE	basic_fbstring (const value_type *s, size_type n, const A &=A())

FOLLY_MALLOC_NOINLINE	basic_fbstring (size_type n, value_type c, const A &=A())

template<class InIt >
FOLLY_MALLOC_NOINLINE	basic_fbstring (InIt begin, InIt end, typename std::enable_if< !std::is_same< InIt, value_type * >::value, const A >::type &=A())

FOLLY_MALLOC_NOINLINE	basic_fbstring (const value_type b, const value_type e, const A &=A())

	basic_fbstring (value_type *s, size_type n, size_type c, AcquireMallocatedString a)

FOLLY_MALLOC_NOINLINE	basic_fbstring (std::initializer_list< value_type > il)

	~basic_fbstring () noexcept

basic_fbstring &	operator= (const basic_fbstring &lhs)

basic_fbstring &	operator= (basic_fbstring &&goner) noexcept

template<typename A2 >
basic_fbstring &	operator= (const std::basic_string< E, T, A2 > &rhs)

std::basic_string< E, T, A >	toStdString () const

basic_fbstring &	operator= (const value_type *s)

template<typename TP >
std::enable_if< std::is_same< typename std::decay< TP >::type, typename folly::basic_fbstring< E, T, A, Storage >::value_type >::value, basic_fbstring< E, T, A, Storage > & >::type	operator= (TP c)

basic_fbstring &	operator= (std::initializer_list< value_type > il)

iterator	begin ()

const_iterator	begin () const

const_iterator	cbegin () const

iterator	end ()

const_iterator	end () const

const_iterator	cend () const

reverse_iterator	rbegin ()

const_reverse_iterator	rbegin () const

const_reverse_iterator	crbegin () const

reverse_iterator	rend ()

const_reverse_iterator	rend () const

const_reverse_iterator	crend () const

const value_type &	front () const

const value_type &	back () const

value_type &	front ()

value_type &	back ()

void	pop_back ()

size_type	size () const

size_type	length () const

size_type	max_size () const

void	resize (size_type n, value_type c=value_type())

size_type	capacity () const

void	reserve (size_type res_arg=0)

void	shrink_to_fit ()

void	clear ()

bool	empty () const

const_reference	operator[] (size_type pos) const

reference	operator[] (size_type pos)

const_reference	at (size_type n) const

reference	at (size_type n)

basic_fbstring &	operator+= (const basic_fbstring &str)

basic_fbstring &	operator+= (const value_type *s)

basic_fbstring &	operator+= (const value_type c)

basic_fbstring &	operator+= (std::initializer_list< value_type > il)

basic_fbstring &	append (const basic_fbstring &str)

basic_fbstring &	append (const basic_fbstring &str, const size_type pos, size_type n)

basic_fbstring &	append (const value_type *s, size_type n)

basic_fbstring &	append (const value_type *s)

basic_fbstring &	append (size_type n, value_type c)

template<class InputIterator >
basic_fbstring &	append (InputIterator first, InputIterator last)

basic_fbstring &	append (std::initializer_list< value_type > il)

void	push_back (const value_type c)

basic_fbstring &	assign (const basic_fbstring &str)

basic_fbstring &	assign (basic_fbstring &&str)

basic_fbstring &	assign (const basic_fbstring &str, const size_type pos, size_type n)

basic_fbstring &	assign (const value_type *s, const size_type n)

basic_fbstring &	assign (const value_type *s)

basic_fbstring &	assign (std::initializer_list< value_type > il)

template<class ItOrLength , class ItOrChar >
basic_fbstring &	assign (ItOrLength first_or_n, ItOrChar last_or_c)

basic_fbstring &	insert (size_type pos1, const basic_fbstring &str)

basic_fbstring &	insert (size_type pos1, const basic_fbstring &str, size_type pos2, size_type n)

basic_fbstring &	insert (size_type pos, const value_type *s, size_type n)

basic_fbstring &	insert (size_type pos, const value_type *s)

basic_fbstring &	insert (size_type pos, size_type n, value_type c)

iterator	insert (const_iterator p, const value_type c)

template<class ItOrLength , class ItOrChar >
iterator	insert (const_iterator p, ItOrLength first_or_n, ItOrChar last_or_c)

iterator	insert (const_iterator p, std::initializer_list< value_type > il)

basic_fbstring &	erase (size_type pos=0, size_type n=npos)

iterator	erase (iterator position)

iterator	erase (iterator first, iterator last)

basic_fbstring &	replace (size_type pos1, size_type n1, const basic_fbstring &str)

basic_fbstring &	replace (size_type pos1, size_type n1, const basic_fbstring &str, size_type pos2, size_type n2)

basic_fbstring &	replace (size_type pos, size_type n1, const value_type *s)

template<class StrOrLength , class NumOrChar >
basic_fbstring &	replace (size_type pos, size_type n1, StrOrLength s_or_n2, NumOrChar n_or_c)

basic_fbstring &	replace (iterator i1, iterator i2, const basic_fbstring &str)

basic_fbstring &	replace (iterator i1, iterator i2, const value_type *s)

template<class T1 , class T2 >
basic_fbstring &	replace (iterator i1, iterator i2, T1 first_or_n_or_s, T2 last_or_c_or_n)

size_type	copy (value_type *s, size_type n, size_type pos=0) const

void	swap (basic_fbstring &rhs)

const value_type *	c_str () const

const value_type *	data () const

allocator_type	get_allocator () const

size_type	find (const basic_fbstring &str, size_type pos=0) const

size_type	find (const value_type *needle, size_type pos, size_type nsize) const

size_type	find (const value_type *s, size_type pos=0) const

size_type	find (value_type c, size_type pos=0) const

size_type	rfind (const basic_fbstring &str, size_type pos=npos) const

size_type	rfind (const value_type *s, size_type pos, size_type n) const

size_type	rfind (const value_type *s, size_type pos=npos) const

size_type	rfind (value_type c, size_type pos=npos) const

size_type	find_first_of (const basic_fbstring &str, size_type pos=0) const

size_type	find_first_of (const value_type *s, size_type pos, size_type n) const

size_type	find_first_of (const value_type *s, size_type pos=0) const

size_type	find_first_of (value_type c, size_type pos=0) const

size_type	find_last_of (const basic_fbstring &str, size_type pos=npos) const

size_type	find_last_of (const value_type *s, size_type pos, size_type n) const

size_type	find_last_of (const value_type *s, size_type pos=npos) const

size_type	find_last_of (value_type c, size_type pos=npos) const

size_type	find_first_not_of (const basic_fbstring &str, size_type pos=0) const

size_type	find_first_not_of (const value_type *s, size_type pos, size_type n) const

size_type	find_first_not_of (const value_type *s, size_type pos=0) const

size_type	find_first_not_of (value_type c, size_type pos=0) const

size_type	find_last_not_of (const basic_fbstring &str, size_type pos=npos) const

size_type	find_last_not_of (const value_type *s, size_type pos, size_type n) const

size_type	find_last_not_of (const value_type *s, size_type pos=npos) const

size_type	find_last_not_of (value_type c, size_type pos=npos) const

basic_fbstring	substr (size_type pos=0, size_type n=npos) const &

basic_fbstring	substr (size_type pos=0, size_type n=npos)&&

int	compare (const basic_fbstring &str) const

int	compare (size_type pos1, size_type n1, const basic_fbstring &str) const

int	compare (size_type pos1, size_type n1, const value_type *s) const

int	compare (size_type pos1, size_type n1, const value_type *s, size_type n2) const

int	compare (size_type pos1, size_type n1, const basic_fbstring &str, size_type pos2, size_type n2) const

int	compare (const value_type *s) const

template<class InputIter >
basic_fbstring< E, T, A, S > &	replaceImplDiscr (iterator i1, iterator i2, InputIter b, InputIter e, std::integral_constant< int, 0 >)

Static Public Attributes
static constexpr size_type	npos = size_type(-1)

Private Types
typedef std::basic_istream< value_type, traits_type >	istream_type

Private Member Functions
bool	isSane () const

istream_type &	getlineImpl (istream_type &is, value_type delim)

iterator	insertImplDiscr (const_iterator i, size_type n, value_type c, std::true_type)

template<class InputIter >
iterator	insertImplDiscr (const_iterator i, InputIter b, InputIter e, std::false_type)

template<class FwdIterator >
iterator	insertImpl (const_iterator i, FwdIterator s1, FwdIterator s2, std::forward_iterator_tag)

template<class InputIterator >
iterator	insertImpl (const_iterator i, InputIterator b, InputIterator e, std::input_iterator_tag)

basic_fbstring &	replaceImplDiscr (iterator i1, iterator i2, const value_type *s, size_type n, std::integral_constant< int, 2 >)

basic_fbstring &	replaceImplDiscr (iterator i1, iterator i2, size_type n2, value_type c, std::integral_constant< int, 1 >)

template<class InputIter >
basic_fbstring &	replaceImplDiscr (iterator i1, iterator i2, InputIter b, InputIter e, std::integral_constant< int, 0 >)

template<class FwdIterator >
bool	replaceAliased (iterator, iterator, FwdIterator, FwdIterator, std::false_type)

template<class FwdIterator >
bool	replaceAliased (iterator i1, iterator i2, FwdIterator s1, FwdIterator s2, std::true_type)

template<class FwdIterator >
void	replaceImpl (iterator i1, iterator i2, FwdIterator s1, FwdIterator s2, std::forward_iterator_tag)

template<class InputIterator >
void	replaceImpl (iterator i1, iterator i2, InputIterator b, InputIterator e, std::input_iterator_tag)

Static Private Member Functions
template<typename Ex , typename... Args>
static FOLLY_ALWAYS_INLINE void	enforce (bool condition, Args &&...args)

static void	procrustes (size_type &n, size_type nmax)

static size_type	traitsLength (const value_type *s)

Private Attributes
Storage	store_

Friends
istream_type &	getline (istream_type &is, basic_fbstring &str, value_type delim)

istream_type &	getline (istream_type &is, basic_fbstring &str)

Detailed Description

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>
class folly::basic_fbstring< E, T, A, Storage >

This is the basic_string replacement. For conformity, basic_fbstring takes the same template parameters, plus the last one which is the core.

Definition at line 1070 of file FBString.h.

Member Typedef Documentation

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

typedef A folly::basic_fbstring< E, T, A, Storage >::allocator_type

Definition at line 1102 of file FBString.h.

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

typedef const E* folly::basic_fbstring< E, T, A, Storage >::const_iterator

Definition at line 1112 of file FBString.h.

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

typedef A::const_pointer folly::basic_fbstring< E, T, A, Storage >::const_pointer

Definition at line 1109 of file FBString.h.

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

typedef A::const_reference folly::basic_fbstring< E, T, A, Storage >::const_reference

Definition at line 1107 of file FBString.h.

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

typedef std::reverse_iterator<const_iterator> folly::basic_fbstring< E, T, A, Storage >::const_reverse_iterator

Definition at line 1114 of file FBString.h.

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

typedef A::difference_type folly::basic_fbstring< E, T, A, Storage >::difference_type

Definition at line 1104 of file FBString.h.

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

typedef std::true_type folly::basic_fbstring< E, T, A, Storage >::IsRelocatable

Definition at line 1117 of file FBString.h.

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

typedef std::basic_istream<value_type, traits_type> folly::basic_fbstring< E, T, A, Storage >::istream_type

private

Definition at line 1508 of file FBString.h.

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

typedef E* folly::basic_fbstring< E, T, A, Storage >::iterator

Definition at line 1111 of file FBString.h.

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

typedef A::pointer folly::basic_fbstring< E, T, A, Storage >::pointer

Definition at line 1108 of file FBString.h.

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

typedef A::reference folly::basic_fbstring< E, T, A, Storage >::reference

Definition at line 1106 of file FBString.h.

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

typedef std::reverse_iterator<iterator> folly::basic_fbstring< E, T, A, Storage >::reverse_iterator

Definition at line 1113 of file FBString.h.

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

typedef A::size_type folly::basic_fbstring< E, T, A, Storage >::size_type

Definition at line 1103 of file FBString.h.

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

typedef T folly::basic_fbstring< E, T, A, Storage >::traits_type

Definition at line 1100 of file FBString.h.

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

typedef traits_type::char_type folly::basic_fbstring< E, T, A, Storage >::value_type

Definition at line 1101 of file FBString.h.

Constructor & Destructor Documentation

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

folly::basic_fbstring< E, T, A, Storage >::basic_fbstring ( )

inlinenoexcept

Definition at line 1143 of file FBString.h.

1143 : basic_fbstring(A()) {}

folly::basic_fbstring::basic_fbstring

basic_fbstring() noexcept

Definition: FBString.h:1143

folly::A

std::unique_ptr< int > A

Definition: ThenCompileTest.h:26

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

folly::basic_fbstring< E, T, A, Storage >::basic_fbstring ( const A & )

inlineexplicitnoexcept

Definition at line 1145 of file FBString.h.

1145 {}

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

folly::basic_fbstring< E, T, A, Storage >::basic_fbstring ( const basic_fbstring< E, T, A, Storage > & str )

inline

Definition at line 1147 of file FBString.h.

1147 : store_(str.store_) {}

folly::basic_fbstring::store_

Storage store_

Definition: FBString.h:1873

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

folly::basic_fbstring< E, T, A, Storage >::basic_fbstring ( basic_fbstring< E, T, A, Storage > && goner )

inlinenoexcept

Definition at line 1150 of file FBString.h.

1151 : store_(std::move(goner.store_)) {}

folly::gen::move

constexpr detail::Map< Move > move

Definition: Base-inl.h:2567

folly::basic_fbstring::store_

Storage store_

Definition: FBString.h:1873

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

template<typename A2 >

folly::basic_fbstring< E, T, A, Storage >::basic_fbstring ( const std::basic_string< E, T, A2 > & str )

inline

Definition at line 1156 of file FBString.h.

1157 : store_(str.data(), str.size()) {}

folly::basic_fbstring::store_

Storage store_

Definition: FBString.h:1873

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

folly::basic_fbstring< E, T, A, Storage >::basic_fbstring	(	const basic_fbstring< E, T, A, Storage > &	str,
		size_type	pos,
		size_type	n = `npos`,
		const A &	= `A()`
	)

inline

Definition at line 1160 of file FBString.h.

                         {
     assign(str, pos, n);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

FOLLY_MALLOC_NOINLINE folly::basic_fbstring< E, T, A, Storage >::basic_fbstring	(	const value_type *	s,
		const A &	= `A()`
	)

inline

Definition at line 1169 of file FBString.h.

1170 : store_(s, traitsLength(s)) {}

folly::basic_fbstring::traitsLength

static size_type traitsLength(const value_type *s)

Definition: FBString.h:1878

static set< string > s

Definition: StringKeyedBenchmark.cpp:48

folly::basic_fbstring::store_

Storage store_

Definition: FBString.h:1873

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

FOLLY_MALLOC_NOINLINE folly::basic_fbstring< E, T, A, Storage >::basic_fbstring	(	const value_type *	s,
		size_type	n,
		const A &	= `A()`
	)

inline

Definition at line 1173 of file FBString.h.

1174 : store_(s, n) {}

static set< string > s

Definition: StringKeyedBenchmark.cpp:48

folly::basic_fbstring::store_

Storage store_

Definition: FBString.h:1873

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

FOLLY_MALLOC_NOINLINE folly::basic_fbstring< E, T, A, Storage >::basic_fbstring	(	size_type	n,
		value_type	c,
		const A &	= `A()`
	)

inline

Definition at line 1177 of file FBString.h.

                                                               {
     auto const pData = store_.expandNoinit(n);
     fbstring_detail::podFill(pData, pData + n, c);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

template<class InIt >

FOLLY_MALLOC_NOINLINE folly::basic_fbstring< E, T, A, Storage >::basic_fbstring	(	InIt	begin,
		InIt	end,
		typename std::enable_if< !std::is_same< InIt, value_type * >::value, const A >::type &	= `A()`
	)

inline

Definition at line 1183 of file FBString.h.

              {
     assign(begin, end);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

FOLLY_MALLOC_NOINLINE folly::basic_fbstring< E, T, A, Storage >::basic_fbstring	(	const value_type *	b,
		const value_type *	e,
		const A &	= `A()`
	)

inline

Definition at line 1195 of file FBString.h.

1196 : store_(b, size_type(e - b)) {}

char b

Definition: OptionalTest.cpp:53

folly::basic_fbstring::size_type

A::size_type size_type

Definition: FBString.h:1103

folly::basic_fbstring::store_

Storage store_

Definition: FBString.h:1873

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

folly::basic_fbstring< E, T, A, Storage >::basic_fbstring	(	value_type *	s,
		size_type	n,
		size_type	c,
		AcquireMallocatedString	a
	)

inline

Definition at line 1199 of file FBString.h.

1204 : store_(s, n, c, a) {}

char a

Definition: OptionalTest.cpp:53

static set< string > s

Definition: StringKeyedBenchmark.cpp:48

folly::basic_fbstring::store_

Storage store_

Definition: FBString.h:1873

char c

Definition: OptionalTest.cpp:53

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

FOLLY_MALLOC_NOINLINE folly::basic_fbstring< E, T, A, Storage >::basic_fbstring ( std::initializer_list< value_type > il )

inline

Definition at line 1208 of file FBString.h.

                                                      {
     assign(il.begin(), il.end());
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

folly::basic_fbstring< E, T, A, Storage >::~basic_fbstring ( )

inlinenoexcept

Definition at line 1212 of file FBString.h.

1212 {}

Member Function Documentation

template<typename E , class T , class A , class S >

basic_fbstring< E, T, A, S > & folly::basic_fbstring< E, T, A, S >::append ( const basic_fbstring< E, T, A, Storage > & str )

inline

Definition at line 1953 of file FBString.h.

References append(), folly::basic_fbstring< E, T, A, Storage >::data(), FBSTRING_ASSERT, folly::size(), and folly::basic_fbstring< E, T, A, Storage >::size().

Referenced by BENCHMARK(), proxygen::HPACKDecodeBuffer::decodeLiteral(), folly::basic_fbstring< E, T, A, Storage >::insertImpl(), folly::operator+(), folly::parseTo(), folly::basic_fbstring< E, T, A, Storage >::replaceAliased(), folly::basic_fbstring< E, T, A, Storage >::replaceImpl(), and folly::toAppend().

                                {
 #ifndef NDEBUG
   auto desiredSize = size() + str.size();
 #endif
   append(str.data(), str.size());
   FBSTRING_ASSERT(size() == desiredSize);
   return *this;
 }

template<typename E , class T , class A , class S >

basic_fbstring< E, T, A, S > & folly::basic_fbstring< E, T, A, S >::append	(	const basic_fbstring< E, T, A, Storage > &	str,
		const size_type	pos,
		size_type	n
	)

inline

Definition at line 1964 of file FBString.h.

References append(), folly::basic_fbstring< E, T, A, Storage >::data(), FOLLY_MALLOC_NOINLINE, and folly::basic_fbstring< E, T, A, Storage >::size().

                  {
   const size_type sz = str.size();
   enforce<std::out_of_range>(pos <= sz, "");
   procrustes(n, sz - pos);
   return append(str.data() + pos, n);
 }

template<typename E , class T , class A , class S >

FOLLY_MALLOC_NOINLINE basic_fbstring< E, T, A, S > & folly::basic_fbstring< E, T, A, S >::append	(	const value_type *	s,
		size_type	n
	)

inline

Definition at line 1976 of file FBString.h.

References data, FBSTRING_ASSERT, FBSTRING_UNLIKELY, folly::fbstring_detail::podCopy(), folly::fbstring_detail::podMove(), and folly::size().

                                                                    {
   Invariant checker(*this);
 
   if (FBSTRING_UNLIKELY(!n)) {
     // Unlikely but must be done
     return *this;
   }
   auto const oldSize = size();
   auto const oldData = data();
   auto pData = store_.expandNoinit(n, /* expGrowth = */ true);
 
   // Check for aliasing (rare). We could use "<=" here but in theory
   // those do not work for pointers unless the pointers point to
   // elements in the same array. For that reason we use
   // std::less_equal, which is guaranteed to offer a total order
   // over pointers. See discussion at http://goo.gl/Cy2ya for more
   // info.
   std::less_equal<const value_type*> le;
   if (FBSTRING_UNLIKELY(le(oldData, s) && !le(oldData + oldSize, s))) {
     FBSTRING_ASSERT(le(s + n, oldData + oldSize));
     // expandNoinit() could have moved the storage, restore the source.
     s = data() + (s - oldData);
     fbstring_detail::podMove(s, s + n, pData);
   } else {
     fbstring_detail::podCopy(s, s + n, pData);
   }
 
   FBSTRING_ASSERT(size() == oldSize + n);
   return *this;
 }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::append ( const value_type * s )

inline

Definition at line 1421 of file FBString.h.

                                               {
     return append(s, traitsLength(s));
   }

template<typename E , class T , class A , class S >

basic_fbstring< E, T, A, S > & folly::basic_fbstring< E, T, A, S >::append	(	size_type	n,
		value_type	c
	)

inline

Definition at line 2008 of file FBString.h.

References folly::fbstring_detail::podFill().

                   {
   Invariant checker(*this);
   auto pData = store_.expandNoinit(n, /* expGrowth = */ true);
   fbstring_detail::podFill(pData, pData + n, c);
   return *this;
 }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

template<class InputIterator >

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::append	(	InputIterator	first,
		InputIterator	last
	)

inline

Definition at line 1428 of file FBString.h.

                                                                   {
     insert(end(), first, last);
     return *this;
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::append ( std::initializer_list< value_type > il )

inline

Definition at line 1433 of file FBString.h.

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

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::assign ( const basic_fbstring< E, T, A, Storage > & str )

inline

Definition at line 1441 of file FBString.h.

Referenced by folly::errnoStr().

                                                     {
     if (&str == this) {
       return *this;
     }
     return assign(str.data(), str.size());
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::assign ( basic_fbstring< E, T, A, Storage > && str )

inline

Definition at line 1448 of file FBString.h.

                                                {
     return *this = std::move(str);
   }

template<typename E , class T , class A , class S >

basic_fbstring< E, T, A, S > & folly::basic_fbstring< E, T, A, S >::assign	(	const basic_fbstring< E, T, A, Storage > &	str,
		const size_type	pos,
		size_type	n
	)

inline

Definition at line 2018 of file FBString.h.

References folly::basic_fbstring< E, T, A, Storage >::data(), FOLLY_MALLOC_NOINLINE, and folly::basic_fbstring< E, T, A, Storage >::size().

                  {
   const size_type sz = str.size();
   enforce<std::out_of_range>(pos <= sz, "");
   procrustes(n, sz - pos);
   return assign(str.data() + pos, n);
 }

template<typename E , class T , class A , class S >

FOLLY_MALLOC_NOINLINE basic_fbstring< E, T, A, S > & folly::basic_fbstring< E, T, A, S >::assign	(	const value_type *	s,
		const size_type	n
	)

inline

Definition at line 2030 of file FBString.h.

References FBSTRING_ASSERT, folly::fbstring_detail::podCopy(), folly::fbstring_detail::podMove(), resize(), and folly::size().

                                                                          {
   Invariant checker(*this);
 
   if (n == 0) {
     resize(0);
   } else if (size() >= n) {
     // s can alias this, we need to use podMove.
     fbstring_detail::podMove(s, s + n, store_.mutableData());
     store_.shrink(size() - n);
     FBSTRING_ASSERT(size() == n);
   } else {
     // If n is larger than size(), s cannot alias this string's
     // storage.
     resize(0);
     // Do not use exponential growth here: assign() should be tight,
     // to mirror the behavior of the equivalent constructor.
     fbstring_detail::podCopy(s, s + n, store_.expandNoinit(n));
   }
 
   FBSTRING_ASSERT(size() == n);
   return *this;
 }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::assign ( const value_type * s )

inline

Definition at line 1457 of file FBString.h.

                                               {
     return assign(s, traitsLength(s));
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::assign ( std::initializer_list< value_type > il )

inline

Definition at line 1461 of file FBString.h.

                                                              {
     return assign(il.begin(), il.end());
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

template<class ItOrLength , class ItOrChar >

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::assign	(	ItOrLength	first_or_n,
		ItOrChar	last_or_c
	)

inline

Definition at line 1466 of file FBString.h.

                                                                     {
     return replace(begin(), end(), first_or_n, last_or_c);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

const_reference folly::basic_fbstring< E, T, A, Storage >::at ( size_type n ) const

inline

Definition at line 1385 of file FBString.h.

                                         {
     enforce<std::out_of_range>(n < size(), "");
     return (*this)[n];
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

reference folly::basic_fbstring< E, T, A, Storage >::at ( size_type n )

inline

Definition at line 1390 of file FBString.h.

                             {
     enforce<std::out_of_range>(n < size(), "");
     return (*this)[n];
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

const value_type& folly::basic_fbstring< E, T, A, Storage >::back ( ) const

inline

Definition at line 1318 of file FBString.h.

Referenced by TEST().

                                  {
     FBSTRING_ASSERT(!empty());
     // Should be begin()[size() - 1], but that branches twice
     return *(end() - 1);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

value_type& folly::basic_fbstring< E, T, A, Storage >::back ( )

inline

Definition at line 1326 of file FBString.h.

                      {
     FBSTRING_ASSERT(!empty());
     // Should be begin()[size() - 1], but that branches twice
     return *(end() - 1);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

iterator folly::basic_fbstring< E, T, A, Storage >::begin ( )

inline

Definition at line 1265 of file FBString.h.

Referenced by TEST().

                    {
     return store_.mutableData();
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

const_iterator folly::basic_fbstring< E, T, A, Storage >::begin ( ) const

inline

Definition at line 1269 of file FBString.h.

                                {
     return store_.data();
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

const value_type* folly::basic_fbstring< E, T, A, Storage >::c_str ( ) const

inline

Definition at line 1712 of file FBString.h.

Referenced by TEST().

                                   {
     return store_.c_str();
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::capacity ( ) const

inline

Definition at line 1351 of file FBString.h.

Referenced by TEST().

                              {
     return store_.capacity();
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

const_iterator folly::basic_fbstring< E, T, A, Storage >::cbegin ( ) const

inline

Definition at line 1273 of file FBString.h.

                                 {
     return begin();
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

const_iterator folly::basic_fbstring< E, T, A, Storage >::cend ( ) const

inline

Definition at line 1285 of file FBString.h.

                               {
     return end();
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

void folly::basic_fbstring< E, T, A, Storage >::clear ( )

inline

Definition at line 1368 of file FBString.h.

Referenced by BENCHMARK_RELATIVE(), proxygen::HPACKDecodeBuffer::decodeLiteral(), folly::parseTo(), StringUnsplit_Gen(), folly::test::TEST(), TEST(), and TEST_F().

                {
     resize(0);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

int folly::basic_fbstring< E, T, A, Storage >::compare ( const basic_fbstring< E, T, A, Storage > & str ) const

inline

Definition at line 1829 of file FBString.h.

Referenced by folly::operator<(), folly::operator==(), and folly::operator>().

                                                {
     // FIX due to Goncalo N M de Carvalho July 18, 2005
     return compare(0, size(), str);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

int folly::basic_fbstring< E, T, A, Storage >::compare	(	size_type	pos1,
		size_type	n1,
		const basic_fbstring< E, T, A, Storage > &	str
	)		const

inline

Definition at line 1834 of file FBString.h.

                                                                              {
     return compare(pos1, n1, str.data(), str.size());
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

int folly::basic_fbstring< E, T, A, Storage >::compare	(	size_type	pos1,
		size_type	n1,
		const value_type *	s
	)		const

inline

Definition at line 1838 of file FBString.h.

                                                                        {
     return compare(pos1, n1, s, traitsLength(s));
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

int folly::basic_fbstring< E, T, A, Storage >::compare	(	size_type	pos1,
		size_type	n1,
		const value_type *	s,
		size_type	n2
	)		const

inline

Definition at line 1842 of file FBString.h.

             {
     enforce<std::out_of_range>(pos1 <= size(), "");
     procrustes(n1, size() - pos1);
     // The line below fixed by Jean-Francois Bastien, 04-23-2007. Thanks!
     const int r = traits_type::compare(pos1 + data(), s, std::min(n1, n2));
     return r != 0 ? r : n1 > n2 ? 1 : n1 < n2 ? -1 : 0;
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

int folly::basic_fbstring< E, T, A, Storage >::compare	(	size_type	pos1,
		size_type	n1,
		const basic_fbstring< E, T, A, Storage > &	str,
		size_type	pos2,
		size_type	n2
	)		const

inline

Definition at line 1851 of file FBString.h.

                           {
     enforce<std::out_of_range>(pos2 <= str.size(), "");
     return compare(
         pos1, n1, str.data() + pos2, std::min(n2, str.size() - pos2));
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

int folly::basic_fbstring< E, T, A, Storage >::compare ( const value_type * s ) const

inline

Definition at line 1863 of file FBString.h.

                                          {
     // Could forward to compare(0, size(), s, traitsLength(s))
     // but that does two extra checks
     const size_type n1(size()), n2(traitsLength(s));
     const int r = traits_type::compare(data(), s, std::min(n1, n2));
     return r != 0 ? r : n1 > n2 ? 1 : n1 < n2 ? -1 : 0;
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::copy	(	value_type *	s,
		size_type	n,
		size_type	pos = `0`
	)		const

inline

Definition at line 1698 of file FBString.h.

                                                                       {
     enforce<std::out_of_range>(pos <= size(), "");
     procrustes(n, size() - pos);
 
     if (n != 0) {
       fbstring_detail::podCopy(data() + pos, data() + pos + n, s);
     }
     return n;
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

const_reverse_iterator folly::basic_fbstring< E, T, A, Storage >::crbegin ( ) const

inline

Definition at line 1297 of file FBString.h.

                                          {
     return rbegin();
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

const_reverse_iterator folly::basic_fbstring< E, T, A, Storage >::crend ( ) const

inline

Definition at line 1309 of file FBString.h.

                                        {
     return rend();
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

const value_type* folly::basic_fbstring< E, T, A, Storage >::data ( ) const

inline

Definition at line 1716 of file FBString.h.

                                  {
     return c_str();
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

bool folly::basic_fbstring< E, T, A, Storage >::empty ( ) const

inline

Definition at line 1372 of file FBString.h.

Referenced by proxygen::HPACKContext::getIndex(), proxygen::HPACKHeader::hasValue(), TEST(), and TEST_F().

                      {
     return size() == 0;
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

iterator folly::basic_fbstring< E, T, A, Storage >::end ( )

inline

Definition at line 1277 of file FBString.h.

Referenced by TEST().

                  {
     return store_.mutableData() + store_.size();
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

const_iterator folly::basic_fbstring< E, T, A, Storage >::end ( ) const

inline

Definition at line 1281 of file FBString.h.

                              {
     return store_.data() + store_.size();
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

template<typename Ex , typename... Args>

static FOLLY_ALWAYS_INLINE void folly::basic_fbstring< E, T, A, Storage >::enforce	(	bool	condition,
		Args &&...	args
	)

inlinestaticprivate

Definition at line 1072 of file FBString.h.

                                                                           {
     if (!condition) {
       throw_exception<Ex>(static_cast<Args&&>(args)...);
     }
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::erase	(	size_type	pos = `0`,
		size_type	n = `npos`
	)

inline

Definition at line 1555 of file FBString.h.

Referenced by folly::operator>>().

                                                                {
     Invariant checker(*this);
 
     enforce<std::out_of_range>(pos <= length(), "");
     procrustes(n, length() - pos);
     std::copy(begin() + pos + n, end(), begin() + pos);
     resize(length() - n);
     return *this;
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

iterator folly::basic_fbstring< E, T, A, Storage >::erase ( iterator position )

inline

Definition at line 1565 of file FBString.h.

                                     {
     const size_type pos(position - begin());
     enforce<std::out_of_range>(pos <= size(), "");
     erase(pos, 1);
     return begin() + pos;
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

iterator folly::basic_fbstring< E, T, A, Storage >::erase	(	iterator	first,
		iterator	last
	)

inline

Definition at line 1572 of file FBString.h.

                                                 {
     const size_type pos(first - begin());
     erase(pos, last - first);
     return begin() + pos;
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::find	(	const basic_fbstring< E, T, A, Storage > &	str,
		size_type	pos = `0`
	)		const

inline

Definition at line 1724 of file FBString.h.

Referenced by proxygen::HeaderIndexingStrategy::indexHeader(), and TEST().

                                                                      {
     return find(str.data(), pos, str.length());
   }

template<typename E , class T , class A , class S >

basic_fbstring< E, T, A, S >::size_type folly::basic_fbstring< E, T, A, S >::find	(	const value_type *	needle,
		size_type	pos,
		size_type	nsize
	)		const

inline

Definition at line 2090 of file FBString.h.

References data, FBSTRING_ASSERT, i, folly::size(), and folly::gen::skip().

                                  {
   auto const size = this->size();
   // nsize + pos can overflow (eg pos == npos), guard against that by checking
   // that nsize + pos does not wrap around.
   if (nsize + pos > size || nsize + pos < pos) {
     return npos;
   }
 
   if (nsize == 0) {
     return pos;
   }
   // Don't use std::search, use a Boyer-Moore-like trick by comparing
   // the last characters first
   auto const haystack = data();
   auto const nsize_1 = nsize - 1;
   auto const lastNeedle = needle[nsize_1];
 
   // Boyer-Moore skip value for the last char in the needle. Zero is
   // not a valid value; skip will be computed the first time it's
   // needed.
   size_type skip = 0;
 
   const E* i = haystack + pos;
   auto iEnd = haystack + size - nsize_1;
 
   while (i < iEnd) {
     // Boyer-Moore: match the last element in the needle
     while (i[nsize_1] != lastNeedle) {
       if (++i == iEnd) {
         // not found
         return npos;
       }
     }
     // Here we know that the last char matches
     // Continue in pedestrian mode
     for (size_t j = 0;;) {
       FBSTRING_ASSERT(j < nsize);
       if (i[j] != needle[j]) {
         // Not found, we can skip
         // Compute the skip value lazily
         if (skip == 0) {
           skip = 1;
           while (skip <= nsize_1 && needle[nsize_1 - skip] != lastNeedle) {
             ++skip;
           }
         }
         i += skip;
         break;
       }
       // Check if done searching
       if (++j == nsize) {
         // Yay
         return i - haystack;
       }
     }
   }
   return npos;
 }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::find	(	const value_type *	s,
		size_type	pos = `0`
	)		const

inline

Definition at line 1731 of file FBString.h.

                                                                {
     return find(s, pos, traitsLength(s));
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::find	(	value_type	c,
		size_type	pos = `0`
	)		const

inline

Definition at line 1735 of file FBString.h.

                                                         {
     return find(&c, pos, 1);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::find_first_not_of	(	const basic_fbstring< E, T, A, Storage > &	str,
		size_type	pos = `0`
	)		const

inline

Definition at line 1783 of file FBString.h.

             {
     return find_first_not_of(str.data(), pos, str.size());
   }

template<typename E , class T , class A , class S >

basic_fbstring< E, T, A, S >::size_type folly::basic_fbstring< E, T, A, S >::find_first_not_of	(	const value_type *	s,
		size_type	pos,
		size_type	n
	)		const

inline

Definition at line 2408 of file FBString.h.

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

                        {
   if (pos < length()) {
     const_iterator i(begin() + pos), finish(end());
     for (; i != finish; ++i) {
       if (traits_type::find(s, n, *i) == nullptr) {
         return i - begin();
       }
     }
   }
   return npos;
 }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::find_first_not_of	(	const value_type *	s,
		size_type	pos = `0`
	)		const

inline

Definition at line 1791 of file FBString.h.

                                                                             {
     return find_first_not_of(s, pos, traitsLength(s));
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::find_first_not_of	(	value_type	c,
		size_type	pos = `0`
	)		const

inline

Definition at line 1795 of file FBString.h.

                                                                      {
     return find_first_not_of(&c, pos, 1);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::find_first_of	(	const basic_fbstring< E, T, A, Storage > &	str,
		size_type	pos = `0`
	)		const

inline

Definition at line 1753 of file FBString.h.

                                                                               {
     return find_first_of(str.data(), pos, str.length());
   }

template<typename E , class T , class A , class S >

basic_fbstring< E, T, A, S >::size_type folly::basic_fbstring< E, T, A, S >::find_first_of	(	const value_type *	s,
		size_type	pos,
		size_type	n
	)		const

inline

Definition at line 2369 of file FBString.h.

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

                        {
   if (pos > length() || n == 0) {
     return npos;
   }
   const_iterator i(begin() + pos), finish(end());
   for (; i != finish; ++i) {
     if (traits_type::find(s, n, *i) != nullptr) {
       return i - begin();
     }
   }
   return npos;
 }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::find_first_of	(	const value_type *	s,
		size_type	pos = `0`
	)		const

inline

Definition at line 1760 of file FBString.h.

                                                                         {
     return find_first_of(s, pos, traitsLength(s));
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::find_first_of	(	value_type	c,
		size_type	pos = `0`
	)		const

inline

Definition at line 1764 of file FBString.h.

                                                                  {
     return find_first_of(&c, pos, 1);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::find_last_not_of	(	const basic_fbstring< E, T, A, Storage > &	str,
		size_type	pos = `npos`
	)		const

inline

Definition at line 1799 of file FBString.h.

             {
     return find_last_not_of(str.data(), pos, str.length());
   }

template<typename E , class T , class A , class S >

basic_fbstring< E, T, A, S >::size_type folly::basic_fbstring< E, T, A, S >::find_last_not_of	(	const value_type *	s,
		size_type	pos,
		size_type	n
	)		const

inline

Definition at line 2425 of file FBString.h.

References folly::test::begin(), folly::empty(), i, min, and folly::size().

                        {
   if (!this->empty()) {
     pos = std::min(pos, size() - 1);
     const_iterator i(begin() + pos);
     for (;; --i) {
       if (traits_type::find(s, n, *i) == nullptr) {
         return i - begin();
       }
       if (i == begin()) {
         break;
       }
     }
   }
   return npos;
 }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::find_last_not_of	(	const value_type *	s,
		size_type	pos = `npos`
	)		const

inline

Definition at line 1807 of file FBString.h.

                                                                               {
     return find_last_not_of(s, pos, traitsLength(s));
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::find_last_not_of	(	value_type	c,
		size_type	pos = `npos`
	)		const

inline

Definition at line 1811 of file FBString.h.

                                                                        {
     return find_last_not_of(&c, pos, 1);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::find_last_of	(	const basic_fbstring< E, T, A, Storage > &	str,
		size_type	pos = `npos`
	)		const

inline

Definition at line 1768 of file FBString.h.

             {
     return find_last_of(str.data(), pos, str.length());
   }

template<typename E , class T , class A , class S >

basic_fbstring< E, T, A, S >::size_type folly::basic_fbstring< E, T, A, S >::find_last_of	(	const value_type *	s,
		size_type	pos,
		size_type	n
	)		const

inline

Definition at line 2387 of file FBString.h.

References folly::test::begin(), folly::empty(), i, and min.

                        {
   if (!empty() && n > 0) {
     pos = std::min(pos, length() - 1);
     const_iterator i(begin() + pos);
     for (;; --i) {
       if (traits_type::find(s, n, *i) != nullptr) {
         return i - begin();
       }
       if (i == begin()) {
         break;
       }
     }
   }
   return npos;
 }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::find_last_of	(	const value_type *	s,
		size_type	pos = `npos`
	)		const

inline

Definition at line 1775 of file FBString.h.

                                                                           {
     return find_last_of(s, pos, traitsLength(s));
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::find_last_of	(	value_type	c,
		size_type	pos = `npos`
	)		const

inline

Definition at line 1779 of file FBString.h.

                                                                    {
     return find_last_of(&c, pos, 1);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

const value_type& folly::basic_fbstring< E, T, A, Storage >::front ( ) const

inline

Definition at line 1315 of file FBString.h.

Referenced by TEST().

                                   {
     return *begin();
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

value_type& folly::basic_fbstring< E, T, A, Storage >::front ( )

inline

Definition at line 1323 of file FBString.h.

                       {
     return *begin();
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

allocator_type folly::basic_fbstring< E, T, A, Storage >::get_allocator ( ) const

inline

Definition at line 1720 of file FBString.h.

                                        {
     return allocator_type();
   }

template<typename E , class T , class A , class S >

basic_fbstring< E, T, A, S >::istream_type & folly::basic_fbstring< E, T, A, S >::getlineImpl	(	istream_type &	is,
		value_type	delim
	)

inlineprivate

Definition at line 2056 of file FBString.h.

References FBSTRING_ASSERT, reserve(), resize(), and folly::size().

                                                                           {
   Invariant checker(*this);
 
   clear();
   size_t size = 0;
   while (true) {
     size_t avail = capacity() - size;
     // fbstring has 1 byte extra capacity for the null terminator,
     // and getline null-terminates the read string.
     is.getline(store_.expandNoinit(avail), avail + 1, delim);
     size += is.gcount();
 
     if (is.bad() || is.eof() || !is.fail()) {
       // Done by either failure, end of file, or normal read.
       if (!is.bad() && !is.eof()) {
         --size; // gcount() also accounts for the delimiter.
       }
       resize(size);
       break;
     }
 
     FBSTRING_ASSERT(size == this->size());
     FBSTRING_ASSERT(size == capacity());
     // Start at minimum allocation 63 + terminator = 64.
     reserve(std::max<size_t>(63, 3 * size / 2));
     // Clear the error so we can continue reading.
     is.clear();
   }
   return is;
 }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::insert	(	size_type	pos1,
		const basic_fbstring< E, T, A, Storage > &	str
	)

inline

Definition at line 1470 of file FBString.h.

                                                                     {
     return insert(pos1, str.data(), str.size());
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::insert	(	size_type	pos1,
		const basic_fbstring< E, T, A, Storage > &	str,
		size_type	pos2,
		size_type	n
	)

inline

Definition at line 1474 of file FBString.h.

                    {
     enforce<std::out_of_range>(pos2 <= str.length(), "");
     procrustes(n, str.length() - pos2);
     return insert(pos1, str.data() + pos2, n);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::insert	(	size_type	pos,
		const value_type *	s,
		size_type	n
	)

inline

Definition at line 1484 of file FBString.h.

                                                                           {
     enforce<std::out_of_range>(pos <= length(), "");
     insert(begin() + pos, s, s + n);
     return *this;
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::insert	(	size_type	pos,
		const value_type *	s
	)

inline

Definition at line 1490 of file FBString.h.

                                                              {
     return insert(pos, s, traitsLength(s));
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::insert	(	size_type	pos,
		size_type	n,
		value_type	c
	)

inline

Definition at line 1494 of file FBString.h.

                                                                    {
     enforce<std::out_of_range>(pos <= length(), "");
     insert(begin() + pos, n, c);
     return *this;
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

iterator folly::basic_fbstring< E, T, A, Storage >::insert	(	const_iterator	p,
		const value_type	c
	)

inline

Definition at line 1500 of file FBString.h.

                                                         {
     const size_type pos = p - cbegin();
     insert(p, 1, c);
     return begin() + pos;
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

template<class ItOrLength , class ItOrChar >

iterator folly::basic_fbstring< E, T, A, Storage >::insert	(	const_iterator	p,
		ItOrLength	first_or_n,
		ItOrChar	last_or_c
	)

inline

Definition at line 1546 of file FBString.h.

                                                                                {
     using Sel = bool_constant<std::numeric_limits<ItOrLength>::is_specialized>;
     return insertImplDiscr(p, first_or_n, last_or_c, Sel());
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

iterator folly::basic_fbstring< E, T, A, Storage >::insert	(	const_iterator	p,
		std::initializer_list< value_type >	il
	)

inline

Definition at line 1551 of file FBString.h.

                                                                         {
     return insert(p, il.begin(), il.end());
   }

template<typename E , class T , class A , class S >

template<class FwdIterator >

basic_fbstring< E, T, A, S >::iterator folly::basic_fbstring< E, T, A, S >::insertImpl	(	const_iterator	i,
		FwdIterator	s1,
		FwdIterator	s2,
		std::forward_iterator_tag
	)

inlineprivate

Definition at line 2188 of file FBString.h.

References b, folly::test::begin(), folly::padded::cbegin(), folly::padded::cend(), folly::copy(), FBSTRING_ASSERT, folly::fbstring_detail::podMove(), and folly::size().

                              {
   Invariant checker(*this);
 
   FBSTRING_ASSERT(i >= cbegin() && i <= cend());
   const size_type pos = i - cbegin();
   auto n = std::distance(s1, s2);
   FBSTRING_ASSERT(n >= 0);
 
   auto oldSize = size();
   store_.expandNoinit(n, /* expGrowth = */ true);
   auto b = begin();
   fbstring_detail::podMove(b + pos, b + oldSize, b + pos + n);
   std::copy(s1, s2, b + pos);
 
   return b + pos;
 }

template<typename E , class T , class A , class S >

template<class InputIterator >

basic_fbstring< E, T, A, S >::iterator folly::basic_fbstring< E, T, A, S >::insertImpl	(	const_iterator	i,
		InputIterator	b,
		InputIterator	e,
		std::input_iterator_tag
	)

inlineprivate

Definition at line 2212 of file FBString.h.

References folly::basic_fbstring< E, T, A, Storage >::append(), b, folly::test::begin(), folly::padded::cbegin(), folly::padded::cend(), folly::basic_fbstring< E, T, A, Storage >::push_back(), folly::swap(), and shell_builder::temp.

                            {
   const auto pos = i - cbegin();
   basic_fbstring temp(cbegin(), i);
   for (; b != e; ++b) {
     temp.push_back(*b);
   }
   temp.append(i, cend());
   swap(temp);
   return begin() + pos;
 }

template<typename E , class T , class A , class S >

basic_fbstring< E, T, A, S >::iterator folly::basic_fbstring< E, T, A, S >::insertImplDiscr	(	const_iterator	i,
		size_type	n,
		value_type	c,
		std::true_type
	)

inlineprivate

Definition at line 2154 of file FBString.h.

References b, folly::test::begin(), folly::padded::cbegin(), folly::padded::cend(), FBSTRING_ASSERT, folly::fbstring_detail::podFill(), folly::fbstring_detail::podMove(), and folly::size().

                   {
   Invariant checker(*this);
 
   FBSTRING_ASSERT(i >= cbegin() && i <= cend());
   const size_type pos = i - cbegin();
 
   auto oldSize = size();
   store_.expandNoinit(n, /* expGrowth = */ true);
   auto b = begin();
   fbstring_detail::podMove(b + pos, b + oldSize, b + pos + n);
   fbstring_detail::podFill(b + pos, b + pos + n, c);
 
   return b + pos;
 }

template<typename E , class T , class A , class S >

template<class InputIter >

basic_fbstring< E, T, A, S >::iterator folly::basic_fbstring< E, T, A, S >::insertImplDiscr	(	const_iterator	i,
		InputIter	b,
		InputIter	e,
		std::false_type
	)

inlineprivate

Definition at line 2176 of file FBString.h.

                    {
   return insertImpl(
       i, b, e, typename std::iterator_traits<InputIter>::iterator_category());
 }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

bool folly::basic_fbstring< E, T, A, Storage >::isSane ( ) const

inlineprivate

Definition at line 1078 of file FBString.h.

                       {
     return begin() <= end() && empty() == (size() == 0) &&
         empty() == (begin() == end()) && size() <= max_size() &&
         capacity() <= max_size() && size() <= capacity() &&
         begin()[size()] == '\0';
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::length ( ) const

inline

Definition at line 1341 of file FBString.h.

Referenced by proxygen::TestStreamingCallback::duplicate(), folly::basic_fbstring< char >::find(), folly::basic_fbstring< char >::find_first_of(), folly::basic_fbstring< char >::find_last_not_of(), folly::basic_fbstring< char >::find_last_of(), folly::basic_fbstring< char >::insert(), folly::basic_fbstring< char >::replace(), and folly::basic_fbstring< char >::rfind().

                            {
     return size();
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::max_size ( ) const

inline

Definition at line 1345 of file FBString.h.

Referenced by folly::operator>>().

                              {
     return std::numeric_limits<size_type>::max();
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::operator+= ( const basic_fbstring< E, T, A, Storage > & str )

inline

Definition at line 1396 of file FBString.h.

                                                         {
     return append(str);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::operator+= ( const value_type * s )

inline

Definition at line 1400 of file FBString.h.

                                                   {
     return append(s);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::operator+= ( const value_type c )

inline

Definition at line 1404 of file FBString.h.

                                                  {
     push_back(c);
     return *this;
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::operator+= ( std::initializer_list< value_type > il )

inline

Definition at line 1409 of file FBString.h.

                                                                  {
     append(il);
     return *this;
   }

template<typename E , class T , class A , class S >

basic_fbstring< E, T, A, S > & folly::basic_fbstring< E, T, A, S >::operator= ( const basic_fbstring< E, T, A, Storage > & lhs )

inline

Definition at line 1886 of file FBString.h.

References folly::basic_fbstring< E, T, A, Storage >::data(), FBSTRING_UNLIKELY, and folly::basic_fbstring< E, T, A, Storage >::size().

                                {
   Invariant checker(*this);
 
   if (FBSTRING_UNLIKELY(&lhs == this)) {
     return *this;
   }
 
   return assign(lhs.data(), lhs.size());
 }

template<typename E , class T , class A , class S >

basic_fbstring< E, T, A, S > & folly::basic_fbstring< E, T, A, S >::operator= ( basic_fbstring< E, T, A, Storage > && goner )

inlinenoexcept

Definition at line 1899 of file FBString.h.

References FBSTRING_UNLIKELY, folly::gen::move, type, and value.

                                      {
   if (FBSTRING_UNLIKELY(&goner == this)) {
     // Compatibility with std::basic_string<>,
     // C++11 21.4.2 [string.cons] / 23 requires self-move-assignment support.
     return *this;
   }
   // No need of this anymore
   this->~basic_fbstring();
   // Move the goner into this
   new (&store_) S(std::move(goner.store_));
   return *this;
 }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

template<typename A2 >

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::operator= ( const std::basic_string< E, T, A2 > & rhs )

inline

Definition at line 1222 of file FBString.h.

                                                                   {
     return assign(rhs.data(), rhs.size());
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::operator= ( const value_type * s )

inline

Definition at line 1237 of file FBString.h.

                                                  {
     return assign(s);
   }

template<typename E, class T, class A , class S >

template<typename TP >

std::enable_if< std::is_same< typename std::decay< TP >::type, typename folly::basic_fbstring< E, T, A, S >::value_type >::value, basic_fbstring< E, T, A, S > & >::type folly::basic_fbstring< E, T, A, S >::operator= ( TP c )

inline

Definition at line 1920 of file FBString.h.

References c, folly::empty(), folly::size(), and folly::basic_fbstring< E, T, A, Storage >::swap().

                                           {
   Invariant checker(*this);
 
   if (empty()) {
     store_.expandNoinit(1);
   } else if (store_.isShared()) {
     basic_fbstring(1, c).swap(*this);
     return *this;
   } else {
     store_.shrink(size() - 1);
   }
   front() = c;
   return *this;
 }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::operator= ( std::initializer_list< value_type > il )

inline

Definition at line 1260 of file FBString.h.

                                                                 {
     return assign(il.begin(), il.end());
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

const_reference folly::basic_fbstring< E, T, A, Storage >::operator[] ( size_type pos ) const

inline

Definition at line 1377 of file FBString.h.

                                                   {
     return *(begin() + pos);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

reference folly::basic_fbstring< E, T, A, Storage >::operator[] ( size_type pos )

inline

Definition at line 1381 of file FBString.h.

                                       {
     return *(begin() + pos);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

void folly::basic_fbstring< E, T, A, Storage >::pop_back ( )

inline

Definition at line 1331 of file FBString.h.

                   {
     FBSTRING_ASSERT(!empty());
     store_.shrink(1);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

static void folly::basic_fbstring< E, T, A, Storage >::procrustes	(	size_type &	n,
		size_type	nmax
	)

inlinestaticprivate

Definition at line 1120 of file FBString.h.

                                                        {
     if (n > nmax) {
       n = nmax;
     }
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

void folly::basic_fbstring< E, T, A, Storage >::push_back ( const value_type c )

inline

Definition at line 1437 of file FBString.h.

Referenced by BENCHMARK(), proxygen::huffman::HuffTree::decode(), folly::basic_fbstring< E, T, A, Storage >::insertImpl(), folly::operator+(), folly::operator>>(), folly::test::TEST(), and TEST().

                                      { // primitive
     store_.push_back(c);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

reverse_iterator folly::basic_fbstring< E, T, A, Storage >::rbegin ( )

inline

Definition at line 1289 of file FBString.h.

                             {
     return reverse_iterator(end());
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

const_reverse_iterator folly::basic_fbstring< E, T, A, Storage >::rbegin ( ) const

inline

Definition at line 1293 of file FBString.h.

                                         {
     return const_reverse_iterator(end());
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

reverse_iterator folly::basic_fbstring< E, T, A, Storage >::rend ( )

inline

Definition at line 1301 of file FBString.h.

                           {
     return reverse_iterator(begin());
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

const_reverse_iterator folly::basic_fbstring< E, T, A, Storage >::rend ( ) const

inline

Definition at line 1305 of file FBString.h.

                                       {
     return const_reverse_iterator(begin());
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::replace	(	size_type	pos1,
		size_type	n1,
		const basic_fbstring< E, T, A, Storage > &	str
	)

inline

Definition at line 1581 of file FBString.h.

Referenced by TEST().

                                                                    {
     return replace(pos1, n1, str.data(), str.size());
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::replace	(	size_type	pos1,
		size_type	n1,
		const basic_fbstring< E, T, A, Storage > &	str,
		size_type	pos2,
		size_type	n2
	)

inline

Definition at line 1587 of file FBString.h.

                     {
     enforce<std::out_of_range>(pos2 <= str.length(), "");
     return replace(
         pos1, n1, str.data() + pos2, std::min(n2, str.size() - pos2));
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::replace	(	size_type	pos,
		size_type	n1,
		const value_type *	s
	)

inline

Definition at line 1599 of file FBString.h.

                                                                             {
     return replace(pos, n1, s, traitsLength(s));
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

template<class StrOrLength , class NumOrChar >

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::replace	(	size_type	pos,
		size_type	n1,
		StrOrLength	s_or_n2,
		NumOrChar	n_or_c
	)

inline

Definition at line 1612 of file FBString.h.

                                                                               {
     Invariant checker(*this);
 
     enforce<std::out_of_range>(pos <= size(), "");
     procrustes(n1, length() - pos);
     const iterator b = begin() + pos;
     return replace(b, b + n1, s_or_n2, n_or_c);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::replace	(	iterator	i1,
		iterator	i2,
		const basic_fbstring< E, T, A, Storage > &	str
	)

inline

Definition at line 1621 of file FBString.h.

                                                                                {
     return replace(i1, i2, str.data(), str.length());
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::replace	(	iterator	i1,
		iterator	i2,
		const value_type *	s
	)

inline

Definition at line 1625 of file FBString.h.

                                                                          {
     return replace(i1, i2, s, traitsLength(s));
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

template<class T1 , class T2 >

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::replace	(	iterator	i1,
		iterator	i2,
		T1	first_or_n_or_s,
		T2	last_or_c_or_n
	)

inline

Definition at line 1690 of file FBString.h.

                                                                            {
     constexpr bool num1 = std::numeric_limits<T1>::is_specialized,
                    num2 = std::numeric_limits<T2>::is_specialized;
     using Sel =
         std::integral_constant<int, num1 ? (num2 ? 1 : -1) : (num2 ? 2 : 0)>;
     return replaceImplDiscr(i1, i2, first_or_n_or_s, last_or_c_or_n, Sel());
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

template<class FwdIterator >

bool folly::basic_fbstring< E, T, A, Storage >::replaceAliased	(	iterator	,
		iterator	,
		FwdIterator	,
		FwdIterator	,
		std::false_type
	)

inlineprivate

Definition at line 1654 of file FBString.h.

                      {
     return false;
   }

template<typename E , class T , class A , class S >

template<class FwdIterator >

bool folly::basic_fbstring< E, T, A, S >::replaceAliased	(	iterator	i1,
		iterator	i2,
		FwdIterator	s1,
		FwdIterator	s2,
		std::true_type
	)

inlineprivate

Definition at line 2274 of file FBString.h.

References folly::basic_fbstring< E, T, A, Storage >::append(), folly::test::begin(), folly::test::end(), folly::basic_fbstring< E, T, A, Storage >::reserve(), folly::size(), folly::swap(), and shell_builder::temp.

                   {
   std::less_equal<const value_type*> le{};
   const bool aliased = le(&*begin(), &*s1) && le(&*s1, &*end());
   if (!aliased) {
     return false;
   }
   // Aliased replace, copy to new string
   basic_fbstring temp;
   temp.reserve(size() - (i2 - i1) + std::distance(s1, s2));
   temp.append(begin(), i1).append(s1, s2).append(i2, end());
   swap(temp);
   return true;
 }

template<typename E , class T , class A , class S >

template<class FwdIterator >

void folly::basic_fbstring< E, T, A, S >::replaceImpl	(	iterator	i1,
		iterator	i2,
		FwdIterator	s1,
		FwdIterator	s2,
		std::forward_iterator_tag
	)

inlineprivate

Definition at line 2295 of file FBString.h.

References folly::copy(), folly::fbstring_detail::copy_n(), FBSTRING_ASSERT, isSane(), and value.

                              {
   Invariant checker(*this);
 
   // Handle aliased replace
   using Sel = bool_constant<
       std::is_same<FwdIterator, iterator>::value ||
       std::is_same<FwdIterator, const_iterator>::value>;
   if (replaceAliased(i1, i2, s1, s2, Sel())) {
     return;
   }
 
   auto const n1 = i2 - i1;
   FBSTRING_ASSERT(n1 >= 0);
   auto const n2 = std::distance(s1, s2);
   FBSTRING_ASSERT(n2 >= 0);
 
   if (n1 > n2) {
     // shrinks
     std::copy(s1, s2, i1);
     erase(i1 + n2, i2);
   } else {
     // grows
     s1 = fbstring_detail::copy_n(s1, n1, i1).first;
     insert(i2, s1, s2);
   }
   FBSTRING_ASSERT(isSane());
 }

template<typename E , class T , class A , class S >

template<class InputIterator >

void folly::basic_fbstring< E, T, A, S >::replaceImpl	(	iterator	i1,
		iterator	i2,
		InputIterator	b,
		InputIterator	e,
		std::input_iterator_tag
	)

inlineprivate

Definition at line 2330 of file FBString.h.

References folly::basic_fbstring< E, T, A, Storage >::append(), folly::test::begin(), folly::test::end(), folly::swap(), and shell_builder::temp.

                            {
   basic_fbstring temp(begin(), i1);
   temp.append(b, e).append(i2, end());
   swap(temp);
 }

template<typename E , class T , class A , class S >

basic_fbstring< E, T, A, S > & folly::basic_fbstring< E, T, A, S >::replaceImplDiscr	(	iterator	i1,
		iterator	i2,
		const value_type *	s,
		size_type	n,
		std::integral_constant< int, 2 >
	)

inlineprivate

Definition at line 2228 of file FBString.h.

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

                                   {
   FBSTRING_ASSERT(i1 <= i2);
   FBSTRING_ASSERT(begin() <= i1 && i1 <= end());
   FBSTRING_ASSERT(begin() <= i2 && i2 <= end());
   return replace(i1, i2, s, s + n);
 }

template<typename E , class T , class A , class S >

basic_fbstring< E, T, A, S > & folly::basic_fbstring< E, T, A, S >::replaceImplDiscr	(	iterator	i1,
		iterator	i2,
		size_type	n2,
		value_type	c,
		std::integral_constant< int, 1 >
	)

inlineprivate

Definition at line 2241 of file FBString.h.

References FBSTRING_ASSERT, and isSane().

                                   {
   const size_type n1 = i2 - i1;
   if (n1 > n2) {
     std::fill(i1, i1 + n2, c);
     erase(i1 + n2, i2);
   } else {
     std::fill(i1, i2, c);
     insert(i2, n2 - n1, c);
   }
   FBSTRING_ASSERT(isSane());
   return *this;
 }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

template<class InputIter >

basic_fbstring& folly::basic_fbstring< E, T, A, Storage >::replaceImplDiscr	(	iterator	i1,
		iterator	i2,
		InputIter	b,
		InputIter	e,
		std::integral_constant< int, 0 >
	)

private

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

template<class InputIter >

basic_fbstring<E, T, A, S>& folly::basic_fbstring< E, T, A, Storage >::replaceImplDiscr	(	iterator	i1,
		iterator	i2,
		InputIter	b,
		InputIter	e,
		std::integral_constant< int, 0 >
	)

inline

Definition at line 2261 of file FBString.h.

                                   {
   using Cat = typename std::iterator_traits<InputIter>::iterator_category;
   replaceImpl(i1, i2, b, e, Cat());
   return *this;
 }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

void folly::basic_fbstring< E, T, A, Storage >::reserve ( size_type res_arg = 0 )

inline

Definition at line 1355 of file FBString.h.

Referenced by BENCHMARK(), folly::operator+(), folly::basic_fbstring< E, T, A, Storage >::replaceAliased(), folly::test::TEST(), and TEST().

                                       {
     enforce<std::length_error>(res_arg <= max_size(), "");
     store_.reserve(res_arg);
   }

template<typename E , class T , class A , class S >

void folly::basic_fbstring< E, T, A, S >::resize	(	size_type	n,
		value_type	c = `value_type()`
	)

inline

Definition at line 1936 of file FBString.h.

References FBSTRING_ASSERT, folly::fbstring_detail::podFill(), and folly::size().

Referenced by BENCHMARK().

                           {
   Invariant checker(*this);
 
   auto size = this->size();
   if (n <= size) {
     store_.shrink(size - n);
   } else {
     auto const delta = n - size;
     auto pData = store_.expandNoinit(delta);
     fbstring_detail::podFill(pData, pData + delta, c);
   }
   FBSTRING_ASSERT(this->size() == n);
 }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::rfind	(	const basic_fbstring< E, T, A, Storage > &	str,
		size_type	pos = `npos`
	)		const

inline

Definition at line 1739 of file FBString.h.

                                                                          {
     return rfind(str.data(), pos, str.length());
   }

template<typename E , class T , class A , class S >

basic_fbstring< E, T, A, S >::size_type folly::basic_fbstring< E, T, A, S >::rfind	(	const value_type *	s,
		size_type	pos,
		size_type	n
	)		const

inline

Definition at line 2343 of file FBString.h.

References folly::test::begin(), i, and min.

                        {
   if (n > length()) {
     return npos;
   }
   pos = std::min(pos, length() - n);
   if (n == 0) {
     return pos;
   }
 
   const_iterator i(begin() + pos);
   for (;; --i) {
     if (traits_type::eq(*i, *s) && traits_type::compare(&*i, s, n) == 0) {
       return i - begin();
     }
     if (i == begin()) {
       break;
     }
   }
   return npos;
 }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::rfind	(	const value_type *	s,
		size_type	pos = `npos`
	)		const

inline

Definition at line 1745 of file FBString.h.

                                                                    {
     return rfind(s, pos, traitsLength(s));
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::rfind	(	value_type	c,
		size_type	pos = `npos`
	)		const

inline

Definition at line 1749 of file FBString.h.

                                                             {
     return rfind(&c, pos, 1);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

void folly::basic_fbstring< E, T, A, Storage >::shrink_to_fit ( )

inline

Definition at line 1360 of file FBString.h.

                        {
     // Shrink only if slack memory is sufficiently large
     if (capacity() < size() * 3 / 2) {
       return;
     }
     basic_fbstring(cbegin(), cend()).swap(*this);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

size_type folly::basic_fbstring< E, T, A, Storage >::size ( ) const

inline

Definition at line 1337 of file FBString.h.

Referenced by folly::basic_fbstring< E, T, A, Storage >::append(), folly::basic_fbstring< char >::assign(), folly::basic_fbstring< E, T, A, Storage >::assign(), BENCHMARK(), BENCHMARK_RELATIVE(), proxygen::HPACKHeader::bytes(), folly::basic_fbstring< char >::compare(), folly::basic_fbstring< char >::find_first_not_of(), folly::basic_fbstring< char >::insert(), proxygen::TestStreamingCallback::onHeader(), folly::operator+(), folly::operator<(), folly::operator<<(), folly::basic_fbstring< E, T, A, Storage >::operator=(), folly::operator==(), folly::operator>(), folly::basic_fbstring< char >::replace(), StringUnsplit_Gen(), TEST(), folly::test::TEST(), TEST_F(), folly::toAppend(), and folly::toStdString().

                          {
     return store_.size();
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring folly::basic_fbstring< E, T, A, Storage >::substr	(	size_type	pos = `0`,
		size_type	n = `npos`
	)		const

inline

Definition at line 1815 of file FBString.h.

                                                                       {
     enforce<std::out_of_range>(pos <= size(), "");
     return basic_fbstring(data() + pos, std::min(n, size() - pos));
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

basic_fbstring folly::basic_fbstring< E, T, A, Storage >::substr	(	size_type	pos = `0`,
		size_type	n = `npos`
	)

inline

Definition at line 1820 of file FBString.h.

                                                                   {
     enforce<std::out_of_range>(pos <= size(), "");
     erase(0, pos);
     if (n < size()) {
       resize(n);
     }
     return std::move(*this);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

void folly::basic_fbstring< E, T, A, Storage >::swap ( basic_fbstring< E, T, A, Storage > & rhs )

inline

Definition at line 1708 of file FBString.h.

Referenced by folly::basic_fbstring< E, T, A, Storage >::operator=(), folly::basic_fbstring< char >::shrink_to_fit(), and folly::swap().

                                  {
     store_.swap(rhs.store_);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

std::basic_string<E, T, A> folly::basic_fbstring< E, T, A, Storage >::toStdString ( ) const

inline

Definition at line 1227 of file FBString.h.

Referenced by fizz::test::HandshakeTest::expectClientSuccess(), fizz::test::HandshakeTest::expectError(), fizz::test::HandshakeTest::expectServerError(), fizz::test::HandshakeTest::expectServerSuccess(), wangle::getSessionFromCacheData(), folly::detail::TypeDescriptor::name(), proxygen::HTTP2Codec::onHeader(), proxygen::compress::SimStreamingCallback::onHeader(), fizz::server::AsyncFizzServerT< SM >::ActionMoveVisitor::operator()(), fizz::client::AsyncFizzClientT< SM >::ActionMoveVisitor::operator()(), TEST(), fizz::client::test::TEST_F(), and folly::toDynamic().

                                                {
     return std::basic_string<E, T, A>(data(), size());
   }

template<typename E , class T , class A , class S >

FOLLY_MALLOC_NOINLINE basic_fbstring< E, T, A, S >::size_type folly::basic_fbstring< E, T, A, S >::traitsLength ( const value_type * s )

inlinestaticprivate

Definition at line 1878 of file FBString.h.

                                                             {
   return s ? traits_type::length(s)
            : (throw_exception<std::logic_error>(
                   "basic_fbstring: null pointer initializer not valid"),
               0);
 }

Friends And Related Function Documentation

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

istream_type& getline	(	istream_type &	is,
		basic_fbstring< E, T, A, Storage > &	str,
		value_type	delim
	)

friend

Definition at line 1513 of file FBString.h.

                                                                    {
     return str.getlineImpl(is, delim);
   }

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

istream_type& getline	(	istream_type &	is,
		basic_fbstring< E, T, A, Storage > &	str
	)

friend

Definition at line 1517 of file FBString.h.

                                                                              {
     return getline(is, str, '\n');
   }

Member Data Documentation

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

constexpr basic_fbstring< E1, T, A, S >::size_type folly::basic_fbstring< E1, T, A, S >::npos = size_type(-1)

static

Definition at line 1116 of file FBString.h.

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>

Storage folly::basic_fbstring< E, T, A, Storage >::store_

private

Definition at line 1873 of file FBString.h.

Referenced by folly::basic_fbstring< char >::swap().

The documentation for this class was generated from the following file:

proxygen/folly/folly/FBString.h

Classes

Public Types

Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>> class folly::basic_fbstring< E, T, A, Storage >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

template<typename E, class T = std::char_traits<E>, class A = std::allocator<E>, class Storage = fbstring_core<E>>
class folly::basic_fbstring< E, T, A, Storage >