Classes | Typedefs | Enumerations | Functions | Variables
absl::strings_internal Namespace Reference

Classes

struct  AlphaNumBuffer
 
struct  AlphaNumFormatterImpl
 
struct  AppendUninitializedTraits
 
struct  AppendUninitializedTraits< string_type, absl::void_t< decltype(std::declval< string_type & >() .__append_default_init(237))> >
 
struct  base64_testcase
 
class  BigUnsigned
 
class  Charmap
 
class  ConvertibleToStringView
 
class  CordTestAccess
 
struct  DefaultFormatter
 
struct  DefaultFormatter< absl::string_view >
 
struct  DefaultFormatter< char * >
 
struct  DefaultFormatter< const char * >
 
struct  DefaultFormatter< std::string >
 
struct  DefaultFormatter< std::unique_ptr< ValueType > >
 
struct  DefaultFormatter< ValueType * >
 
class  DereferenceFormatterImpl
 
struct  HasConstIterator
 
struct  HasConstIterator< T, absl::void_t< typename T::const_iterator > >
 
struct  HasEmplace
 
struct  HasEmplace< T, absl::void_t< decltype(std::declval< T >().emplace())> >
 
struct  HasMappedType
 
struct  HasMappedType< T, absl::void_t< typename T::mapped_type > >
 
struct  HasValueType
 
struct  HasValueType< T, absl::void_t< typename T::value_type > >
 
struct  IsArrayImpl
 
struct  IsArrayImpl< A< T, N > >
 
struct  IsBaseOfArrayImpl
 
struct  IsBaseOfArrayImpl< A< T, N > >
 
struct  IsBaseOfBitsetImpl
 
struct  IsBaseOfBitsetImpl< B< N > >
 
struct  IsBaseOfSpecializationImpl
 
struct  IsBaseOfSpecializationImpl< C, T, absl::void_t< typename C::key_type, typename C::hasher, typename C::key_equal, typename C::allocator_type > >
 
struct  IsBaseOfSpecializationImpl< C, T, absl::void_t< typename C::key_type, typename C::key_compare, typename C::allocator_type > >
 
struct  IsBaseOfSpecializationImpl< C, T, absl::void_t< typename C::key_type, typename C::mapped_type, typename C::hasher, typename C::key_equal, typename C::allocator_type > >
 
struct  IsBaseOfSpecializationImpl< C, T, absl::void_t< typename C::key_type, typename C::mapped_type, typename C::key_compare, typename C::allocator_type > >
 
struct  IsBaseOfSpecializationImpl< C, T, absl::void_t< typename C::value_type, typename C::allocator_type > >
 
struct  IsBaseOfSTLContainer
 
struct  IsBitsetImpl
 
struct  IsBitsetImpl< B< N > >
 
struct  IsConvertibleToArrayImpl
 
struct  IsConvertibleToArrayImpl< A< T, N > >
 
struct  IsConvertibleToBitsetImpl
 
struct  IsConvertibleToBitsetImpl< B< N > >
 
struct  IsConvertibleToSpecializationImpl
 
struct  IsConvertibleToSpecializationImpl< C, T, absl::void_t< typename C::key_type, typename C::hasher, typename C::key_equal, typename C::allocator_type > >
 
struct  IsConvertibleToSpecializationImpl< C, T, absl::void_t< typename C::key_type, typename C::key_compare, typename C::allocator_type > >
 
struct  IsConvertibleToSpecializationImpl< C, T, absl::void_t< typename C::key_type, typename C::mapped_type, typename C::hasher, typename C::key_equal, typename C::allocator_type > >
 
struct  IsConvertibleToSpecializationImpl< C, T, absl::void_t< typename C::key_type, typename C::mapped_type, typename C::key_compare, typename C::allocator_type > >
 
struct  IsConvertibleToSpecializationImpl< C, T, absl::void_t< typename C::value_type, typename C::allocator_type > >
 
struct  IsConvertibleToSTLContainer
 
