Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
google::protobuf Namespace Reference

Namespaces

 arena_metrics
 
 compiler
 
 descriptor
 
 descriptor_database
 
 descriptor_pb2
 
 descriptor_pool
 
 descriptor_unittest
 
 Enum
 
 EnumValue
 
 expr
 
 FieldMask
 
 FloatValue
 
 Int64Value
 
 internal
 
 io
 
 json_format
 
 message
 
 message_factory
 
 Option
 
 proto_builder
 
 protobuf_unittest
 
 pyext
 
 python
 
 reflection
 
 service
 
 service_reflection
 
 stringpiece_internal
 
 strings
 
 symbol_database
 
 TestUtil
 
 text_encoding
 
 text_format
 
 text_format_unittest
 
 Timestamp
 
 util
 

Classes

class  ArenaHooksTestUtil
 
struct  ArenaOptions
 
class  ArenaOptionsTestFriend
 
class  AssignDescriptorsHelper
 
class  BigEndian
 
class  BinaryAndJsonConformanceSuite
 
class  Bits
 
class  Closure
 
class  ConformanceTestRunner
 
class  ConformanceTestSuite
 
struct  DebugStringOptions
 
class  Descriptor
 
class  DescriptorBuilder
 
class  DescriptorDatabase
 
class  DescriptorPool
 
class  DescriptorPoolDatabase
 
class  DualArena
 
class  DynamicMapSorter
 
class  DynamicMessage
 
class  DynamicMessageFactory
 
class  DynamicMessageReflectionHelper
 
class  DynamicMessageTest
 
class  EncodedDescriptorDatabase
 
class  EnumDescriptor
 
class  EnumValueDescriptor
 
class  FieldDescriptor
 
class  File
 
class  FileDescriptor
 
class  FileDescriptorTables
 
class  ForkPipeRunner
 
class  GeneratedMessageReflectionTestHelper
 
struct  hash
 
struct  hash< bool >
 
struct  hash< const char * >
 
struct  hash< const Key * >
 
struct  hash< std::pair< First, Second > >
 
struct  hash< std::string >
 
struct  hash< string >
 
struct  is_proto_enum
 
class  LogSilencer
 
class  Map
 
class  MapEntryMessageComparator
 
class  MapIterator
 
class  MapKey
 
class  MapLiteTestUtil
 
struct  MapPair
 
class  MapReflectionTester
 
class  MapTestUtilImpl
 
class  MapValueConstRef
 
class  MapValueRef
 
struct  MathLimits
 
class  MathUtil
 
class  MergedDescriptorDatabase
 
class  Message
 
class  MessageFactory
 
class  MessageLite
 
struct  Metadata
 
class  MethodDescriptor
 
class  MustBeConstructedWithOneThroughEight
 
class  MustBeConstructedWithOneThroughFour
 
class  MutableRepeatedFieldRef
 
class  MutableRepeatedFieldRef< T, typename std::enable_if< std::is_base_of< Message, T >::value >::type >
 
class  MutableRepeatedFieldRef< T, typename std::enable_if<!std::is_base_of< Message, T >::value >::type >
 
struct  NoOpAccessListener
 
class  Notifier
 
class  OneofDescriptor
 
class  PleaseDontCopyMe
 
class  PleaseMoveMe
 
class  Reflection
 
class  RepeatedField
 
class  RepeatedFieldRef
 
class  RepeatedFieldRef< T, typename std::enable_if< std::is_base_of< Message, T >::value >::type >
 
class  RepeatedFieldRef< T, typename std::enable_if<!std::is_base_of< Message, T >::value >::type >
 
class  RepeatedPtrField
 
class  ResultCallback
 
class  ResultCallback1
 
class  ResultCallback2
 
class  RpcChannel
 
class  RpcController
 
class  ScopedMemoryLog
 
class  Service
 
class  ServiceDescriptor
 
class  SimpleDataType
 
class  SimpleDescriptorDatabase
 
class  SingleArena
 
struct  SourceLocation
 
struct  streq
 
class  StringPiece
 
class  Symbol
 
class  TestUtilLite
 
class  TextFormat
 
class  TextFormatConformanceTestSuite
 
class  uint128
 
struct  uint128_pod
 
class  UnknownField
 
class  UnknownFieldSet
 
class  UnknownFieldSetTest
 
struct  WeakRepeatedPtrField
 
class  ZeroCopyCodedInputStream
 

Typedefs

template<class T >
using AccessListener = NoOpAccessListener< T >
 
using ConstStringParam = const std::string &
 
using EmptyDefault = ArenaStringPtr::EmptyDefault
 
typedef int16_t int16
 
typedef int32_t int32
 
typedef int64_t int64
 
typedef int8_t int8
 
typedef void LogHandler(LogLevel level, const char *filename, int line, const std::string &message)
 
typedef string::difference_type stringpiece_ssize_type
 
typedef unsigned int uint
 
typedef uint16_t uint16
 
typedef uint32_t uint32
 
typedef uint64_t uint64
 
typedef uint8_t uint8
 

Enumerations

enum  { IS_COMPILER_MSVC = 0 }
 
enum  LogLevel {
  LOGLEVEL_INFO, LOGLEVEL_WARNING, LOGLEVEL_ERROR, LOGLEVEL_FATAL,
  LOGLEVEL_DFATAL = LOGLEVEL_FATAL, LOGLEVEL_INFO, LOGLEVEL_WARNING, LOGLEVEL_ERROR,
  LOGLEVEL_FATAL, LOGLEVEL_DFATAL = LOGLEVEL_FATAL
}
 
enum  LogLevel {
  LOGLEVEL_INFO, LOGLEVEL_WARNING, LOGLEVEL_ERROR, LOGLEVEL_FATAL,
  LOGLEVEL_DFATAL = LOGLEVEL_FATAL, LOGLEVEL_INFO, LOGLEVEL_WARNING, LOGLEVEL_ERROR,
  LOGLEVEL_FATAL, LOGLEVEL_DFATAL = LOGLEVEL_FATAL
}
 

Functions

template<typename Sequence , typename Collection >
void AddTokenCounts (const Sequence &sequence, const typename Collection::value_type::second_type &increment, Collection *const count_map)
 
uint64 Align8 (uint64 n)
 
class PROTOBUF_EXPORT alignas (8) Arena final
 
template<typename T >
internal::AllocatedRepeatedPtrFieldBackInsertIterator< TAllocatedRepeatedPtrFieldBackInserter (RepeatedPtrField< T > *const mutable_field)
 
static char * Append1 (char *out, const AlphaNum &x)
 
static char * Append1 (char *out, const AlphaNum &x)
 
static char * Append2 (char *out, const AlphaNum &x1, const AlphaNum &x2)
 
static char * Append2 (char *out, const AlphaNum &x1, const AlphaNum &x2)
 
static char * Append4 (char *out, const AlphaNum &x1, const AlphaNum &x2, const AlphaNum &x3, const AlphaNum &x4)
 
static char * Append4 (char *out, const AlphaNum &x1, const AlphaNum &x2, const AlphaNum &x3, const AlphaNum &x4)
 
template<class MapContainer , class KeyContainer >
void AppendKeysFromMap (const MapContainer &map_container, KeyContainer *key_container)
 
template<class MapContainer , class KeyType >
void AppendKeysFromMap (const MapContainer &map_container, std::vector< KeyType > *key_container)
 
template<class MapContainer , class ValueType >
void AppendValuesFromMap (const MapContainer &map_container, std::vector< ValueType > *value_container)
 
template<class MapContainer , class ValueContainer >
void AppendValuesFromMap (const MapContainer &map_container, ValueContainer *value_container)
 
bool ascii_isalnum (char c)
 
bool ascii_isdigit (char c)
 
bool ascii_islower (char c)
 
bool ascii_isspace (char c)
 
bool ascii_isupper (char c)
 
char ascii_tolower (char c)
 
char ascii_toupper (char c)
 
void AssignParsingMergeMessages (unittest::TestAllTypesLite *msg1, unittest::TestAllTypesLite *msg2, unittest::TestAllTypesLite *msg3)
 
int Base64Escape (const unsigned char *src, int szsrc, char *dest, int szdest)
 
void Base64Escape (const unsigned char *src, int szsrc, std::string *dest, bool do_padding)
 
void Base64Escape (const unsigned char *src, int szsrc, string *dest, bool do_padding)
 
void Base64Escape (StringPiece src, std::string *dest)
 
void Base64Escape (StringPiece src, string *dest)
 
int Base64EscapeInternal (const unsigned char *src, int szsrc, char *dest, int szdest, const char *base64, bool do_padding)
 
void Base64EscapeInternal (const unsigned char *src, int szsrc, std::string *dest, bool do_padding, const char *base64_chars)
 
void Base64EscapeInternal (const unsigned char *src, int szsrc, string *dest, bool do_padding, const char *base64_chars)
 
bool Base64Unescape (StringPiece src, std::string *dest)
 
bool Base64Unescape (StringPiece src, string *dest)
 
static bool Base64UnescapeInternal (const char *src, int slen, std::string *dest, const signed char *unbase64)
 
static bool Base64UnescapeInternal (const char *src, int slen, string *dest, const signed char *unbase64)
 
int Base64UnescapeInternal (const char *src_param, int szsrc, char *dest, int szdest, const signed char *unbase64)
 
static uint16 bswap_16 (uint16 x)
 
static uint16 bswap_16 (uint16 x)
 
static uint32 bswap_32 (uint32 x)
 
static uint32 bswap_32 (uint32 x)
 
static uint64 bswap_64 (uint64 x)
 
static uint64 bswap_64 (uint64 x)
 
static void BuildLookupTable (StringPiece characters_wanted, bool *table)
 
int CalculateBase64EscapedLen (int input_len)
 
int CalculateBase64EscapedLen (int input_len, bool do_padding)
 
void CaptureTestStderr ()
 
void CaptureTestStdout ()
 
bool CaseEqual (StringPiece s1, StringPiece s2)
 
std::string CEscape (const std::string &src)
 
string CEscape (const string &src)
 
void CEscapeAndAppend (StringPiece src, std::string *dest)
 
void CEscapeAndAppend (StringPiece src, string *dest)
 
static size_t CEscapedLength (StringPiece src)
 
static size_t CEscapedLength (StringPiece src)
 
int CEscapeInternal (const char *src, int src_len, char *dest, int dest_len, bool use_hex, bool utf8_safe)
 
bool CheckedRead (int fd, void *buf, size_t len)
 
void CheckedWrite (int fd, const void *buf, size_t len)
 
void CheckFieldIndex (const FieldDescriptor *field, int index)
 
template<typename Iter , typename Iter2 , typename Index >
static bool CheckForMutualSubsymbols (StringPiece symbol_name, Iter *iter, Iter2 end, const Index &index)
 
void CleanStringLineEndings (const std::string &src, std::string *dst, bool auto_end_last_line)
 
void CleanStringLineEndings (const string &src, string *dst, bool auto_end_last_line)
 
void CleanStringLineEndings (std::string *str, bool auto_end_last_line)
 
void CleanStringLineEndings (string *str, bool auto_end_last_line)
 
template<class Collection , class Key >
bool ContainsKey (const Collection &collection, const Key &key)
 
template<class Collection , class Key , class Value >
bool ContainsKeyValuePair (const Collection &collection, const Key &key, const Value &value)
 
 DEF_FP_LIMITS (long double, LDBL)
 
void DelocalizeRadix (char *buffer)
 
void PROTOBUF_EXPORT DoNothing ()
 
void DoTest (const ConformanceRequest &request, ConformanceResponse *response)
 
bool DoTestIo ()
 
char * DoubleToBuffer (double value, char *buffer)
 
template<typename T >
const TDynamicCastToGenerated (const Message *from)
 
template<typename T >
TDynamicCastToGenerated (Message *from)
 
int EncodeAsUTF8Char (uint32 code_point, char *output)
 
template<class Collection >
Collection::value_type::second_type EraseKeyReturnValuePtr (Collection *const collection, const typename Collection::value_type::first_type &key)
 
static bool ExistingFileMatchesProto (const FileDescriptor *existing_file, const FileDescriptorProto &proto)
 
static bool ExistingFileMatchesProto (const FileDescriptor *existing_file, const FileDescriptorProto &proto)
 
void ExpectMessageMerged (const unittest::TestAllTypesLite &message)
 
char * FastHex32ToBuffer (uint32 value, char *buffer)
 
char * FastHex64ToBuffer (uint64 value, char *buffer)
 
char * FastHexToBuffer (int i, char *buffer)
 
char * FastInt32ToBuffer (int32 i, char *buffer)
 
char * FastInt32ToBufferLeft (int32 i, char *buffer)
 
char * FastInt64ToBuffer (int64 i, char *buffer)
 
char * FastInt64ToBufferLeft (int64 i, char *buffer)
 
char * FastIntToBuffer (int i, char *buffer)
 
char * FastLongToBuffer (long i, char *buffer)
 
char * FastUInt32ToBuffer (uint32 i, char *buffer)
 
char * FastUInt32ToBufferLeft (uint32 u, char *buffer)
 
char * FastUInt64ToBuffer (uint64 i, char *buffer)
 
char * FastUInt64ToBufferLeft (uint64 u64, char *buffer)
 
char * FastUIntToBuffer (unsigned int i, char *buffer)
 
char * FastULongToBuffer (unsigned long i, char *buffer)
 
void FillArenaAwareFields (TestAllTypes *message)
 
template<class Collection , class Key , class Value >
bool FindCopy (const Collection &collection, const Key &key, Value *const value)
 
template<class Collection >
Collection::value_type::second_type::element_type & FindLinkedPtrOrDie (const Collection &collection, const typename Collection::value_type::first_type &key)
 
template<class Collection >
Collection::value_type::second_type::element_type * FindLinkedPtrOrNull (const Collection &collection, const typename Collection::value_type::first_type &key)
 
template<class Collection >
Collection::value_type::second_type & FindOrDie (Collection &collection, const typename Collection::value_type::first_type &key)
 
template<class Collection >
const Collection::value_type::second_type & FindOrDie (const Collection &collection, const typename Collection::value_type::first_type &key)
 
template<class Collection >
Collection::value_type::second_type & FindOrDieNoPrint (Collection &collection, const typename Collection::value_type::first_type &key)
 
template<class Collection >
const Collection::value_type::second_type & FindOrDieNoPrint (const Collection &collection, const typename Collection::value_type::first_type &key)
 
template<class Collection >
Collection::value_type::second_type * FindOrNull (Collection &collection, const typename Collection::value_type::first_type &key)
 
template<class Collection >
const Collection::value_type::second_type * FindOrNull (const Collection &collection, const typename Collection::value_type::first_type &key)
 
template<class Collection >
Collection::value_type::second_type FindPtrOrNull (Collection &collection, const typename Collection::value_type::first_type &key)
 
template<class Collection >
Collection::value_type::second_type FindPtrOrNull (const Collection &collection, const typename Collection::value_type::first_type &key)
 
template<class Collection >
const Collection::value_type::second_type & FindWithDefault (const Collection &collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &value)
 
char * FloatToBuffer (float value, char *buffer)
 
static int Fls128 (uint128 n)
 
static int Fls128 (uint128 n)
 
static int Fls64 (uint64 n)
 
static int Fls64 (uint64 n)
 
string GetCapturedTestStderr ()
 
string GetCapturedTestStdout ()
 
template<typename E >
const EnumDescriptorGetEnumDescriptor ()
 
MessageGetGroup (int field_number, const FieldDescriptor *field, Message *msg, const Reflection *reflection)
 
uint32 ghtonl (uint32 x)
 
int GlobalReplaceSubstring (const std::string &substring, const std::string &replacement, std::string *s)
 
int GlobalReplaceSubstring (const string &substring, const string &replacement, string *s)
 
uint16 GOOGLE_UNALIGNED_LOAD16 (const void *p)
 
uint32 GOOGLE_UNALIGNED_LOAD32 (const void *p)
 
uint64 GOOGLE_UNALIGNED_LOAD64 (const void *p)
 
void GOOGLE_UNALIGNED_STORE16 (void *p, uint16 v)
 
void GOOGLE_UNALIGNED_STORE32 (void *p, uint32 v)
 
void GOOGLE_UNALIGNED_STORE64 (void *p, uint64 v)
 
 HANDLE_TYPE (bool, FieldDescriptor::CPPTYPE_BOOL, -1)
 
 HANDLE_TYPE (double, FieldDescriptor::CPPTYPE_DOUBLE, -1)
 
 HANDLE_TYPE (float, FieldDescriptor::CPPTYPE_FLOAT, -1)
 
 HANDLE_TYPE (int32, FieldDescriptor::CPPTYPE_INT32, -1)
 
 HANDLE_TYPE (int64, FieldDescriptor::CPPTYPE_INT64, -1)
 
 HANDLE_TYPE (uint32, FieldDescriptor::CPPTYPE_UINT32, -1)
 
 HANDLE_TYPE (uint64, FieldDescriptor::CPPTYPE_UINT64, -1)
 
bool HasPrefixString (const string &str, const string &prefix)
 
bool HasPrefixString (StringPiece str, StringPiece prefix)
 
bool HasSuffixString (const string &str, const string &suffix)
 
bool HasSuffixString (StringPiece str, StringPiece suffix)
 
int hex_digit_to_int (char c)
 
template<class Collection >
bool InsertAndDeleteExisting (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &value)
 
template<class Collection >
bool InsertIfNotPresent (Collection *const collection, const typename Collection::value_type &vt)
 
template<class Collection >
bool InsertIfNotPresent (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &value)
 
template<class Collection >
Collection::value_type::second_type & InsertKeyOrDie (Collection *const collection, const typename Collection::value_type::first_type &key)
 
template<class MapContainer , class KeyContainer >
void InsertKeysFromMap (const MapContainer &map_container, KeyContainer *key_container)
 
template<class Collection >
void InsertOrDie (Collection *const collection, const typename Collection::value_type &value)
 
template<class Collection >
void InsertOrDie (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &data)
 
template<class Collection >
void InsertOrDieNoPrint (Collection *const collection, const typename Collection::value_type &value)
 
template<class Collection >
void InsertOrDieNoPrint (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &data)
 
template<class Collection >
Collection::value_type::second_type * InsertOrReturnExisting (Collection *const collection, const typename Collection::value_type &vt)
 
template<class Collection >
Collection::value_type::second_type * InsertOrReturnExisting (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &data)
 
template<class Collection >
bool InsertOrUpdate (Collection *const collection, const typename Collection::value_type &vt)
 
template<class Collection >
bool InsertOrUpdate (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &value)
 
template<class Collection , class InputIterator >
void InsertOrUpdateMany (Collection *const collection, InputIterator first, InputIterator last)
 
 INSTANTIATE_TEST_SUITE_P (ArenaString, DualArena, testing::Combine(testing::Bool(), testing::Bool()))
 
 INSTANTIATE_TEST_SUITE_P (ArenaString, SingleArena, testing::Bool())
 
 INSTANTIATE_TEST_SUITE_P (UseArena, DynamicMessageTest, ::testing::Bool())
 
char * InternalFastHexToBuffer (uint64 value, char *buffer, int num_byte)
 
static bool IsLite (const FileDescriptor *file)
 
static bool IsLite (const FileDescriptor *file)
 
bool isprint (char c)
 
bool IsValidCodePoint (uint32 code_point)
 
static bool IsValidFloatChar (char c)
 
static bool IsValidFloatChar (char c)
 
bool isxdigit (char c)
 
template<typename Range >
string Join (const Range &components, const char *delim)
 
template<typename Range >
std::string Join (const Range &components, const char *delim)
 
template<typename Iterator >
void Join (Iterator start, Iterator end, const char *delim, std::string *result)
 
template<typename Iterator >
void Join (Iterator start, Iterator end, const char *delim, string *result)
 
std::string JoinStrings (const std::vector< std::string > &components, const char *delim)
 
void JoinStrings (const std::vector< std::string > &components, const char *delim, std::string *result)
 
string JoinStrings (const std::vector< string > &components, const char *delim)
 
void JoinStrings (const std::vector< string > &components, const char *delim, string *result)
 
template<class ITERATOR >
static void JoinStringsIterator (const ITERATOR &start, const ITERATOR &end, const char *delim, std::string *result)
 
template<class ITERATOR >
static void JoinStringsIterator (const ITERATOR &start, const ITERATOR &end, const char *delim, string *result)
 
template<typename ExtendeeType , typename TypeTraitsType , internal::FieldType field_type, bool is_packed>
void LinkExtensionReflection (const google::protobuf::internal::ExtensionIdentifier< ExtendeeType, TypeTraitsType, field_type, is_packed > &extension)
 
template<typename T >
void LinkMessageReflection ()
 
