strings_internal

Records

class DefaultFormatter<std::string_view>

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

class DefaultFormatter<std::unique_ptr<ValueType>>

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

```
class HasEmplace
```

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

```
class HasMappedType
```

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

```
class HasValueType
```

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

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

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

class SplitterIsConvertibleToImpl<C, true, false>

class SplitterIsConvertibleToImpl<C, true, true>

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 38 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 50 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 59 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 68 of file ../../third_party/abseil-cpp/src/absl/strings/internal/resize_uninitialized.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.

TODO: b/446221957 - Delete this function.

Defined at line 80 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 126 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 149 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 150 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 154 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 204 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 234 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 296 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 304 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 313 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 321 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 328 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 498 of file ../../third_party/abseil-cpp/src/absl/strings/str_cat.h
```
template <typename Float>
```
```
std::string FloatToString (Float f)
```
Defined at line 515 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 531 of file ../../third_party/abseil-cpp/src/absl/strings/str_cat.h
```
std::string SingleArgStrCat (unsigned int x)
```
Defined at line 532 of file ../../third_party/abseil-cpp/src/absl/strings/str_cat.h
```
std::string SingleArgStrCat (long x)
```
NOLINTNEXTLINE

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

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

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

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