struct  IsInitializerList
 
struct  IsSpecializationImpl
 
struct  IsSpecializationImpl< T< Args... >, T >
 
struct  IsSTLContainer
 
struct  IsStrictlyBaseOfAndConvertibleToSTLContainer
 
struct  JoinTupleLoop
 
struct  JoinTupleLoop< N, N >
 
class  MaxSplitsImpl
 
struct  NoFormatter
 
class  OStringStream
 
class  PairFormatterImpl
 
struct  ParsedFloat
 
struct  ResizeUninitializedTraits
 
struct  ResizeUninitializedTraits< string_type, absl::void_t< decltype(std::declval< string_type & >() .__resize_default_init(237))> >
 
struct  SelectDelimiter
 
struct  SelectDelimiter< absl::string_view >
 
struct  SelectDelimiter< char * >
 
struct  SelectDelimiter< char >
 
struct  SelectDelimiter< const char * >
 
struct  SelectDelimiter< std::string >
 
class  SplitIterator
 
class  Splitter
 
struct  SplitterIsConvertibleTo
 
struct  SplitterIsConvertibleToImpl
 
struct  SplitterIsConvertibleToImpl< C, true, false >
 
struct  SplitterIsConvertibleToImpl< C, true, true >
 
class  StreamFormatterImpl
 
struct  StringConstant
 
struct  uint32_test_case
 
struct  uint64_test_case
 
struct  ViableSubstitution
 

Typedefs

using FixedMapping = std::initializer_list< std::pair< absl::string_view, absl::string_view > >
 
template<typename C >
using IsArray = IsArrayImpl< absl::decay_t< C > >
 
template<typename C >
using IsBaseOfArray = IsBaseOfArrayImpl< absl::decay_t< C > >
 
template<typename C >
using IsBaseOfBitset = IsBaseOfBitsetImpl< absl::decay_t< C > >
 
template<typename C , template< typename... > class T>
using IsBaseOfSpecialization = IsBaseOfSpecializationImpl< absl::decay_t< C >, T >
 
template<typename C >
using IsBitset = IsBitsetImpl< absl::decay_t< C > >
 
template<typename C >
using IsConvertibleToArray = IsConvertibleToArrayImpl< absl::decay_t< C > >
 
template<typename C >
using IsConvertibleToBitset = IsConvertibleToBitsetImpl< absl::decay_t< C > >
 
template<typename C , template< typename... > class T>
using IsConvertibleToSpecialization = IsConvertibleToSpecializationImpl< absl::decay_t< C >, T >
 
template<typename C , template< typename... > class T>
using IsSpecialization = IsSpecializationImpl< absl::decay_t< C >, T >
 

Enumerations

enum  { kMaxEncodedUTF8Size = 4 }
 
enum  { kMaxEncodedUTF8Size = 4 }
 
enum  FloatType {
  FloatType::kNumber, FloatType::kInfinity, FloatType::kNan, FloatType::kNumber,
  FloatType::kInfinity, FloatType::kNan
}
 
enum  FloatType {
  FloatType::kNumber, FloatType::kInfinity, FloatType::kNan, FloatType::kNumber,
  FloatType::kInfinity, FloatType::kNan
}
 

Functions

constexpr Charmap AlnumCharmap ()
 
constexpr Charmap AlphaCharmap ()
 
void AppendPieces (std::string *dest, std::initializer_list< absl::string_view > pieces)
 
int ApplySubstitutions (absl::string_view s, std::vector< strings_internal::ViableSubstitution > *subs_ptr, std::string *result_ptr)
 
int ApplySubstitutions (absl::string_view s, std::vector< ViableSubstitution > *subs_ptr, std::string *result_ptr)
 
const std::array< base64_testcase, 5 > & base64_strings ()
 
size_t Base64EscapeInternal (const unsigned char *src, size_t szsrc, char *dest, size_t szdest, const char *base64, bool do_padding)
 