template<class Collection >
Collection::value_type::second_type & LookupOrInsert (Collection *const collection, const typename Collection::value_type &vt)
 
template<class Collection >
Collection::value_type::second_type & LookupOrInsert (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &value)
 
template<class Collection >
Collection::value_type::second_type & LookupOrInsertNew (Collection *const collection, const typename Collection::value_type::first_type &key)
 
template<class Collection , class Arg >
Collection::value_type::second_type & LookupOrInsertNew (Collection *const collection, const typename Collection::value_type::first_type &key, const Arg &arg)
 
template<class Collection >
Collection::value_type::second_type::element_type * LookupOrInsertNewLinkedPtr (Collection *const collection, const typename Collection::value_type::first_type &key)
 
template<class Collection , class Arg >
Collection::value_type::second_type::element_type * LookupOrInsertNewLinkedPtr (Collection *const collection, const typename Collection::value_type::first_type &key, const Arg &arg)
 
template<class Collection >
Collection::value_type::second_type & LookupOrInsertNewSharedPtr (Collection *const collection, const typename Collection::value_type::first_type &key)
 
template<class Collection , class Arg >
Collection::value_type::second_type & LookupOrInsertNewSharedPtr (Collection *const collection, const typename Collection::value_type::first_type &key, const Arg &arg)
 
void LowerString (std::string *s)
 
void LowerString (string *s)
 
static int memcasecmp (const char *s1, const char *s2, size_t len)
 
static int memcasecmp (const char *s1, const char *s2, size_t len)
 
template<typename T , typename Less >
static void MergeIntoFlat (std::set< T, Less > *s, std::vector< T > *flat)
 
template<typename Class >
ClosureNewCallback (Class *object, void(Class::*method)())
 
template<typename Class , typename Arg1 >
ClosureNewCallback (Class *object, void(Class::*method)(Arg1), Arg1 arg1)
 
template<typename Class , typename Arg1 , typename Arg2 >
ClosureNewCallback (Class *object, void(Class::*method)(Arg1, Arg2), Arg1 arg1, Arg2 arg2)
 
template<typename R >
ResultCallback< R > * NewCallback (R(*function)())
 
template<typename R , typename A1 >
ResultCallback1< R, A1 > * NewCallback (R(*function)(A1))
 
template<typename R , typename P1 >
ResultCallback< R > * NewCallback (R(*function)(P1), P1 p1)
 
template<typename R , typename P1 , typename A1 >
ResultCallback1< R, A1 > * NewCallback (R(*function)(P1, A1), P1 p1)
 
ClosureNewCallback (void(*function)())
 
template<typename Arg1 >
ClosureNewCallback (void(*function)(Arg1), Arg1 arg1)
 
template<typename Arg1 , typename Arg2 >
ClosureNewCallback (void(*function)(Arg1, Arg2), Arg1 arg1, Arg2 arg2)
 
template<typename Class >
ClosureNewPermanentCallback (Class *object, void(Class::*method)())
 
template<typename Class , typename Arg1 >
ClosureNewPermanentCallback (Class *object, void(Class::*method)(Arg1), Arg1 arg1)
 
template<typename Class , typename Arg1 , typename Arg2 >
ClosureNewPermanentCallback (Class *object, void(Class::*method)(Arg1, Arg2), Arg1 arg1, Arg2 arg2)
 
template<typename R >
ResultCallback< R > * NewPermanentCallback (R(*function)())
 
template<typename R , typename A1 >
ResultCallback1< R, A1 > * NewPermanentCallback (R(*function)(A1))
 
template<typename R , typename P1 >
ResultCallback< R > * NewPermanentCallback (R(*function)(P1), P1 p1)
 
template<typename R , typename P1 , typename A1 >
ResultCallback1< R, A1 > * NewPermanentCallback (R(*function)(P1, A1), P1 p1)
 
template<typename R , typename T , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename A1 , typename A2 >
ResultCallback2< R, A1, A2 > * NewPermanentCallback (T *object, R(T::*function)(P1, P2, P3, P4, P5, P6, A1, A2), typename internal::InternalConstRef< P1 >::type p1, typename internal::InternalConstRef< P2 >::type p2, typename internal::InternalConstRef< P3 >::type p3, typename internal::InternalConstRef< P4 >::type p4, typename internal::InternalConstRef< P5 >::type p5, typename internal::InternalConstRef< P6 >::type p6)
 
template<typename R , typename T1 , typename T2 >
ResultCallback< R > * NewPermanentCallback (T1 *object, R(T2::*function)())
 
ClosureNewPermanentCallback (void(*function)())
 
template<typename Arg1 >
ClosureNewPermanentCallback (void(*function)(Arg1), Arg1 arg1)
 
template<typename Arg1 , typename Arg2 >
ClosureNewPermanentCallback (void(*function)(Arg1, Arg2), Arg1 arg1, Arg2 arg2)
 
bool operator! (const uint128 &val)
 
bool operator!= (const Duration &d1, const Duration &d2)
 
bool operator!= (const Timestamp &t1, const Timestamp &t2)
 
bool operator!= (const uint128 &lhs, const uint128 &rhs)
 
bool operator!= (StringPiece x, StringPiece y)
 
Duration operator% (const Duration &d1, const Duration &d2)
 
uint128 operator% (const uint128 &lhs, const uint128 &rhs)
 
Durationoperator%= (Duration &d1, const Duration &d2)
 
uint128 operator* (const uint128 &lhs, const uint128 &rhs)
 
template<typename T >
Duration operator* (Duration d, T r)
 
template<typename T >
Duration operator* (T r, Duration d)
 
Durationoperator*= (Duration &d, double r)
 
Durationoperator*= (Duration &d, int64 r)
 
template<typename T >
Durationoperator*= (Duration &d, T r)
 
Timestamp operator+ (const Duration &d, const Timestamp &t)
 
Duration operator+ (const Duration &d1, const Duration &d2)
 
Timestamp operator+ (const Timestamp &t, const Duration &d)
 
uint128 operator+ (const uint128 &lhs, const uint128 &rhs)
 
Durationoperator+= (Duration &d1, const Duration &d2)
 
Timestampoperator+= (Timestamp &t, const Duration &d)
 
Duration operator- (const Duration &d)
 
Duration operator- (const Duration &d1, const Duration &d2)
 
Timestamp operator- (const Timestamp &t, const Duration &d)
 
Duration operator- (const Timestamp &t1, const Timestamp &t2)
 
uint128 operator- (const uint128 &lhs, const uint128 &rhs)
 
uint128 operator- (const uint128 &val)
 
Durationoperator-= (Duration &d1, const Duration &d2)
 
Timestampoperator-= (Timestamp &t, const Duration &d)
 
int64 operator/ (const Duration &d1, const Duration &d2)
 
uint128 operator/ (const uint128 &lhs, const uint128 &rhs)
 
template<typename T >
Duration operator/ (Duration d, T r)
 
Durationoperator/= (Duration &d, double r)
 
Durationoperator/= (Duration &d, int64 r)
 
template<typename T >
Durationoperator/= (Duration &d, T r)
 
bool operator< (const Duration &d1, const Duration &d2)
 
bool operator< (const Timestamp &t1, const Timestamp &t2)
 
bool operator< (StringPiece x, StringPiece y)
 
uint128 operator<< (const uint128 &val, int amount)
 
std::ostream & operator<< (std::ostream &o, const uint128 &b)
 
std::ostream & operator<< (std::ostream &o, StringPiece piece)
 
std::ostream & operator<< (std::ostream &out, const Duration &d)
 
std::ostream & operator<< (std::ostream &out, const Timestamp &t)
 
bool operator<= (const Duration &d1, const Duration &d2)
 
bool operator<= (const Timestamp &t1, const Timestamp &t2)
 
bool operator<= (StringPiece x, StringPiece y)
 
bool operator== (const Duration &d1, const Duration &d2)
 
bool operator== (const Timestamp &t1, const Timestamp &t2)
 
bool operator== (const uint128 &lhs, const uint128 &rhs)
 
bool operator== (StringPiece x, StringPiece y)
 
bool operator> (const Duration &d1, const Duration &d2)
 
bool operator> (const Timestamp &t1, const Timestamp &t2)
 
bool operator> (StringPiece x, StringPiece y)
 
bool operator>= (const Duration &d1, const Duration &d2)
 
bool operator>= (const Timestamp &t1, const Timestamp &t2)
 
bool operator>= (StringPiece x, StringPiece y)
 
uint128 operator>> (const uint128 &val, int amount)
 
uint128 operator~ (const uint128 &val)
 
void ParseFailureList (const char *filename, conformance::FailureSet *failure_list)
 
const char * ParseLenDelim (int field_number, const FieldDescriptor *field, Message *msg, const Reflection *reflection, const char *ptr, internal::ParseContext *ctx)
 
const char * ParsePackedField (const FieldDescriptor *field, Message *msg, const Reflection *reflection, const char *ptr, internal::ParseContext *ctx)
 
class PROTOBUF_EXPORT PROTOBUF_ALIGNAS (8) Arena final
 
