strings_internal

Records

class AppendUninitializedTraits<string_type, absl::void_t<decltype(std::declval<string_type&>()
                                           .__append_default_init(237))>>

class DefaultFormatter<std::string_view>

```
class DefaultFormatter<ValueType*>
```

class DefaultFormatter<std::unique_ptr<ValueType>>

class HasConstIterator<T, absl::void_t<typename T::const_iterator>>

```
class HasEmplace
```

class HasEmplace<T, absl::void_t<decltype(std::declval<T>().emplace())>>

```
class HasMappedType
```

class HasMappedType<T, absl::void_t<typename T::mapped_type>>

```
class HasValueType
```

class HasValueType<T, absl::void_t<typename T::value_type>>

class ResizeUninitializedTraits<string_type, absl::void_t<decltype(std::declval<string_type&>()
                                           .__resize_default_init(237))>>

class ShouldUseLifetimeBound<StringType, Container, std::enable_if_t<
        std::is_same<StringType, std::string>::value &&
        std::is_same<typename Container::value_type, absl::string_view>::value>>

class SplitterIsConvertibleToImpl<C, true, false>

class SplitterIsConvertibleToImpl<C, true, true>

class has_Resize_and_overwrite<T, std::void_t<decltype(std::declval<T&>()._Resize_and_overwrite(
           std::declval<size_t>(), ProbeResizeAndOverwriteOp))>>

class has__google_nonstandard_backport_resize_and_overwrite

class has__google_nonstandard_backport_resize_and_overwrite<T, std::void_t<
        decltype(std::declval<T&>()
                     .__google_nonstandard_backport_resize_and_overwrite(
                         std::declval<size_t>(), ProbeResizeAndOverwriteOp))>>

```
class has__resize_and_overwrite
```

class has__resize_and_overwrite<T, std::void_t<decltype(std::declval<T&>().__resize_and_overwrite(
           std::declval<size_t>(), ProbeResizeAndOverwriteOp))>>

```
class has__resize_default_init
```

class has__resize_default_init<T, std::void_t<decltype(std::declval<T&>().__resize_default_init(42))>>

Functions

void AbslFormatFlush (UnimplementedSink * sink, absl::string_view v)

Support `absl::Format(

&sink

, format, args...)`.

```
void AbslFormatFlush (StringifySink * sink, absl::string_view v)
```
Support `absl::Format(

&sink

, format, args...)`.

Defined at line 35 of file ../../third_party/abseil-cpp/src/absl/strings/internal/stringify_sink.h
```
template <typename T>
```
```
string_view ExtractStringification (StringifySink & sink, const T & v)
```
Defined at line 47 of file ../../third_party/abseil-cpp/src/absl/strings/internal/stringify_sink.h
```
std::false_type IsInitializerListDispatch ()
```
IsInitializerList

<T

>::value is true iff T is an std::initializer_list. More

details below in Splitter

<

> where this is used.

template <typename T>

std::true_type IsInitializerListDispatch (std::initializer_list<T> * )

std::string CatPieces (std::initializer_list<absl::string_view> pieces)

Do not call directly - this is not part of the public API.

void AppendPieces (std::string * _Nonnull dest, std::initializer_list<absl::string_view> pieces)

```
template <typename string_type>
```
```
bool STLStringSupportsNontrashingResize (string_type * )
```
Returns true if the std::string implementation supports a resize where

the new characters added to the std::string are left untouched.

(A better name might be "STLStringSupportsUninitializedResize", alluding to

the previous function.)

Defined at line 58 of file ../../third_party/abseil-cpp/src/absl/strings/internal/resize_uninitialized.h
```
template <typename T>
```
```
StringConstant<T> MakeStringConstant (T )
```
Factory function for `StringConstant` instances.

It supports callables that have a constexpr default constructor and a

constexpr operator().

It must return an `absl::string_view` or `const char*` pointing to constant

data. This is validated at compile time.

Defined at line 59 of file ../../third_party/abseil-cpp/src/absl/strings/internal/string_constant.h
```
template <typename string_type, typename = void>
```
```
void STLStringResizeUninitialized (string_type * s, size_t new_size)
```
Like str->resize(new_size), except any new characters added to "*str" as a

result of resizing may be left uninitialized, rather than being filled with

'0' bytes. Typically used when code is then going to overwrite the backing

store of the std::string with known data.

Defined at line 67 of file ../../third_party/abseil-cpp/src/absl/strings/internal/resize_uninitialized.h
```
size_t ProbeResizeAndOverwriteOp (char * , size_t )
```
Defined at line 72 of file ../../third_party/abseil-cpp/src/absl/strings/resize_and_overwrite.h
```
template <typename string_type>
```
```
void STLStringResizeUninitializedAmortized (string_type * s, size_t new_size)
```
Like STLStringResizeUninitialized(str, new_size), except guaranteed to use

exponential growth so that the amortized complexity of increasing the string

size by a small amount is O(1), in contrast to O(str->size()) in the case of

precise growth.

Defined at line 94 of file ../../third_party/abseil-cpp/src/absl/strings/internal/resize_uninitialized.h
```
template <typename T, typename Op>
```
```
void StringResizeAndOverwriteFallback (T & str, typename T::size_type n, Op op)
```
A less-efficient fallback implementation that uses resize().

Defined at line 125 of file ../../third_party/abseil-cpp/src/absl/strings/resize_and_overwrite.h