template<typename String >
void Base64EscapeInternal (const unsigned char *src, size_t szsrc, String *dest, bool do_padding, const char *base64_chars)
 
constexpr Charmap BlankCharmap ()
 
size_t CalculateBase64EscapedLenInternal (size_t input_len, bool do_padding)
 
std::string CatPieces (std::initializer_list< absl::string_view > pieces)
 
constexpr Charmap CntrlCharmap ()
 
template<int N, int M>
int Compare (const BigUnsigned< N > &lhs, const BigUnsigned< M > &rhs)
 
constexpr Charmap DigitCharmap ()
 
size_t EncodeUTF8Char (char *buffer, char32_t utf8_char)
 
template<typename StrToStrMapping >
std::vector< ViableSubstitutionFindSubstitutions (absl::string_view s, const StrToStrMapping &replacements)
 
constexpr Charmap GraphCharmap ()
 
template<bool case_sensitive>
const char * int_memmatch (const char *haystack, size_t haylen, const char *needle, size_t neelen)
 
std::false_type IsInitializerListDispatch (...)
 
template<typename T >
std::true_type IsInitializerListDispatch (std::initializer_list< T > *)
 
template<typename IntType >
bool Itoa (IntType value, int base, std::string *destination)
 
template<typename... T, typename Formatter >
std::string JoinAlgorithm (const std::tuple< T... > &tup, absl::string_view sep, Formatter &&fmt)
 
template<typename Iterator , typename Formatter >
std::string JoinAlgorithm (Iterator start, Iterator end, absl::string_view s, Formatter &&f)
 
template<typename Iterator , typename = typename std::enable_if<std::is_convertible< typename std::iterator_traits<Iterator>::iterator_category, std::forward_iterator_tag>::value>::type>
std::string JoinAlgorithm (Iterator start, Iterator end, absl::string_view s, NoFormatter)
 
template<typename Range >
std::string JoinRange (const Range &range, absl::string_view separator)
 
template<typename Range , typename Formatter >
std::string JoinRange (const Range &range, absl::string_view separator, Formatter &&fmt)
 
template<typename Iterator >
std::string JoinRange (Iterator first, Iterator last, absl::string_view separator)
 
constexpr Charmap LowerCharmap ()
 
template<typename T >
constexpr StringConstant< TMakeStringConstant (T)
 
int memcasecmp (const char *s1, const char *s2, size_t len)
 
const char * memcasemem (const char *phaystack, size_t haylen, const char *pneedle, size_t needlelen)
 
const char * memcasestr (const char *phaystack, size_t haylen, const char *pneedle)
 
char * memcat (char *dest, size_t destlen, const char *src, size_t srclen)
 
size_t memcspn (const char *s, size_t slen, const char *reject)
 
char * memdup (const char *s, size_t slen)
 
const char * memmatch (const char *phaystack, size_t haylen, const char *pneedle, size_t neelen)
 
const char * memmem (const char *phaystack, size_t haylen, const char *pneedle, size_t needlelen)
 
char * mempbrk (const char *s, size_t slen, const char *accept)
 
char * memrchr (const char *s, int c, size_t slen)
 
size_t memspn (const char *s, size_t slen, const char *accept)
 
const char * memstr (const char *phaystack, size_t haylen, const char *pneedle)
 
template<int N, int M>
bool operator!= (const BigUnsigned< N > &lhs, const BigUnsigned< M > &rhs)
 
template<int N, int M>
bool operator< (const BigUnsigned< N > &lhs, const BigUnsigned< M > &rhs)
 
template<int N>
std::ostream & operator<< (std::ostream &os, const BigUnsigned< N > &num)
 
template<int N, int M>
bool operator<= (const BigUnsigned< N > &lhs, const BigUnsigned< M > &rhs)
 
template<int N, int M>
bool operator== (const BigUnsigned< N > &lhs, const BigUnsigned< M > &rhs)
 