const Descriptor::ReservedRange * PROTOBUF_DEFINE_ACCESSOR (FieldDescriptor, containing_oneof, const OneofDescriptor *) PROTOBUF_DEFINE_ARRAY_ACCESSOR(EnumDescriptor
 
 PROTOBUF_DEFINE_ARRAY_ACCESSOR (Descriptor, extension_range, const Descriptor::ExtensionRange *) PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor
 
const Descriptor::ReservedRange const EnumValueDescriptorPROTOBUF_DEFINE_ARRAY_ACCESSOR (EnumDescriptor, reserved_range, const EnumDescriptor::ReservedRange *) PROTOBUF_DEFINE_ARRAY_ACCESSOR(ServiceDescriptor
 
const Descriptor::ReservedRange * PROTOBUF_DEFINE_ARRAY_ACCESSOR (EnumDescriptor, value, const EnumValueDescriptor *) PROTOBUF_DEFINE_ARRAY_ACCESSOR(EnumDescriptor
 
const Descriptor::ReservedRange const EnumDescriptor::ReservedRange const ServiceDescriptorPROTOBUF_DEFINE_ARRAY_ACCESSOR (FileDescriptor, extension, const FieldDescriptor *) inline Descriptor
 
const Descriptor::ReservedRange const EnumValueDescriptor const MethodDescriptorPROTOBUF_DEFINE_ARRAY_ACCESSOR (FileDescriptor, service, const ServiceDescriptor *) PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor
 
const Descriptor::ReservedRange const EnumDescriptor::ReservedRange * PROTOBUF_DEFINE_ARRAY_ACCESSOR (ServiceDescriptor, method, const MethodDescriptor *) PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor
 
static uint64 RandomUint64 ()
 
static uint64 RandomUint64 ()
 
template<>
const RepeatedPtrField< std::string > & Reflection::GetRepeatedPtrField< std::string > (const Message &message, const FieldDescriptor *field) const
 
template<>
const RepeatedPtrField< std::string > & Reflection::GetRepeatedPtrFieldInternal< std::string > (const Message &message, const FieldDescriptor *field) const
 
template<>
RepeatedPtrField< std::string > * Reflection::MutableRepeatedPtrField< std::string > (Message *message, const FieldDescriptor *field) const
 
template<>
RepeatedPtrField< std::string > * Reflection::MutableRepeatedPtrFieldInternal< std::string > (Message *message, const FieldDescriptor *field) const
 
bool ReflectiveValidator (const void *arg, int val)
 
void RegisterAllTypesInternal (const Metadata *file_level_metadata, int size)
 
template<typename T >
internal::RepeatedFieldBackInsertIterator< TRepeatedFieldBackInserter (RepeatedField< T > *const mutable_field)
 
template<typename T >
internal::RepeatedPtrFieldBackInsertIterator< TRepeatedFieldBackInserter (RepeatedPtrField< T > *const mutable_field)
 
template<typename T >
internal::RepeatedPtrFieldBackInsertIterator< TRepeatedPtrFieldBackInserter (RepeatedPtrField< T > *const mutable_field)
 
void ReplaceCharacters (std::string *s, const char *remove, char replacewith)
 
void ReplaceCharacters (string *s, const char *remove, char replacewith)
 
template<typename IntType >
bool safe_int_internal (std::string text, IntType *value_p)
 
template<typename IntType >
bool safe_int_internal (string text, IntType *value_p)
 
template<typename IntType >
bool safe_parse_negative_int (const std::string &text, IntType *value_p)
 
template<typename IntType >
bool safe_parse_negative_int (const string &text, IntType *value_p)
 
template<typename IntType >
bool safe_parse_positive_int (std::string text, IntType *value_p)
 
template<typename IntType >
bool safe_parse_positive_int (string text, IntType *value_p)
 
bool safe_parse_sign (std::string *text, bool *negative_ptr)
 
bool safe_parse_sign (string *text, bool *negative_ptr)
 
bool safe_strto32 (const char *str, int32 *value)
 
bool safe_strto32 (const std::string &str, int32 *value)
 
bool safe_strto32 (const string &str, int32 *value)
 
bool safe_strto32 (StringPiece str, int32 *value)
 
bool safe_strto64 (const char *str, int64 *value)
 
bool safe_strto64 (const std::string &str, int64 *value)
 
bool safe_strto64 (const string &str, int64 *value)
 
bool safe_strto64 (StringPiece str, int64 *value)
 
bool safe_strtob (StringPiece str, bool *value)
 
bool safe_strtod (const char *str, double *value)
 
bool safe_strtod (const std::string &str, double *value)
 
bool safe_strtod (const string &str, double *value)
 
bool safe_strtod (StringPiece str, double *value)
 
bool safe_strtof (const char *str, float *value)
 
bool safe_strtof (const std::string &str, float *value)
 
bool safe_strtof (const string &str, float *value)
 
bool safe_strtof (StringPiece str, float *value)
 
bool safe_strtou32 (const char *str, uint32 *value)
 
bool safe_strtou32 (const std::string &str, uint32 *value)
 
bool safe_strtou32 (const string &str, uint32 *value)
 
bool safe_strtou32 (StringPiece str, uint32 *value)
 
bool safe_strtou64 (const char *str, uint64 *value)
 
bool safe_strtou64 (const std::string &str, uint64 *value)
 
bool safe_strtou64 (const string &str, uint64 *value)
 
bool safe_strtou64 (StringPiece str, uint64 *value)
 
template<typename IntType >
bool safe_uint_internal (std::string text, IntType *value_p)
 
template<typename IntType >
bool safe_uint_internal (string text, IntType *value_p)
 
uint8SerializeToArrayImpl (const MessageLite &msg, uint8 *target, int size)
 
void SetAllTypesInEmptyMessageUnknownFields (unittest::TestEmptyMessageLite *empty_message)
 
void SetField (uint64 val, const FieldDescriptor *field, Message *msg, const Reflection *reflection)
 
LogHandlerSetLogHandler (LogHandler *new_func)
 
void SetSomeTypesInEmptyMessageUnknownFields (unittest::TestEmptyMessageLite *empty_message)
 
void ShutdownProtobufLibrary ()
 
string SimpleBtoa (bool value)
 
string SimpleDtoa (double value)
 
string SimpleFtoa (float value)
 
string SimpleItoa (int i)
 
string SimpleItoa (long i)
 
string SimpleItoa (long long i)
 
string SimpleItoa (unsigned int i)
 
string SimpleItoa (unsigned long i)
 
string SimpleItoa (unsigned long long i)
 
std::vector< string > Split (const string &full, const char *delim, bool skip_empty=true)
 
std::vector< std::string > Split (StringPiece full, const char *delim, bool skip_empty=true)
 
void SplitStringAllowEmpty (const string &full, const char *delim, std::vector< string > *result)
 
void SplitStringAllowEmpty (StringPiece full, const char *delim, std::vector< std::string > *result)
 
template<typename StringType , typename ITR >
static void SplitStringToIteratorAllowEmpty (const StringType &full, const char *delim, int pieces, ITR &result)
 
template<typename ITR >
static void SplitStringToIteratorAllowEmpty (StringPiece full, const char *delim, int pieces, ITR &result)
 
template<typename ITR >
static void SplitStringToIteratorUsing (const string &full, const char *delim, ITR &result)
 
template<typename ITR >
static void SplitStringToIteratorUsing (StringPiece full, const char *delim, ITR &result)
 
void SplitStringUsing (const string &full, const char *delim, std::vector< string > *result)
 
void SplitStringUsing (StringPiece full, const char *delim, std::vector< std::string > *result)
 
const std::string & SStringPrintf (std::string *dst, const char *format,...)
 
const string & SStringPrintf (string *dst, const char *format,...)
 
void STLStringResizeUninitialized (std::string *s, size_t new_size)
 
void STLStringResizeUninitialized (string *s, size_t new_size)
 
void STLStringResizeUninitializedAmortized (std::string *s, size_t new_size)
 
void StrAppend (std::string *result, const AlphaNum &a)
 
void StrAppend (std::string *result, const AlphaNum &a, const AlphaNum &b)
 
void StrAppend (std::string *result, const AlphaNum &a, const AlphaNum &b, const AlphaNum &c)
 
void StrAppend (std::string *result, const AlphaNum &a, const AlphaNum &b, const AlphaNum &c, const AlphaNum &d)
 
void StrAppend (string *result, const AlphaNum &a)
 
void StrAppend (string *result, const AlphaNum &a, const AlphaNum &b)
 
void StrAppend (string *result, const AlphaNum &a, const AlphaNum &b, const AlphaNum &c)
 
void StrAppend (string *result, const AlphaNum &a, const AlphaNum &b, const AlphaNum &c, const AlphaNum &d)
 
string StrCat (const AlphaNum &a)
 
string StrCat (const AlphaNum &a, const AlphaNum &b)
 
string StrCat (const AlphaNum &a, const AlphaNum &b, const AlphaNum &c)
 
string StrCat (const AlphaNum &a, const AlphaNum &b, const AlphaNum &c, const AlphaNum &d)
 
string StrCat (const AlphaNum &a, const AlphaNum &b, const AlphaNum &c, const AlphaNum &d, const AlphaNum &e)
 
string StrCat (const AlphaNum &a, const AlphaNum &b, const AlphaNum &c, const AlphaNum &d, const AlphaNum &e, const AlphaNum &f)
 
string StrCat (const AlphaNum &a, const AlphaNum &b, const AlphaNum &c, const AlphaNum &d, const AlphaNum &e, const AlphaNum &f, const AlphaNum &g)
 
string StrCat (const AlphaNum &a, const AlphaNum &b, const AlphaNum &c, const AlphaNum &d, const AlphaNum &e, const AlphaNum &f, const AlphaNum &g, const AlphaNum &h)
 
string StrCat (const AlphaNum &a, const AlphaNum &b, const AlphaNum &c, const AlphaNum &d, const AlphaNum &e, const AlphaNum &f, const AlphaNum &g, const AlphaNum &h, const AlphaNum &i)
 
char * string_as_array (std::string *str)
 
char * string_as_array (string *str)
 
void StringAppendF (std::string *dst, const char *format,...)
 
void StringAppendF (string *dst, const char *format,...)
 
void StringAppendV (std::string *dst, const char *format, va_list ap)
 
void StringAppendV (string *dst, const char *format, va_list ap)
 
string StringPrintf (const char *format,...)
 
std::string StringPrintfVector (const char *format, const std::vector< std::string > &v)
 
string StringPrintfVector (const char *format, const std::vector< string > &v)
 
std::string StringReplace (const std::string &s, const std::string &oldsub, const std::string &newsub, bool replace_all)
 
void StringReplace (const std::string &s, const std::string &oldsub, const std::string &newsub, bool replace_all, std::string *res)
 
string StringReplace (const string &s, const string &oldsub, const string &newsub, bool replace_all)
 
void StringReplace (const string &s, const string &oldsub, const string &newsub, bool replace_all, string *res)
 
std::string StripPrefixString (const std::string &str, const std::string &prefix)
 
string StripPrefixString (const string &str, const string &prefix)
 
void StripString (string *s, const char *remove, char replacewith)
 
std::string StripSuffixString (const std::string &str, const std::string &suffix)
 
string StripSuffixString (const string &str, const string &suffix)
 
void StripWhitespace (std::string *str)
 
void StripWhitespace (string *str)
 
int32 strto32 (const char *nptr, char **endptr, int base)
 
int32 strto32_adaptor (const char *nptr, char **endptr, int base)
 
int64 strto64 (const char *nptr, char **endptr, int base)
 
uint32 strtou32 (const char *nptr, char **endptr, int base)
 
uint32 strtou32_adaptor (const char *nptr, char **endptr, int base)
 
uint64 strtou64 (const char *nptr, char **endptr, int base)
 
 TEST (ArenaStringPtrTest, ArenaStringPtrOnArena)
 
 TEST (ArenaStringPtrTest, ArenaStringPtrOnArenaNoSSO)
 
 TEST (ArenaStringPtrTest, ArenaStringPtrOnHeap)
 
 TEST (ArenaTest, AddAllocatedToRepeatedField)
 
 TEST (ArenaTest, AddAllocatedToRepeatedFieldViaReflection)
 
 TEST (ArenaTest, AddAllocatedWithReflection)
 
 TEST (ArenaTest, AddCleanup)
 
 TEST (ArenaTest, Alignment)
 
 TEST (ArenaTest, ArenaConstructable)
 
 TEST (ArenaTest, ArenaHooksSanity)
 
 TEST (ArenaTest, ArenaHooksWhenAllocationsNotNeeded)
 
 TEST (ArenaTest, ArenaOneofReflection)
 
 TEST (ArenaTest, BasicCreate)
 
 TEST (ArenaTest, BlockSizeDoubling)
 
 TEST (ArenaTest, BlockSizeSmallerThanAllocation)
 
 TEST (ArenaTest, CreateAndConstCopy)
 
 TEST (ArenaTest, CreateAndMove)
 
 TEST (ArenaTest, CreateAndNonConstCopy)
 
 TEST (ArenaTest, CreateWithEightConstructorArguments)
 
 TEST (ArenaTest, CreateWithFourConstructorArguments)
 
 TEST (ArenaTest, CreateWithMoveArguments)
 
 TEST (ArenaTest, DestructorSkippable)
 
 TEST (ArenaTest, ExtensionsOnArena)
 
 TEST (ArenaTest, GetArenaShouldReturnNullForNonArenaAllocatedMessages)
 
 TEST (ArenaTest, GetArenaShouldReturnNullForNonArenaCompatibleTypes)
 
 TEST (ArenaTest, GetArenaShouldReturnTheArenaForArenaAllocatedMessages)
 
 TEST (ArenaTest, InitialBlockTooSmall)
 
 TEST (ArenaTest, NoHeapAllocationsTest)
 
 TEST (ArenaTest, OneofMerge)
 
 TEST (ArenaTest, ParseCorruptedString)
 
 TEST (ArenaTest, Parsing)
 
 TEST (ArenaTest, ReflectionSwapFields)
 
 TEST (ArenaTest, ReleaseFromArenaMessageMakesCopy)
 
 TEST (ArenaTest, ReleaseLastRepeatedField)
 
 TEST (ArenaTest, ReleaseMessage)
 
 TEST (ArenaTest, ReleaseString)
 
 TEST (ArenaTest, RepeatedFieldOnArena)
 
 TEST (ArenaTest, RepeatedFieldWithNonPODType)
 
 TEST (ArenaTest, RepeatedPtrFieldAddClearedTest)
 
 TEST (ArenaTest, SetAllocatedAcrossArenas)
 
 TEST (ArenaTest, SetAllocatedAcrossArenasWithReflection)
 
 TEST (ArenaTest, SetAllocatedMessage)
 
 TEST (ArenaTest, SetAllocatedString)
 
 TEST (ArenaTest, SpaceAllocated_and_Used)
 
 TEST (ArenaTest, Swap)
 
 TEST (ArenaTest, SwapBetweenArenaAndNonArenaUsingReflection)
 
 TEST (ArenaTest, SwapBetweenArenaAndNonArenaWithAllFieldsSet)
 
 TEST (ArenaTest, SwapBetweenArenasUsingReflection)
 
 TEST (ArenaTest, SwapBetweenArenasWithAllFieldsSet)
 
 TEST (ArenaTest, SwapRepeatedField)
 
 TEST (ArenaTest, SwapRepeatedFieldWithDifferentArenas)
 
 TEST (ArenaTest, SwapRepeatedFieldWithNoArenaOnLeftHandSide)
 
 TEST (ArenaTest, SwapRepeatedFieldWithNoArenaOnRightHandSide)
 
 TEST (ArenaTest, UnknownFields)
 
 TEST (ArenaTest, UnsafeArenaAddAllocated)
 
 TEST (ArenaTest, UnsafeArenaAddAllocatedToRepeatedField)
 
 TEST (ArenaTest, UnsafeArenaRelease)
 
 TEST (ArenaTest, UnsafeArenaReleaseAdd)
 
 TEST (ArenaTest, UnsafeArenaSetAllocatedAcrossArenas)
 
 TEST (ArenaTest, UnsafeArenaSetAllocatedAcrossArenasWithReflection)
 
 TEST (ArenaTest, UnsafeArenaSwap)
 
 TEST (ArenaTest, UnsafeSetAllocatedOnArena)
 
 TEST (DropUnknownFieldsTest, DynamicMessage)
 
 TEST (DropUnknownFieldsTest, GeneratedMessage)
 
 TEST (Int128, AliasTests)
 
 TEST (Int128, AllTests)
 
 TEST (Int128, DivideAndMod)
 
 TEST (Int128, DivideAndModRandomInputs)
 
 TEST (Int128, Multiply)
 
 TEST (Int128, OperatorAssignReturnRef)
 
 TEST (Int128, OStream)
 
 TEST (Int128, PodTests)
 
 TEST (Lite, AliasedEnum)
 
 TEST (Lite, AllLite1)
 
 TEST (Lite, AllLite10)
 
 TEST (Lite, AllLite11)
 
 TEST (Lite, AllLite12)
 
 TEST (Lite, AllLite13)
 
 TEST (Lite, AllLite14)
 
 TEST (Lite, AllLite15)
 
 TEST (Lite, AllLite16)
 
 TEST (Lite, AllLite17)
 
 TEST (Lite, AllLite18)
 
 TEST (Lite, AllLite19)
 
 TEST (Lite, AllLite2)
 
 TEST (Lite, AllLite20)
 
 TEST (Lite, AllLite21)
 
 TEST (Lite, AllLite22)
 
 TEST (Lite, AllLite23)
 
 TEST (Lite, AllLite24)
 
 TEST (Lite, AllLite25)
 
 TEST (Lite, AllLite26)
 
 TEST (Lite, AllLite27)
 
 TEST (Lite, AllLite28)
 
 TEST (Lite, AllLite29)
 
 TEST (Lite, AllLite3)
 
 TEST (Lite, AllLite32)
 
 TEST (Lite, AllLite33)
 
 TEST (Lite, AllLite34)
 
 TEST (Lite, AllLite35)
 
 TEST (Lite, AllLite36)
 
 TEST (Lite, AllLite37)
 
 TEST (Lite, AllLite38)
 
 TEST (Lite, AllLite39)
 
 TEST (Lite, AllLite40)
 
 TEST (Lite, AllLite41)
 
 TEST (Lite, AllLite42)
 
 TEST (Lite, AllLite43)
 
 TEST (Lite, AllLite44)
 
 TEST (Lite, AllLite45)
 
 TEST (Lite, AllLite46)
 
 TEST (Lite, AllLite47)
 
 TEST (Lite, AllLite5)
 
 TEST (Lite, AllLite6)
 
 TEST (Lite, AllLite7)
 
 TEST (Lite, AllLite8)
 
 TEST (Lite, AllLite9)
 
 TEST (Lite, CodedInputStreamRollback)
 
 TEST (Lite, CorrectEnding)
 
 TEST (Lite, DebugString)
 
 TEST (Lite, EnumNameToValue)
 
 TEST (Lite, EnumValueToName)
 
 TEST (Lite, MapCrash)
 
 TEST (Lite, NestedEnumNameToValue)
 
 TEST (Lite, NestedEnumValueToName)
 
 TEST (PreserveUnknownEnumTest, DynamicEnumValueDescriptors)
 
 TEST (PreserveUnknownEnumTest, DynamicProto2HidesUnknownValues)
 
 TEST (PreserveUnknownEnumTest, IntegerEnumReflectionAPI)
 
 TEST (PreserveUnknownEnumTest, PreserveParseAndSerialize)
 
 TEST (PreserveUnknownEnumTest, PreserveParseAndSerializeDynamicMessage)
 
 TEST (PreserveUnknownEnumTest, Proto2CatchesUnknownValues)
 
 TEST (PreserveUnknownEnumTest, Proto2HidesUnknownValues)
 
 TEST (PreserveUnknownEnumTest, SupportsUnknownEnumValuesAPI)
 
 TEST_F (DynamicMessageTest, Arena)
 
 TEST_F (DynamicMessageTest, Defaults)
 
 TEST_F (DynamicMessageTest, Descriptor)
 
 TEST_F (DynamicMessageTest, OnePrototype)
 
 TEST_F (DynamicMessageTest, Proto3)
 
 TEST_P (DualArena, Swap)
 
 TEST_P (DynamicMessageTest, Extensions)
 
 TEST_P (DynamicMessageTest, IndependentOffsets)
 
 TEST_P (DynamicMessageTest, Oneof)
 
 TEST_P (DynamicMessageTest, PackedFields)
 
 TEST_P (DynamicMessageTest, SpaceUsed)
 
 TEST_P (SingleArena, GetSet)
 
 TEST_P (SingleArena, MutableAccessor)
 
 TEST_P (SingleArena, NullDefault)
 
template<typename T , bool use_arena>
void TestParseCorruptedString (const T &message)
 
string TestSourceDir ()
 
void TestSwapRepeatedField (Arena *arena1, Arena *arena2)
 
string TestTempDir ()
 
PROTOBUF_EXPORT string ToHex (uint64 num)
 
static std::string ToLowercaseWithoutUnderscores (const std::string &name)
 
static std::string ToLowercaseWithoutUnderscores (const std::string &name)
 
std::string ToUpper (const std::string &s)
 
string ToUpper (const string &s)
 
void ToUpper (std::string *s)
 
uint64 Uint128High64 (const uint128 &v)
 
uint64 Uint128Low64 (const uint128 &v)
 
int UnescapeCEscapeSequences (const char *source, char *dest)
 
int UnescapeCEscapeSequences (const char *source, char *dest, std::vector< std::string > *errors)
 
int UnescapeCEscapeSequences (const char *source, char *dest, std::vector< string > *errors)
 
std::string UnescapeCEscapeString (const std::string &src)
 
int UnescapeCEscapeString (const std::string &src, std::string *dest)
 
int UnescapeCEscapeString (const std::string &src, std::string *dest, std::vector< std::string > *errors)
 
string UnescapeCEscapeString (const string &src)
 
int UnescapeCEscapeString (const string &src, string *dest)
 
int UnescapeCEscapeString (const string &src, string *dest, std::vector< string > *errors)
 
template<typename T >
internal::UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator< TUnsafeArenaAllocatedRepeatedPtrFieldBackInserter (RepeatedPtrField< T > *const mutable_field)
 
template<class Collection >
bool UpdateReturnCopy (Collection *const collection, const typename Collection::value_type &vt, typename Collection::value_type::second_type *previous)
 
template<class Collection >
bool UpdateReturnCopy (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &value, typename Collection::value_type::second_type *previous)
 
void UpperString (std::string *s)
 
void UpperString (string *s)
 
void UsageError ()
 
int UTF8FirstLetterNumBytes (const char *src, int len)
 
static bool ValidateQualifiedName (const std::string &name)
 
static bool ValidateQualifiedName (StringPiece name)
 
int WebSafeBase64Escape (const unsigned char *src, int szsrc, char *dest, int szdest, bool do_padding)
 
void WebSafeBase64Escape (const unsigned char *src, int szsrc, std::string *dest, bool do_padding)
 
void WebSafeBase64Escape (const unsigned char *src, int szsrc, string *dest, bool do_padding)
 
void WebSafeBase64Escape (StringPiece src, std::string *dest)
 
void WebSafeBase64Escape (StringPiece src, string *dest)
 
void WebSafeBase64EscapeWithPadding (StringPiece src, std::string *dest)
 
void WebSafeBase64EscapeWithPadding (StringPiece src, string *dest)
 
int WebSafeBase64Unescape (const char *src, int szsrc, char *dest, int szdest)
 
bool WebSafeBase64Unescape (StringPiece src, std::string *dest)
 
bool WebSafeBase64Unescape (StringPiece src, string *dest)
 
static std::string WrapString (const char *value)
 
static std::string WrapString (const char *value)
 

Variables

 __path__ = __import__('pkgutil').extend_path(__path__, __name__)
 
string __version__ = '3.9.1'
 
const int DEFAULT_FILE_MODE = 0777
 
const std::string * empty_default = &internal::GetEmptyString()
 
static const LogLevel ERROR = LOGLEVEL_ERROR
 
static const LogLevel ERROR = LOGLEVEL_ERROR
 
const Descriptor::ReservedRange const EnumValueDescriptor const MethodDescriptor extension
 
static const char kBase64Chars []
 
static const char kBase64Chars []
 
static const int kDoubleToBufferSize = 32
 
static const int kDoubleToBufferSize = 32
 
static const int kFastInt32ToBufferOffset = 11
 
static const int kFastInt32ToBufferOffset = 11
 
static const int kFastInt64ToBufferOffset = 21
 
static const int kFastInt64ToBufferOffset = 21
 
static const int kFastToBufferSize = 32
 
static const int kFastToBufferSize = 32
 
static const int kFloatToBufferSize = 24
 
static const int kFloatToBufferSize = 24
 
static const int32 kint32max = 0x7FFFFFFF
 
static const int32 kint32max = 0x7FFFFFFF
 
static const int32 kint32min = -kint32max - 1
 
static const int32 kint32min = -kint32max - 1
 
static const int64 kint64max = int64_t{0x7FFFFFFFFFFFFFFF}
 
static const int64 kint64max = PROTOBUF_LONGLONG(0x7FFFFFFFFFFFFFFF)
 
static const int64 kint64min = -kint64max - 1
 
static const int64 kint64min = -kint64max - 1
 
static const char *const kNonLinkedWeakMessageReplacementName = "google.protobuf.Empty"
 
static const char *const kNonLinkedWeakMessageReplacementName = "google.protobuf.Empty"
 
const int kStringPrintfVectorMaxArgs = 32
 
const uint128_pod kuint128max
 
static const uint32 kuint32max = 0xFFFFFFFFu
 
static const uint32 kuint32max = 0xFFFFFFFFu
 
static const uint64 kuint64max = uint64_t{0xFFFFFFFFFFFFFFFFu}
 
static const uint64 kuint64max = PROTOBUF_ULONGLONG(0xFFFFFFFFFFFFFFFF)
 
static const signed char kUnBase64 []
 
static const signed char kUnBase64 []
 
static constexpr int kUnknownFieldRecursionLimit = 10
 
static const signed char kUnWebSafeBase64 []
 
static const signed char kUnWebSafeBase64 []
 
static const unsigned char kUTF8LenTbl [256]
 
static const unsigned char kUTF8LenTbl [256]
 
static const char kWebSafeBase64Chars []
 
static const char kWebSafeBase64Chars []
 
const Descriptor::ReservedRange const EnumValueDescriptor method
 
const internal::LazyString nonempty_default {{{"default", 7}}, {nullptr}}
 
static int original_stderr_ = -1
 
static int original_stderr_ = -1
 
static int original_stdout_ = -1
 
static int original_stdout_ = -1
 
template class PROTOBUF_EXPORT RepeatedField< bool >
 
template class PROTOBUF_EXPORT RepeatedField< double >
 
template class PROTOBUF_EXPORT RepeatedField< float >
 
template class PROTOBUF_EXPORT RepeatedField< int32 >
 
template class PROTOBUF_EXPORT_TEMPLATE_DEFINE RepeatedField< int32_t >
 
template class PROTOBUF_EXPORT RepeatedField< int64 >
 
template class PROTOBUF_EXPORT_TEMPLATE_DEFINE RepeatedField< int64_t >
 
template class PROTOBUF_EXPORT RepeatedField< uint32 >
 
template class PROTOBUF_EXPORT_TEMPLATE_DEFINE RepeatedField< uint32_t >
 
template class PROTOBUF_EXPORT RepeatedField< uint64 >
 
template class PROTOBUF_EXPORT_TEMPLATE_DEFINE RepeatedField< uint64_t >
 
 reserved_range
 
const Descriptor::ReservedRange const EnumDescriptor::ReservedRange service
 
static std::string stderr_capture_filename_
 
static string stderr_capture_filename_
 
static std::string stdout_capture_filename_
 
static string stdout_capture_filename_
 
static const char string_printf_empty_block [256] = { '\0' }
 
static const char string_printf_empty_block [256] = { '\0' }
 
static const char two_ASCII_digits [100][2]
 
static const char two_ASCII_digits [100][2]
 
static const int UTFmax = 4
 
static const int UTFmax = 4
 
const Descriptor::ReservedRange value
 
static const LogLevel WARNING = LOGLEVEL_WARNING
 
static const LogLevel WARNING = LOGLEVEL_WARNING
 

Typedef Documentation

◆ AccessListener

template<class T >
using google::protobuf::AccessListener = typedef NoOpAccessListener<T>

Definition at line 163 of file field_access_listener.h.

◆ ConstStringParam

using google::protobuf::ConstStringParam = typedef const std::string &

◆ EmptyDefault

◆ int16

◆ int32

◆ int64

◆ int8

◆ LogHandler

typedef void google::protobuf::LogHandler(LogLevel level, const char *filename, int line, const std::string &message)

◆ stringpiece_ssize_type

typedef string::difference_type google::protobuf::stringpiece_ssize_type

◆ uint

typedef unsigned int google::protobuf::uint

◆ uint16

◆ uint32

◆ uint64

◆ uint8

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
IS_COMPILER_MSVC 

Definition at line 54 of file bloaty/third_party/protobuf/src/google/protobuf/stubs/stringprintf.cc.

◆ LogLevel [1/2]

Enumerator
LOGLEVEL_INFO 
LOGLEVEL_WARNING 
LOGLEVEL_ERROR 
LOGLEVEL_FATAL 
LOGLEVEL_DFATAL 
LOGLEVEL_INFO 
LOGLEVEL_WARNING 
LOGLEVEL_ERROR 
LOGLEVEL_FATAL 
LOGLEVEL_DFATAL 

Definition at line 45 of file bloaty/third_party/protobuf/src/google/protobuf/stubs/logging.h.

◆ LogLevel [2/2]

Enumerator
LOGLEVEL_INFO 
LOGLEVEL_WARNING 
LOGLEVEL_ERROR 
LOGLEVEL_FATAL 
LOGLEVEL_DFATAL 
LOGLEVEL_INFO 
LOGLEVEL_WARNING 
LOGLEVEL_ERROR 
LOGLEVEL_FATAL 
LOGLEVEL_DFATAL 

Definition at line 47 of file protobuf/src/google/protobuf/stubs/logging.h.

Function Documentation

◆ AddTokenCounts()

template<typename Sequence , typename Collection >
void google::protobuf::AddTokenCounts ( const Sequence &  sequence,
const typename Collection::value_type::second_type &  increment,
Collection *const  count_map 
)

◆ Align8()

uint64_t google::protobuf::Align8 ( uint64  n)

◆ alignas()

class PROTOBUF_EXPORT google::protobuf::alignas ( )
final

◆ AllocatedRepeatedPtrFieldBackInserter()

template<typename T >
internal::AllocatedRepeatedPtrFieldBackInsertIterator< T > google::protobuf::AllocatedRepeatedPtrFieldBackInserter ( RepeatedPtrField< T > *const  mutable_field)

◆ Append1() [1/2]

static char* google::protobuf::Append1 ( char *  out,
const AlphaNum x 
)
static

◆ Append1() [2/2]

static char* google::protobuf::Append1 ( char *  out,
const AlphaNum x 
)
static

◆ Append2() [1/2]

static char* google::protobuf::Append2 ( char *  out,
const AlphaNum x1,
const AlphaNum x2 
)
static

◆ Append2() [2/2]

static char* google::protobuf::Append2 ( char *  out,
const AlphaNum x1,
const AlphaNum x2 
)
static

◆ Append4() [1/2]

static char* google::protobuf::Append4 ( char *  out,
const AlphaNum x1,
const AlphaNum x2,
const AlphaNum x3,
const AlphaNum x4 
)
static

◆ Append4() [2/2]

static char* google::protobuf::Append4 ( char *  out,
const AlphaNum x1,
const AlphaNum x2,
const AlphaNum x3,
const AlphaNum x4 
)
static

◆ AppendKeysFromMap() [1/2]

template<class MapContainer , class KeyContainer >
void google::protobuf::AppendKeysFromMap ( const MapContainer &  map_container,
KeyContainer *  key_container 
)

◆ AppendKeysFromMap() [2/2]

template<class MapContainer , class KeyType >
void google::protobuf::AppendKeysFromMap ( const MapContainer &  map_container,
std::vector< KeyType > *  key_container 
)

◆ AppendValuesFromMap() [1/2]

template<class MapContainer , class ValueType >
void google::protobuf::AppendValuesFromMap ( const MapContainer &  map_container,
std::vector< ValueType > *  value_container 
)

◆ AppendValuesFromMap() [2/2]

template<class MapContainer , class ValueContainer >
void google::protobuf::AppendValuesFromMap ( const MapContainer &  map_container,
ValueContainer *  value_container 
)

◆ ascii_isalnum()

bool google::protobuf::ascii_isalnum ( char  c)
inline

◆ ascii_isdigit()

bool google::protobuf::ascii_isdigit ( char  c)
inline

◆ ascii_islower()

bool google::protobuf::ascii_islower ( char  c)
inline

◆ ascii_isspace()

bool google::protobuf::ascii_isspace ( char  c)
inline

◆ ascii_isupper()

bool google::protobuf::ascii_isupper ( char  c)
inline

◆ ascii_tolower()

char google::protobuf::ascii_tolower ( char  c)
inline

◆ ascii_toupper()

char google::protobuf::ascii_toupper ( char  c)
inline

◆ AssignParsingMergeMessages()

void google::protobuf::AssignParsingMergeMessages ( unittest::TestAllTypesLite *  msg1,
unittest::TestAllTypesLite *  msg2,
unittest::TestAllTypesLite *  msg3 
)

◆ Base64Escape() [1/5]

PROTOBUF_EXPORT int google::protobuf::Base64Escape ( const unsigned char *  src,
int  szsrc,
char *  dest,
int  szdest 
)

◆ Base64Escape() [2/5]

PROTOBUF_EXPORT void google::protobuf::Base64Escape ( const unsigned char *  src,
int  szsrc,
std::string *  dest,
bool  do_padding 
)

◆ Base64Escape() [3/5]

PROTOBUF_EXPORT void google::protobuf::Base64Escape ( const unsigned char *  src,
int  szsrc,
string *  dest,
bool  do_padding 
)

◆ Base64Escape() [4/5]

PROTOBUF_EXPORT void google::protobuf::Base64Escape ( StringPiece  src,
std::string *  dest 
)

◆ Base64Escape() [5/5]

PROTOBUF_EXPORT void google::protobuf::Base64Escape ( StringPiece  src,
string *  dest 
)

◆ Base64EscapeInternal() [1/3]

int google::protobuf::Base64EscapeInternal ( const unsigned char *  src,
int  szsrc,
char *  dest,
int  szdest,
const char *  base64,
bool  do_padding 
)

◆ Base64EscapeInternal() [2/3]

void google::protobuf::Base64EscapeInternal ( const unsigned char *  src,
int  szsrc,
std::string *  dest,
bool  do_padding,
const char *  base64_chars 
)

◆ Base64EscapeInternal() [3/3]

void google::protobuf::Base64EscapeInternal ( const unsigned char *  src,
int  szsrc,
string *  dest,
bool  do_padding,
const char *  base64_chars 
)

◆ Base64Unescape() [1/2]

PROTOBUF_EXPORT bool google::protobuf::Base64Unescape ( StringPiece  src,
std::string *  dest 
)

◆ Base64Unescape() [2/2]

PROTOBUF_EXPORT bool google::protobuf::Base64Unescape ( StringPiece  src,
string *  dest 
)

◆ Base64UnescapeInternal() [1/3]

static bool google::protobuf::Base64UnescapeInternal ( const char *  src,
int  slen,
std::string *  dest,
const signed char *  unbase64 
)
static

◆ Base64UnescapeInternal() [2/3]

static bool google::protobuf::Base64UnescapeInternal ( const char *  src,
int  slen,
string *  dest,
const signed char *  unbase64 
)
static

◆ Base64UnescapeInternal() [3/3]

int google::protobuf::Base64UnescapeInternal ( const char *  src_param,
int  szsrc,
char *  dest,
int  szdest,
const signed char *  unbase64 
)

◆ bswap_16() [1/2]

static uint16 google::protobuf::bswap_16 ( uint16  x)
inlinestatic

◆ bswap_16() [2/2]

static uint16 google::protobuf::bswap_16 ( uint16  x)
inlinestatic

◆ bswap_32() [1/2]

static uint32 google::protobuf::bswap_32 ( uint32  x)
inlinestatic

◆ bswap_32() [2/2]

static uint32 google::protobuf::bswap_32 ( uint32  x)
inlinestatic

◆ bswap_64() [1/2]

static uint64 google::protobuf::bswap_64 ( uint64  x)
inlinestatic

◆ bswap_64() [2/2]

static uint64 google::protobuf::bswap_64 ( uint64  x)
inlinestatic

◆ BuildLookupTable()

static void google::protobuf::BuildLookupTable ( StringPiece  characters_wanted,
bool table 
)
inlinestatic

◆ CalculateBase64EscapedLen() [1/2]

PROTOBUF_EXPORT int google::protobuf::CalculateBase64EscapedLen ( int  input_len)

◆ CalculateBase64EscapedLen() [2/2]

PROTOBUF_EXPORT int google::protobuf::CalculateBase64EscapedLen ( int  input_len,
bool  do_padding 
)

◆ CaptureTestStderr()

void google::protobuf::CaptureTestStderr ( )

◆ CaptureTestStdout()

void google::protobuf::CaptureTestStdout ( )

◆ CaseEqual()

bool google::protobuf::CaseEqual ( StringPiece  s1,
StringPiece  s2 
)
inline

◆ CEscape() [1/2]

PROTOBUF_EXPORT std::string google::protobuf::CEscape ( const std::string &  src)

◆ CEscape() [2/2]

PROTOBUF_EXPORT string google::protobuf::CEscape ( const string &  src)

◆ CEscapeAndAppend() [1/2]

PROTOBUF_EXPORT void google::protobuf::CEscapeAndAppend ( StringPiece  src,
std::string *  dest 
)

◆ CEscapeAndAppend() [2/2]

PROTOBUF_EXPORT void google::protobuf::CEscapeAndAppend ( StringPiece  src,
string *  dest 
)

◆ CEscapedLength() [1/2]

static size_t google::protobuf::CEscapedLength ( StringPiece  src)
inlinestatic

◆ CEscapedLength() [2/2]

static size_t google::protobuf::CEscapedLength ( StringPiece  src)
inlinestatic

◆ CEscapeInternal()

int google::protobuf::CEscapeInternal ( const char *  src,
int  src_len,
char *  dest,
int  dest_len,
bool  use_hex,
bool  utf8_safe 
)

◆ CheckedRead()

bool google::protobuf::CheckedRead ( int  fd,
void *  buf,
size_t  len 
)

Definition at line 80 of file protobuf/conformance/conformance_cpp.cc.

◆ CheckedWrite()

void google::protobuf::CheckedWrite ( int  fd,
const void *  buf,
size_t  len 
)

Definition at line 98 of file protobuf/conformance/conformance_cpp.cc.

◆ CheckFieldIndex()

void google::protobuf::CheckFieldIndex ( const FieldDescriptor field,
int  index 
)

◆ CheckForMutualSubsymbols()

template<typename Iter , typename Iter2 , typename Index >
static bool google::protobuf::CheckForMutualSubsymbols ( StringPiece  symbol_name,
Iter *  iter,
Iter2  end,
const Index &  index 
)
static

◆ CleanStringLineEndings() [1/4]

PROTOBUF_EXPORT void google::protobuf::CleanStringLineEndings ( const std::string &  src,
std::string *  dst,
bool  auto_end_last_line 
)

◆ CleanStringLineEndings() [2/4]

PROTOBUF_EXPORT void google::protobuf::CleanStringLineEndings ( const string &  src,
string *  dst,
bool  auto_end_last_line 
)

◆ CleanStringLineEndings() [3/4]

PROTOBUF_EXPORT void google::protobuf::CleanStringLineEndings ( std::string *  str,
bool  auto_end_last_line 
)

◆ CleanStringLineEndings() [4/4]

PROTOBUF_EXPORT void google::protobuf::CleanStringLineEndings ( string *  str,
bool  auto_end_last_line 
)

◆ ContainsKey()

template<class Collection , class Key >
bool google::protobuf::ContainsKey ( const Collection &  collection,
const Key &  key 
)

◆ ContainsKeyValuePair()

template<class Collection , class Key , class Value >
bool google::protobuf::ContainsKeyValuePair ( const Collection &  collection,
const Key &  key,
const Value value 
)

◆ DEF_FP_LIMITS()

google::protobuf::DEF_FP_LIMITS ( long double  ,
LDBL   
)

◆ DelocalizeRadix()

void google::protobuf::DelocalizeRadix ( char *  buffer)

◆ DoNothing()

void google::protobuf::DoNothing ( )

◆ DoTest()

void google::protobuf::DoTest ( const ConformanceRequest &  request,
ConformanceResponse *  response 
)

Definition at line 104 of file protobuf/conformance/conformance_cpp.cc.

◆ DoTestIo()

bool google::protobuf::DoTestIo ( )

Definition at line 212 of file protobuf/conformance/conformance_cpp.cc.

◆ DoubleToBuffer()

PROTOBUF_EXPORT char * google::protobuf::DoubleToBuffer ( double  value,
char *  buffer 
)

◆ DynamicCastToGenerated() [1/2]

template<typename T >
const T * google::protobuf::DynamicCastToGenerated ( const Message from)

◆ DynamicCastToGenerated() [2/2]

template<typename T >
T * google::protobuf::DynamicCastToGenerated ( Message from)

◆ EncodeAsUTF8Char()

PROTOBUF_EXPORT int google::protobuf::EncodeAsUTF8Char ( uint32  code_point,
char *  output 
)

◆ EraseKeyReturnValuePtr()

template<class Collection >
Collection::value_type::second_type google::protobuf::EraseKeyReturnValuePtr ( Collection *const  collection,
const typename Collection::value_type::first_type &  key 
)

◆ ExistingFileMatchesProto() [1/2]

static bool google::protobuf::ExistingFileMatchesProto ( const FileDescriptor existing_file,
const FileDescriptorProto proto 
)
static

◆ ExistingFileMatchesProto() [2/2]

static bool google::protobuf::ExistingFileMatchesProto ( const FileDescriptor existing_file,
const FileDescriptorProto proto 
)
static

Definition at line 4836 of file protobuf/src/google/protobuf/descriptor.cc.

◆ ExpectMessageMerged()

void google::protobuf::ExpectMessageMerged ( const unittest::TestAllTypesLite &  message)

◆ FastHex32ToBuffer()

PROTOBUF_EXPORT char * google::protobuf::FastHex32ToBuffer ( uint32  value,
char *  buffer 
)

◆ FastHex64ToBuffer()

PROTOBUF_EXPORT char * google::protobuf::FastHex64ToBuffer ( uint64  value,
char *  buffer 
)

◆ FastHexToBuffer()

PROTOBUF_EXPORT char * google::protobuf::FastHexToBuffer ( int  i,
char *  buffer 
)

◆ FastInt32ToBuffer()

PROTOBUF_EXPORT char * google::protobuf::FastInt32ToBuffer ( int32  i,
char *  buffer 
)

◆ FastInt32ToBufferLeft()

PROTOBUF_EXPORT char * google::protobuf::FastInt32ToBufferLeft ( int32  i,
char *  buffer 
)

◆ FastInt64ToBuffer()

PROTOBUF_EXPORT char * google::protobuf::FastInt64ToBuffer ( int64  i,
char *  buffer 
)

◆ FastInt64ToBufferLeft()

PROTOBUF_EXPORT char * google::protobuf::FastInt64ToBufferLeft ( int64  i,
char *  buffer 
)

◆ FastIntToBuffer()

char * google::protobuf::FastIntToBuffer ( int  i,
char *  buffer 
)
inline

◆ FastLongToBuffer()

char * google::protobuf::FastLongToBuffer ( long  i,
char *  buffer 
)
inline

◆ FastUInt32ToBuffer()

char * google::protobuf::FastUInt32ToBuffer ( uint32  i,
char *  buffer 
)
inline

◆ FastUInt32ToBufferLeft()

PROTOBUF_EXPORT char * google::protobuf::FastUInt32ToBufferLeft ( uint32  u,
char *  buffer 
)

◆ FastUInt64ToBuffer()

char * google::protobuf::FastUInt64ToBuffer ( uint64  i,
char *  buffer 
)
inline

◆ FastUInt64ToBufferLeft()

PROTOBUF_EXPORT char * google::protobuf::FastUInt64ToBufferLeft ( uint64  u64,
char *  buffer 
)

◆ FastUIntToBuffer()

char * google::protobuf::FastUIntToBuffer ( unsigned int  i,
char *  buffer 
)
inline

◆ FastULongToBuffer()

char * google::protobuf::FastULongToBuffer ( unsigned long  i,
char *  buffer 
)
inline

◆ FillArenaAwareFields()

void google::protobuf::FillArenaAwareFields ( TestAllTypes *  message)

◆ FindCopy()

template<class Collection , class Key , class Value >
bool google::protobuf::FindCopy ( const Collection &  collection,
const Key &  key,
Value *const  value 
)

◆ FindLinkedPtrOrDie()

template<class Collection >
Collection::value_type::second_type::element_type & google::protobuf::FindLinkedPtrOrDie ( const Collection &  collection,
const typename Collection::value_type::first_type &  key 
)

◆ FindLinkedPtrOrNull()

template<class Collection >
Collection::value_type::second_type::element_type * google::protobuf::FindLinkedPtrOrNull ( const Collection &  collection,
const typename Collection::value_type::first_type &  key 
)

◆ FindOrDie() [1/2]

template<class Collection >
Collection::value_type::second_type & google::protobuf::FindOrDie ( Collection &  collection,
const typename Collection::value_type::first_type &  key 
)

◆ FindOrDie() [2/2]

template<class Collection >
const Collection::value_type::second_type & google::protobuf::FindOrDie ( const Collection &  collection,
const typename Collection::value_type::first_type &  key 
)

◆ FindOrDieNoPrint() [1/2]

template<class Collection >
Collection::value_type::second_type & google::protobuf::FindOrDieNoPrint ( Collection &  collection,
const typename Collection::value_type::first_type &  key 
)

◆ FindOrDieNoPrint() [2/2]

template<class Collection >
const Collection::value_type::second_type & google::protobuf::FindOrDieNoPrint ( const Collection &  collection,
const typename Collection::value_type::first_type &  key 
)

◆ FindOrNull() [1/2]

template<class Collection >
Collection::value_type::second_type * google::protobuf::FindOrNull ( Collection &  collection,
const typename Collection::value_type::first_type &  key 
)

◆ FindOrNull() [2/2]

template<class Collection >
const Collection::value_type::second_type * google::protobuf::FindOrNull ( const Collection &  collection,
const typename Collection::value_type::first_type &  key 
)

◆ FindPtrOrNull() [1/2]

template<class Collection >
Collection::value_type::second_type google::protobuf::FindPtrOrNull ( Collection &  collection,
const typename Collection::value_type::first_type &  key 
)

◆ FindPtrOrNull() [2/2]

template<class Collection >
Collection::value_type::second_type google::protobuf::FindPtrOrNull ( const Collection &  collection,
const typename Collection::value_type::first_type &  key 
)

◆ FindWithDefault()

template<class Collection >
const Collection::value_type::second_type & google::protobuf::FindWithDefault ( const Collection &  collection,
const typename Collection::value_type::first_type &  key,
const typename Collection::value_type::second_type &  value 
)

◆ FloatToBuffer()

PROTOBUF_EXPORT char * google::protobuf::FloatToBuffer ( float  value,
char *  buffer 
)

◆ Fls128() [1/2]

static int google::protobuf::Fls128 ( uint128  n)
inlinestatic

Definition at line 74 of file protobuf/src/google/protobuf/stubs/int128.cc.

◆ Fls128() [2/2]

static int google::protobuf::Fls128 ( uint128  n)
inlinestatic

◆ Fls64() [1/2]

static int google::protobuf::Fls64 ( uint64  n)
inlinestatic

Definition at line 60 of file protobuf/src/google/protobuf/stubs/int128.cc.

◆ Fls64() [2/2]

static int google::protobuf::Fls64 ( uint64  n)
inlinestatic

◆ GetCapturedTestStderr()

std::string google::protobuf::GetCapturedTestStderr ( )

◆ GetCapturedTestStdout()

std::string google::protobuf::GetCapturedTestStdout ( )

◆ GetEnumDescriptor()

template<typename E >
const EnumDescriptor * google::protobuf::GetEnumDescriptor ( )

◆ GetGroup()

Message* google::protobuf::GetGroup ( int  field_number,
const FieldDescriptor field,
Message msg,
const Reflection reflection 
)

◆ ghtonl()

PROTOBUF_EXPORT uint32 google::protobuf::ghtonl ( uint32  x)

◆ GlobalReplaceSubstring() [1/2]

PROTOBUF_EXPORT int google::protobuf::GlobalReplaceSubstring ( const std::string &  substring,
const std::string &  replacement,
std::string *  s 
)

◆ GlobalReplaceSubstring() [2/2]

PROTOBUF_EXPORT int google::protobuf::GlobalReplaceSubstring ( const string &  substring,
const string &  replacement,
string *  s 
)

◆ GOOGLE_UNALIGNED_LOAD16()

uint16 google::protobuf::GOOGLE_UNALIGNED_LOAD16 ( const void *  p)
inline

◆ GOOGLE_UNALIGNED_LOAD32()

uint32 google::protobuf::GOOGLE_UNALIGNED_LOAD32 ( const void *  p)
inline

◆ GOOGLE_UNALIGNED_LOAD64()

uint64 google::protobuf::GOOGLE_UNALIGNED_LOAD64 ( const void *  p)
inline

◆ GOOGLE_UNALIGNED_STORE16()

void google::protobuf::GOOGLE_UNALIGNED_STORE16 ( void *  p,
uint16  v 
)
inline

◆ GOOGLE_UNALIGNED_STORE32()

void google::protobuf::GOOGLE_UNALIGNED_STORE32 ( void *  p,
uint32  v 
)
inline

◆ GOOGLE_UNALIGNED_STORE64()

void google::protobuf::GOOGLE_UNALIGNED_STORE64 ( void *  p,
uint64  v 
)
inline

◆ HANDLE_TYPE() [1/7]

google::protobuf::HANDLE_TYPE ( bool  ,
FieldDescriptor::CPPTYPE_BOOL  ,
1 
)

◆ HANDLE_TYPE() [2/7]

google::protobuf::HANDLE_TYPE ( double  ,
FieldDescriptor::CPPTYPE_DOUBLE  ,
1 
)

◆ HANDLE_TYPE() [3/7]

google::protobuf::HANDLE_TYPE ( float  ,
FieldDescriptor::CPPTYPE_FLOAT  ,
1 
)

◆ HANDLE_TYPE() [4/7]

google::protobuf::HANDLE_TYPE ( int32  ,
FieldDescriptor::CPPTYPE_INT32  ,
1 
)

◆ HANDLE_TYPE() [5/7]

google::protobuf::HANDLE_TYPE ( int64  ,
FieldDescriptor::CPPTYPE_INT64  ,
1 
)

◆ HANDLE_TYPE() [6/7]

google::protobuf::HANDLE_TYPE ( uint32  ,
FieldDescriptor::CPPTYPE_UINT32  ,
1 
)

◆ HANDLE_TYPE() [7/7]

google::protobuf::HANDLE_TYPE ( uint64  ,
FieldDescriptor::CPPTYPE_UINT64  ,
1 
)

◆ HasPrefixString() [1/2]

bool google::protobuf::HasPrefixString ( const string &  str,
const string &  prefix 
)
inline

◆ HasPrefixString() [2/2]

bool google::protobuf::HasPrefixString ( StringPiece  str,
StringPiece  prefix 
)
inline

◆ HasSuffixString() [1/2]

bool google::protobuf::HasSuffixString ( const string &  str,
const string &  suffix 
)
inline

◆ HasSuffixString() [2/2]

bool google::protobuf::HasSuffixString ( StringPiece  str,
StringPiece  suffix 
)
inline

◆ hex_digit_to_int()

int google::protobuf::hex_digit_to_int ( char  c)
inline

◆ InsertAndDeleteExisting()

template<class Collection >
bool google::protobuf::InsertAndDeleteExisting ( Collection *const  collection,
const typename Collection::value_type::first_type &  key,
const typename Collection::value_type::second_type &  value 
)

◆ InsertIfNotPresent() [1/2]

template<class Collection >
bool google::protobuf::InsertIfNotPresent ( Collection *const  collection,
const typename Collection::value_type vt 
)

◆ InsertIfNotPresent() [2/2]

template<class Collection >
bool google::protobuf::InsertIfNotPresent ( Collection *const  collection,
const typename Collection::value_type::first_type &  key,
const typename Collection::value_type::second_type &  value 
)

◆ InsertKeyOrDie()

template<class Collection >
Collection::value_type::second_type & google::protobuf::InsertKeyOrDie ( Collection *const  collection,
const typename Collection::value_type::first_type &  key 
)

◆ InsertKeysFromMap()

template<class MapContainer , class KeyContainer >
void google::protobuf::InsertKeysFromMap ( const MapContainer &  map_container,
KeyContainer *  key_container 
)

◆ InsertOrDie() [1/2]

template<class Collection >
void google::protobuf::InsertOrDie ( Collection *const  collection,
const typename Collection::value_type value 
)

◆ InsertOrDie() [2/2]

template<class Collection >
void google::protobuf::InsertOrDie ( Collection *const  collection,
const typename Collection::value_type::first_type &  key,
const typename Collection::value_type::second_type &  data 
)

◆ InsertOrDieNoPrint() [1/2]

template<class Collection >
void google::protobuf::InsertOrDieNoPrint ( Collection *const  collection,
const typename Collection::value_type value 
)

◆ InsertOrDieNoPrint() [2/2]

template<class Collection >
void google::protobuf::InsertOrDieNoPrint ( Collection *const  collection,
const typename Collection::value_type::first_type &  key,
const typename Collection::value_type::second_type &  data 
)

◆ InsertOrReturnExisting() [1/2]

template<class Collection >
Collection::value_type::second_type * google::protobuf::InsertOrReturnExisting ( Collection *const  collection,
const typename Collection::value_type vt 
)

◆ InsertOrReturnExisting() [2/2]

template<class Collection >
Collection::value_type::second_type * google::protobuf::InsertOrReturnExisting ( Collection *const  collection,
const typename Collection::value_type::first_type &  key,
const typename Collection::value_type::second_type &  data 
)

◆ InsertOrUpdate() [1/2]

template<class Collection >
bool google::protobuf::InsertOrUpdate ( Collection *const  collection,
const typename Collection::value_type vt 
)

◆ InsertOrUpdate() [2/2]

template<class Collection >
bool google::protobuf::InsertOrUpdate ( Collection *const  collection,
const typename Collection::value_type::first_type &  key,
const typename Collection::value_type::second_type &  value 
)

◆ InsertOrUpdateMany()

template<class Collection , class InputIterator >
void google::protobuf::InsertOrUpdateMany ( Collection *const  collection,
InputIterator  first,
InputIterator  last 
)

◆ INSTANTIATE_TEST_SUITE_P() [1/3]

google::protobuf::INSTANTIATE_TEST_SUITE_P ( ArenaString  ,
DualArena  ,
testing::Combine(testing::Bool(), testing::Bool())   
)

◆ INSTANTIATE_TEST_SUITE_P() [2/3]

google::protobuf::INSTANTIATE_TEST_SUITE_P ( ArenaString  ,
SingleArena  ,
testing::Bool()   
)

◆ INSTANTIATE_TEST_SUITE_P() [3/3]

google::protobuf::INSTANTIATE_TEST_SUITE_P ( UseArena  ,
DynamicMessageTest  ,
::testing::Bool()   
)

◆ InternalFastHexToBuffer()

char * google::protobuf::InternalFastHexToBuffer ( uint64  value,
char *  buffer,
int  num_byte 
)

◆ IsLite() [1/2]

static bool google::protobuf::IsLite ( const FileDescriptor file)
static

◆ IsLite() [2/2]

static bool google::protobuf::IsLite ( const FileDescriptor file)
static

Definition at line 6480 of file protobuf/src/google/protobuf/descriptor.cc.

◆ isprint()

bool google::protobuf::isprint ( char  c)
inline

◆ IsValidCodePoint()

bool google::protobuf::IsValidCodePoint ( uint32  code_point)
inline

◆ IsValidFloatChar() [1/2]

static bool google::protobuf::IsValidFloatChar ( char  c)
inlinestatic

◆ IsValidFloatChar() [2/2]

static bool google::protobuf::IsValidFloatChar ( char  c)
inlinestatic

◆ isxdigit()

bool google::protobuf::isxdigit ( char  c)
inline

◆ Join() [1/4]

template<typename Range >
string google::protobuf::Join ( const Range components,
const char *  delim 
)

◆ Join() [2/4]

template<typename Range >
std::string google::protobuf::Join ( const Range components,
const char *  delim 
)

◆ Join() [3/4]

template<typename Iterator >
void google::protobuf::Join ( Iterator  start,
Iterator  end,
const char *  delim,
std::string *  result 
)

◆ Join() [4/4]

template<typename Iterator >
void google::protobuf::Join ( Iterator  start,
Iterator  end,
const char *  delim,
string *  result 
)

◆ JoinStrings() [1/4]

std::string google::protobuf::JoinStrings ( const std::vector< std::string > &  components,
const char *  delim 
)
inline

◆ JoinStrings() [2/4]

PROTOBUF_EXPORT void google::protobuf::JoinStrings ( const std::vector< std::string > &  components,
const char *  delim,
std::string *  result 
)

◆ JoinStrings() [3/4]

string google::protobuf::JoinStrings ( const std::vector< string > &  components,
const char *  delim 
)
inline

◆ JoinStrings() [4/4]

PROTOBUF_EXPORT void google::protobuf::JoinStrings ( const std::vector< string > &  components,
const char *  delim,
string *  result 
)

◆ JoinStringsIterator() [1/2]

template<class ITERATOR >
static void google::protobuf::JoinStringsIterator ( const ITERATOR &  start,
const ITERATOR &  end,
const char *  delim,
std::string *  result 
)
static

◆ JoinStringsIterator() [2/2]

template<class ITERATOR >
static void google::protobuf::JoinStringsIterator ( const ITERATOR &  start,
const ITERATOR &  end,
const char *  delim,
string *  result 
)
static

◆ LinkExtensionReflection()

template<typename ExtendeeType , typename TypeTraitsType , internal::FieldType field_type, bool is_packed>
void google::protobuf::LinkExtensionReflection ( const google::protobuf::internal::ExtensionIdentifier< ExtendeeType, TypeTraitsType, field_type, is_packed > &  extension)

◆ LinkMessageReflection()

template<typename T >
void google::protobuf::LinkMessageReflection ( )

◆ LookupOrInsert() [1/2]

template<class Collection >
Collection::value_type::second_type & google::protobuf::LookupOrInsert ( Collection *const  collection,
const typename Collection::value_type vt 
)

◆ LookupOrInsert() [2/2]

template<class Collection >
Collection::value_type::second_type & google::protobuf::LookupOrInsert ( Collection *const  collection,
const typename Collection::value_type::first_type &  key,
const typename Collection::value_type::second_type &  value 
)

◆ LookupOrInsertNew() [1/2]

template<class Collection >
Collection::value_type::second_type & google::protobuf::LookupOrInsertNew ( Collection *const  collection,
const typename Collection::value_type::first_type &  key 
)

◆ LookupOrInsertNew() [2/2]

template<class Collection , class Arg >
Collection::value_type::second_type & google::protobuf::LookupOrInsertNew ( Collection *const  collection,
const typename Collection::value_type::first_type &  key,
const Arg arg 
)

◆ LookupOrInsertNewLinkedPtr() [1/2]

template<class Collection >
Collection::value_type::second_type::element_type * google::protobuf::LookupOrInsertNewLinkedPtr ( Collection *const  collection,
const typename Collection::value_type::first_type &  key 
)

◆ LookupOrInsertNewLinkedPtr() [2/2]

template<class Collection , class Arg >
Collection::value_type::second_type::element_type * google::protobuf::LookupOrInsertNewLinkedPtr ( Collection *const  collection,
const typename Collection::value_type::first_type &  key,
const Arg arg 
)

◆ LookupOrInsertNewSharedPtr() [1/2]

template<class Collection >
Collection::value_type::second_type & google::protobuf::LookupOrInsertNewSharedPtr ( Collection *const  collection,
const typename Collection::value_type::first_type &  key 
)

◆ LookupOrInsertNewSharedPtr() [2/2]

template<class Collection , class Arg >
Collection::value_type::second_type & google::protobuf::LookupOrInsertNewSharedPtr ( Collection *const  collection,
const typename Collection::value_type::first_type &  key,
const Arg arg 
)

◆ LowerString() [1/2]

void google::protobuf::LowerString ( std::string *  s)
inline

◆ LowerString() [2/2]

void google::protobuf::LowerString ( string *  s)
inline

◆ memcasecmp() [1/2]

static int google::protobuf::memcasecmp ( const char *  s1,
const char *  s2,
size_t  len 
)
static

◆ memcasecmp() [2/2]

static int google::protobuf::memcasecmp ( const char *  s1,
const char *  s2,
size_t  len 
)
static

◆ MergeIntoFlat()

template<typename T , typename Less >
static void google::protobuf::MergeIntoFlat ( std::set< T, Less > *  s,
std::vector< T > *  flat 
)
static

◆ NewCallback() [1/10]

template<typename Class >
Closure * google::protobuf::NewCallback ( Class *  object,
void(Class::*)()  method 
)
inline

◆ NewCallback() [2/10]

template<typename Class , typename Arg1 >
Closure * google::protobuf::NewCallback ( Class *  object,
void(Class::*)(Arg1)  method,
Arg1  arg1 
)
inline

◆ NewCallback() [3/10]

template<typename Class , typename Arg1 , typename Arg2 >
Closure * google::protobuf::NewCallback ( Class *  object,
void(Class::*)(Arg1, Arg2)  method,
Arg1  arg1,
Arg2  arg2 
)
inline

◆ NewCallback() [4/10]

template<typename R >
ResultCallback< R > * google::protobuf::NewCallback ( R(*)()  function)
inline

◆ NewCallback() [5/10]

template<typename R , typename A1 >
ResultCallback1< R, A1 > * google::protobuf::NewCallback ( R(*)(A1)  function)
inline

◆ NewCallback() [6/10]

template<typename R , typename P1 >
ResultCallback< R > * google::protobuf::NewCallback ( R(*)(P1)  function,
P1  p1 
)
inline

◆ NewCallback() [7/10]

template<typename R , typename P1 , typename A1 >
ResultCallback1< R, A1 > * google::protobuf::NewCallback ( R(*)(P1, A1)  function,
P1  p1 
)
inline

◆ NewCallback() [8/10]

Closure * google::protobuf::NewCallback ( void(*)()  function)
inline

◆ NewCallback() [9/10]

template<typename Arg1 >
Closure * google::protobuf::NewCallback ( void(*)(Arg1)  function,
Arg1  arg1 
)
inline

◆ NewCallback() [10/10]

template<typename Arg1 , typename Arg2 >
Closure * google::protobuf::NewCallback ( void(*)(Arg1, Arg2)  function,
Arg1  arg1,
Arg2  arg2 
)
inline

◆ NewPermanentCallback() [1/12]

template<typename Class >
Closure * google::protobuf::NewPermanentCallback ( Class *  object,
void(Class::*)()  method 
)
inline

◆ NewPermanentCallback() [2/12]

template<typename Class , typename Arg1 >
Closure * google::protobuf::NewPermanentCallback ( Class *  object,
void(Class::*)(Arg1)  method,
Arg1  arg1 
)
inline

◆ NewPermanentCallback() [3/12]

template<typename Class , typename Arg1 , typename Arg2 >
Closure * google::protobuf::NewPermanentCallback ( Class *  object,
void(Class::*)(Arg1, Arg2)  method,
Arg1  arg1,
Arg2  arg2 
)
inline

◆ NewPermanentCallback() [4/12]

template<typename R >
ResultCallback< R > * google::protobuf::NewPermanentCallback ( R(*)()  function)
inline

◆ NewPermanentCallback() [5/12]

template<typename R , typename A1 >
ResultCallback1< R, A1 > * google::protobuf::NewPermanentCallback ( R(*)(A1)  function)
inline

◆ NewPermanentCallback() [6/12]

template<typename R , typename P1 >
ResultCallback< R > * google::protobuf::NewPermanentCallback ( R(*)(P1)  function,
P1  p1 
)
inline

◆ NewPermanentCallback() [7/12]

template<typename R , typename P1 , typename A1 >
ResultCallback1< R, A1 > * google::protobuf::NewPermanentCallback ( R(*)(P1, A1)  function,
P1  p1 
)
inline

◆ NewPermanentCallback() [8/12]

template<typename R , typename T , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename A1 , typename A2 >
ResultCallback2< R, A1, A2 > * google::protobuf::NewPermanentCallback ( T object,
R(T::*)(P1, P2, P3, P4, P5, P6, A1, A2)  function,
typename internal::InternalConstRef< P1 >::type  p1,
typename internal::InternalConstRef< P2 >::type  p2,
typename internal::InternalConstRef< P3 >::type  p3,
typename internal::InternalConstRef< P4 >::type  p4,
typename internal::InternalConstRef< P5 >::type  p5,
typename internal::InternalConstRef< P6 >::type  p6 
)
inline

◆ NewPermanentCallback() [9/12]

template<typename R , typename T1 , typename T2 >
ResultCallback< R > * google::protobuf::NewPermanentCallback ( T1 *  object,
R(T2::*)()  function 
)
inline

◆ NewPermanentCallback() [10/12]

Closure * google::protobuf::NewPermanentCallback ( void(*)()  function)
inline

◆ NewPermanentCallback() [11/12]

template<typename Arg1 >
Closure * google::protobuf::NewPermanentCallback ( void(*)(Arg1)  function,
Arg1  arg1 
)
inline

◆ NewPermanentCallback() [12/12]

template<typename Arg1 , typename Arg2 >
Closure * google::protobuf::NewPermanentCallback ( void(*)(Arg1, Arg2)  function,
Arg1  arg1,
Arg2  arg2 
)
inline

◆ operator!()

bool google::protobuf::operator! ( const uint128 val)
inline

◆ operator!=() [1/4]

◆ operator!=() [2/4]

◆ operator!=() [3/4]

bool google::protobuf::operator!= ( const uint128 lhs,
const uint128 rhs 
)
inline

◆ operator!=() [4/4]

◆ operator%() [1/2]

Duration google::protobuf::operator% ( const Duration d1,
const Duration d2 
)
inline

◆ operator%() [2/2]

uint128 google::protobuf::operator% ( const uint128 lhs,
const uint128 rhs 
)
inline

◆ operator%=()

PROTOBUF_EXPORT Duration & google::protobuf::operator%= ( Duration d1,
const Duration d2 
)

◆ operator*() [1/3]

uint128 google::protobuf::operator* ( const uint128 lhs,
const uint128 rhs 
)
inline

◆ operator*() [2/3]

template<typename T >
Duration google::protobuf::operator* ( Duration  d,
T  r 
)
inline

◆ operator*() [3/3]

template<typename T >
Duration google::protobuf::operator* ( T  r,
Duration  d 
)
inline

◆ operator*=() [1/3]

PROTOBUF_EXPORT Duration & google::protobuf::operator*= ( Duration d,
double  r 
)

◆ operator*=() [2/3]

PROTOBUF_EXPORT Duration & google::protobuf::operator*= ( Duration d,
int64  r 
)

◆ operator*=() [3/3]

template<typename T >
Duration & google::protobuf::operator*= ( Duration d,
T  r 
)

◆ operator+() [1/4]

Timestamp google::protobuf::operator+ ( const Duration d,
const Timestamp t 
)
inline

◆ operator+() [2/4]

Duration google::protobuf::operator+ ( const Duration d1,
const Duration d2 
)
inline

◆ operator+() [3/4]

Timestamp google::protobuf::operator+ ( const Timestamp t,
const Duration d 
)
inline

◆ operator+() [4/4]

uint128 google::protobuf::operator+ ( const uint128 lhs,
const uint128 rhs 
)
inline

◆ operator+=() [1/2]

PROTOBUF_EXPORT Duration & google::protobuf::operator+= ( Duration d1,
const Duration d2 
)

◆ operator+=() [2/2]

PROTOBUF_EXPORT Timestamp & google::protobuf::operator+= ( Timestamp t,
const Duration d 
)

◆ operator-() [1/6]

Duration google::protobuf::operator- ( const Duration d)
inline

◆ operator-() [2/6]

Duration google::protobuf::operator- ( const Duration d1,
const Duration d2 
)
inline

◆ operator-() [3/6]

Timestamp google::protobuf::operator- ( const Timestamp t,
const Duration d 
)
inline

◆ operator-() [4/6]

PROTOBUF_EXPORT Duration google::protobuf::operator- ( const Timestamp t1,
const Timestamp t2 
)

◆ operator-() [5/6]

uint128 google::protobuf::operator- ( const uint128 lhs,
const uint128 rhs 
)
inline

◆ operator-() [6/6]

uint128 google::protobuf::operator- ( const uint128 val)
inline

◆ operator-=() [1/2]

PROTOBUF_EXPORT Duration & google::protobuf::operator-= ( Duration d1,
const Duration d2 
)

◆ operator-=() [2/2]

PROTOBUF_EXPORT Timestamp & google::protobuf::operator-= ( Timestamp t,
const Duration d 
)

◆ operator/() [1/3]

PROTOBUF_EXPORT int64_t google::protobuf::operator/ ( const Duration d1,
const Duration d2 
)

◆ operator/() [2/3]

uint128 google::protobuf::operator/ ( const uint128 lhs,
const uint128 rhs 
)
inline

◆ operator/() [3/3]

template<typename T >
Duration google::protobuf::operator/ ( Duration  d,
T  r 
)
inline

◆ operator/=() [1/3]

PROTOBUF_EXPORT Duration & google::protobuf::operator/= ( Duration d,
double  r 
)

◆ operator/=() [2/3]

PROTOBUF_EXPORT Duration & google::protobuf::operator/= ( Duration d,
int64  r 
)

◆ operator/=() [3/3]

template<typename T >
Duration & google::protobuf::operator/= ( Duration d,
T  r 
)

◆ operator<() [1/3]

bool google::protobuf::operator< ( const Duration d1,
const Duration d2 
)
inline

◆ operator<() [2/3]

bool google::protobuf::operator< ( const Timestamp t1,
const Timestamp t2 
)
inline

◆ operator<() [3/3]

bool google::protobuf::operator< ( StringPiece  x,
StringPiece  y 
)
inline

◆ operator<<() [1/5]

uint128 google::protobuf::operator<< ( const uint128 val,
int  amount 
)
inline

◆ operator<<() [2/5]

PROTOBUF_EXPORT std::ostream & google::protobuf::operator<< ( std::ostream &  o,
const uint128 b 
)

◆ operator<<() [3/5]

std::ostream & google::protobuf::operator<< ( std::ostream &  o,
StringPiece  piece 
)

◆ operator<<() [4/5]

std::ostream & google::protobuf::operator<< ( std::ostream &  out,
const Duration d 
)
inline

◆ operator<<() [5/5]

std::ostream & google::protobuf::operator<< ( std::ostream &  out,
const Timestamp t 
)
inline

◆ operator<=() [1/3]

bool google::protobuf::operator<= ( const Duration d1,
const Duration d2 
)
inline

◆ operator<=() [2/3]

bool google::protobuf::operator<= ( const Timestamp t1,
const Timestamp t2 
)
inline

◆ operator<=() [3/3]

bool google::protobuf::operator<= ( StringPiece  x,
StringPiece  y 
)
inline

◆ operator==() [1/4]

bool google::protobuf::operator== ( const Duration d1,
const Duration d2 
)
inline

◆ operator==() [2/4]

bool google::protobuf::operator== ( const Timestamp t1,
const Timestamp t2 
)
inline

◆ operator==() [3/4]

bool google::protobuf::operator== ( const uint128 lhs,
const uint128 rhs 
)
inline

◆ operator==() [4/4]

bool google::protobuf::operator== ( StringPiece  x,
StringPiece  y 
)
inline

◆ operator>() [1/3]

bool google::protobuf::operator> ( const Duration d1,
const Duration d2 
)
inline

◆ operator>() [2/3]

bool google::protobuf::operator> ( const Timestamp t1,
const Timestamp t2 
)
inline

◆ operator>() [3/3]

bool google::protobuf::operator> ( StringPiece  x,
StringPiece  y 
)
inline

◆ operator>=() [1/3]

bool google::protobuf::operator>= ( const Duration d1,
const Duration d2 
)
inline

◆ operator>=() [2/3]

bool google::protobuf::operator>= ( const Timestamp t1,
const Timestamp t2 
)
inline

◆ operator>=() [3/3]

bool google::protobuf::operator>= ( StringPiece  x,
StringPiece  y 
)
inline

◆ operator>>()

uint128 google::protobuf::operator>> ( const uint128 val,
int  amount 
)
inline

◆ operator~()

uint128 google::protobuf::operator~ ( const uint128 val)
inline

◆ ParseFailureList()

void google::protobuf::ParseFailureList ( const char *  filename,
conformance::FailureSet *  failure_list 
)

◆ ParseLenDelim()

const char* google::protobuf::ParseLenDelim ( int  field_number,
const FieldDescriptor field,
Message msg,
const Reflection reflection,
const char *  ptr,
internal::ParseContext ctx 
)

◆ ParsePackedField()

const char* google::protobuf::ParsePackedField ( const FieldDescriptor field,
Message msg,
const Reflection reflection,
const char *  ptr,
internal::ParseContext ctx 
)

◆ PROTOBUF_ALIGNAS()

class PROTOBUF_EXPORT google::protobuf::PROTOBUF_ALIGNAS ( )
final

◆ PROTOBUF_DEFINE_ACCESSOR()

const Descriptor::ReservedRange* google::protobuf::PROTOBUF_DEFINE_ACCESSOR ( FieldDescriptor  ,
containing_oneof  ,
const OneofDescriptor  
)

◆ PROTOBUF_DEFINE_ARRAY_ACCESSOR() [1/6]

google::protobuf::PROTOBUF_DEFINE_ARRAY_ACCESSOR ( Descriptor  ,
extension_range  ,
const Descriptor::ExtensionRange *   
)

◆ PROTOBUF_DEFINE_ARRAY_ACCESSOR() [2/6]

const Descriptor::ReservedRange const EnumValueDescriptor* google::protobuf::PROTOBUF_DEFINE_ARRAY_ACCESSOR ( EnumDescriptor  ,
reserved_range  ,
const EnumDescriptor::ReservedRange *   
)

◆ PROTOBUF_DEFINE_ARRAY_ACCESSOR() [3/6]

const Descriptor::ReservedRange* google::protobuf::PROTOBUF_DEFINE_ARRAY_ACCESSOR ( EnumDescriptor  ,
value  ,
const EnumValueDescriptor  
)

◆ PROTOBUF_DEFINE_ARRAY_ACCESSOR() [4/6]

const Descriptor::ReservedRange const EnumDescriptor::ReservedRange const ServiceDescriptor* google::protobuf::PROTOBUF_DEFINE_ARRAY_ACCESSOR ( FileDescriptor  ,
extension  ,
const FieldDescriptor  
)

Definition at line 2179 of file protobuf/src/google/protobuf/descriptor.h.

◆ PROTOBUF_DEFINE_ARRAY_ACCESSOR() [5/6]

const Descriptor::ReservedRange const EnumValueDescriptor const MethodDescriptor* google::protobuf::PROTOBUF_DEFINE_ARRAY_ACCESSOR ( FileDescriptor  ,
service  ,
const ServiceDescriptor  
)

◆ PROTOBUF_DEFINE_ARRAY_ACCESSOR() [6/6]

const Descriptor::ReservedRange const EnumDescriptor::ReservedRange* google::protobuf::PROTOBUF_DEFINE_ARRAY_ACCESSOR ( ServiceDescriptor  ,
method  ,
const MethodDescriptor  
)

◆ RandomUint64() [1/2]

static uint64 google::protobuf::RandomUint64 ( )
static

◆ RandomUint64() [2/2]

static uint64 google::protobuf::RandomUint64 ( )
static

◆ Reflection::GetRepeatedPtrField< std::string >()

template<>
const RepeatedPtrField<std::string>& google::protobuf::Reflection::GetRepeatedPtrField< std::string > ( const Message message,
const FieldDescriptor field 
) const
inline

◆ Reflection::GetRepeatedPtrFieldInternal< std::string >()

template<>
const RepeatedPtrField<std::string>& google::protobuf::Reflection::GetRepeatedPtrFieldInternal< std::string > ( const Message message,
const FieldDescriptor field 
) const
inline

Definition at line 1409 of file protobuf/src/google/protobuf/message.h.

◆ Reflection::MutableRepeatedPtrField< std::string >()

template<>
RepeatedPtrField<std::string>* google::protobuf::Reflection::MutableRepeatedPtrField< std::string > ( Message message,
const FieldDescriptor field 
) const
inline

◆ Reflection::MutableRepeatedPtrFieldInternal< std::string >()

template<>
RepeatedPtrField<std::string>* google::protobuf::Reflection::MutableRepeatedPtrFieldInternal< std::string > ( Message message,
const FieldDescriptor field 
) const
inline

Definition at line 1417 of file protobuf/src/google/protobuf/message.h.

◆ ReflectiveValidator()

bool google::protobuf::ReflectiveValidator ( const void *  arg,
int  val 
)

◆ RegisterAllTypesInternal()

void google::protobuf::RegisterAllTypesInternal ( const Metadata file_level_metadata,
int  size 
)

◆ RepeatedFieldBackInserter() [1/2]

template<typename T >
internal::RepeatedFieldBackInsertIterator< T > google::protobuf::RepeatedFieldBackInserter ( RepeatedField< T > *const  mutable_field)

◆ RepeatedFieldBackInserter() [2/2]

template<typename T >
internal::RepeatedPtrFieldBackInsertIterator< T > google::protobuf::RepeatedFieldBackInserter ( RepeatedPtrField< T > *const  mutable_field)

◆ RepeatedPtrFieldBackInserter()

template<typename T >
internal::RepeatedPtrFieldBackInsertIterator< T > google::protobuf::RepeatedPtrFieldBackInserter ( RepeatedPtrField< T > *const  mutable_field)

◆ ReplaceCharacters() [1/2]

PROTOBUF_EXPORT void google::protobuf::ReplaceCharacters ( std::string *  s,
const char *  remove,
char  replacewith 
)

◆ ReplaceCharacters() [2/2]

PROTOBUF_EXPORT void google::protobuf::ReplaceCharacters ( string *  s,
const char *  remove,
char  replacewith 
)

◆ safe_int_internal() [1/2]

template<typename IntType >
bool google::protobuf::safe_int_internal ( std::string  text,
IntType *  value_p 
)

◆ safe_int_internal() [2/2]

template<typename IntType >
bool google::protobuf::safe_int_internal ( string  text,
IntType *  value_p 
)

◆ safe_parse_negative_int() [1/2]

template<typename IntType >
bool google::protobuf::safe_parse_negative_int ( const std::string &  text,
IntType *  value_p 
)

◆ safe_parse_negative_int() [2/2]

template<typename IntType >
bool google::protobuf::safe_parse_negative_int ( const string &  text,
IntType *  value_p 
)

◆ safe_parse_positive_int() [1/2]

template<typename IntType >
bool google::protobuf::safe_parse_positive_int ( std::string  text,
IntType *  value_p 
)

◆ safe_parse_positive_int() [2/2]

template<typename IntType >
bool google::protobuf::safe_parse_positive_int ( string  text,
IntType *  value_p 
)

◆ safe_parse_sign() [1/2]

bool google::protobuf::safe_parse_sign ( std::string *  text,
bool negative_ptr 
)
inline

◆ safe_parse_sign() [2/2]

bool google::protobuf::safe_parse_sign ( string *  text,
bool negative_ptr 
)
inline

◆ safe_strto32() [1/4]

bool google::protobuf::safe_strto32 ( const char *  str,
int32 value 
)
inline

◆ safe_strto32() [2/4]

PROTOBUF_EXPORT bool google::protobuf::safe_strto32 ( const std::string &  str,
int32 value 
)

◆ safe_strto32() [3/4]

PROTOBUF_EXPORT bool google::protobuf::safe_strto32 ( const string &  str,
int32 value 
)

◆ safe_strto32() [4/4]

bool google::protobuf::safe_strto32 ( StringPiece  str,
int32 value 
)
inline

◆ safe_strto64() [1/4]

bool google::protobuf::safe_strto64 ( const char *  str,
int64 value 
)
inline

◆ safe_strto64() [2/4]

PROTOBUF_EXPORT bool google::protobuf::safe_strto64 ( const std::string &  str,
int64 value 
)

◆ safe_strto64() [3/4]

PROTOBUF_EXPORT bool google::protobuf::safe_strto64 ( const string &  str,
int64 value 
)

◆ safe_strto64() [4/4]

bool google::protobuf::safe_strto64 ( StringPiece  str,
int64 value 
)
inline

◆ safe_strtob()

PROTOBUF_EXPORT bool google::protobuf::safe_strtob ( StringPiece  str,
bool value 
)

◆ safe_strtod() [1/4]

PROTOBUF_EXPORT bool google::protobuf::safe_strtod ( const char *  str,
double *  value 
)

◆ safe_strtod() [2/4]

bool google::protobuf::safe_strtod ( const std::string &  str,
double *  value 
)
inline

◆ safe_strtod() [3/4]

bool google::protobuf::safe_strtod ( const string &  str,
double *  value 
)
inline

◆ safe_strtod() [4/4]

bool google::protobuf::safe_strtod ( StringPiece  str,
double *  value 
)
inline

◆ safe_strtof() [1/4]

PROTOBUF_EXPORT bool google::protobuf::safe_strtof ( const char *  str,
float *  value 
)

◆ safe_strtof() [2/4]

bool google::protobuf::safe_strtof ( const std::string &  str,
float *  value 
)
inline

◆ safe_strtof() [3/4]

bool google::protobuf::safe_strtof ( const string &  str,
float *  value 
)
inline

◆ safe_strtof() [4/4]

bool google::protobuf::safe_strtof ( StringPiece  str,
float *  value 
)
inline

◆ safe_strtou32() [1/4]

bool google::protobuf::safe_strtou32 ( const char *  str,
uint32 value 
)
inline

◆ safe_strtou32() [2/4]

PROTOBUF_EXPORT bool google::protobuf::safe_strtou32 ( const std::string &  str,
uint32 value 
)

◆ safe_strtou32() [3/4]

PROTOBUF_EXPORT bool google::protobuf::safe_strtou32 ( const string &  str,
uint32 value 
)

◆ safe_strtou32() [4/4]

bool google::protobuf::safe_strtou32 ( StringPiece  str,
uint32 value 
)
inline

◆ safe_strtou64() [1/4]

bool google::protobuf::safe_strtou64 ( const char *  str,
uint64 value 
)
inline

◆ safe_strtou64() [2/4]

PROTOBUF_EXPORT bool google::protobuf::safe_strtou64 ( const std::string &  str,
uint64 value 
)

◆ safe_strtou64() [3/4]

PROTOBUF_EXPORT bool google::protobuf::safe_strtou64 ( const string &  str,
uint64 value 
)

◆ safe_strtou64() [4/4]

bool google::protobuf::safe_strtou64 ( StringPiece  str,
uint64 value 
)
inline

◆ safe_uint_internal() [1/2]

template<typename IntType >
bool google::protobuf::safe_uint_internal ( std::string  text,
IntType *  value_p 
)

◆ safe_uint_internal() [2/2]

template<typename IntType >
bool google::protobuf::safe_uint_internal ( string  text,
IntType *  value_p 
)

◆ SerializeToArrayImpl()

uint8_t * google::protobuf::SerializeToArrayImpl ( const MessageLite msg,
uint8 target,
int  size 
)
inline

◆ SetAllTypesInEmptyMessageUnknownFields()

void google::protobuf::SetAllTypesInEmptyMessageUnknownFields ( unittest::TestEmptyMessageLite *  empty_message)

◆ SetField()

void google::protobuf::SetField ( uint64  val,
const FieldDescriptor field,
Message msg,
const Reflection reflection 
)

◆ SetLogHandler()

PROTOBUF_EXPORT LogHandler * google::protobuf::SetLogHandler ( LogHandler new_func)

◆ SetSomeTypesInEmptyMessageUnknownFields()

void google::protobuf::SetSomeTypesInEmptyMessageUnknownFields ( unittest::TestEmptyMessageLite *  empty_message)

◆ ShutdownProtobufLibrary()

PROTOBUF_EXPORT void google::protobuf::ShutdownProtobufLibrary ( )

◆ SimpleBtoa()

std::string google::protobuf::SimpleBtoa ( bool  value)
inline

◆ SimpleDtoa()

PROTOBUF_EXPORT std::string google::protobuf::SimpleDtoa ( double  value)

◆ SimpleFtoa()

PROTOBUF_EXPORT std::string google::protobuf::SimpleFtoa ( float  value)

◆ SimpleItoa() [1/6]

PROTOBUF_EXPORT std::string google::protobuf::SimpleItoa ( int  i)

◆ SimpleItoa() [2/6]

PROTOBUF_EXPORT std::string google::protobuf::SimpleItoa ( long  i)

◆ SimpleItoa() [3/6]

PROTOBUF_EXPORT std::string google::protobuf::SimpleItoa ( long long  i)

◆ SimpleItoa() [4/6]

PROTOBUF_EXPORT std::string google::protobuf::SimpleItoa ( unsigned int  i)

◆ SimpleItoa() [5/6]

PROTOBUF_EXPORT std::string google::protobuf::SimpleItoa ( unsigned long  i)

◆ SimpleItoa() [6/6]

PROTOBUF_EXPORT std::string google::protobuf::SimpleItoa ( unsigned long long  i)

◆ Split() [1/2]

std::vector<string> google::protobuf::Split ( const string &  full,
const char *  delim,
bool  skip_empty = true 
)
inline

◆ Split() [2/2]

std::vector<std::string> google::protobuf::Split ( StringPiece  full,
const char *  delim,
bool  skip_empty = true 
)
inline

◆ SplitStringAllowEmpty() [1/2]

PROTOBUF_EXPORT void google::protobuf::SplitStringAllowEmpty ( const string &  full,
const char *  delim,
std::vector< string > *  result 
)

◆ SplitStringAllowEmpty() [2/2]

PROTOBUF_EXPORT void google::protobuf::SplitStringAllowEmpty ( StringPiece  full,
const char *  delim,
std::vector< std::string > *  result 
)

◆ SplitStringToIteratorAllowEmpty() [1/2]

template<typename StringType , typename ITR >
static void google::protobuf::SplitStringToIteratorAllowEmpty ( const StringType &  full,
const char *  delim,
int  pieces,
ITR &  result 
)
inlinestatic

◆ SplitStringToIteratorAllowEmpty() [2/2]

template<typename ITR >
static void google::protobuf::SplitStringToIteratorAllowEmpty ( StringPiece  full,
const char *  delim,
int  pieces,
ITR &  result 
)
inlinestatic

◆ SplitStringToIteratorUsing() [1/2]

template<typename ITR >
static void google::protobuf::SplitStringToIteratorUsing ( const string &  full,
const char *  delim,
ITR &  result 
)
inlinestatic

◆ SplitStringToIteratorUsing() [2/2]

template<typename ITR >
static void google::protobuf::SplitStringToIteratorUsing ( StringPiece  full,
const char *  delim,
ITR &  result 
)
inlinestatic

◆ SplitStringUsing() [1/2]

PROTOBUF_EXPORT void google::protobuf::SplitStringUsing ( const string &  full,
const char *  delim,
std::vector< string > *  result 
)

◆ SplitStringUsing() [2/2]

PROTOBUF_EXPORT void google::protobuf::SplitStringUsing ( StringPiece  full,
const char *  delim,
std::vector< std::string > *  result 
)

◆ SStringPrintf() [1/2]

const PROTOBUF_EXPORT std::string & google::protobuf::SStringPrintf ( std::string *  dst,
const char *  format,
  ... 
)

◆ SStringPrintf() [2/2]

const PROTOBUF_EXPORT string & google::protobuf::SStringPrintf ( string *  dst,
const char *  format,
  ... 
)

◆ STLStringResizeUninitialized() [1/2]

void google::protobuf::STLStringResizeUninitialized ( std::string *  s,
size_t  new_size 
)
inline

◆ STLStringResizeUninitialized() [2/2]

void google::protobuf::STLStringResizeUninitialized ( string *  s,
size_t  new_size 
)
inline

◆ STLStringResizeUninitializedAmortized()

void google::protobuf::STLStringResizeUninitializedAmortized ( std::string *  s,
size_t  new_size 
)
inline

◆ StrAppend() [1/8]

PROTOBUF_EXPORT void google::protobuf::StrAppend ( std::string *  result,
const AlphaNum a 
)

◆ StrAppend() [2/8]

PROTOBUF_EXPORT void google::protobuf::StrAppend ( std::string *  result,
const AlphaNum a,
const AlphaNum b 
)

◆ StrAppend() [3/8]

PROTOBUF_EXPORT void google::protobuf::StrAppend ( std::string *  result,
const AlphaNum a,
const AlphaNum b,
const AlphaNum c 
)

◆ StrAppend() [4/8]

PROTOBUF_EXPORT void google::protobuf::StrAppend ( std::string *  result,
const AlphaNum a,
const AlphaNum b,
const AlphaNum c,
const AlphaNum d 
)

◆ StrAppend() [5/8]

PROTOBUF_EXPORT void google::protobuf::StrAppend ( string *  result,
const AlphaNum a 
)

◆ StrAppend() [6/8]

PROTOBUF_EXPORT void google::protobuf::StrAppend ( string *  result,
const AlphaNum a,
const AlphaNum b 
)

◆ StrAppend() [7/8]

PROTOBUF_EXPORT void google::protobuf::StrAppend ( string *  result,
const AlphaNum a,
const AlphaNum b,
const AlphaNum c 
)

◆ StrAppend() [8/8]

PROTOBUF_EXPORT void google::protobuf::StrAppend ( string *  result,
const AlphaNum a,
const AlphaNum b,
const AlphaNum c,
const AlphaNum d 
)

◆ StrCat() [1/9]

std::string google::protobuf::StrCat ( const AlphaNum a)
inline

◆ StrCat() [2/9]

PROTOBUF_EXPORT std::string google::protobuf::StrCat ( const AlphaNum a,
const AlphaNum b 
)

◆ StrCat() [3/9]

PROTOBUF_EXPORT std::string google::protobuf::StrCat ( const AlphaNum a,
const AlphaNum b,
const AlphaNum c 
)

◆ StrCat() [4/9]

PROTOBUF_EXPORT std::string google::protobuf::StrCat ( const AlphaNum a,
const AlphaNum b,
const AlphaNum c,
const AlphaNum d 
)

◆ StrCat() [5/9]

PROTOBUF_EXPORT std::string google::protobuf::StrCat ( const AlphaNum a,
const AlphaNum b,
const AlphaNum c,
const AlphaNum d,
const AlphaNum e 
)

◆ StrCat() [6/9]

PROTOBUF_EXPORT std::string google::protobuf::StrCat ( const AlphaNum a,
const AlphaNum b,
const AlphaNum c,
const AlphaNum d,
const AlphaNum e,
const AlphaNum f 
)

◆ StrCat() [7/9]

PROTOBUF_EXPORT std::string google::protobuf::StrCat ( const AlphaNum a,
const AlphaNum b,
const AlphaNum c,
const AlphaNum d,
const AlphaNum e,
const AlphaNum f,
const AlphaNum g 
)

◆ StrCat() [8/9]

PROTOBUF_EXPORT std::string google::protobuf::StrCat ( const AlphaNum a,
const AlphaNum b,
const AlphaNum c,
const AlphaNum d,
const AlphaNum e,
const AlphaNum f,
const AlphaNum g,
const AlphaNum h 
)

◆ StrCat() [9/9]

PROTOBUF_EXPORT std::string google::protobuf::StrCat ( const AlphaNum a,
const AlphaNum b,
const AlphaNum c,
const AlphaNum d,
const AlphaNum e,
const AlphaNum f,
const AlphaNum g,
const AlphaNum h,
const AlphaNum i 
)

◆ string_as_array() [1/2]

char* google::protobuf::string_as_array ( std::string *  str)
inline

◆ string_as_array() [2/2]

char* google::protobuf::string_as_array ( string *  str)
inline

◆ StringAppendF() [1/2]

PROTOBUF_EXPORT void google::protobuf::StringAppendF ( std::string *  dst,
const char *  format,
  ... 
)

◆ StringAppendF() [2/2]

PROTOBUF_EXPORT void google::protobuf::StringAppendF ( string *  dst,
const char *  format,
  ... 
)

◆ StringAppendV() [1/2]

PROTOBUF_EXPORT void google::protobuf::StringAppendV ( std::string *  dst,
const char *  format,
va_list  ap 
)

◆ StringAppendV() [2/2]

PROTOBUF_EXPORT void google::protobuf::StringAppendV ( string *  dst,
const char *  format,
va_list  ap 
)

◆ StringPrintf()

PROTOBUF_EXPORT std::string google::protobuf::StringPrintf ( const char *  format,
  ... 
)

◆ StringPrintfVector() [1/2]

PROTOBUF_EXPORT std::string google::protobuf::StringPrintfVector ( const char *  format,
const std::vector< std::string > &  v 
)

◆ StringPrintfVector() [2/2]

PROTOBUF_EXPORT string google::protobuf::StringPrintfVector ( const char *  format,
const std::vector< string > &  v 
)

◆ StringReplace() [1/4]

PROTOBUF_EXPORT std::string google::protobuf::StringReplace ( const std::string &  s,
const std::string &  oldsub,
const std::string &  newsub,
bool  replace_all 
)

◆ StringReplace() [2/4]

void google::protobuf::StringReplace ( const std::string &  s,
const std::string &  oldsub,
const std::string &  newsub,
bool  replace_all,
std::string *  res 
)

◆ StringReplace() [3/4]

PROTOBUF_EXPORT string google::protobuf::StringReplace ( const string &  s,
const string &  oldsub,
const string &  newsub,
bool  replace_all 
)

◆ StringReplace() [4/4]

void google::protobuf::StringReplace ( const string &  s,
const string &  oldsub,
const string &  newsub,
bool  replace_all,
string *  res 
)

◆ StripPrefixString() [1/2]

std::string google::protobuf::StripPrefixString ( const std::string &  str,
const std::string &  prefix 
)
inline

◆ StripPrefixString() [2/2]

string google::protobuf::StripPrefixString ( const string &  str,
const string &  prefix 
)
inline

◆ StripString()

PROTOBUF_EXPORT void google::protobuf::StripString ( string *  s,
const char *  remove,
char  replacewith 
)

◆ StripSuffixString() [1/2]

std::string google::protobuf::StripSuffixString ( const std::string &  str,
const std::string &  suffix 
)
inline

◆ StripSuffixString() [2/2]

string google::protobuf::StripSuffixString ( const string &  str,
const string &  suffix 
)
inline

◆ StripWhitespace() [1/2]

PROTOBUF_EXPORT void google::protobuf::StripWhitespace ( std::string *  str)

◆ StripWhitespace() [2/2]

PROTOBUF_EXPORT void google::protobuf::StripWhitespace ( string *  str)

◆ strto32()

int32 google::protobuf::strto32 ( const char *  nptr,
char **  endptr,
int  base 
)
inline

◆ strto32_adaptor()

PROTOBUF_EXPORT int32 google::protobuf::strto32_adaptor ( const char *  nptr,
char **  endptr,
int  base 
)

◆ strto64()

int64 google::protobuf::strto64 ( const char *  nptr,
char **  endptr,
int  base 
)
inline

◆ strtou32()

uint32 google::protobuf::strtou32 ( const char *  nptr,
char **  endptr,
int  base 
)
inline

◆ strtou32_adaptor()

PROTOBUF_EXPORT uint32 google::protobuf::strtou32_adaptor ( const char *  nptr,
char **  endptr,
int  base 
)

◆ strtou64()

uint64 google::protobuf::strtou64 ( const char *  nptr,
char **  endptr,
int  base 
)
inline

◆ TEST() [1/133]

google::protobuf::TEST ( ArenaStringPtrTest  ,
ArenaStringPtrOnArena   
)

◆ TEST() [2/133]

google::protobuf::TEST ( ArenaStringPtrTest  ,
ArenaStringPtrOnArenaNoSSO   
)

◆ TEST() [3/133]

google::protobuf::TEST ( ArenaStringPtrTest  ,
ArenaStringPtrOnHeap   
)

◆ TEST() [4/133]

google::protobuf::TEST ( ArenaTest  ,
AddAllocatedToRepeatedField   
)

◆ TEST() [5/133]

google::protobuf::TEST ( ArenaTest  ,
AddAllocatedToRepeatedFieldViaReflection   
)

◆ TEST() [6/133]

google::protobuf::TEST ( ArenaTest  ,
AddAllocatedWithReflection   
)

◆ TEST() [7/133]

google::protobuf::TEST ( ArenaTest  ,
AddCleanup   
)

◆ TEST() [8/133]

google::protobuf::TEST ( ArenaTest  ,
Alignment   
)

◆ TEST() [9/133]

google::protobuf::TEST ( ArenaTest  ,
ArenaConstructable   
)

◆ TEST() [10/133]

google::protobuf::TEST ( ArenaTest  ,
ArenaHooksSanity   
)

◆ TEST() [11/133]

google::protobuf::TEST ( ArenaTest  ,
ArenaHooksWhenAllocationsNotNeeded   
)

◆ TEST() [12/133]

google::protobuf::TEST ( ArenaTest  ,
ArenaOneofReflection   
)

◆ TEST() [13/133]

google::protobuf::TEST ( ArenaTest  ,
BasicCreate   
)

◆ TEST() [14/133]

google::protobuf::TEST ( ArenaTest  ,
BlockSizeDoubling   
)

◆ TEST() [15/133]

google::protobuf::TEST ( ArenaTest  ,
BlockSizeSmallerThanAllocation   
)

◆ TEST() [16/133]

google::protobuf::TEST ( ArenaTest  ,
CreateAndConstCopy   
)

◆ TEST() [17/133]

google::protobuf::TEST ( ArenaTest  ,
CreateAndMove   
)

◆ TEST() [18/133]

google::protobuf::TEST ( ArenaTest  ,
CreateAndNonConstCopy   
)

◆ TEST() [19/133]

google::protobuf::TEST ( ArenaTest  ,
CreateWithEightConstructorArguments   
)

◆ TEST() [20/133]

google::protobuf::TEST ( ArenaTest  ,
CreateWithFourConstructorArguments   
)

◆ TEST() [21/133]

google::protobuf::TEST ( ArenaTest  ,
CreateWithMoveArguments   
)

◆ TEST() [22/133]

google::protobuf::TEST ( ArenaTest  ,
DestructorSkippable   
)

◆ TEST() [23/133]

google::protobuf::TEST ( ArenaTest  ,
ExtensionsOnArena   
)

◆ TEST() [24/133]

google::protobuf::TEST ( ArenaTest  ,
GetArenaShouldReturnNullForNonArenaAllocatedMessages   
)

◆ TEST() [25/133]

google::protobuf::TEST ( ArenaTest  ,
GetArenaShouldReturnNullForNonArenaCompatibleTypes   
)

◆ TEST() [26/133]

google::protobuf::TEST ( ArenaTest  ,
GetArenaShouldReturnTheArenaForArenaAllocatedMessages   
)

◆ TEST() [27/133]

google::protobuf::TEST ( ArenaTest  ,
InitialBlockTooSmall   
)

◆ TEST() [28/133]

google::protobuf::TEST ( ArenaTest  ,
NoHeapAllocationsTest   
)

◆ TEST() [29/133]

google::protobuf::TEST ( ArenaTest  ,
OneofMerge   
)

◆ TEST() [30/133]

google::protobuf::TEST ( ArenaTest  ,
ParseCorruptedString   
)

◆ TEST() [31/133]

google::protobuf::TEST ( ArenaTest  ,
Parsing   
)

◆ TEST() [32/133]

google::protobuf::TEST ( ArenaTest  ,
ReflectionSwapFields   
)

◆ TEST() [33/133]

google::protobuf::TEST ( ArenaTest  ,
ReleaseFromArenaMessageMakesCopy   
)

◆ TEST() [34/133]

google::protobuf::TEST ( ArenaTest  ,
ReleaseLastRepeatedField   
)

◆ TEST() [35/133]

google::protobuf::TEST ( ArenaTest  ,
ReleaseMessage   
)

◆ TEST() [36/133]

google::protobuf::TEST ( ArenaTest  ,
ReleaseString   
)

◆ TEST() [37/133]

google::protobuf::TEST ( ArenaTest  ,
RepeatedFieldOnArena   
)

◆ TEST() [38/133]

google::protobuf::TEST ( ArenaTest  ,
RepeatedFieldWithNonPODType   
)

◆ TEST() [39/133]

google::protobuf::TEST ( ArenaTest  ,
RepeatedPtrFieldAddClearedTest   
)

◆ TEST() [40/133]

google::protobuf::TEST ( ArenaTest  ,
SetAllocatedAcrossArenas   
)

◆ TEST() [41/133]

google::protobuf::TEST ( ArenaTest  ,
SetAllocatedAcrossArenasWithReflection   
)

◆ TEST() [42/133]

google::protobuf::TEST ( ArenaTest  ,
SetAllocatedMessage   
)

◆ TEST() [43/133]

google::protobuf::TEST ( ArenaTest  ,
SetAllocatedString   
)

◆ TEST() [44/133]

google::protobuf::TEST ( ArenaTest  ,
SpaceAllocated_and_Used   
)

◆ TEST() [45/133]

google::protobuf::TEST ( ArenaTest  ,
Swap   
)

◆ TEST() [46/133]

google::protobuf::TEST ( ArenaTest  ,
SwapBetweenArenaAndNonArenaUsingReflection   
)

◆ TEST() [47/133]

google::protobuf::TEST ( ArenaTest  ,
SwapBetweenArenaAndNonArenaWithAllFieldsSet   
)

◆ TEST() [48/133]

google::protobuf::TEST ( ArenaTest  ,
SwapBetweenArenasUsingReflection   
)

◆ TEST() [49/133]

google::protobuf::TEST ( ArenaTest  ,
SwapBetweenArenasWithAllFieldsSet   
)

◆ TEST() [50/133]

google::protobuf::TEST ( ArenaTest  ,
SwapRepeatedField   
)

◆ TEST() [51/133]

google::protobuf::TEST ( ArenaTest  ,
SwapRepeatedFieldWithDifferentArenas   
)

◆ TEST() [52/133]

google::protobuf::TEST ( ArenaTest  ,
SwapRepeatedFieldWithNoArenaOnLeftHandSide   
)

◆ TEST() [53/133]

google::protobuf::TEST ( ArenaTest  ,
SwapRepeatedFieldWithNoArenaOnRightHandSide   
)

◆ TEST() [54/133]

google::protobuf::TEST ( ArenaTest  ,
UnknownFields   
)

◆ TEST() [55/133]

google::protobuf::TEST ( ArenaTest  ,
UnsafeArenaAddAllocated   
)

◆ TEST() [56/133]

google::protobuf::TEST ( ArenaTest  ,
UnsafeArenaAddAllocatedToRepeatedField   
)

◆ TEST() [57/133]

google::protobuf::TEST ( ArenaTest  ,
UnsafeArenaRelease   
)

◆ TEST() [58/133]

google::protobuf::TEST ( ArenaTest  ,
UnsafeArenaReleaseAdd   
)

◆ TEST() [59/133]

google::protobuf::TEST ( ArenaTest  ,
UnsafeArenaSetAllocatedAcrossArenas   
)

◆ TEST() [60/133]

google::protobuf::TEST ( ArenaTest  ,
UnsafeArenaSetAllocatedAcrossArenasWithReflection   
)

◆ TEST() [61/133]

google::protobuf::TEST ( ArenaTest  ,
UnsafeArenaSwap   
)

◆ TEST() [62/133]

google::protobuf::TEST ( ArenaTest  ,
UnsafeSetAllocatedOnArena   
)

◆ TEST() [63/133]

google::protobuf::TEST ( DropUnknownFieldsTest  ,
DynamicMessage   
)

◆ TEST() [64/133]

google::protobuf::TEST ( DropUnknownFieldsTest  ,
GeneratedMessage   
)

◆ TEST() [65/133]

google::protobuf::TEST ( Int128  ,
AliasTests   
)

◆ TEST() [66/133]

google::protobuf::TEST ( Int128  ,
AllTests   
)

◆ TEST() [67/133]

google::protobuf::TEST ( Int128  ,
DivideAndMod   
)

◆ TEST() [68/133]

google::protobuf::TEST ( Int128  ,
DivideAndModRandomInputs   
)

◆ TEST() [69/133]

google::protobuf::TEST ( Int128  ,
Multiply   
)

◆ TEST() [70/133]

google::protobuf::TEST ( Int128  ,
OperatorAssignReturnRef   
)

◆ TEST() [71/133]

google::protobuf::TEST ( Int128  ,
OStream   
)

◆ TEST() [72/133]

google::protobuf::TEST ( Int128  ,
PodTests   
)

◆ TEST() [73/133]

google::protobuf::TEST ( Lite  ,
AliasedEnum   
)

◆ TEST() [74/133]

google::protobuf::TEST ( Lite  ,
AllLite1   
)

◆ TEST() [75/133]

google::protobuf::TEST ( Lite  ,
AllLite10   
)

◆ TEST() [76/133]

google::protobuf::TEST ( Lite  ,
AllLite11   
)

◆ TEST() [77/133]

google::protobuf::TEST ( Lite  ,
AllLite12   
)

◆ TEST() [78/133]

google::protobuf::TEST ( Lite  ,
AllLite13   
)

◆ TEST() [79/133]

google::protobuf::TEST ( Lite  ,
AllLite14   
)

◆ TEST() [80/133]

google::protobuf::TEST ( Lite  ,
AllLite15   
)

◆ TEST() [81/133]

google::protobuf::TEST ( Lite  ,
AllLite16   
)

◆ TEST() [82/133]

google::protobuf::TEST ( Lite  ,
AllLite17   
)

◆ TEST() [83/133]

google::protobuf::TEST ( Lite  ,
AllLite18   
)

◆ TEST() [84/133]

google::protobuf::TEST ( Lite  ,
AllLite19   
)

◆ TEST() [85/133]

google::protobuf::TEST ( Lite  ,
AllLite2   
)

◆ TEST() [86/133]

google::protobuf::TEST ( Lite  ,
AllLite20   
)

◆ TEST() [87/133]

google::protobuf::TEST ( Lite  ,
AllLite21   
)

◆ TEST() [88/133]

google::protobuf::TEST ( Lite  ,
AllLite22   
)

◆ TEST() [89/133]

google::protobuf::TEST ( Lite  ,
AllLite23   
)

◆ TEST() [90/133]

google::protobuf::TEST ( Lite  ,
AllLite24   
)

◆ TEST() [91/133]

google::protobuf::TEST ( Lite  ,
AllLite25   
)

◆ TEST() [92/133]

google::protobuf::TEST ( Lite  ,
AllLite26   
)

◆ TEST() [93/133]

google::protobuf::TEST ( Lite  ,
AllLite27   
)

◆ TEST() [94/133]

google::protobuf::TEST ( Lite  ,
AllLite28   
)

◆ TEST() [95/133]

google::protobuf::TEST ( Lite  ,
AllLite29   
)

◆ TEST() [96/133]

google::protobuf::TEST ( Lite  ,
AllLite3   
)

◆ TEST() [97/133]

google::protobuf::TEST ( Lite  ,
AllLite32   
)

◆ TEST() [98/133]

google::protobuf::TEST ( Lite  ,
AllLite33   
)

◆ TEST() [99/133]

google::protobuf::TEST ( Lite  ,
AllLite34   
)

◆ TEST() [100/133]

google::protobuf::TEST ( Lite  ,
AllLite35   
)

◆ TEST() [101/133]

google::protobuf::TEST ( Lite  ,
AllLite36   
)

◆ TEST() [102/133]

google::protobuf::TEST ( Lite  ,
AllLite37   
)

◆ TEST() [103/133]

google::protobuf::TEST ( Lite  ,
AllLite38   
)

◆ TEST() [104/133]

google::protobuf::TEST ( Lite  ,
AllLite39   
)

◆ TEST() [105/133]

google::protobuf::TEST ( Lite  ,
AllLite40   
)

◆ TEST() [106/133]

google::protobuf::TEST ( Lite  ,
AllLite41   
)

◆ TEST() [107/133]

google::protobuf::TEST ( Lite  ,
AllLite42   
)

◆ TEST() [108/133]

google::protobuf::TEST ( Lite  ,
AllLite43   
)

◆ TEST() [109/133]

google::protobuf::TEST ( Lite  ,
AllLite44   
)

◆ TEST() [110/133]

google::protobuf::TEST ( Lite  ,
AllLite45   
)

◆ TEST() [111/133]

google::protobuf::TEST ( Lite  ,
AllLite46   
)

◆ TEST() [112/133]

google::protobuf::TEST ( Lite  ,
AllLite47   
)

◆ TEST() [113/133]

google::protobuf::TEST ( Lite  ,
AllLite5   
)

◆ TEST() [114/133]

google::protobuf::TEST ( Lite  ,
AllLite6   
)

◆ TEST() [115/133]

google::protobuf::TEST ( Lite  ,
AllLite7   
)

◆ TEST() [116/133]

google::protobuf::TEST ( Lite  ,
AllLite8   
)

◆ TEST() [117/133]

google::protobuf::TEST ( Lite  ,
AllLite9   
)

◆ TEST() [118/133]

google::protobuf::TEST ( Lite  ,
CodedInputStreamRollback   
)

◆ TEST() [119/133]

google::protobuf::TEST ( Lite  ,
CorrectEnding   
)

◆ TEST() [120/133]

google::protobuf::TEST ( Lite  ,
DebugString   
)

◆ TEST() [121/133]

google::protobuf::TEST ( Lite  ,
EnumNameToValue   
)

◆ TEST() [122/133]

google::protobuf::TEST ( Lite  ,
EnumValueToName   
)

◆ TEST() [123/133]

google::protobuf::TEST ( Lite  ,
MapCrash   
)

◆ TEST() [124/133]

google::protobuf::TEST ( Lite  ,
NestedEnumNameToValue   
)

◆ TEST() [125/133]

google::protobuf::TEST ( Lite  ,
NestedEnumValueToName   
)

◆ TEST() [126/133]

google::protobuf::TEST ( PreserveUnknownEnumTest  ,
DynamicEnumValueDescriptors   
)

◆ TEST() [127/133]

google::protobuf::TEST ( PreserveUnknownEnumTest  ,
DynamicProto2HidesUnknownValues   
)

◆ TEST() [128/133]

google::protobuf::TEST ( PreserveUnknownEnumTest  ,
IntegerEnumReflectionAPI   
)

◆ TEST() [129/133]

google::protobuf::TEST ( PreserveUnknownEnumTest  ,
PreserveParseAndSerialize   
)

◆ TEST() [130/133]

google::protobuf::TEST ( PreserveUnknownEnumTest  ,
PreserveParseAndSerializeDynamicMessage   
)

◆ TEST() [131/133]

google::protobuf::TEST ( PreserveUnknownEnumTest  ,
Proto2CatchesUnknownValues   
)

◆ TEST() [132/133]

google::protobuf::TEST ( PreserveUnknownEnumTest  ,
Proto2HidesUnknownValues   
)

◆ TEST() [133/133]

google::protobuf::TEST ( PreserveUnknownEnumTest  ,
SupportsUnknownEnumValuesAPI   
)

◆ TEST_F() [1/5]

google::protobuf::TEST_F ( DynamicMessageTest  ,
Arena   
)

◆ TEST_F() [2/5]

google::protobuf::TEST_F ( DynamicMessageTest  ,
Defaults   
)

◆ TEST_F() [3/5]

google::protobuf::TEST_F ( DynamicMessageTest  ,
Descriptor   
)

◆ TEST_F() [4/5]

google::protobuf::TEST_F ( DynamicMessageTest  ,
OnePrototype   
)

◆ TEST_F() [5/5]

google::protobuf::TEST_F ( DynamicMessageTest  ,
Proto3   
)

◆ TEST_P() [1/9]

google::protobuf::TEST_P ( DualArena  ,
Swap   
)

◆ TEST_P() [2/9]

google::protobuf::TEST_P ( DynamicMessageTest  ,
Extensions   
)

◆ TEST_P() [3/9]

google::protobuf::TEST_P ( DynamicMessageTest  ,
IndependentOffsets   
)

◆ TEST_P() [4/9]

google::protobuf::TEST_P ( DynamicMessageTest  ,
Oneof   
)

◆ TEST_P() [5/9]

google::protobuf::TEST_P ( DynamicMessageTest  ,
PackedFields   
)

◆ TEST_P() [6/9]

google::protobuf::TEST_P ( DynamicMessageTest  ,
SpaceUsed   
)

◆ TEST_P() [7/9]

google::protobuf::TEST_P ( SingleArena  ,
GetSet   
)

◆ TEST_P() [8/9]

google::protobuf::TEST_P ( SingleArena  ,
MutableAccessor   
)

◆ TEST_P() [9/9]

google::protobuf::TEST_P ( SingleArena  ,
NullDefault   
)

◆ TestParseCorruptedString()

template<typename T , bool use_arena>
void google::protobuf::TestParseCorruptedString ( const T message)

◆ TestSourceDir()

std::string google::protobuf::TestSourceDir ( )

◆ TestSwapRepeatedField()

void google::protobuf::TestSwapRepeatedField ( Arena arena1,
Arena arena2 
)

◆ TestTempDir()

std::string google::protobuf::TestTempDir ( )

◆ ToHex()

PROTOBUF_EXPORT std::string google::protobuf::ToHex ( uint64  num)

◆ ToLowercaseWithoutUnderscores() [1/2]

static std::string google::protobuf::ToLowercaseWithoutUnderscores ( const std::string &  name)
static

◆ ToLowercaseWithoutUnderscores() [2/2]

static std::string google::protobuf::ToLowercaseWithoutUnderscores ( const std::string &  name)
static

Definition at line 6528 of file protobuf/src/google/protobuf/descriptor.cc.

◆ ToUpper() [1/3]

std::string google::protobuf::ToUpper ( const std::string &  s)
inline

◆ ToUpper() [2/3]

string google::protobuf::ToUpper ( const string &  s)
inline

◆ ToUpper() [3/3]

void google::protobuf::ToUpper ( std::string *  s)
inline

◆ Uint128High64()

uint64 google::protobuf::Uint128High64 ( const uint128 v)
inline

◆ Uint128Low64()

uint64 google::protobuf::Uint128Low64 ( const uint128 v)
inline

◆ UnescapeCEscapeSequences() [1/3]

PROTOBUF_EXPORT int google::protobuf::UnescapeCEscapeSequences ( const char *  source,
char *  dest 
)

◆ UnescapeCEscapeSequences() [2/3]

PROTOBUF_EXPORT int google::protobuf::UnescapeCEscapeSequences ( const char *  source,
char *  dest,
std::vector< std::string > *  errors 
)

◆ UnescapeCEscapeSequences() [3/3]

PROTOBUF_EXPORT int google::protobuf::UnescapeCEscapeSequences ( const char *  source,
char *  dest,
std::vector< string > *  errors 
)

◆ UnescapeCEscapeString() [1/6]

PROTOBUF_EXPORT std::string google::protobuf::UnescapeCEscapeString ( const std::string &  src)

◆ UnescapeCEscapeString() [2/6]

PROTOBUF_EXPORT int google::protobuf::UnescapeCEscapeString ( const std::string &  src,
std::string *  dest 
)

◆ UnescapeCEscapeString() [3/6]

PROTOBUF_EXPORT int google::protobuf::UnescapeCEscapeString ( const std::string &  src,
std::string *  dest,
std::vector< std::string > *  errors 
)

◆ UnescapeCEscapeString() [4/6]

PROTOBUF_EXPORT string google::protobuf::UnescapeCEscapeString ( const string &  src)

◆ UnescapeCEscapeString() [5/6]

PROTOBUF_EXPORT int google::protobuf::UnescapeCEscapeString ( const string &  src,
string *  dest 
)

◆ UnescapeCEscapeString() [6/6]

PROTOBUF_EXPORT int google::protobuf::UnescapeCEscapeString ( const string &  src,
string *  dest,
std::vector< string > *  errors 
)

◆ UnsafeArenaAllocatedRepeatedPtrFieldBackInserter()

template<typename T >
internal::UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator< T > google::protobuf::UnsafeArenaAllocatedRepeatedPtrFieldBackInserter ( RepeatedPtrField< T > *const  mutable_field)

◆ UpdateReturnCopy() [1/2]

template<class Collection >
bool google::protobuf::UpdateReturnCopy ( Collection *const  collection,
const typename Collection::value_type vt,
typename Collection::value_type::second_type *  previous 
)

◆ UpdateReturnCopy() [2/2]

template<class Collection >
bool google::protobuf::UpdateReturnCopy ( Collection *const  collection,
const typename Collection::value_type::first_type &  key,
const typename Collection::value_type::second_type &  value,
typename Collection::value_type::second_type *  previous 
)

◆ UpperString() [1/2]

void google::protobuf::UpperString ( std::string *  s)
inline

◆ UpperString() [2/2]

void google::protobuf::UpperString ( string *  s)
inline

◆ UsageError()

void google::protobuf::UsageError ( )

◆ UTF8FirstLetterNumBytes()

PROTOBUF_EXPORT int google::protobuf::UTF8FirstLetterNumBytes ( const char *  src,
int  len 
)

◆ ValidateQualifiedName() [1/2]

static bool google::protobuf::ValidateQualifiedName ( const std::string &  name)
static

◆ ValidateQualifiedName() [2/2]

static bool google::protobuf::ValidateQualifiedName ( StringPiece  name)
static

Definition at line 4445 of file protobuf/src/google/protobuf/descriptor.cc.

◆ WebSafeBase64Escape() [1/5]

PROTOBUF_EXPORT int google::protobuf::WebSafeBase64Escape ( const unsigned char *  src,
int  szsrc,
char *  dest,
int  szdest,
bool  do_padding 
)

◆ WebSafeBase64Escape() [2/5]

PROTOBUF_EXPORT void google::protobuf::WebSafeBase64Escape ( const unsigned char *  src,
int  szsrc,
std::string *  dest,
bool  do_padding 
)

◆ WebSafeBase64Escape() [3/5]

PROTOBUF_EXPORT void google::protobuf::WebSafeBase64Escape ( const unsigned char *  src,
int  szsrc,
string *  dest,
bool  do_padding 
)

◆ WebSafeBase64Escape() [4/5]

PROTOBUF_EXPORT void google::protobuf::WebSafeBase64Escape ( StringPiece  src,
std::string *  dest 
)

◆ WebSafeBase64Escape() [5/5]

PROTOBUF_EXPORT void google::protobuf::WebSafeBase64Escape ( StringPiece  src,
string *  dest 
)

◆ WebSafeBase64EscapeWithPadding() [1/2]

PROTOBUF_EXPORT void google::protobuf::WebSafeBase64EscapeWithPadding ( StringPiece  src,
std::string *  dest 
)

◆ WebSafeBase64EscapeWithPadding() [2/2]

PROTOBUF_EXPORT void google::protobuf::WebSafeBase64EscapeWithPadding ( StringPiece  src,
string *  dest 
)

◆ WebSafeBase64Unescape() [1/3]

PROTOBUF_EXPORT int google::protobuf::WebSafeBase64Unescape ( const char *  src,
int  szsrc,
char *  dest,
int  szdest 
)

◆ WebSafeBase64Unescape() [2/3]

PROTOBUF_EXPORT bool google::protobuf::WebSafeBase64Unescape ( StringPiece  src,
std::string *  dest 
)

◆ WebSafeBase64Unescape() [3/3]

PROTOBUF_EXPORT bool google::protobuf::WebSafeBase64Unescape ( StringPiece  src,
string *  dest 
)

◆ WrapString() [1/2]

static std::string google::protobuf::WrapString ( const char *  value)
static

◆ WrapString() [2/2]

static std::string google::protobuf::WrapString ( const char *  value)
static

Definition at line 55 of file inlined_string_field_unittest.cc.

Variable Documentation

◆ __path__

google.protobuf.__path__ = __import__('pkgutil').extend_path(__path__, __name__)
private

◆ __version__

string google.protobuf.__version__ = '3.9.1'
private

◆ DEFAULT_FILE_MODE

const int google::protobuf::DEFAULT_FILE_MODE = 0777

◆ empty_default

const std::string* google::protobuf::empty_default = &internal::GetEmptyString()

◆ ERROR [1/2]

const LogLevel google::protobuf::ERROR = LOGLEVEL_ERROR
static

◆ ERROR [2/2]

const LogLevel google::protobuf::ERROR = LOGLEVEL_ERROR
static

◆ extension

const Descriptor::ReservedRange const EnumValueDescriptor const MethodDescriptor google::protobuf::extension

◆ kBase64Chars [1/2]

const char google::protobuf::kBase64Chars[]
static
Initial value:
=
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

Definition at line 2189 of file protobuf/src/google/protobuf/stubs/strutil.cc.

◆ kBase64Chars [2/2]

const char google::protobuf::kBase64Chars[]
static
Initial value:
=
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

Definition at line 2200 of file bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc.

◆ kDoubleToBufferSize [1/2]

const int google::protobuf::kDoubleToBufferSize = 32
static

◆ kDoubleToBufferSize [2/2]

const int google::protobuf::kDoubleToBufferSize = 32
static

◆ kFastInt32ToBufferOffset [1/2]

const int google::protobuf::kFastInt32ToBufferOffset = 11
static

◆ kFastInt32ToBufferOffset [2/2]

const int google::protobuf::kFastInt32ToBufferOffset = 11
static

◆ kFastInt64ToBufferOffset [1/2]

const int google::protobuf::kFastInt64ToBufferOffset = 21
static

◆ kFastInt64ToBufferOffset [2/2]

const int google::protobuf::kFastInt64ToBufferOffset = 21
static

◆ kFastToBufferSize [1/2]

const int google::protobuf::kFastToBufferSize = 32
static

◆ kFastToBufferSize [2/2]

const int google::protobuf::kFastToBufferSize = 32
static

◆ kFloatToBufferSize [1/2]

const int google::protobuf::kFloatToBufferSize = 24
static

◆ kFloatToBufferSize [2/2]

const int google::protobuf::kFloatToBufferSize = 24
static

◆ kint32max [1/2]

const int32 google::protobuf::kint32max = 0x7FFFFFFF
static

◆ kint32max [2/2]

const int32 google::protobuf::kint32max = 0x7FFFFFFF
static

◆ kint32min [1/2]

const int32 google::protobuf::kint32min = -kint32max - 1
static

◆ kint32min [2/2]

const int32 google::protobuf::kint32min = -kint32max - 1
static

◆ kint64max [1/2]

const int64 google::protobuf::kint64max = int64_t{0x7FFFFFFFFFFFFFFF}
static

◆ kint64max [2/2]

const int64 google::protobuf::kint64max = PROTOBUF_LONGLONG(0x7FFFFFFFFFFFFFFF)
static

◆ kint64min [1/2]

const int64 google::protobuf::kint64min = -kint64max - 1
static

◆ kint64min [2/2]

const int64 google::protobuf::kint64min = -kint64max - 1
static

◆ kNonLinkedWeakMessageReplacementName [1/2]

const char* const google::protobuf::kNonLinkedWeakMessageReplacementName = "google.protobuf.Empty"
static

◆ kNonLinkedWeakMessageReplacementName [2/2]

const char* const google::protobuf::kNonLinkedWeakMessageReplacementName = "google.protobuf.Empty"
static

Definition at line 362 of file protobuf/src/google/protobuf/descriptor.cc.

◆ kStringPrintfVectorMaxArgs

const PROTOBUF_EXPORT int google::protobuf::kStringPrintfVectorMaxArgs = 32

◆ kuint128max

const PROTOBUF_EXPORT uint128_pod google::protobuf::kuint128max
Initial value:
= {
static_cast<uint64>(PROTOBUF_LONGLONG(0xFFFFFFFFFFFFFFFF)),
static_cast<uint64>(PROTOBUF_LONGLONG(0xFFFFFFFFFFFFFFFF))
}

Definition at line 44 of file bloaty/third_party/protobuf/src/google/protobuf/stubs/int128.cc.

◆ kuint32max [1/2]

const uint32 google::protobuf::kuint32max = 0xFFFFFFFFu
static

◆ kuint32max [2/2]

const uint32 google::protobuf::kuint32max = 0xFFFFFFFFu
static

◆ kuint64max [1/2]

const uint64 google::protobuf::kuint64max = uint64_t{0xFFFFFFFFFFFFFFFFu}
static

◆ kuint64max [2/2]

const uint64 google::protobuf::kuint64max = PROTOBUF_ULONGLONG(0xFFFFFFFFFFFFFFFF)
static

◆ kUnBase64 [1/2]

const signed char google::protobuf::kUnBase64[]
static

◆ kUnBase64 [2/2]

const signed char google::protobuf::kUnBase64[]
static

◆ kUnknownFieldRecursionLimit

constexpr int google::protobuf::kUnknownFieldRecursionLimit = 10
staticconstexpr

◆ kUnWebSafeBase64 [1/2]

const signed char google::protobuf::kUnWebSafeBase64[]
static

◆ kUnWebSafeBase64 [2/2]

const signed char google::protobuf::kUnWebSafeBase64[]
static

◆ kUTF8LenTbl [1/2]

const unsigned char google::protobuf::kUTF8LenTbl[256]
static
Initial value:
= {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 4, 4, 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}

Definition at line 2279 of file protobuf/src/google/protobuf/stubs/strutil.cc.

◆ kUTF8LenTbl [2/2]

const unsigned char google::protobuf::kUTF8LenTbl[256]
static
Initial value:
= {
1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,
2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,
3,3,3,3,3,3,3,3, 3,3,3,3,3,3,3,3, 4,4,4,4,4,4,4,4, 4,4,4,4,4,4,4,4
}

Definition at line 2290 of file bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc.

◆ kWebSafeBase64Chars [1/2]

const char google::protobuf::kWebSafeBase64Chars[]
static
Initial value:
=
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"

Definition at line 2192 of file protobuf/src/google/protobuf/stubs/strutil.cc.

◆ kWebSafeBase64Chars [2/2]

const char google::protobuf::kWebSafeBase64Chars[]
static
Initial value:
=
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"

Definition at line 2203 of file bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc.

◆ method

const Descriptor::ReservedRange const EnumValueDescriptor google::protobuf::method

◆ nonempty_default

const internal::LazyString google::protobuf::nonempty_default {{{"default", 7}}, {nullptr}}

◆ original_stderr_ [1/2]

int google::protobuf::original_stderr_ = -1
static

◆ original_stderr_ [2/2]

int google::protobuf::original_stderr_ = -1
static

◆ original_stdout_ [1/2]

int google::protobuf::original_stdout_ = -1
static

◆ original_stdout_ [2/2]

int google::protobuf::original_stdout_ = -1
static

◆ RepeatedField< bool >

template class PROTOBUF_EXPORT_TEMPLATE_DECLARE google::protobuf::RepeatedField< bool >

◆ RepeatedField< double >

template class PROTOBUF_EXPORT_TEMPLATE_DECLARE google::protobuf::RepeatedField< double >

◆ RepeatedField< float >

template class PROTOBUF_EXPORT_TEMPLATE_DECLARE google::protobuf::RepeatedField< float >

◆ RepeatedField< int32 >

template class PROTOBUF_EXPORT google::protobuf::RepeatedField< int32 >

◆ RepeatedField< int32_t >

template class PROTOBUF_EXPORT_TEMPLATE_DECLARE google::protobuf::RepeatedField< int32_t >

◆ RepeatedField< int64 >

template class PROTOBUF_EXPORT google::protobuf::RepeatedField< int64 >

◆ RepeatedField< int64_t >

template class PROTOBUF_EXPORT_TEMPLATE_DECLARE google::protobuf::RepeatedField< int64_t >

◆ RepeatedField< uint32 >

template class PROTOBUF_EXPORT google::protobuf::RepeatedField< uint32 >

◆ RepeatedField< uint32_t >

template class PROTOBUF_EXPORT_TEMPLATE_DECLARE google::protobuf::RepeatedField< uint32_t >

◆ RepeatedField< uint64 >

template class PROTOBUF_EXPORT google::protobuf::RepeatedField< uint64 >

◆ RepeatedField< uint64_t >

template class PROTOBUF_EXPORT_TEMPLATE_DECLARE google::protobuf::RepeatedField< uint64_t >

◆ reserved_range

const Descriptor::ReservedRange google::protobuf::reserved_range

◆ service

const Descriptor::ReservedRange const EnumDescriptor::ReservedRange google::protobuf::service

Definition at line 2177 of file protobuf/src/google/protobuf/descriptor.h.

◆ stderr_capture_filename_ [1/2]

std::string google::protobuf::stderr_capture_filename_
static

◆ stderr_capture_filename_ [2/2]

string google::protobuf::stderr_capture_filename_
static

◆ stdout_capture_filename_ [1/2]

std::string google::protobuf::stdout_capture_filename_
static

◆ stdout_capture_filename_ [2/2]

string google::protobuf::stdout_capture_filename_
static

◆ string_printf_empty_block [1/2]

const char google::protobuf::string_printf_empty_block[256] = { '\0' }
static

◆ string_printf_empty_block [2/2]

const char google::protobuf::string_printf_empty_block[256] = { '\0' }
static

◆ two_ASCII_digits [1/2]

const char google::protobuf::two_ASCII_digits[100][2]
static
Initial value:
= {
{'0','0'}, {'0','1'}, {'0','2'}, {'0','3'}, {'0','4'},
{'0','5'}, {'0','6'}, {'0','7'}, {'0','8'}, {'0','9'},
{'1','0'}, {'1','1'}, {'1','2'}, {'1','3'}, {'1','4'},
{'1','5'}, {'1','6'}, {'1','7'}, {'1','8'}, {'1','9'},
{'2','0'}, {'2','1'}, {'2','2'}, {'2','3'}, {'2','4'},
{'2','5'}, {'2','6'}, {'2','7'}, {'2','8'}, {'2','9'},
{'3','0'}, {'3','1'}, {'3','2'}, {'3','3'}, {'3','4'},
{'3','5'}, {'3','6'}, {'3','7'}, {'3','8'}, {'3','9'},
{'4','0'}, {'4','1'}, {'4','2'}, {'4','3'}, {'4','4'},
{'4','5'}, {'4','6'}, {'4','7'}, {'4','8'}, {'4','9'},
{'5','0'}, {'5','1'}, {'5','2'}, {'5','3'}, {'5','4'},
{'5','5'}, {'5','6'}, {'5','7'}, {'5','8'}, {'5','9'},
{'6','0'}, {'6','1'}, {'6','2'}, {'6','3'}, {'6','4'},
{'6','5'}, {'6','6'}, {'6','7'}, {'6','8'}, {'6','9'},
{'7','0'}, {'7','1'}, {'7','2'}, {'7','3'}, {'7','4'},
{'7','5'}, {'7','6'}, {'7','7'}, {'7','8'}, {'7','9'},
{'8','0'}, {'8','1'}, {'8','2'}, {'8','3'}, {'8','4'},
{'8','5'}, {'8','6'}, {'8','7'}, {'8','8'}, {'8','9'},
{'9','0'}, {'9','1'}, {'9','2'}, {'9','3'}, {'9','4'},
{'9','5'}, {'9','6'}, {'9','7'}, {'9','8'}, {'9','9'}
}

Definition at line 940 of file protobuf/src/google/protobuf/stubs/strutil.cc.

◆ two_ASCII_digits [2/2]

const char google::protobuf::two_ASCII_digits[100][2]
static
Initial value:
= {
{'0','0'}, {'0','1'}, {'0','2'}, {'0','3'}, {'0','4'},
{'0','5'}, {'0','6'}, {'0','7'}, {'0','8'}, {'0','9'},
{'1','0'}, {'1','1'}, {'1','2'}, {'1','3'}, {'1','4'},
{'1','5'}, {'1','6'}, {'1','7'}, {'1','8'}, {'1','9'},
{'2','0'}, {'2','1'}, {'2','2'}, {'2','3'}, {'2','4'},
{'2','5'}, {'2','6'}, {'2','7'}, {'2','8'}, {'2','9'},
{'3','0'}, {'3','1'}, {'3','2'}, {'3','3'}, {'3','4'},
{'3','5'}, {'3','6'}, {'3','7'}, {'3','8'}, {'3','9'},
{'4','0'}, {'4','1'}, {'4','2'}, {'4','3'}, {'4','4'},
{'4','5'}, {'4','6'}, {'4','7'}, {'4','8'}, {'4','9'},
{'5','0'}, {'5','1'}, {'5','2'}, {'5','3'}, {'5','4'},
{'5','5'}, {'5','6'}, {'5','7'}, {'5','8'}, {'5','9'},
{'6','0'}, {'6','1'}, {'6','2'}, {'6','3'}, {'6','4'},
{'6','5'}, {'6','6'}, {'6','7'}, {'6','8'}, {'6','9'},
{'7','0'}, {'7','1'}, {'7','2'}, {'7','3'}, {'7','4'},
{'7','5'}, {'7','6'}, {'7','7'}, {'7','8'}, {'7','9'},
{'8','0'}, {'8','1'}, {'8','2'}, {'8','3'}, {'8','4'},
{'8','5'}, {'8','6'}, {'8','7'}, {'8','8'}, {'8','9'},
{'9','0'}, {'9','1'}, {'9','2'}, {'9','3'}, {'9','4'},
{'9','5'}, {'9','6'}, {'9','7'}, {'9','8'}, {'9','9'}
}

Definition at line 962 of file bloaty/third_party/protobuf/src/google/protobuf/stubs/strutil.cc.

◆ UTFmax [1/2]

const int google::protobuf::UTFmax = 4
static

◆ UTFmax [2/2]

const int google::protobuf::UTFmax = 4
static

◆ value

const Descriptor::ReservedRange google::protobuf::value

◆ WARNING [1/2]

const LogLevel google::protobuf::WARNING = LOGLEVEL_WARNING
static

◆ WARNING [2/2]

const LogLevel google::protobuf::WARNING = LOGLEVEL_WARNING
static
google::protobuf::uint64
uint64_t uint64
Definition: third_party/bloaty/third_party/protobuf/src/google/protobuf/stubs/port.h:156


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