template <typename T, typename Op>

void StringResizeAndOverwriteImpl (T & str, typename T::size_type n, Op op)

Defined at line 145 of file ../../third_party/abseil-cpp/src/absl/strings/resize_and_overwrite.h

```
bool operator== (const SplitIterator<Splitter> & a, const SplitIterator<Splitter> & b)
```
Defined at line 154 of file ../../third_party/abseil-cpp/src/absl/strings/internal/str_split_internal.h
```
bool operator!= (const SplitIterator<Splitter> & a, const SplitIterator<Splitter> & b)
```
Defined at line 158 of file ../../third_party/abseil-cpp/src/absl/strings/internal/str_split_internal.h
```
template <typename Iterator, typename Formatter>
```
```
std::string JoinAlgorithm (Iterator start, Iterator end, absl::string_view s, Formatter && f)
```
The main joining algorithm. This simply joins the elements in the given

iterator range, each separated by the given separator, into an output string,

and formats each element using the provided Formatter object.

Defined at line 205 of file ../../third_party/abseil-cpp/src/absl/strings/internal/str_join_internal.h
```
template <typename Iterator, typename = std::enable_if_t<
                                          base_internal::IsAtLeastForwardIterator<Iterator>::value>>
```
```
std::string JoinAlgorithm (Iterator start, Iterator end, absl::string_view s, NoFormatter )
```
A joining algorithm that's optimized for a forward iterator range of

string-like objects that do not need any additional formatting. This is to

optimize the common case of joining, say, a std::vector

<string

> or a

std::vector

<absl

::string_view>.

This is an overload of the previous JoinAlgorithm() function. Here the

Formatter argument is of type NoFormatter. Since NoFormatter is an internal

type, this overload is only invoked when strings::Join() is called with a

range of string-like objects (e.g., std::string, absl::string_view), and an

explicit Formatter argument was NOT specified.

The optimization is that the needed space will be reserved in the output

string to avoid the need to resize while appending. To do this, the iterator

range will be traversed twice: once to calculate the total needed size, and

then again to copy the elements and delimiters to the output string.

Defined at line 235 of file ../../third_party/abseil-cpp/src/absl/strings/internal/str_join_internal.h

template <typename... T, typename Formatter>

std::string JoinAlgorithm (const std::tuple<T...> & tup, absl::string_view sep, Formatter && fmt)

Defined at line 297 of file ../../third_party/abseil-cpp/src/absl/strings/internal/str_join_internal.h

template <typename Iterator>

std::string JoinRange (Iterator first, Iterator last, absl::string_view separator)

Defined at line 305 of file ../../third_party/abseil-cpp/src/absl/strings/internal/str_join_internal.h

template <typename Range, typename Formatter>

std::string JoinRange (const Range & range, absl::string_view separator, Formatter && fmt)

Defined at line 314 of file ../../third_party/abseil-cpp/src/absl/strings/internal/str_join_internal.h

```
template <typename Range>
```
```
std::string JoinRange (const Range & range, absl::string_view separator)
```
Defined at line 322 of file ../../third_party/abseil-cpp/src/absl/strings/internal/str_join_internal.h

template <typename Tuple, std::size_t... I>

std::string JoinTuple (const Tuple & value, absl::string_view separator, std::index_sequence<I...> )

Defined at line 329 of file ../../third_party/abseil-cpp/src/absl/strings/internal/str_join_internal.h

```
template <typename Integer>
```
```
std::string IntegerToString (Integer i)
```
Defined at line 470 of file ../../third_party/abseil-cpp/src/absl/strings/str_cat.h
```
template <typename Float>
```
```
std::string FloatToString (Float f)
```
Defined at line 487 of file ../../third_party/abseil-cpp/src/absl/strings/str_cat.h
```
std::string SingleArgStrCat (int x)
```
`SingleArgStrCat` overloads take built-in `int`, `long` and `long long` types

(signed / unsigned) to avoid ambiguity on the call side. If we used int32_t

and int64_t, then at least one of the three (`int` / `long` / `long long`)

would have been ambiguous when passed to `SingleArgStrCat`.

Defined at line 503 of file ../../third_party/abseil-cpp/src/absl/strings/str_cat.h
```
std::string SingleArgStrCat (unsigned int x)
```
Defined at line 504 of file ../../third_party/abseil-cpp/src/absl/strings/str_cat.h
```
std::string SingleArgStrCat (long x)
```
NOLINTNEXTLINE

Defined at line 508 of file ../../third_party/abseil-cpp/src/absl/strings/str_cat.h
```
std::string SingleArgStrCat (unsigned long x)
```
NOLINTNEXTLINE

Defined at line 510 of file ../../third_party/abseil-cpp/src/absl/strings/str_cat.h
```
std::string SingleArgStrCat (long long x)
```
NOLINTNEXTLINE

Defined at line 514 of file ../../third_party/abseil-cpp/src/absl/strings/str_cat.h
```
std::string SingleArgStrCat (unsigned long long x)
```
NOLINTNEXTLINE

Defined at line 516 of file ../../third_party/abseil-cpp/src/absl/strings/str_cat.h
```
std::string SingleArgStrCat (float x)
```
Defined at line 519 of file ../../third_party/abseil-cpp/src/absl/strings/str_cat.h
```
std::string SingleArgStrCat (double x)
```
Defined at line 520 of file ../../third_party/abseil-cpp/src/absl/strings/str_cat.h