template<int N, int M>
bool operator> (const BigUnsigned< N > &lhs, const BigUnsigned< M > &rhs)
 
template<int N, int M>
bool operator>= (const BigUnsigned< N > &lhs, const BigUnsigned< M > &rhs)
 
template<int base>
ParsedFloat ParseFloat (const char *begin, const char *end, absl::chars_format format_flags)
 
template<int base>
strings_internal::ParsedFloat ParseFloat (const char *begin, const char *end, chars_format format_flags)
 
template ParsedFloat ParseFloat< 10 > (const char *begin, const char *end, chars_format format_flags)
 
template ParsedFloat ParseFloat< 16 > (const char *begin, const char *end, chars_format format_flags)
 
double Pow10 (int exp)
 
constexpr Charmap PrintCharmap ()
 
constexpr Charmap PunctCharmap ()
 
constexpr Charmap SpaceCharmap ()
 
template<typename string_type >
void STLStringReserveAmortized (string_type *s, size_t new_size)
 
template<typename string_type , typename = void>
void STLStringResizeUninitialized (string_type *s, size_t new_size)
 
template<typename string_type >
void STLStringResizeUninitializedAmortized (string_type *s, size_t new_size)
 
template<typename string_type >
constexpr bool STLStringSupportsNontrashingResize (string_type *)
 
const std::array< uint32_test_case, 27 > & strtouint32_test_cases ()
 
const std::array< uint64_test_case, 34 > & strtouint64_test_cases ()
 
 TEST (BigUnsigned, FiveToTheNth)
 
 TEST (BigUnsigned, MultiplyByBigUnsigned)
 
 TEST (BigUnsigned, MultiplyByOverflow)
 
 TEST (BigUnsigned, MultiplyByUint32)
 
 TEST (BigUnsigned, ShiftLeft)
 
 TEST (BigUnsigned, TenToTheNth)
 
constexpr Charmap UpperCharmap ()
 
constexpr Charmap XDigitCharmap ()
 

Variables

const ABSL_CONST_INIT char kBase64Chars []
 
const ABSL_DLL uint32_t kFiveToNth [14]
 
constexpr int kMaxSmallPowerOfFive = 13
 
constexpr int kMaxSmallPowerOfTen = 9
 
const ABSL_DLL uint32_t kTenToNth [10]
 

Typedef Documentation

◆ FixedMapping

Definition at line 24 of file abseil-cpp/absl/strings/str_replace.cc.

◆ IsArray

template<typename C >
using absl::strings_internal::IsArray = typedef IsArrayImpl<absl::decay_t<C> >

◆ IsBaseOfArray

template<typename C >
using absl::strings_internal::IsBaseOfArray = typedef IsBaseOfArrayImpl<absl::decay_t<C> >

◆ IsBaseOfBitset

template<typename C >
using absl::strings_internal::IsBaseOfBitset = typedef IsBaseOfBitsetImpl<absl::decay_t<C> >

◆ IsBaseOfSpecialization

template<typename C , template< typename... > class T>
using absl::strings_internal::IsBaseOfSpecialization = typedef IsBaseOfSpecializationImpl<absl::decay_t<C>, T>

◆ IsBitset

template<typename C >
using absl::strings_internal::IsBitset = typedef IsBitsetImpl<absl::decay_t<C> >

◆ IsConvertibleToArray

◆ IsConvertibleToBitset

◆ IsConvertibleToSpecialization

template<typename C , template< typename... > class T>
using absl::strings_internal::IsConvertibleToSpecialization = typedef IsConvertibleToSpecializationImpl<absl::decay_t<C>, T>

◆ IsSpecialization

template<typename C , template< typename... > class T>
using absl::strings_internal::IsSpecialization = typedef IsSpecializationImpl<absl::decay_t<C>, T>

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
kMaxEncodedUTF8Size 

Definition at line 43 of file bloaty/third_party/abseil-cpp/absl/strings/internal/utf8.h.

◆ anonymous enum

