strings_internal

Records

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/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/absl/strings/internal/stringify_sink.h

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

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

void AppendPieces (absl::Nonnull<std::string *> 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/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 64 of file ../../third_party/abseil-cpp/absl/strings/internal/string_constant.h

void STLStringAppendUninitializedAmortized (std::string * dest, size_t to_append)

```
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/absl/strings/internal/resize_uninitialized.h
```
template <typename string_type>
```
```
void STLStringReserveAmortized (string_type * s, size_t new_size)
```
Used to ensure 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 75 of file ../../third_party/abseil-cpp/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.

Defined at line 106 of file ../../third_party/abseil-cpp/absl/strings/internal/resize_uninitialized.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`.

std::string SingleArgStrCat (unsigned int x)

```
std::string SingleArgStrCat (long x)
```

std::string SingleArgStrCat (unsigned long x)

std::string SingleArgStrCat (long long x)

std::string SingleArgStrCat (unsigned long long x)

```
std::string SingleArgStrCat (float x)
```
```
std::string SingleArgStrCat (double x)
```
```
void SingleArgStrAppend (std::string & str, int x)
```
`SingleArgStrAppend` overloads are defined here for the same reasons as with

`SingleArgStrCat` above.

void SingleArgStrAppend (std::string & str, unsigned int x)

void SingleArgStrAppend (std::string & str, long x)

void SingleArgStrAppend (std::string & str, unsigned long x)

void SingleArgStrAppend (std::string & str, long long x)

void SingleArgStrAppend (std::string & strunsigned long long x)