anonymous enum
Enumerator
kMaxEncodedUTF8Size 

Definition at line 43 of file abseil-cpp/absl/strings/internal/utf8.h.

◆ FloatType [1/2]

Enumerator
kNumber 
kInfinity 
kNan 
kNumber 
kInfinity 
kNan 

Definition at line 28 of file bloaty/third_party/abseil-cpp/absl/strings/internal/charconv_parse.h.

◆ FloatType [2/2]

Enumerator
kNumber 
kInfinity 
kNan 
kNumber 
kInfinity 
kNan 

Definition at line 28 of file abseil-cpp/absl/strings/internal/charconv_parse.h.

Function Documentation

◆ AlnumCharmap()

constexpr Charmap absl::strings_internal::AlnumCharmap ( )
constexpr

Definition at line 139 of file abseil-cpp/absl/strings/internal/char_map.h.

◆ AlphaCharmap()

constexpr Charmap absl::strings_internal::AlphaCharmap ( )
constexpr

Definition at line 138 of file abseil-cpp/absl/strings/internal/char_map.h.

◆ AppendPieces()

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

Definition at line 169 of file abseil-cpp/absl/strings/str_cat.cc.

◆ ApplySubstitutions() [1/2]

int absl::strings_internal::ApplySubstitutions ( absl::string_view  s,
std::vector< strings_internal::ViableSubstitution > *  subs_ptr,
std::string *  result_ptr 
)

Definition at line 29 of file abseil-cpp/absl/strings/str_replace.cc.

◆ ApplySubstitutions() [2/2]

int absl::strings_internal::ApplySubstitutions ( absl::string_view  s,
std::vector< ViableSubstitution > *  subs_ptr,
std::string *  result_ptr 
)

Definition at line 29 of file abseil-cpp/absl/strings/str_replace.cc.

◆ base64_strings()

const std::array< base64_testcase, 5 > & absl::strings_internal::base64_strings ( )
inline

◆ Base64EscapeInternal() [1/2]

size_t absl::strings_internal::Base64EscapeInternal ( const unsigned char *  src,
size_t  szsrc,
char *  dest,
size_t  szdest,
const char *  base64,
bool  do_padding 
)

Definition at line 73 of file abseil-cpp/absl/strings/internal/escaping.cc.

◆ Base64EscapeInternal() [2/2]

template<typename String >
void absl::strings_internal::Base64EscapeInternal ( const unsigned char *  src,
size_t  szsrc,
String *  dest,
bool  do_padding,
const char *  base64_chars 
)

Definition at line 42 of file abseil-cpp/absl/strings/internal/escaping.h.

◆ BlankCharmap()

constexpr Charmap absl::strings_internal::BlankCharmap ( )
constexpr

Definition at line 148 of file abseil-cpp/absl/strings/internal/char_map.h.

◆ CalculateBase64EscapedLenInternal()

size_t absl::strings_internal::CalculateBase64EscapedLenInternal ( size_t  input_len,
bool  do_padding 
)

Definition at line 27 of file abseil-cpp/absl/strings/internal/escaping.cc.

◆ CatPieces()

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

Definition at line 141 of file abseil-cpp/absl/strings/str_cat.cc.

◆ CntrlCharmap()

constexpr Charmap absl::strings_internal::CntrlCharmap ( )
constexpr

Definition at line 145 of file abseil-cpp/absl/strings/internal/char_map.h.

◆ Compare()

template<int N, int M>
int absl::strings_internal::Compare ( const BigUnsigned< N > &  lhs,
const BigUnsigned< M > &  rhs 
)

◆ DigitCharmap()

constexpr Charmap absl::strings_internal::DigitCharmap ( )
constexpr

Definition at line 137 of file abseil-cpp/absl/strings/internal/char_map.h.

◆ EncodeUTF8Char()

size_t absl::strings_internal::EncodeUTF8Char ( char *  buffer,
char32_t  utf8_char 
)

Definition at line 23 of file abseil-cpp/absl/strings/internal/utf8.cc.

◆ FindSubstitutions()

template<typename StrToStrMapping >
std::vector< ViableSubstitution > absl::strings_internal::FindSubstitutions ( absl::string_view  s,
const StrToStrMapping &  replacements 
)

Definition at line 158 of file abseil-cpp/absl/strings/str_replace.h.

◆ GraphCharmap()

constexpr Charmap absl::strings_internal::GraphCharmap ( )
constexpr

Definition at line 149 of file abseil-cpp/absl/strings/internal/char_map.h.

◆ int_memmatch()

template<bool case_sensitive>
const char * absl::strings_internal::int_memmatch ( const char *  haystack,
size_t  haylen,
const char *  needle,
size_t  neelen 
)

Definition at line 89 of file abseil-cpp/absl/strings/internal/memutil.h.

◆ IsInitializerListDispatch() [1/2]

std::false_type absl::strings_internal::IsInitializerListDispatch (   ...)

◆ IsInitializerListDispatch() [2/2]

template<typename T >
std::true_type absl::strings_internal::IsInitializerListDispatch ( std::initializer_list< T > *  )

◆ Itoa()

template<typename IntType >
bool absl::strings_internal::Itoa ( IntType  value,
int  base,
std::string *  destination 
)
inline

◆ JoinAlgorithm() [1/3]

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

◆ JoinAlgorithm() [2/3]

template<typename Iterator , typename Formatter >
std::string absl::strings_internal::JoinAlgorithm ( Iterator  start,
Iterator  end,
absl::string_view  s,
Formatter &&  f 
)

◆ JoinAlgorithm() [3/3]

template<typename Iterator , typename = typename std::enable_if<std::is_convertible< typename std::iterator_traits<Iterator>::iterator_category, std::forward_iterator_tag>::value>::type>
std::string absl::strings_internal::JoinAlgorithm ( Iterator  start,
Iterator  end,
absl::string_view  s,
NoFormatter   
)

◆ JoinRange() [1/3]

template<typename Range >
std::string absl::strings_internal::JoinRange ( const Range range,
absl::string_view  separator 
)

◆ JoinRange() [2/3]

template<typename Range , typename Formatter >
std::string absl::strings_internal::JoinRange ( const Range range,
absl::string_view  separator,
Formatter &&  fmt 
)

◆ JoinRange() [3/3]

template<typename Iterator >
std::string absl::strings_internal::JoinRange ( Iterator  first,
Iterator  last,
absl::string_view  separator 
)

◆ LowerCharmap()

constexpr Charmap absl::strings_internal::LowerCharmap ( )
constexpr

Definition at line 136 of file abseil-cpp/absl/strings/internal/char_map.h.

◆ MakeStringConstant()

template<typename T >
constexpr StringConstant< T > absl::strings_internal::MakeStringConstant ( T  )
constexpr

◆ memcasecmp()

int absl::strings_internal::memcasecmp ( const char *  s1,
const char *  s2,
size_t  len 
)

Definition at line 23 of file abseil-cpp/absl/strings/internal/memutil.cc.

◆ memcasemem()

const char * absl::strings_internal::memcasemem ( const char *  phaystack,
size_t  haylen,
const char *  pneedle,
size_t  needlelen 
)
inline

Definition at line 134 of file abseil-cpp/absl/strings/internal/memutil.h.

◆ memcasestr()

const char * absl::strings_internal::memcasestr ( const char *  phaystack,
size_t  haylen,
const char *  pneedle 
)
inline

Definition at line 124 of file abseil-cpp/absl/strings/internal/memutil.h.

◆ memcat()

char * absl::strings_internal::memcat ( char *  dest,
size_t  destlen,
const char *  src,
size_t  srclen 
)
inline

Definition at line 75 of file abseil-cpp/absl/strings/internal/memutil.h.

◆ memcspn()

size_t absl::strings_internal::memcspn ( const char *  s,
size_t  slen,
const char *  reject 
)

Definition at line 63 of file abseil-cpp/absl/strings/internal/memutil.cc.

◆ memdup()

char * absl::strings_internal::memdup ( const char *  s,
size_t  slen 
)

Definition at line 36 of file abseil-cpp/absl/strings/internal/memutil.cc.

◆ memmatch()

const char * absl::strings_internal::memmatch ( const char *  phaystack,
size_t  haylen,
const char *  pneedle,
size_t  neelen 
)

Definition at line 89 of file abseil-cpp/absl/strings/internal/memutil.cc.

◆ memmem()

const char * absl::strings_internal::memmem ( const char *  phaystack,
size_t  haylen,
const char *  pneedle,
size_t  needlelen 
)
inline

Definition at line 129 of file abseil-cpp/absl/strings/internal/memutil.h.

◆ mempbrk()

char * absl::strings_internal::mempbrk ( const char *  s,
size_t  slen,
const char *  accept 
)

Definition at line 76 of file abseil-cpp/absl/strings/internal/memutil.cc.

◆ memrchr()

char * absl::strings_internal::memrchr ( const char *  s,
int  c,
size_t  slen 
)

Definition at line 43 of file abseil-cpp/absl/strings/internal/memutil.cc.

◆ memspn()

size_t absl::strings_internal::memspn ( const char *  s,
size_t  slen,
const char *  accept 
)

Definition at line 50 of file abseil-cpp/absl/strings/internal/memutil.cc.

◆ memstr()

const char * absl::strings_internal::memstr ( const char *  phaystack,
size_t  haylen,
const char *  pneedle 
)
inline

Definition at line 119 of file abseil-cpp/absl/strings/internal/memutil.h.

◆ operator!=()

template<int N, int M>
bool absl::strings_internal::operator!= ( const BigUnsigned< N > &  lhs,
const BigUnsigned< M > &  rhs 
)

◆ operator<()

template<int N, int M>
bool absl::strings_internal::operator< ( const BigUnsigned< N > &  lhs,
const BigUnsigned< M > &  rhs 
)

◆ operator<<()

template<int N>
std::ostream & absl::strings_internal::operator<< ( std::ostream &  os,
const BigUnsigned< N > &  num 
)

◆ operator<=()

template<int N, int M>
bool absl::strings_internal::operator<= ( const BigUnsigned< N > &  lhs,
const BigUnsigned< M > &  rhs 
)

◆ operator==()

template<int N, int M>
bool absl::strings_internal::operator== ( const BigUnsigned< N > &  lhs,
const BigUnsigned< M > &  rhs 
)

◆ operator>()

template<int N, int M>
bool absl::strings_internal::operator> ( const BigUnsigned< N > &  lhs,
const BigUnsigned< M > &  rhs 
)

◆ operator>=()

template<int N, int M>
bool absl::strings_internal::operator>= ( const BigUnsigned< N > &  lhs,
const BigUnsigned< M > &  rhs 
)

◆ ParseFloat() [1/2]

template<int base>
ParsedFloat absl::strings_internal::ParseFloat ( const char *  begin,
const char *  end,
absl::chars_format  format_flags 
)

◆ ParseFloat() [2/2]

template<int base>
strings_internal::ParsedFloat absl::strings_internal::ParseFloat ( const char *  begin,
const char *  end,
chars_format  format_flags 
)

◆ ParseFloat< 10 >()

template ParsedFloat absl::strings_internal::ParseFloat< 10 > ( const char *  begin,
const char *  end,
chars_format  format_flags 
)

◆ ParseFloat< 16 >()

template ParsedFloat absl::strings_internal::ParseFloat< 16 > ( const char *  begin,
const char *  end,
chars_format  format_flags 
)

◆ Pow10()

double absl::strings_internal::Pow10 ( int  exp)

◆ PrintCharmap()

constexpr Charmap absl::strings_internal::PrintCharmap ( )
constexpr

Definition at line 143 of file abseil-cpp/absl/strings/internal/char_map.h.

◆ PunctCharmap()

constexpr Charmap absl::strings_internal::PunctCharmap ( )
constexpr

Definition at line 150 of file abseil-cpp/absl/strings/internal/char_map.h.

◆ SpaceCharmap()

constexpr Charmap absl::strings_internal::SpaceCharmap ( )
constexpr

Definition at line 144 of file abseil-cpp/absl/strings/internal/char_map.h.

◆ STLStringReserveAmortized()

template<typename string_type >
void absl::strings_internal::STLStringReserveAmortized ( string_type *  s,
size_t  new_size 
)

◆ STLStringResizeUninitialized()

template<typename string_type , typename = void>
void absl::strings_internal::STLStringResizeUninitialized ( string_type *  s,
size_t  new_size 
)
inline

◆ STLStringResizeUninitializedAmortized()

template<typename string_type >
void absl::strings_internal::STLStringResizeUninitializedAmortized ( string_type *  s,
size_t  new_size 
)

◆ STLStringSupportsNontrashingResize()

template<typename string_type >
constexpr bool absl::strings_internal::STLStringSupportsNontrashingResize ( string_type *  )
inlineconstexpr

◆ strtouint32_test_cases()

const std::array< uint32_test_case, 27 > & absl::strings_internal::strtouint32_test_cases ( )
inline

◆ strtouint64_test_cases()

const std::array< uint64_test_case, 34 > & absl::strings_internal::strtouint64_test_cases ( )
inline

◆ TEST() [1/6]

absl::strings_internal::TEST ( BigUnsigned  ,
FiveToTheNth   
)

◆ TEST() [2/6]

absl::strings_internal::TEST ( BigUnsigned  ,
MultiplyByBigUnsigned   
)

◆ TEST() [3/6]

absl::strings_internal::TEST ( BigUnsigned  ,
MultiplyByOverflow   
)

◆ TEST() [4/6]

absl::strings_internal::TEST ( BigUnsigned  ,
MultiplyByUint32   
)

◆ TEST() [5/6]

absl::strings_internal::TEST ( BigUnsigned  ,
ShiftLeft   
)

◆ TEST() [6/6]

absl::strings_internal::TEST ( BigUnsigned  ,
TenToTheNth   
)

◆ UpperCharmap()

constexpr Charmap absl::strings_internal::UpperCharmap ( )
constexpr

Definition at line 135 of file abseil-cpp/absl/strings/internal/char_map.h.

◆ XDigitCharmap()

constexpr Charmap absl::strings_internal::XDigitCharmap ( )
constexpr

Definition at line 140 of file abseil-cpp/absl/strings/internal/char_map.h.

Variable Documentation

◆ kBase64Chars

const ABSL_CONST_INIT char absl::strings_internal::kBase64Chars
Initial value:
=
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

Definition at line 24 of file abseil-cpp/absl/strings/internal/escaping.cc.

◆ kFiveToNth

const ABSL_DLL uint32_t absl::strings_internal::kFiveToNth
Initial value:
= {
1, 5, 25, 125, 625, 3125, 15625,
78125, 390625, 1953125, 9765625, 48828125, 244140625, 1220703125,
}

Definition at line 161 of file abseil-cpp/absl/strings/internal/charconv_bigint.cc.

◆ kMaxSmallPowerOfFive

constexpr int absl::strings_internal::kMaxSmallPowerOfFive = 13
constexpr

◆ kMaxSmallPowerOfTen

constexpr int absl::strings_internal::kMaxSmallPowerOfTen = 9
constexpr

◆ kTenToNth

const ABSL_DLL uint32_t absl::strings_internal::kTenToNth
Initial value:
= {
1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000,
}

Definition at line 166 of file abseil-cpp/absl/strings/internal/charconv_bigint.cc.



grpc
Author(s):
autogenerated on Fri May 16 2025 03:02:55