Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
google.protobuf.internal Namespace Reference

Namespaces

 _parameterized
 
 api_implementation
 
 containers
 
 decoder
 
 descriptor_database_test
 
 descriptor_pool_test
 
 descriptor_test
 
 encoder
 
 enum_type_wrapper
 
 extension_dict
 
 generator_test
 
 import_test_package
 
 json_format_test
 
 keywords_test
 
 message_factory_test
 
 message_listener
 
 message_test
 
 proto_builder_test
 
 python_message
 
 reflection_test
 
 service_reflection_test
 
 symbol_database_test
 
 test_util
 
 testing_refleaks
 
 text_encoding_test
 
 text_format_test
 
 type_checkers
 
 unknown_fields_test
 
 well_known_types
 
 well_known_types_test
 
 wire_format
 
 wire_format_test
 

Classes

class  AccessorHelper
 
struct  AddDescriptorsRunner
 
class  AllocatedRepeatedPtrFieldBackInsertIterator
 
struct  AllocationPolicy
 
struct  and_
 
class  AnyMetadata
 
class  ArenaHolder
 
class  ArenaImpl
 
class  ArenaMetricsCollector
 
struct  ArenaStringPtr
 
struct  ArrayOutput
 
union  AuxiliaryParseTableField
 
union  AuxillaryParseTableField
 
struct  big_
 
struct  BoundedZCIS
 
class  CachedSize
 
class  CallOnceInitializedMutex
 
class  CodedOutputStreamFieldSkipper
 
struct  CompareByDerefFirst
 
struct  CompareByFirstField
 
struct  CompareHelper
 
struct  CompareHelper< ArenaStringPtr >
 
struct  CompareMapKey
 
struct  CompileAssert
 
struct  ConstantInitialized
 
struct  DateTime
 
struct  DeconstructMapEntry
 
struct  DeconstructMapEntry< MapEntry< Derived, K, V, key, value > >
 
struct  DeconstructMapEntry< MapEntry< Derived, K, V, key, value, default_enum > >
 
struct  DeconstructMapEntry< MapEntryLite< T, K, V, key, value > >
 
struct  DeconstructMapEntry< MapEntryLite< T, K, V, key, value, default_enum > >
 
class  DescriptorPoolExtensionFinder
 
struct  DescriptorTable
 
class  DynamicMapField
 
struct  ElementCopier
 
struct  ElementCopier< Element, true >
 
struct  EndianHelper
 
struct  EndianHelper< 1 >
 
struct  EndianHelper< 2 >
 
struct  EndianHelper< 4 >
 
struct  EndianHelper< 8 >
 
struct  EnumEntry
 
struct  EnumParseWrapper
 
class  EnumTypeTraits
 
class  EpsCopyInputStream
 
class  ExplicitlyConstructed
 
class  ExtensionFinder
 
class  ExtensionIdentifier
 
struct  ExtensionInfo
 
class  ExtensionSet
 
struct  FieldMetadata
 
class  FieldSkipper
 
struct  FromHelper
 
struct  FromHelper< WireFormatLite::TYPE_BYTES >
 
struct  FromHelper< WireFormatLite::TYPE_MESSAGE >
 
struct  FromHelper< WireFormatLite::TYPE_STRING >
 
class  FunctionClosure0
 
class  FunctionClosure1
 
class  FunctionClosure2
 
class  FunctionResultCallback_0_0
 
class  FunctionResultCallback_0_1
 
class  FunctionResultCallback_1_0
 
class  FunctionResultCallback_1_1
 
class  GeneratedExtensionFinder
 
class  GenericTypeHandler
 
class  GetDeallocator
 
class  HasBits
 
struct  identity_
 
struct  if_
 
struct  if_< false, A, B >
 
class  ImplicitWeakMessage
 
class  ImplicitWeakTypeHandler
 
class  InlinedStringField
 
struct  integral_constant
 
struct  InternalConstRef
 
class  InternalMetadata
 
class  InternalMetadataWithArena
 
class  InternalMetadataWithArenaBase
 
class  InternalMetadataWithArenaLite
 
struct  IsMovable
 
class  LazyDescriptor
 
class  LazyString
 
class  LiteUnknownFieldSetter
 
class  LogFinisher
 
class  LogMessage
 
class  MapAllocator
 
class  MapArenaMessageCreator
 
class  MapArenaMessageCreator< Type, false >
 
class  MapArenaMessageCreator< Type, true >
 
class  MapEntry
 
struct  MapEntryFuncs
 
struct  MapEntryHelper
 
struct  MapEntryHelper< MapEntry< Derived, Key, Value, kKeyFieldType, kValueFieldType > >
 
struct  MapEntryHelper< MapEntry< Derived, Key, Value, kKeyFieldType, kValueFieldType, default_enum_value > >
 
struct  MapEntryHelper< MapEntryLite< T, Key, Value, kKeyFieldType, kValueFieldType > >
 
struct  MapEntryHelper< MapEntryLite< T, Key, Value, kKeyFieldType, kValueFieldType, default_enum_value > >
 
class  MapEntryImpl
 
class  MapEntryLite
 
struct  MapEntryToMapField
 
struct  MapEntryToMapField< MapEntry< T, Key, Value, kKeyFieldType, kValueFieldType > >
 
struct  MapEntryToMapField< MapEntry< T, Key, Value, kKeyFieldType, kValueFieldType, default_enum_value > >
 
struct  MapEntryToMapField< MapEntryLite< T, Key, Value, kKeyFieldType, kValueFieldType > >
 
struct  MapEntryToMapField< MapEntryLite< T, Key, Value, kKeyFieldType, kValueFieldType, default_enum_value > >
 
class  MapField
 
class  MapFieldAccessor
 
class  MapFieldBase
 
class  MapFieldBasePrimitiveTest
 
class  MapFieldBaseStub
 
class  MapFieldInDynamicMessageTest
 
class  MapFieldLite
 
class  MapFieldPrinterHelper
 
class  MapFieldReflectionTest
 
class  MapFieldStateTest
 
struct  MapIf
 
struct  MapIf< false, TrueType, FalseType >
 
struct  MapIf< true, TrueType, FalseType >
 
class  MapImplTest
 
class  MapKeySorter
 
class  MapTypeHandler
 
class  MapTypeHandler< WireFormatLite::TYPE_MESSAGE, Type >
 
class  MapValueInitializer
 
class  MapValueInitializer< false, Type >
 
class  MapValueInitializer< true, Type >
 
class  MapWireFieldTypeTraits
 
class  MergePartialFromCodedStreamHelper
 
struct  MessageDescriptorGetter
 
struct  MessageDescriptorGetter< Message >
 
struct  MessageOwned
 
class  MessageSetFieldSkipper
 
class  MessageTypeTraits
 
class  MethodClosure0
 
class  MethodClosure1
 
class  MethodClosure2
 
class  MethodResultCallback_0_0
 
class  MethodResultCallback_6_2
 
struct  MigrationSchema
 
struct  MoveHelper
 
struct  MoveHelper< false, false, true, T >
 
struct  MoveHelper< false, true, is_stringlike, T >
 
struct  MoveHelper< true, is_message, is_stringlike, T >
 
class  MutexLock
 
class  MutexLockMaybe
 
class  MyMapField
 
class  NoHeapChecker
 
struct  ObjectDestructor
 
struct  ObjectDestructor< true, T >
 
struct  OneOfFieldHelper
 
struct  OneOfFieldHelper< FieldMetadata::kInlinedType >
 
struct  or_
 
struct  OutputHelper
 
struct  OutputHelper< ArrayOutput, type >
 
struct  OutputHelper< io::CodedOutputStream, type >
 
struct  PackedFieldHelper
 
struct  PackedFieldHelper< FieldMetadata::kInlinedType >
 
struct  PackedFieldHelper< WireFormatLite::TYPE_BYTES >
 
struct  PackedFieldHelper< WireFormatLite::TYPE_GROUP >
 
struct  PackedFieldHelper< WireFormatLite::TYPE_MESSAGE >
 
struct  PackedFieldHelper< WireFormatLite::TYPE_STRING >
 
class  ParseContext
 
struct  ParseTable
 
struct  ParseTableField
 
struct  PrimitiveTraits
 
struct  PrimitiveTypeHelper
 
struct  PrimitiveTypeHelper< FieldMetadata::kInlinedType >
 
struct  PrimitiveTypeHelper< WireFormatLite::TYPE_BOOL >
 
struct  PrimitiveTypeHelper< WireFormatLite::TYPE_BYTES >
 
struct  PrimitiveTypeHelper< WireFormatLite::TYPE_DOUBLE >
 
struct  PrimitiveTypeHelper< WireFormatLite::TYPE_ENUM >
 
struct  PrimitiveTypeHelper< WireFormatLite::TYPE_FIXED32 >
 
struct  PrimitiveTypeHelper< WireFormatLite::TYPE_FIXED64 >
 
struct  PrimitiveTypeHelper< WireFormatLite::TYPE_FLOAT >
 
struct  PrimitiveTypeHelper< WireFormatLite::TYPE_INT32 >
 
struct  PrimitiveTypeHelper< WireFormatLite::TYPE_INT64 >
 
struct  PrimitiveTypeHelper< WireFormatLite::TYPE_SFIXED32 >
 
struct  PrimitiveTypeHelper< WireFormatLite::TYPE_SFIXED64 >
 
struct  PrimitiveTypeHelper< WireFormatLite::TYPE_SINT32 >
 
struct  PrimitiveTypeHelper< WireFormatLite::TYPE_SINT64 >
 
struct  PrimitiveTypeHelper< WireFormatLite::TYPE_STRING >
 
struct  PrimitiveTypeHelper< WireFormatLite::TYPE_UINT32 >
 
struct  PrimitiveTypeHelper< WireFormatLite::TYPE_UINT64 >
 
class  PrimitiveTypeTraits
 
class  Proto3ArenaTestHelper
 
class  RandomAccessRepeatedFieldAccessor
 
class  ReflectionAccessor
 
class  ReflectionOps
 
struct  ReflectionSchema
 
struct  RefTypeTraits
 
struct  RefTypeTraits< T, typename std::enable_if< is_proto_enum< T >::value >::type >
 
struct  RefTypeTraits< T, typename std::enable_if< PrimitiveTraits< T >::is_primitive >::type >
 
struct  RefTypeTraits< T, typename std::enable_if< std::is_base_of< Message, T >::value >::type >
 
struct  RefTypeTraits< T, typename std::enable_if< std::is_same< std::string, T >::value >::type >
 
struct  RemapEntry
 
struct  RemoveConst
 
struct  RemoveConst< const T >
 
class  RepeatedEnumTypeTraits
 
class  RepeatedFieldAccessor
 
class  RepeatedFieldBackInsertIterator
 
struct  RepeatedFieldHelper
 
struct  RepeatedFieldHelper< FieldMetadata::kInlinedType >
 
struct  RepeatedFieldHelper< WireFormatLite::TYPE_BYTES >
 
struct  RepeatedFieldHelper< WireFormatLite::TYPE_GROUP >
 
struct  RepeatedFieldHelper< WireFormatLite::TYPE_MESSAGE >
 
struct  RepeatedFieldHelper< WireFormatLite::TYPE_STRING >
 
class  RepeatedFieldPrimitiveAccessor
 
class  RepeatedFieldRefIterator
 
class  RepeatedFieldWrapper
 
class  RepeatedMessageTypeHandler
 
class  RepeatedMessageTypeTraits
 
class  RepeatedPrimitiveDefaults
 
class  RepeatedPrimitiveTypeTraits
 
class  RepeatedPtrFieldBackInsertIterator
 
class  RepeatedPtrFieldBase
 
class  RepeatedPtrFieldMessageAccessor
 
class  RepeatedPtrFieldStringAccessor
 
class  RepeatedPtrFieldWrapper
 
class  RepeatedPtrIterator
 
class  RepeatedPtrOverPtrsIterator
 
class  RepeatedStringTypeTraits
 
struct  SCCInfo
 
struct  SCCInfoBase
 
class  SerialArena
 
struct  SerializationTable
 
struct  ShutdownData
 
struct  SingularFieldHelper
 
struct  SingularFieldHelper< FieldMetadata::kInlinedType >
 
struct  SingularFieldHelper< WireFormatLite::TYPE_BYTES >
 
struct  SingularFieldHelper< WireFormatLite::TYPE_GROUP >
 
struct  SingularFieldHelper< WireFormatLite::TYPE_MESSAGE >
 
struct  SingularFieldHelper< WireFormatLite::TYPE_STRING >
 
struct  SortItem
 
struct  SourceWrapper
 
struct  StringPiecePod
 
class  StringTypeHandler
 
class  StringTypeTraits
 
class  SwapFieldHelper
 
class  SymbolBase
 
class  SymbolBaseN
 
class  TaggedAllocationPolicyPtr
 
class  TaggedPtr
 
struct  TcFieldData
 
class  TcParser
 
struct  TcParseTable
 
struct  TcParseTableBase
 
class  ThreadSafeArena
 
struct  TransparentSupport
 
struct  type_equals_
 
struct  type_equals_< A, A >
 
class  TypeDefinedMapFieldBase
 
struct  TypeImplementsMergeBehavior
 
struct  TypeImplementsMergeBehavior< std::string >
 
struct  TypeImplementsMergeBehaviorProbeForMergeFrom
 
class  UnknownFieldLiteParserHelper
 
class  UnknownFieldParserHelper
 
class  UnknownFieldSetFieldSkipper
 
class  UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator
 
struct  UTF8StateMachineObj
 
class  WireFormat
 
class  WireFormatLite
 
class  ZeroFieldsBase
 

Typedefs

typedef bool EnumValidityFunc(int number)
 
typedef bool EnumValidityFuncWithArg(const void *arg, int number)
 
typedef false_type false_
 
typedef integral_constant< bool, falsefalse_type
 
typedef uint8 FieldType
 
template<typename T >
using KeyForTree = typename std::conditional< std::is_scalar< T >::value, T, std::reference_wrapper< const T > >::type
 
using LifecycleId = int64_t
 
using LifecycleIdAtomic = uint64_t
 
template<typename T >
using MakeUnsignedT = typename std::conditional< std::is_integral< T >::value, std::make_unsigned< T >, std::common_type< T > >::type::type
 
using Mutex = WrappedMutex
 
using once_flag = std::once_flag
 
typedef MutexLock ReaderMutexLock
 
typedef char small_
 
typedef void(* SpecialSerializer) (const uint8 *base, uint32 offset, uint32 tag, uint32 has_offset, io::CodedOutputStream *output)
 
template<typename Key >
using TreeForMap = std::map< KeyForTree< Key >, void *, typename TransparentSupport< Key >::less, MapAllocator< std::pair< const KeyForTree< Key >, void * > >>
 
typedef true_type true_
 
typedef integral_constant< bool, truetrue_type
 
typedef UTF8StateMachineObj UTF8ScanObj
 
typedef MutexLock WriterMutexLock
 

Enumerations

enum  { kInvalidFieldOffsetTag = 0x40000000u }
 
enum  Cardinality {
  Cardinality_SINGULAR = 0, Cardinality_REPEATED = 1, Cardinality_ONEOF = 3, Cardinality_SINGULAR = 0,
  Cardinality_REPEATED = 1, Cardinality_ONEOF = 3
}
 
enum  Cardinality {
  Cardinality_SINGULAR = 0, Cardinality_REPEATED = 1, Cardinality_ONEOF = 3, Cardinality_SINGULAR = 0,
  Cardinality_REPEATED = 1, Cardinality_ONEOF = 3
}
 
enum  ExitReason {
  kExitDstSpaceFull = 239, kExitIllegalStructure, kExitOK, kExitReject,
  kExitReplace1, kExitReplace2, kExitReplace3, kExitReplace21,
  kExitReplace31, kExitReplace32, kExitReplaceOffset1, kExitReplaceOffset2,
  kExitReplace1S0, kExitSpecial, kExitDoAgain, kExitRejectAlt,
  kExitNone, kExitDstSpaceFull = 239, kExitIllegalStructure, kExitOK,
  kExitReject, kExitReplace1, kExitReplace2, kExitReplace3,
  kExitReplace21, kExitReplace31, kExitReplace32, kExitReplaceOffset1,
  kExitReplaceOffset2, kExitReplace1S0, kExitSpecial, kExitDoAgain,
  kExitRejectAlt, kExitNone
}
 
enum  ExitReason {
  kExitDstSpaceFull = 239, kExitIllegalStructure, kExitOK, kExitReject,
  kExitReplace1, kExitReplace2, kExitReplace3, kExitReplace21,
  kExitReplace31, kExitReplace32, kExitReplaceOffset1, kExitReplaceOffset2,
  kExitReplace1S0, kExitSpecial, kExitDoAgain, kExitRejectAlt,
  kExitNone, kExitDstSpaceFull = 239, kExitIllegalStructure, kExitOK,
  kExitReject, kExitReplace1, kExitReplace2, kExitReplace3,
  kExitReplace21, kExitReplace31, kExitReplace32, kExitReplaceOffset1,
  kExitReplaceOffset2, kExitReplace1S0, kExitSpecial, kExitDoAgain,
  kExitRejectAlt, kExitNone
}
 
enum  ProcessingType {
  ProcessingType_STRING = 0, ProcessingType_CORD = 1, ProcessingType_STRING_PIECE = 2, ProcessingType_INLINED = 3,
  ProcessingType_MESSAGE = 4, ProcessingType_STRING = 0, ProcessingType_CORD = 1, ProcessingType_STRING_PIECE = 2,
  ProcessingType_INLINED = 3, ProcessingType_MESSAGE = 4
}
 
enum  ProcessingType {
  ProcessingType_STRING = 0, ProcessingType_CORD = 1, ProcessingType_STRING_PIECE = 2, ProcessingType_INLINED = 3,
  ProcessingType_MESSAGE = 4, ProcessingType_STRING = 0, ProcessingType_CORD = 1, ProcessingType_STRING_PIECE = 2,
  ProcessingType_INLINED = 3, ProcessingType_MESSAGE = 4
}
 
enum  ProcessingTypes {
  TYPE_STRING_CORD = 19, TYPE_STRING_STRING_PIECE = 20, TYPE_BYTES_CORD = 21, TYPE_BYTES_STRING_PIECE = 22,
  TYPE_STRING_INLINED = 23, TYPE_BYTES_INLINED = 24, TYPE_MAP = 25, TYPE_STRING_CORD = 19,
  TYPE_STRING_STRING_PIECE = 20, TYPE_BYTES_CORD = 21, TYPE_BYTES_STRING_PIECE = 22, TYPE_STRING_INLINED = 23,
  TYPE_BYTES_INLINED = 24, TYPE_MAP = 25
}
 
enum  ProcessingTypes {
  TYPE_STRING_CORD = 19, TYPE_STRING_STRING_PIECE = 20, TYPE_BYTES_CORD = 21, TYPE_BYTES_STRING_PIECE = 22,
  TYPE_STRING_INLINED = 23, TYPE_BYTES_INLINED = 24, TYPE_MAP = 25, TYPE_STRING_CORD = 19,
  TYPE_STRING_STRING_PIECE = 20, TYPE_BYTES_CORD = 21, TYPE_BYTES_STRING_PIECE = 22, TYPE_STRING_INLINED = 23,
  TYPE_BYTES_INLINED = 24, TYPE_MAP = 25
}
 
enum  StringType { StringType_STRING = 0, StringType_INLINED = 3, StringType_STRING = 0, StringType_INLINED = 3 }
 
enum  StringType { StringType_STRING = 0, StringType_INLINED = 3, StringType_STRING = 0, StringType_INLINED = 3 }
 

Functions

void AddDescriptors (const DescriptorTable *table)
 
template<typename Type >
TypeAddField (MessageLite *msg, int64 offset)
 
template<typename Type >
void AddField (MessageLite *msg, int64 offset, Type value)
 
template<>
std::string * AddField< std::string > (MessageLite *msg, int64 offset)
 
template<size_t align>
void AlignFail (uintptr_t address)
 
template void AlignFail< 4 > (uintptr_t)
 
template void AlignFail< 8 > (uintptr_t)
 
PROTOBUF_ALWAYS_INLINE void * AlignTo (void *ptr, size_t align)
 
size_t AlignUpTo8 (size_t n)
 
template<typename Key , typename T >
bool AllAreInitialized (const Map< Key, T > &t)
 
template<typename Derived , typename Key , typename T , WireFormatLite::FieldType key_wire_type, WireFormatLite::FieldType value_wire_type>
bool AllAreInitialized (const MapField< Derived, Key, T, key_wire_type, value_wire_type > &field)
 
template<typename Derived , typename Key , typename T , WireFormatLite::FieldType key_wire_type, WireFormatLite::FieldType value_wire_type>
bool AllAreInitialized (const MapFieldLite< Derived, Key, T, key_wire_type, value_wire_type > &field)
 
template<typename Msg >
bool AllAreInitialized (const RepeatedPtrField< Msg > &t)
 
template<class Type >
bool AllAreInitialized (const Type &t)
 
template<class T >
bool AllAreInitializedWeak (const RepeatedPtrField< T > &t)
 
static SerialArena::Memory AllocateMemory (const AllocationPolicy *policy_ptr, size_t last_size, size_t min_bytes)
 
template<>
bool AlmostEquals (double a, double b)
 
template<>
bool AlmostEquals (float a, float b)
 
template<typename T >
bool AlmostEquals (T a, T b)
 
template<typename T >
void arena_delete_object (void *object)
 
template<typename T >
void arena_destruct_object (void *object)
 
void arena_free (void *object, size_t size)
 
Metadata AssignDescriptors (const DescriptorTable *(*table)(), internal::once_flag *once, const Metadata &metadata)
 
void AssignDescriptors (const DescriptorTable *table)
 
void AssignDescriptors (const DescriptorTable *table, bool eager)
 
template<typename To , typename From >
To bit_cast (const From &from)
 
template<int >
void byteswap (void *p)
 
template<>
void byteswap< 1 > (void *p)
 
template<>
void byteswap< 4 > (void *p)
 
template<>
void byteswap< 8 > (void *p)
 
template<typename Iter >
int CalculateReserve (Iter begin, Iter end)
 
template<typename Iter >
int CalculateReserve (Iter begin, Iter end, std::forward_iterator_tag)
 
template<typename Iter >
int CalculateReserve (Iter, Iter, std::input_iterator_tag)
 
int CalculateReserveSize (int total_size, int new_size)
 
template<typename... Args>
void call_once (Args &&... args)
 
static bool CallNoArgValidityFunc (const void *arg, int number)
 
static bool CallNoArgValidityFunc (const void *arg, int number)
 
template<typename T >
TCheckNotNull (const char *, int, const char *name, T *val)
 
void ClearOneofField (const ParseTableField &field, Arena *arena, MessageLite *msg)
 
size_t ComputeUnknownFieldsSize (const InternalMetadata &metadata, size_t total_size, CachedSize *cached_size)
 
size_t ComputeUnknownFieldsSize (const InternalMetadataWithArena &metadata, size_t total_size, CachedSize *cached_size)
 
size_t ComputeUnknownMessageSetItemsSize (const std::string &unknown_fields)
 
size_t ComputeUnknownMessageSetItemsSize (const UnknownFieldSet &unknown_fields)
 
static std::string ConstructKey (uint64 n)
 
static void CopyConstructorHelper (Arena *arena, Map< int32, int32 > *m)
 
FieldDescriptor::CppType cpp_type (FieldType type)
 
bool CreateUnknownEnumValues (const FieldDescriptor *field)
 
bool DateTimeToSeconds (const DateTime &time, int64 *seconds)
 
 DECLARE_STREAM_OPERATOR (long) DECLARE_STREAM_OPERATOR(unsigned long) DECLARE_STREAM_OPERATOR(long long) DECLARE_STREAM_OPERATOR(unsigned long long) LogMessage
 
uint32 DecodeTwoBytes (const char **ptr)
 
void DefaultLogHandler (LogLevel level, const char *filename, int line, const std::string &message)
 
void DefaultLogHandler (LogLevel level, const char *filename, int line, const string &message)
 
void DestroyMessage (const void *message)
 
void DestroyString (const void *s)
 
template<typename T >
static std::string DeterministicSerialization (const T &t)
 
template<typename T >
static std::string DeterministicSerializationWithSerializePartialToCodedStream (const T &t)
 
template<typename T >
static std::string DeterministicSerializationWithSerializeToCodedStream (const T &t)
 
template<typename To , typename From >
To down_cast (From &f)
 
template<typename To , typename From >
To down_cast (From *f)
 
template<typename To , typename From >
To DownCast (From &f)
 
template<typename To , typename From >
To DownCast (From *f)
 
template<typename T >
TDuplicateIfNonNull (T *message)
 
MessageLiteDuplicateIfNonNullInternal (MessageLite *message)
 
template<uint32 tag>
bool ExpectTag (const char *ptr)
 
void ExtensionSerializer (const MessageLite *extendee, const uint8_t *ptr, uint32_t offset, uint32_t tag, uint32_t has_offset, io::CodedOutputStream *output)
 
void ExtensionSerializer (const uint8 *ptr, uint32 offset, uint32 tag, uint32 has_offset, io::CodedOutputStream *output)
 
int fastmemcmp_inlined (const char *a, const char *b, size_t n)
 
WireFormatLite::FieldType field_type (FieldType type)
 
template<typename T >
const PROTOBUF_MUST_USE_RESULT char * FieldParser (uint64 tag, T &field_parser, const char *ptr, ParseContext *ctx)
 
template<typename T >
const PROTOBUF_NODISCARD char * FieldParser (uint64_t tag, T &field_parser, const char *ptr, ParseContext *ctx)
 
template<typename T >
const char * FixedParser (void *object, const char *ptr, ParseContext *ctx)
 
string FormatTime (int64 seconds, int32 nanos)
 
size_t FromIntSize (int size)
 
static int Func (int i, int j)
 
PROTOBUF_EXPORT void GenericSwap (Message *m1, Message *m2)
 
void GenericSwap (MessageLite *m1, MessageLite *m2)
 
template<typename T >
const TGet (const void *ptr)
 
bool GetAnyFieldDescriptors (const Message &message, const FieldDescriptor **type_url_field, const FieldDescriptor **value_field)
 
template<typename InternalMetadata >
ArenaGetArena (MessageLite *msg, int64 arena_offset)
 
template<class To >
const To * GetConstPointerAtOffset (const Message *message, uint32_t offset)
 
template<class To >
const To & GetConstRefAtOffset (const Message &message, uint32_t offset)
 
void GetCurrentTime (int64 *seconds, int32 *nanos)
 
const PROTOBUF_EXPORT std::string & GetEmptyString ()
 
const PROTOBUF_EXPORT std::string & GetEmptyStringAlreadyInited ()
 
ExtensionSetGetExtensionSet (MessageLite *msg, int64 extension_offset)
 
template<typename T >
TGetOwnedMessage (Arena *message_arena, T *submessage, Arena *submessage_arena)
 
MessageLiteGetOwnedMessageInternal (Arena *message_arena, MessageLite *submessage, Arena *submessage_arena)
 
template<class To >
To * GetPointerAtOffset (Message *message, uint32_t offset)
 
static const ReflectionGetReflectionOrDie (const Message &m)
 
static const ReflectionGetReflectionOrDie (const Message &m)
 
std::string GetTypeUrl (StringPiece message_name, StringPiece type_url_prefix)
 
class GOOGLE_PROTOBUF_CAPABILITY ("mutex") PROTOBUF_EXPORT WrappedMutex
 
template<typename UnknownFieldHandler , typename InternalMetadata , Cardinality cardinality>
bool HandleEnum (const ParseTable &table, io::CodedInputStream *input, MessageLite *msg, uint32 *presence, uint32 presence_index, int64 offset, uint32 tag, int field_number)
 
template<typename UnknownFieldHandler , Cardinality cardinality>
bool HandleEnum (const ParseTable &table, io::CodedInputStream *input, MessageLite *msg, uint32_t *presence, uint32_t presence_index, int64_t offset, uint32_t tag, int field_number)
 
template<typename UnknownFieldHandler , Cardinality cardinality, bool is_string_type, StringType ctype>
static bool HandleString (io::CodedInputStream *input, MessageLite *msg, Arena *arena, uint32 *has_bits, uint32 has_bit_index, int64 offset, const void *default_ptr, const char *field_name)
 
template<typename UnknownFieldHandler , Cardinality cardinality, bool is_string_type, StringType ctype>
static bool HandleString (io::CodedInputStream *input, MessageLite *msg, Arena *arena, uint32_t *has_bits, uint32_t has_bit_index, int64_t offset, const void *default_ptr, const char *field_name)
 
template<typename To , typename From >
To implicit_cast (From const &f)
 
template<typename T , typename Metadata >
EnumParseWrapper< T, MetadataInitEnumParseWrapper (T *map_field, bool(*is_valid)(int), uint32 field_num, Metadata *metadata)
 
template<typename UnknownType , typename T >
EnumParseWrapper< UnknownType, TInitEnumParseWrapper (T *map_field, bool(*is_valid)(int), uint32_t field_num, InternalMetadata *metadata)
 
bool InitializeEnumStrings (const EnumEntry *enums, const int *sorted_indices, size_t size, internal::ExplicitlyConstructed< std::string > *enum_strings)
 
void InitImplicitWeakMessageDefaultInstance ()
 
void InitProtobufDefaults ()
 
static bool InitProtobufDefaultsImpl ()
 
static bool InitProtobufDefaultsImpl ()
 
void InitProtobufDefaultsSlow ()
 
void InitSCC (SCCInfoBase *scc)
 
void InitSCCImpl (SCCInfoBase *scc)
 
const char * InlineGreedyStringParser (std::string *s, const char *ptr, ParseContext *ctx)
 
const char * InlineGreedyStringParserUTF8 (std::string *s, const char *ptr, ParseContext *ctx, const char *field_name)
 
const PROTOBUF_MUST_USE_RESULT char * InlineGreedyStringParserUTF8Verify (std::string *s, const char *ptr, ParseContext *ctx, const char *field_name)
 
 INSTANTIATE_TEST_SUITE_P (MapFieldBasePrimitiveTestInstance, MapFieldBasePrimitiveTest, testing::Values(true, false))
 
 INSTANTIATE_TEST_SUITE_P (MapFieldStateTestInstance, MapFieldStateTest, ::testing::Values(CLEAN, MAP_DIRTY, REPEATED_DIRTY))
 
 INSTANTIATE_TEST_SUITE_P (MapFieldStateTestInstance, MapFieldStateTest, testing::Combine(testing::Values(CLEAN, MAP_DIRTY, REPEATED_DIRTY), testing::Values(true, false)))
 
static bool InStateZero (const UTF8ScanObj *st, const uint8 *Tbl)
 
static bool InStateZero (const UTF8ScanObj *st, const uint8 *Tbl)
 
static int Int (const std::string &value)
 
template<>
void InternalMetadata::DoClear< std::string > ()
 
template<>
void InternalMetadata::DoMergeFrom< std::string > (const std::string &other)
 
template<>
void InternalMetadata::DoSwap< std::string > (std::string *other)
 
static uint8_tInternalSerializeMapEntry (const FieldDescriptor *field, const MapKey &key, const MapValueConstRef &value, uint8_t *target, io::EpsCopyOutputStream *stream)
 
static uint8InternalSerializeMapEntry (const FieldDescriptor *field, const MapKey &key, const MapValueRef &value, uint8 *target, io::EpsCopyOutputStream *stream)
 
uint8InternalSerializeUnknownMessageSetItemsToArray (const std::string &unknown_fields, uint8 *target, io::EpsCopyOutputStream *stream)
 
uint8InternalSerializeUnknownMessageSetItemsToArray (const UnknownFieldSet &unknown_fields, uint8 *target, io::EpsCopyOutputStream *stream)
 
template<typename T >
bool IsConstHelper (const T &)
 
template<typename T >
bool IsConstHelper (T &)
 
bool IsForwardIteratorHelper (std::forward_iterator_tag)
 
static bool IsMapValueMessageTyped (const FieldDescriptor *map_field)
 
static bool IsMapValueMessageTyped (const FieldDescriptor *map_field)
 
template<typename T , typename std::enable_if< std::is_integral< T >::value, int >::type = 0>
bool IsNan (T)
 
template<int type>
bool IsNull (const void *ptr)
 
template<>
bool IsNull< FieldMetadata::kInlinedType > (const void *ptr)
 
template<>
bool IsNull< WireFormatLite::TYPE_BYTES > (const void *ptr)
 
template<>
bool IsNull< WireFormatLite::TYPE_GROUP > (const void *ptr)
 
template<>
bool IsNull< WireFormatLite::TYPE_MESSAGE > (const void *ptr)
 
template<>
bool IsNull< WireFormatLite::TYPE_STRING > (const void *ptr)
 
template<>
bool IsOk (bool status)
 
template<typename T >
bool IsOk (T status)
 
bool IsOneofPresent (const void *base, uint32 offset, uint32 tag)
 
bool IsPresent (const void *base, uint32 hasbit)
 
PROTOBUF_EXPORT bool IsStructurallyValidUTF8 (const char *buf, int len)
 
bool IsStructurallyValidUTF8 (const std::string &str)
 
bool IsStructurallyValidUTF8 (StringPiece str)
 
void LogIndexOutOfBounds (int index, int size)
 
int LookUpEnumName (const EnumEntry *enums, const int *sorted_indices, size_t size, int value)
 
bool LookUpEnumValue (const EnumEntry *enums, size_t size, StringPiece name, int *value)
 
template<typename MapFieldType , const SerializationTable * table>
void MapFieldSerializer (const uint8 *base, uint32 offset, uint32 tag, uint32 has_offset, io::CodedOutputStream *output)
 
static size_t MapKeyDataOnlyByteSize (const FieldDescriptor *field, const MapKey &value)
 
void MapTestForceDeterministic ()
 
static size_t MapValueRefDataOnlyByteSize (const FieldDescriptor *field, const MapValueConstRef &value)
 
static size_t MapValueRefDataOnlyByteSize (const FieldDescriptor *field, const MapValueRef &value)
 
size_t MapValueSpaceUsedExcludingSelfLong (bool)
 
size_t MapValueSpaceUsedExcludingSelfLong (const std::string &str)
 
template<typename T , typename = decltype(std::declval<const T&>().SpaceUsedLong())>
size_t MapValueSpaceUsedExcludingSelfLong (const T &message)
 
PROTOBUF_ATTRIBUTE_WEAK ExtensionSet::LazyMessageExtensionMaybeCreateLazyExtension (Arena *arena)
 
template<typename Iterator >
static int64 median (Iterator i0, Iterator i1)
 
void memcpy_inlined (char *dst, const char *src, size_t size)
 
bool memeq (const char *a, const char *b, size_t n)
 
template<int kSize>
std::enable_if<(kSize==0), void >::type memswap (char *, char *)
 
template<bool aliasing>
bool MergeFromImpl (BoundedZCIS input, MessageLite *msg, MessageLite::ParseFlags parse_flags)
 
template<bool alias, typename T >
bool MergeFromImpl (const SourceWrapper< T > &input, MessageLite *msg, MessageLite::ParseFlags parse_flags)
 
template<bool aliasing>
bool MergeFromImpl (io::ZeroCopyInputStream *input, MessageLite *msg, MessageLite::ParseFlags parse_flags)
 
template<bool aliasing>
bool MergeFromImpl (StringPiece input, MessageLite *msg, MessageLite::ParseFlags parse_flags)
 
template bool MergeFromImpl< false > (BoundedZCIS input, MessageLite *msg, MessageLite::ParseFlags parse_flags)
 
template bool MergeFromImpl< false > (io::ZeroCopyInputStream *input, MessageLite *msg, MessageLite::ParseFlags parse_flags)
 
template bool MergeFromImpl< false > (StringPiece input, MessageLite *msg, MessageLite::ParseFlags parse_flags)
 
template bool MergeFromImpl< true > (BoundedZCIS input, MessageLite *msg, MessageLite::ParseFlags parse_flags)
 
template bool MergeFromImpl< true > (io::ZeroCopyInputStream *input, MessageLite *msg, MessageLite::ParseFlags parse_flags)
 
template bool MergeFromImpl< true > (StringPiece input, MessageLite *msg, MessageLite::ParseFlags parse_flags)
 
bool MergePartialFromCodedStream (MessageLite *msg, const ParseTable &table, io::CodedInputStream *input)
 
template<typename UnknownFieldHandler >
bool MergePartialFromCodedStreamImpl (MessageLite *msg, const ParseTable &table, io::CodedInputStream *input)
 
template<typename UnknownFieldHandler , typename InternalMetadata >
bool MergePartialFromCodedStreamImpl (MessageLite *msg, const ParseTable &table, io::CodedInputStream *input)
 
template<typename UnknownFieldHandler , uint32_t kMaxTag>
bool MergePartialFromCodedStreamInlined (MessageLite *msg, const ParseTable &table, io::CodedInputStream *input)
 
template<typename UnknownFieldHandler , typename InternalMetadata , uint32 kMaxTag>
bool MergePartialFromCodedStreamInlined (MessageLite *msg, const ParseTable &table, io::CodedInputStream *input)
 
bool MergePartialFromCodedStreamLite (MessageLite *msg, const ParseTable &table, io::CodedInputStream *input)
 
template<bool aliasing>
bool MergePartialFromImpl (BoundedZCIS input, MessageLite *msg)
 
template<bool alias, typename T >
bool MergePartialFromImpl (const SourceWrapper< T > &input, MessageLite *msg)
 
template<bool aliasing>
bool MergePartialFromImpl (io::ZeroCopyInputStream *input, MessageLite *msg)
 
template<bool aliasing>
bool MergePartialFromImpl (StringPiece input, MessageLite *msg)
 
template bool MergePartialFromImpl< false > (BoundedZCIS input, MessageLite *msg)
 
template bool MergePartialFromImpl< false > (io::ZeroCopyInputStream *input, MessageLite *msg)
 
template bool MergePartialFromImpl< false > (StringPiece input, MessageLite *msg)
 
template bool MergePartialFromImpl< true > (BoundedZCIS input, MessageLite *msg)
 
template bool MergePartialFromImpl< true > (io::ZeroCopyInputStream *input, MessageLite *msg)
 
template bool MergePartialFromImpl< true > (StringPiece input, MessageLite *msg)
 
template<typename Type >
TypeMutableField (MessageLite *msg, uint32 *has_bits, uint32 has_bit_index, int64 offset)
 
const PROTOBUF_EXPORT std::string & NameOfEnum (const EnumDescriptor *descriptor, int value)
 
double NoLocaleStrtod (const char *str, char **endptr)
 
static int64 Now ()
 
void NullLogHandler (LogLevel, const char *, int, const std::string &)
 
void NullLogHandler (LogLevel, const char *, int, const string &)
 
void OnShutdown (void(*func)())
 
template<typename T >
TOnShutdownDelete (T *p)
 
void OnShutdownDestroyMessage (const void *ptr)
 
void OnShutdownDestroyString (const std::string *ptr)
 
void OnShutdownRun (void(*f)(const void *), const void *arg)
 
const char * PackedBoolParser (void *object, const char *ptr, ParseContext *ctx)
 
const char * PackedDoubleParser (void *object, const char *ptr, ParseContext *ctx)
 
const char * PackedEnumParser (void *object, const char *ptr, ParseContext *ctx)
 
template<typename T >
const PROTOBUF_NODISCARD char * PackedEnumParser (void *object, const char *ptr, ParseContext *ctx, bool(*is_valid)(int), InternalMetadata *metadata, int field_num)
 
const char * PackedEnumParser (void *object, const char *ptr, ParseContext *ctx, bool(*is_valid)(int), InternalMetadataWithArena *metadata, int field_num)
 
const char * PackedEnumParser (void *object, const char *ptr, ParseContext *ctx, bool(*is_valid)(int), InternalMetadataWithArenaLite *metadata, int field_num)
 
template<typename T >
const PROTOBUF_NODISCARD char * PackedEnumParserArg (void *object, const char *ptr, ParseContext *ctx, bool(*is_valid)(const void *, int), const void *data, InternalMetadata *metadata, int field_num)
 
const char * PackedEnumParserArg (void *object, const char *ptr, ParseContext *ctx, bool(*is_valid)(const void *, int), const void *data, InternalMetadataWithArena *metadata, int field_num)
 
const char * PackedEnumParserArg (void *object, const char *ptr, ParseContext *ctx, bool(*is_valid)(const void *, int), const void *data, InternalMetadataWithArenaLite *metadata, int field_num)
 
const char * PackedFixed32Parser (void *object, const char *ptr, ParseContext *ctx)
 
const char * PackedFixed64Parser (void *object, const char *ptr, ParseContext *ctx)
 
const char * PackedFloatParser (void *object, const char *ptr, ParseContext *ctx)
 
const char * PackedInt32Parser (void *object, const char *ptr, ParseContext *ctx)
 
const char * PackedInt64Parser (void *object, const char *ptr, ParseContext *ctx)
 
const char * PackedSFixed32Parser (void *object, const char *ptr, ParseContext *ctx)
 
const char * PackedSFixed64Parser (void *object, const char *ptr, ParseContext *ctx)
 
const char * PackedSInt32Parser (void *object, const char *ptr, ParseContext *ctx)
 
const char * PackedSInt64Parser (void *object, const char *ptr, ParseContext *ctx)
 
const char * PackedUInt32Parser (void *object, const char *ptr, ParseContext *ctx)
 
const char * PackedUInt64Parser (void *object, const char *ptr, ParseContext *ctx)
 
bool ParseAnyTypeUrl (const std::string &type_url, std::string *full_type_name)
 
bool ParseAnyTypeUrl (const std::string &type_url, std::string *url_prefix, std::string *full_type_name)
 
bool ParseAnyTypeUrl (StringPiece type_url, std::string *full_type_name)
 
bool ParseAnyTypeUrl (StringPiece type_url, std::string *url_prefix, std::string *full_type_name)
 
const char * ParseBigVarint (const char *p, uint64 *out)
 
template<typename Entry >
bool ParseMap (io::CodedInputStream *input, void *map_field)
 
template<typename MS >
bool ParseMessageSetItemImpl (io::CodedInputStream *input, MS ms)
 
template<typename EnumType >
bool ParseNamedEnum (const EnumDescriptor *descriptor, const std::string &name, EnumType *value)
 
PROTOBUF_EXPORT bool ParseNamedEnum (const EnumDescriptor *descriptor, const std::string &name, int *value)
 
bool ParseTime (const std::string &value, int64 *seconds, int32 *nanos)
 
bool ParseTime (const string &value, int64 *seconds, int32 *nanos)
 
void PrintUTF8ErrorLog (const char *field_name, const char *operation_str, bool emit_stacktrace)
 
template<typename Type >
const TypeRaw (const MessageLite *msg, int64 offset)
 
template<typename Type >
TypeRaw (MessageLite *msg, int64 offset)
 
const char * ReadBOOL (const char *ptr, bool *value)
 
static PROTOBUF_ALWAYS_INLINE bool ReadBytesToString (io::CodedInputStream *input, std::string *value)
 
static PROTOBUF_NDEBUG_INLINE bool ReadBytesToString (io::CodedInputStream *input, std::string *value)
 
const char * ReadDOUBLE (const char *ptr, double *value)
 
template<typename E >
const char * ReadENUM (const char *ptr, E *value)
 
const char * ReadFIXED32 (const char *ptr, uint32 *value)
 
const char * ReadFIXED64 (const char *ptr, uint64 *value)
 
const char * ReadFLOAT (const char *ptr, float *value)
 
const char * ReadINT32 (const char *ptr, int32 *value)
 
const char * ReadINT64 (const char *ptr, int64 *value)
 
template<typename Add >
const char * ReadPackedVarintArray (const char *ptr, const char *end, Add add)
 
const char * ReadSFIXED32 (const char *ptr, int32 *value)
 
const char * ReadSFIXED64 (const char *ptr, int64 *value)
 
const char * ReadSINT32 (const char *ptr, int32 *value)
 
const char * ReadSINT64 (const char *ptr, int64 *value)
 
uint32 ReadSize (const char **pp)
 
std::pair< const char *, int32ReadSizeFallback (const char *p, uint32 res)
 
const char * ReadTag (const char *p, uint32 *out, uint32 max_tag=0)
 
std::pair< const char *, uint32ReadTagFallback (const char *p, uint32 res)
 
const char * ReadUINT32 (const char *ptr, uint32 *value)
 
const char * ReadUINT64 (const char *ptr, uint64 *value)
 
template<typename F >
const char * ReadUnaligned (const char *ptr, F *value)
 
uint64 ReadVarint (const char **p)
 
uint32_t ReadVarint32 (const char **p)
 
uint64_t ReadVarint64 (const char **p)
 
int32 ReadVarintZigZag32 (const char **p)
 
int64 ReadVarintZigZag64 (const char **p)
 
FieldDescriptor::Type real_type (FieldType type)
 
void RegisterFileLevelMetadata (const DescriptorTable *table)
 
template<ProcessingType field_type>
void ResetOneofField (const ParseTable &table, int field_number, Arena *arena, MessageLite *msg, uint32 *oneof_case, int64 offset, const void *default_ptr)
 
static void RunZeroArgFunc (const void *arg)
 
static void RunZeroArgFunc (const void *arg)
 
bool SecondsToDateTime (int64 seconds, DateTime *time)
 
template<typename O >
void SerializeGroupTo (const MessageLite *msg, const void *table_ptr, O *output)
 
PROTOBUF_EXPORT void SerializeInternal (const uint8 *base, const FieldMetadata *table, int32 num_fields, io::CodedOutputStream *output)
 
uint8SerializeInternalToArray (const uint8 *base, const FieldMetadata *table, int32 num_fields, bool is_deterministic, uint8 *buffer)
 
static uint8SerializeMapKeyWithCachedSizes (const FieldDescriptor *field, const MapKey &value, uint8 *target, io::EpsCopyOutputStream *stream)
 
static uint8_tSerializeMapValueRefWithCachedSizes (const FieldDescriptor *field, const MapValueConstRef &value, uint8_t *target, io::EpsCopyOutputStream *stream)
 
static uint8SerializeMapValueRefWithCachedSizes (const FieldDescriptor *field, const MapValueRef &value, uint8 *target, io::EpsCopyOutputStream *stream)
 
void SerializeMessageDispatch (const MessageLite &msg, const FieldMetadata *field_table, int num_fields, int32 cached_size, ArrayOutput *output)
 
void SerializeMessageDispatch (const MessageLite &msg, const FieldMetadata *field_table, int num_fields, int32 cached_size, io::CodedOutputStream *output)
 
void SerializeMessageNoTable (const MessageLite *msg, ArrayOutput *output)
 
void SerializeMessageNoTable (const MessageLite *msg, io::CodedOutputStream *output)
 
template<typename O >
void SerializeMessageTo (const MessageLite *msg, const void *table_ptr, O *output)
 
void SerializeNotImplemented (int field)
 
template<int type, typename O >
void SerializeTo (const void *ptr, O *output)
 
void SetBit (uint32 *has_bits, uint32 has_bit_index)
 
template<typename Type >
void SetField (MessageLite *msg, uint32 *has_bits, uint32 has_bit_index, int64 offset, Type value)
 
template<typename T >
void SetMapKey (MapKey *map_key, const T &value)
 
template<>
void SetMapKey< bool > (MapKey *map_key, const bool &value)
 
template<>
void SetMapKey< int32 > (MapKey *map_key, const int32 &value)
 
template<>
void SetMapKey< int32_t > (MapKey *map_key, const int32_t &value)
 
template<>
void SetMapKey< int64 > (MapKey *map_key, const int64 &value)
 
template<>
void SetMapKey< int64_t > (MapKey *map_key, const int64_t &value)
 
template<>
void SetMapKey< std::string > (MapKey *map_key, const std::string &value)
 
template<>
void SetMapKey< uint32 > (MapKey *map_key, const uint32 &value)
 
template<>
void SetMapKey< uint32_t > (MapKey *map_key, const uint32_t &value)
 
template<>
void SetMapKey< uint64 > (MapKey *map_key, const uint64 &value)
 
template<>
void SetMapKey< uint64_t > (MapKey *map_key, const uint64_t &value)
 
template<typename Type >
void SetOneofField (MessageLite *msg, uint32 *oneof_case, uint32 oneof_case_index, int64 offset, int field_number, Type value)
 
void SetStrWithHeapBuffer (std::string *str, ArenaStringPtr *s)
 
template<typename Key >
PROTOBUF_NOINLINE size_t SpaceUsedInTable (void **table, size_t num_buckets, size_t num_elements, size_t sizeof_node)
 
template<typename Map , typename = typename std::enable_if< !std::is_scalar<typename Map::key_type>::value || !std::is_scalar<typename Map::mapped_type>::value>::type>
size_t SpaceUsedInValues (const Map *map)
 
size_t SpaceUsedInValues (const void *)
 
static void StressTestIterators (int n)
 
static std::string StrFunc (int i, int j)
 
static bool StrictUtf8Check (const FieldDescriptor *field)
 
static bool StrictUtf8Check (const FieldDescriptor *field)
 
const char * StringParser (const char *begin, const char *end, void *object, ParseContext *)
 
size_t StringSpaceUsedExcludingSelfLong (const std::string &str)
 
template<typename T >
void StrongReference (const T &var)
 
static std::string SubMessagePrefix (const std::string &prefix, const FieldDescriptor *field, int index)
 
static std::string SubMessagePrefix (const std::string &prefix, const FieldDescriptor *field, int index)
 
template<typename T >
void SwapBlock (char *p, char *q)
 
void SwapRepeatedPtrToNull (RepeatedPtrField< Message > **from, RepeatedPtrField< Message > **to, Arena *from_arena, Arena *to_arena)
 
bool TableEntryIsEmpty (void *const *table, size_t b)
 
bool TableEntryIsList (void *const *table, size_t b)
 
bool TableEntryIsNonEmptyList (void *const *table, size_t b)
 
bool TableEntryIsTree (void *const *table, size_t b)
 
void TableSerialize (const MessageLite &msg, const SerializationTable *table, io::CodedOutputStream *output)
 
uint8TableSerializeToArray (const MessageLite &msg, const SerializationTable *table, bool is_deterministic, uint8 *buffer)
 
 TEST (ArenaTest, IsInitialized)
 
 TEST (ArenaTest, ParsingAndSerializingNoHeapAllocation)
 
 TEST (ArenaTest, ReflectionInTextFormat)
 
 TEST (ArenaTest, StringMapNoLeak)
 
 TEST (GeneratedMapFieldReflectionTest, Accessors)
 
 TEST (GeneratedMapFieldReflectionTest, ClearField)
 
 TEST (GeneratedMapFieldReflectionTest, EmbedProto2Message)
 
 TEST (GeneratedMapFieldReflectionTest, MapEntryClear)
 
 TEST (GeneratedMapFieldReflectionTest, MergeFromClearMapEntry)
 
 TEST (GeneratedMapFieldReflectionTest, MutableUnknownFields)
 
 TEST (GeneratedMapFieldReflectionTest, Proto2MapEntryClear)
 
 TEST (GeneratedMapFieldReflectionTest, ReleaseLast)
 
 TEST (GeneratedMapFieldReflectionTest, RemoveLast)
 
 TEST (GeneratedMapFieldReflectionTest, SetViaMapReflection)
 
 TEST (GeneratedMapFieldReflectionTest, SpaceUsed)
 
 TEST (GeneratedMapFieldReflectionTest, Swap)
 
 TEST (GeneratedMapFieldReflectionTest, SwapElements)
 
 TEST (GeneratedMapFieldReflectionTest, SwapFields)
 
 TEST (GeneratedMapFieldReflectionTest, SwapWithBothSet)
 
 TEST (GeneratedMapFieldTest, Accessors)
 
 TEST (GeneratedMapFieldTest, Clear)
 
 TEST (GeneratedMapFieldTest, ClearMessageMap)
 
 TEST (GeneratedMapFieldTest, CopyAssignmentOperator)
 
 TEST (GeneratedMapFieldTest, CopyConstructor)
 
 TEST (GeneratedMapFieldTest, CopyFrom)
 
 TEST (GeneratedMapFieldTest, CopyFromDynamicMessage)
 
 TEST (GeneratedMapFieldTest, CopyFromDynamicMessageMapReflection)
 
 TEST (GeneratedMapFieldTest, CopyFromMessageMap)
 
 TEST (GeneratedMapFieldTest, CorruptedWireFormat)
 
 TEST (GeneratedMapFieldTest, DuplicatedKeyWireFormat)
 
 TEST (GeneratedMapFieldTest, DuplicatedValueWireFormat)
 
 TEST (GeneratedMapFieldTest, DynamicMessageCopyFrom)
 
 TEST (GeneratedMapFieldTest, DynamicMessageCopyFromMapReflection)
 
 TEST (GeneratedMapFieldTest, DynamicMessageMergeFromDynamicMessage)
 
 TEST (GeneratedMapFieldTest, IsInitialized)
 
 TEST (GeneratedMapFieldTest, KeysValuesUnknownsWireFormat)
 
 TEST (GeneratedMapFieldTest, MergeFromMessageMap)
 
 TEST (GeneratedMapFieldTest, MessagesMustMerge)
 
 TEST (GeneratedMapFieldTest, MissedKeyWireFormat)
 
 TEST (GeneratedMapFieldTest, MissedValueTextFormat)
 
 TEST (GeneratedMapFieldTest, MissedValueWireFormat)
 
 TEST (GeneratedMapFieldTest, NonEmptyMergeFrom)
 
 TEST (GeneratedMapFieldTest, Proto2SetMapFieldsInitialized)
 
 TEST (GeneratedMapFieldTest, Proto2UnknownEnum)
 
 TEST (GeneratedMapFieldTest, SameTypeMaps)
 
 TEST (GeneratedMapFieldTest, SerializationToArray)
 
 TEST (GeneratedMapFieldTest, SerializationToStream)
 
 TEST (GeneratedMapFieldTest, SetMapFieldsInitialized)
 
 TEST (GeneratedMapFieldTest, StandardWireFormat)
 
 TEST (GeneratedMapFieldTest, SwapWithEmpty)
 
 TEST (GeneratedMapFieldTest, SwapWithOther)
 
 TEST (GeneratedMapFieldTest, SwapWithSelf)
 
 TEST (GeneratedMapFieldTest, SyncDynamicMapWithRepeatedField)
 
 TEST (GeneratedMapFieldTest, UnknownFieldWireFormat)
 
 TEST (GeneratedMapFieldTest, UnorderedWireFormat)
 
 TEST (GeneratedMapFieldTest, UpcastCopyFrom)
 
 TEST (MapFieldTest, ConstInit)
 
 TEST (MapSerializationTest, Deterministic)
 
 TEST (MapSerializationTest, DeterministicSubmessage)
 
 TEST (MoveTest, MoveAssignmentWorks)
 
 TEST (MoveTest, MoveConstructorWorks)
 
 TEST (ReflectionOpsForMapFieldTest, ClearMap)
 
 TEST (ReflectionOpsForMapFieldTest, IsInitialized)
 
 TEST (ReflectionOpsForMapFieldTest, MapCopy)
 
 TEST (ReflectionOpsForMapFieldTest, MapDiscardUnknownFields)
 
 TEST (ReflectionOpsForMapFieldTest, MapSanityCheck)
 
 TEST (ReflectionOpsForMapFieldTest, MergeMap)
 
 TEST (TextFormatMapTest, DynamicMessage)
 
 TEST (TextFormatMapTest, NoDisableIterator)
 
 TEST (TextFormatMapTest, NoDisableReflectionIterator)
 
 TEST (TextFormatMapTest, ParseCorruptedString)
 
 TEST (TextFormatMapTest, SerializeAndParse)
 
 TEST (TextFormatMapTest, Sorted)
 
 TEST (WireFormatForMapFieldTest, MapByteSize)
 
 TEST (WireFormatForMapFieldTest, MapParseHelpers)
 
 TEST (WireFormatForMapFieldTest, ParseMap)
 
 TEST (WireFormatForMapFieldTest, SerializeMap)
 
 TEST (WireFormatForMapFieldTest, SerializeMapDynamicMessage)
 
 TEST_F (MapFieldBasePrimitiveTest, Arena)
 
 TEST_F (MapFieldBasePrimitiveTest, GetRepeatedField)
 
 TEST_F (MapFieldBasePrimitiveTest, MutableRepeatedField)
 
 TEST_F (MapFieldBasePrimitiveTest, SpaceUsedExcludingSelf)
 
 TEST_F (MapFieldInDynamicMessageTest, DynamicMapReflection)
 
 TEST_F (MapFieldInDynamicMessageTest, MapEntryReferernceValidAfterSerialize)
 
 TEST_F (MapFieldInDynamicMessageTest, MapIndependentOffsets)
 
 TEST_F (MapFieldInDynamicMessageTest, MapSpaceUsed)
 
 TEST_F (MapFieldInDynamicMessageTest, MapValueReferernceValidAfterSerialize)
 
 TEST_F (MapFieldInDynamicMessageTest, RecursiveMap)
 
 TEST_F (MapFieldReflectionTest, MapSizeWithDuplicatedKey)
 
 TEST_F (MapFieldReflectionTest, RegularFields)
 
 TEST_F (MapFieldReflectionTest, RepeatedFieldRefForRegularFields)
 
 TEST_F (MapFieldReflectionTest, RepeatedFieldRefMergeFromAndSwap)
 
 TEST_F (MapFieldReflectionTest, UninitializedEntry)
 
 TEST_F (MapImplTest, Assigner)
 
 TEST_F (MapImplTest, BeginIsFast)
 
 TEST_F (MapImplTest, Clear)
 
 TEST_F (MapImplTest, ConstEnd)
 
 TEST_F (MapImplTest, ContainNotExist)
 
 TEST_F (MapImplTest, ConvertToStdMap)
 
 TEST_F (MapImplTest, ConvertToStdVectorOfPairs)
 
 TEST_F (MapImplTest, CopyAssignMapIterator)
 
 TEST_F (MapImplTest, CopyConstructorWithArena)
 
 TEST_F (MapImplTest, CopyConstructorWithoutArena)
 
 TEST_F (MapImplTest, CopyIteratorStressTest)
 
 TEST_F (MapImplTest, CountNonExist)
 
 TEST_F (MapImplTest, EqualRange)
 
 TEST_F (MapImplTest, EraseByIterator)
 
 TEST_F (MapImplTest, EraseMutipleByKey)
 
 TEST_F (MapImplTest, EraseRevalidates)
 
 TEST_F (MapImplTest, EraseSingleByIterator)
 
 TEST_F (MapImplTest, EraseSingleByKey)
 
 TEST_F (MapImplTest, GetReferenceFromIterator)
 
 TEST_F (MapImplTest, HashFlood)
 
 TEST_F (MapImplTest, ImmutableContainNotExist)
 
 TEST_F (MapImplTest, ImmutableFindNonExist)
 
 TEST_F (MapImplTest, InsertByInitializerList)
 
 TEST_F (MapImplTest, InsertByIterator)
 
 TEST_F (MapImplTest, InsertSingle)
 
 TEST_F (MapImplTest, IteratorBasic)
 
 TEST_F (MapImplTest, IteratorCategory)
 
 TEST_F (MapImplTest, IteratorConstness)
 
 TEST_F (MapImplTest, IteratorInvalidation)
 
 TEST_F (MapImplTest, IterConstructor)
 
 TEST_F (MapImplTest, MapKeyAssignment)
 
 TEST_F (MapImplTest, MutableAt)
 
 TEST_F (MapImplTest, MutableFindNonExist)
 
 TEST_F (MapImplTest, OperatorBracket)
 
 TEST_F (MapImplTest, OperatorBracketNonExist)
 
 TEST_F (MapImplTest, Rehash)
 
 TEST_F (MapImplTest, SwapArena)
 
 TEST_F (MapImplTest, SwapBasic)
 
 TEST_F (MapImplTest, ValidIteratorAfterErase)
 
 TEST_P (MapFieldBasePrimitiveTest, Arena)
 
 TEST_P (MapFieldBasePrimitiveTest, EnforceNoArena)
 
 TEST_P (MapFieldBasePrimitiveTest, GetRepeatedField)
 
 TEST_P (MapFieldBasePrimitiveTest, MutableRepeatedField)
 
 TEST_P (MapFieldBasePrimitiveTest, SpaceUsedExcludingSelf)
 
 TEST_P (MapFieldStateTest, Clear)
 
 TEST_P (MapFieldStateTest, GetMap)
 
 TEST_P (MapFieldStateTest, GetMapField)
 
 TEST_P (MapFieldStateTest, MergeFromClean)
 
 TEST_P (MapFieldStateTest, MergeFromMapDirty)
 
 TEST_P (MapFieldStateTest, MergeFromRepeatedDirty)
 
 TEST_P (MapFieldStateTest, MutableMap)
 
 TEST_P (MapFieldStateTest, MutableMapField)
 
 TEST_P (MapFieldStateTest, SpaceUsedExcludingSelf)
 
 TEST_P (MapFieldStateTest, SwapClean)
 
 TEST_P (MapFieldStateTest, SwapMapDirty)
 
 TEST_P (MapFieldStateTest, SwapRepeatedDirty)
 
static void TestDeterministicSerialization (const protobuf_unittest::TestMaps &t, const std::string &filename)
 
template<typename Iter >
static void TestEqualIterators (Iter i0, Iter i1, Iter end)
 
template<typename IteratorType >
static void TestOldVersusNewIterator (int skip, Map< int, int > *m)
 
template<typename T , typename U >
static void TestValidityForAllKeysExcept (int key_to_avoid, const T &check_map, const U &map)
 
int ToCachedSize (size_t size)
 
int ToIntSize (size_t size)
 
template<typename T >
T UnalignedLoad (const char *p)
 
const char * UnknownFieldParse (uint32 tag, InternalMetadataWithArena *metadata, const char *ptr, ParseContext *ctx)
 
const char * UnknownFieldParse (uint32 tag, InternalMetadataWithArenaLite *metadata, const char *ptr, ParseContext *ctx)
 
const char * UnknownFieldParse (uint32 tag, std::string *unknown, const char *ptr, ParseContext *ctx)
 
const char * UnknownFieldParse (uint64 tag, UnknownFieldSet *unknown, const char *ptr, ParseContext *ctx)
 
void UnknownFieldSerializerLite (const uint8 *ptr, uint32 offset, uint32 tag, uint32 has_offset, io::CodedOutputStream *output)
 
void UnknownFieldSetSerializer (const uint8 *base, uint32 offset, uint32 tag, uint32 has_offset, io::CodedOutputStream *output)
 
const char * UnknownGroupLiteParse (std::string *unknown, const char *ptr, ParseContext *ctx)
 
const char * UnknownGroupParse (UnknownFieldSet *unknown, const char *ptr, ParseContext *ctx)
 
template<typename T >
T UnwrapMapKey (const MapKey &map_key)
 
template<>
bool UnwrapMapKey< bool > (const MapKey &map_key)
 
template<>
int32 UnwrapMapKey< int32 > (const MapKey &map_key)
 
template<>
int32_t UnwrapMapKey< int32_t > (const MapKey &map_key)
 
template<>
int64 UnwrapMapKey< int64 > (const MapKey &map_key)
 
template<>
int64_t UnwrapMapKey< int64_t > (const MapKey &map_key)
 
template<>
std::string UnwrapMapKey< std::string > (const MapKey &map_key)
 
template<>
uint32 UnwrapMapKey< uint32 > (const MapKey &map_key)
 
template<>
uint32_t UnwrapMapKey< uint32_t > (const MapKey &map_key)
 
template<>
uint64 UnwrapMapKey< uint64 > (const MapKey &map_key)
 
template<>
uint64_t UnwrapMapKey< uint64_t > (const MapKey &map_key)
 
PROTOBUF_EXPORT char * UTF8CoerceToStructurallyValid (const StringPiece &str, char *dst, char replace_char)
 
PROTOBUF_EXPORT char * UTF8CoerceToStructurallyValid (StringPiece str, char *dst, char replace_char)
 
int UTF8GenericScan (const UTF8ScanObj *st, const char *str, int str_length, int *bytes_consumed)
 
int UTF8GenericScanFastAscii (const UTF8ScanObj *st, const char *str, int str_length, int *bytes_consumed)
 
PROTOBUF_EXPORT int UTF8SpnStructurallyValid (const StringPiece &str)
 
PROTOBUF_EXPORT int UTF8SpnStructurallyValid (StringPiece str)
 
static bool ValidateEnumUsingDescriptor (const void *arg, int number)
 
static bool ValidateEnumUsingDescriptor (const void *arg, int number)
 
template<typename T >
const PROTOBUF_MUST_USE_RESULT char * VarintParse (const char *p, T *out)
 
template<typename T >
const PROTOBUF_NODISCARD char * VarintParse (const char *p, T *out)
 
template<typename T , bool sign>
const char * VarintParser (void *object, const char *ptr, ParseContext *ctx)
 
const char * VarintParseSlow (const char *p, uint32 res, uint32 *out)
 
const char * VarintParseSlow (const char *p, uint32 res, uint64 *out)
 
std::pair< const char *, uint32VarintParseSlow32 (const char *p, uint32 res)
 
std::pair< const char *, uint64VarintParseSlow64 (const char *p, uint32 res32)
 
template<bool ZigZag, bool SignExtended, typename T >
static size_t VarintSize (const T *data, const int n)
 
template<bool ZigZag, bool SignExtended, typename T >
static size_t VarintSize (const T *data, const int n)
 
template<bool ZigZag, typename T >
static size_t VarintSize64 (const T *data, const int n)
 
template<bool ZigZag, typename T >
static size_t VarintSize64 (const T *data, const int n)
 
bool VerifyUTF8 (const std::string *s, const char *field_name)
 
bool VerifyUTF8 (StringPiece str, const char *field_name)
 
void VerifyVersion (int headerVersion, int minLibraryVersion, const char *filename)
 
string VersionString (int version)
 
template<>
bool WireFormatLite::ReadPrimitive< bool, WireFormatLite::TYPE_BOOL > (io::CodedInputStream *input, bool *value)
 
template<>
bool WireFormatLite::ReadPrimitive< double, WireFormatLite::TYPE_DOUBLE > (io::CodedInputStream *input, double *value)
 
template<>
bool WireFormatLite::ReadPrimitive< float, WireFormatLite::TYPE_FLOAT > (io::CodedInputStream *input, float *value)
 
template<>
bool WireFormatLite::ReadPrimitive< int, WireFormatLite::TYPE_ENUM > (io::CodedInputStream *input, int *value)
 
template<>
bool WireFormatLite::ReadPrimitive< int32, WireFormatLite::TYPE_INT32 > (io::CodedInputStream *input, int32 *value)
 
template<>
bool WireFormatLite::ReadPrimitive< int32, WireFormatLite::TYPE_SFIXED32 > (io::CodedInputStream *input, int32 *value)
 
template<>
bool WireFormatLite::ReadPrimitive< int32, WireFormatLite::TYPE_SINT32 > (io::CodedInputStream *input, int32 *value)
 
template<>
bool WireFormatLite::ReadPrimitive< int32_t, WireFormatLite::TYPE_INT32 > (io::CodedInputStream *input, int32_t *value)
 
template<>
bool WireFormatLite::ReadPrimitive< int32_t, WireFormatLite::TYPE_SFIXED32 > (io::CodedInputStream *input, int32_t *value)
 
template<>
bool WireFormatLite::ReadPrimitive< int32_t, WireFormatLite::TYPE_SINT32 > (io::CodedInputStream *input, int32_t *value)
 
template<>
bool WireFormatLite::ReadPrimitive< int64, WireFormatLite::TYPE_INT64 > (io::CodedInputStream *input, int64 *value)
 
template<>
bool WireFormatLite::ReadPrimitive< int64, WireFormatLite::TYPE_SFIXED64 > (io::CodedInputStream *input, int64 *value)
 
template<>
bool WireFormatLite::ReadPrimitive< int64, WireFormatLite::TYPE_SINT64 > (io::CodedInputStream *input, int64 *value)
 
template<>
bool WireFormatLite::ReadPrimitive< int64_t, WireFormatLite::TYPE_INT64 > (io::CodedInputStream *input, int64_t *value)
 
template<>
bool WireFormatLite::ReadPrimitive< int64_t, WireFormatLite::TYPE_SFIXED64 > (io::CodedInputStream *input, int64_t *value)
 
template<>
bool WireFormatLite::ReadPrimitive< int64_t, WireFormatLite::TYPE_SINT64 > (io::CodedInputStream *input, int64_t *value)
 
template<>
bool WireFormatLite::ReadPrimitive< uint32, WireFormatLite::TYPE_FIXED32 > (io::CodedInputStream *input, uint32 *value)
 
template<>
bool WireFormatLite::ReadPrimitive< uint32, WireFormatLite::TYPE_UINT32 > (io::CodedInputStream *input, uint32 *value)
 
template<>
bool WireFormatLite::ReadPrimitive< uint32_t, WireFormatLite::TYPE_FIXED32 > (io::CodedInputStream *input, uint32_t *value)
 
template<>
bool WireFormatLite::ReadPrimitive< uint32_t, WireFormatLite::TYPE_UINT32 > (io::CodedInputStream *input, uint32_t *value)
 
template<>
bool WireFormatLite::ReadPrimitive< uint64, WireFormatLite::TYPE_FIXED64 > (io::CodedInputStream *input, uint64 *value)
 
template<>
bool WireFormatLite::ReadPrimitive< uint64, WireFormatLite::TYPE_UINT64 > (io::CodedInputStream *input, uint64 *value)
 
template<>
bool WireFormatLite::ReadPrimitive< uint64_t, WireFormatLite::TYPE_FIXED64 > (io::CodedInputStream *input, uint64_t *value)
 
template<>
bool WireFormatLite::ReadPrimitive< uint64_t, WireFormatLite::TYPE_UINT64 > (io::CodedInputStream *input, uint64_t *value)
 
template<>
const uint8WireFormatLite::ReadPrimitiveFromArray< double, WireFormatLite::TYPE_DOUBLE > (const uint8 *buffer, double *value)
 
template<>
const uint8WireFormatLite::ReadPrimitiveFromArray< float, WireFormatLite::TYPE_FLOAT > (const uint8 *buffer, float *value)
 
template<>
const uint8WireFormatLite::ReadPrimitiveFromArray< int32, WireFormatLite::TYPE_SFIXED32 > (const uint8 *buffer, int32 *value)
 
template<>
const uint8_tWireFormatLite::ReadPrimitiveFromArray< int32_t, WireFormatLite::TYPE_SFIXED32 > (const uint8_t *buffer, int32_t *value)
 
template<>
const uint8WireFormatLite::ReadPrimitiveFromArray< int64, WireFormatLite::TYPE_SFIXED64 > (const uint8 *buffer, int64 *value)
 
template<>
const uint8_tWireFormatLite::ReadPrimitiveFromArray< int64_t, WireFormatLite::TYPE_SFIXED64 > (const uint8_t *buffer, int64_t *value)
 
template<>
const uint8WireFormatLite::ReadPrimitiveFromArray< uint32, WireFormatLite::TYPE_FIXED32 > (const uint8 *buffer, uint32 *value)
 
template<>
const uint8_tWireFormatLite::ReadPrimitiveFromArray< uint32_t, WireFormatLite::TYPE_FIXED32 > (const uint8_t *buffer, uint32_t *value)
 
template<>
const uint8WireFormatLite::ReadPrimitiveFromArray< uint64, WireFormatLite::TYPE_FIXED64 > (const uint8 *buffer, uint64 *value)
 
template<>
const uint8_tWireFormatLite::ReadPrimitiveFromArray< uint64_t, WireFormatLite::TYPE_FIXED64 > (const uint8_t *buffer, uint64_t *value)
 
template<typename T >
const PROTOBUF_MUST_USE_RESULT char * WireFormatParser (T &field_parser, const char *ptr, ParseContext *ctx)
 
template<typename T >
const PROTOBUF_NODISCARD char * WireFormatParser (T &field_parser, const char *ptr, ParseContext *ctx)
 
template<typename CType >
static void WriteArray (const CType *a, int n, io::CodedOutputStream *output)
 
template<typename CType >
static void WriteArray (const CType *a, int n, io::CodedOutputStream *output)
 
void WriteLengthDelimited (uint32 num, StringPiece val, std::string *s)
 
void WriteLengthDelimited (uint32 num, StringPiece val, UnknownFieldSet *s)
 
template<typename O >
void WriteLengthTo (uint32 length, O *output)
 
template<typename O >
void WriteTagTo (uint32 tag, O *output)
 
void WriteVarint (uint32 num, uint64 val, std::string *s)
 
void WriteVarint (uint32 num, uint64 val, UnknownFieldSet *s)
 
void WriteVarint (uint64 val, std::string *s)
 

Variables

PROTOBUF_EXPORT std::atomic< boolenable_debug_text_format_marker
 
ExplicitlyConstructed< std::string > fixed_address_empty_string {}
 
ExplicitlyConstructed< ImplicitWeakMessageimplicit_weak_message_default_instance
 
internal::once_flag implicit_weak_message_once_init_
 
static PROTOBUF_ATTRIBUTE_INIT_PRIORITY std::true_type init_empty_string
 
PROTOBUF_CONSTINIT std::atomic< boolinit_protobuf_defaults_state {false}
 
static int k0 = 812398771
 
static int k1 = 1312938717
 
static int k2 = 1321555333
 
const char kAnyFullTypeName [] = "google.protobuf.Any"
 
void *const kGlobalEmptyTable [kGlobalEmptyTableSize] = {nullptr}
 
constexpr size_t kGlobalEmptyTableSize = 1
 
constexpr size_t kInt32MaxSize = std::numeric_limits<int32_t>::max()
 
static constexpr const unsigned char kInvalidMask = 0x20
 
static constexpr const unsigned char kInvalidMask = 0x20
 
static const int kMinHeaderVersionForLibrary = 3009000
 
static const int kMinHeaderVersionForLibrary = 3019000
 
static const int kMinHeaderVersionForProtoc = 3009000
 
static const int kMinHeaderVersionForProtoc = 3019000
 
static const int kMinRepeatedFieldAllocationSize = 4
 
static constexpr const unsigned char kNotPackedMask = 0x10
 
static constexpr const unsigned char kNotPackedMask = 0x10
 
static constexpr const unsigned char kOneofMask = 0x40
 
static constexpr const unsigned char kOneofMask = 0x40
 
constexpr int kRepeatedFieldLowerClampLimit = 4
 
constexpr int kRepeatedFieldUpperClampLimit
 
static constexpr const unsigned char kRepeatedMask = 0x20
 
static constexpr const unsigned char kRepeatedMask = 0x20
 
const char kTypeGoogleApisComPrefix [] = "type.googleapis.com/"
 
const char kTypeGoogleProdComPrefix [] = "type.googleprod.com/"
 
static constexpr const unsigned char kTypeMask = 0x1f
 
static constexpr const unsigned char kTypeMask = 0x1f
 
static LogHandlerlog_handler_ = &DefaultLogHandler
 
static LogHandlerlog_handler_ = &DefaultLogHandler
 
static std::atomic< intlog_silencer_count_ = ATOMIC_VAR_INIT(0)
 
static std::atomic< intlog_silencer_count_ = ATOMIC_VAR_INIT(0)
 
const typedef char *(* TailCallParseFunc )(PROTOBUF_TC_PARAM_DECL)
 
static const uint8 utf8acceptnonsurrogates []
 
static const uint8 utf8acceptnonsurrogates []
 
static const unsigned int utf8acceptnonsurrogates_BYTES = 1
 
static const unsigned int utf8acceptnonsurrogates_BYTES = 1
 
static const unsigned char utf8acceptnonsurrogates_fast [256]
 
static const unsigned char utf8acceptnonsurrogates_fast [256]
 
static const unsigned int utf8acceptnonsurrogates_HIADD = 0x00000000
 
static const unsigned int utf8acceptnonsurrogates_HIADD = 0x00000000
 
static const unsigned int utf8acceptnonsurrogates_LOSUB = 0x20202020
 
static const unsigned int utf8acceptnonsurrogates_LOSUB = 0x20202020
 
static const unsigned int utf8acceptnonsurrogates_MAX_EXPAND_X4 = 0
 
static const unsigned int utf8acceptnonsurrogates_MAX_EXPAND_X4 = 0
 
static const UTF8ScanObj utf8acceptnonsurrogates_obj
 
static const UTF8ScanObj utf8acceptnonsurrogates_obj
 
static const RemapEntry utf8acceptnonsurrogates_remap_base []
 
static const RemapEntry utf8acceptnonsurrogates_remap_base []
 
static const unsigned char utf8acceptnonsurrogates_remap_string []
 
static const unsigned char utf8acceptnonsurrogates_remap_string []
 
static const unsigned int utf8acceptnonsurrogates_SHIFT = 8
 
static const unsigned int utf8acceptnonsurrogates_SHIFT = 8
 
static const unsigned int utf8acceptnonsurrogates_STATE0 = 0
 
static const unsigned int utf8acceptnonsurrogates_STATE0 = 0
 
static const unsigned int utf8acceptnonsurrogates_STATE0_SIZE = 256
 
static const unsigned int utf8acceptnonsurrogates_STATE0_SIZE = 256
 
static const unsigned int utf8acceptnonsurrogates_TOTAL_SIZE = 2304
 
static const unsigned int utf8acceptnonsurrogates_TOTAL_SIZE = 2304
 

Typedef Documentation

◆ EnumValidityFunc

typedef bool google::protobuf::internal::EnumValidityFunc(int number)

◆ EnumValidityFuncWithArg

typedef bool google::protobuf::internal::EnumValidityFuncWithArg(const void *arg, int number)

◆ false_

◆ false_type

◆ FieldType

◆ KeyForTree

template<typename T >
using google::protobuf::internal.KeyForTree = typedef typename std::conditional<std::is_scalar<T>::value, T, std::reference_wrapper<const T> >::type

◆ LifecycleId

◆ LifecycleIdAtomic

Definition at line 59 of file protobuf/src/google/protobuf/arena_impl.h.

◆ MakeUnsignedT

template<typename T >
using google::protobuf::internal.MakeUnsignedT = typedef typename std::conditional<std::is_integral<T>::value, std::make_unsigned<T>, std::common_type<T> >::type::type

◆ Mutex

typedef WrappedMutex google::protobuf::internal::Mutex

◆ once_flag

typedef std::once_flag google::protobuf::internal::once_flag

◆ ReaderMutexLock

◆ small_

◆ SpecialSerializer

typedef void(* google::protobuf::internal::SpecialSerializer)(const uint8_t *base, uint32_t offset, uint32_t tag, uint32_t has_offset, io::CodedOutputStream *output)

◆ TreeForMap

template<typename Key >
using google::protobuf::internal.TreeForMap = typedef std::map<KeyForTree<Key>, void*, typename TransparentSupport<Key>::less, MapAllocator<std::pair<const KeyForTree<Key>, void*> >>

◆ true_

◆ true_type

◆ UTF8ScanObj

◆ WriterMutexLock

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
kInvalidFieldOffsetTag 

Definition at line 323 of file protobuf/src/google/protobuf/generated_message_reflection.h.

◆ Cardinality [1/2]

Enumerator
Cardinality_SINGULAR 
Cardinality_REPEATED 
Cardinality_ONEOF 
Cardinality_SINGULAR 
Cardinality_REPEATED 
Cardinality_ONEOF 

Definition at line 66 of file protobuf/src/google/protobuf/generated_message_table_driven_lite.h.

◆ Cardinality [2/2]

Enumerator
Cardinality_SINGULAR 
Cardinality_REPEATED 
Cardinality_ONEOF 
Cardinality_SINGULAR 
Cardinality_REPEATED 
Cardinality_ONEOF 

Definition at line 68 of file bloaty/third_party/protobuf/src/google/protobuf/generated_message_table_driven_lite.h.

◆ ExitReason [1/2]

Enumerator
kExitDstSpaceFull 
kExitIllegalStructure 
kExitOK 
kExitReject 
kExitReplace1 
kExitReplace2 
kExitReplace3 
kExitReplace21 
kExitReplace31 
kExitReplace32 
kExitReplaceOffset1 
kExitReplaceOffset2 
kExitReplace1S0 
kExitSpecial 
kExitDoAgain 
kExitRejectAlt 
kExitNone 
kExitDstSpaceFull 
kExitIllegalStructure 
kExitOK 
kExitReject 
kExitReplace1 
kExitReplace2 
kExitReplace3 
kExitReplace21 
kExitReplace31 
kExitReplace32 
kExitReplaceOffset1 
kExitReplaceOffset2 
kExitReplace1S0 
kExitSpecial 
kExitDoAgain 
kExitRejectAlt 
kExitNone 

Definition at line 54 of file protobuf/src/google/protobuf/stubs/structurally_valid.cc.

◆ ExitReason [2/2]

Enumerator
kExitDstSpaceFull 
kExitIllegalStructure 
kExitOK 
kExitReject 
kExitReplace1 
kExitReplace2 
kExitReplace3 
kExitReplace21 
kExitReplace31 
kExitReplace32 
kExitReplaceOffset1 
kExitReplaceOffset2 
kExitReplace1S0 
kExitSpecial 
kExitDoAgain 
kExitRejectAlt 
kExitNone 
kExitDstSpaceFull 
kExitIllegalStructure 
kExitOK 
kExitReject 
kExitReplace1 
kExitReplace2 
kExitReplace3 
kExitReplace21 
kExitReplace31 
kExitReplace32 
kExitReplaceOffset1 
kExitReplaceOffset2 
kExitReplace1S0 
kExitSpecial 
kExitDoAgain 
kExitRejectAlt 
kExitNone 

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

◆ ProcessingType [1/2]

Enumerator
ProcessingType_STRING 
ProcessingType_CORD 
ProcessingType_STRING_PIECE 
ProcessingType_INLINED 
ProcessingType_MESSAGE 
ProcessingType_STRING 
ProcessingType_CORD 
ProcessingType_STRING_PIECE 
ProcessingType_INLINED 
ProcessingType_MESSAGE 

Definition at line 58 of file protobuf/src/google/protobuf/generated_message_table_driven_lite.h.

◆ ProcessingType [2/2]

Enumerator
ProcessingType_STRING 
ProcessingType_CORD 
ProcessingType_STRING_PIECE 
ProcessingType_INLINED 
ProcessingType_MESSAGE 
ProcessingType_STRING 
ProcessingType_CORD 
ProcessingType_STRING_PIECE 
ProcessingType_INLINED 
ProcessingType_MESSAGE 

Definition at line 60 of file bloaty/third_party/protobuf/src/google/protobuf/generated_message_table_driven_lite.h.

◆ ProcessingTypes [1/2]

Enumerator
TYPE_STRING_CORD 
TYPE_STRING_STRING_PIECE 
TYPE_BYTES_CORD 
TYPE_BYTES_STRING_PIECE 
TYPE_STRING_INLINED 
TYPE_BYTES_INLINED 
TYPE_MAP 
TYPE_STRING_CORD 
TYPE_STRING_STRING_PIECE 
TYPE_BYTES_CORD 
TYPE_BYTES_STRING_PIECE 
TYPE_STRING_INLINED 
TYPE_BYTES_INLINED 
TYPE_MAP 

Definition at line 71 of file protobuf/src/google/protobuf/generated_message_table_driven.h.

◆ ProcessingTypes [2/2]

Enumerator
TYPE_STRING_CORD 
TYPE_STRING_STRING_PIECE 
TYPE_BYTES_CORD 
TYPE_BYTES_STRING_PIECE 
TYPE_STRING_INLINED 
TYPE_BYTES_INLINED 
TYPE_MAP 
TYPE_STRING_CORD 
TYPE_STRING_STRING_PIECE 
TYPE_BYTES_CORD 
TYPE_BYTES_STRING_PIECE 
TYPE_STRING_INLINED 
TYPE_BYTES_INLINED 
TYPE_MAP 

Definition at line 71 of file bloaty/third_party/protobuf/src/google/protobuf/generated_message_table_driven.h.

◆ StringType [1/2]

Enumerator
StringType_STRING 
StringType_INLINED 
StringType_STRING 
StringType_INLINED 

Definition at line 51 of file protobuf/src/google/protobuf/generated_message_table_driven_lite.h.

◆ StringType [2/2]

Enumerator
StringType_STRING 
StringType_INLINED 
StringType_STRING 
StringType_INLINED 

Definition at line 53 of file bloaty/third_party/protobuf/src/google/protobuf/generated_message_table_driven_lite.h.

Function Documentation

◆ AddDescriptors()

void PROTOBUF_EXPORT google::protobuf::internal::AddDescriptors ( const DescriptorTable table)

◆ AddField() [1/2]

template<typename Type >
Type * google::protobuf::internal::AddField ( MessageLite msg,
int64  offset 
)
inline

◆ AddField() [2/2]

template<typename Type >
void google::protobuf::internal::AddField ( MessageLite msg,
int64  offset,
Type  value 
)
inline

◆ AddField< std::string >()

template<>
std::string * google::protobuf::internal::AddField< std::string > ( MessageLite msg,
int64  offset 
)
inline

◆ AlignFail()

template<size_t align>
void google::protobuf::internal::AlignFail ( uintptr_t  address)

Definition at line 101 of file generated_message_tctable_impl.h.

◆ AlignFail< 4 >()

◆ AlignFail< 8 >()

◆ AlignTo()

PROTOBUF_ALWAYS_INLINE void* google::protobuf::internal::AlignTo ( void *  ptr,
size_t  align 
)
inline

◆ AlignUpTo8()

constexpr size_t google::protobuf::internal::AlignUpTo8 ( size_t  n)
inlineconstexpr

◆ AllAreInitialized() [1/5]

template<typename Key , typename T >
bool google::protobuf::internal::AllAreInitialized ( const Map< Key, T > &  t)

◆ AllAreInitialized() [2/5]

template<typename Derived , typename Key , typename T , WireFormatLite::FieldType key_wire_type, WireFormatLite::FieldType value_wire_type>
bool google::protobuf::internal::AllAreInitialized ( const MapField< Derived, Key, T, key_wire_type, value_wire_type > &  field)

Definition at line 625 of file protobuf/src/google/protobuf/map_field.h.

◆ AllAreInitialized() [3/5]

template<typename Derived , typename Key , typename T , WireFormatLite::FieldType key_wire_type, WireFormatLite::FieldType value_wire_type>
bool google::protobuf::internal::AllAreInitialized ( const MapFieldLite< Derived, Key, T, key_wire_type, value_wire_type > &  field)

◆ AllAreInitialized() [4/5]

template<typename Msg >
bool google::protobuf::internal::AllAreInitialized ( const RepeatedPtrField< Msg > &  t)

◆ AllAreInitialized() [5/5]

template<class Type >
bool google::protobuf::internal::AllAreInitialized ( const Type t)

◆ AllAreInitializedWeak()

template<class T >
bool google::protobuf::internal::AllAreInitializedWeak ( const RepeatedPtrField< T > &  t)

◆ AllocateMemory()

static SerialArena::Memory google::protobuf::internal::AllocateMemory ( const AllocationPolicy policy_ptr,
size_t  last_size,
size_t  min_bytes 
)
static

◆ AlmostEquals() [1/3]

template<>
bool google::protobuf::internal::AlmostEquals ( double  a,
double  b 
)
inline

◆ AlmostEquals() [2/3]

template<>
bool google::protobuf::internal::AlmostEquals ( float  a,
float  b 
)
inline

◆ AlmostEquals() [3/3]

template<typename T >
bool google::protobuf::internal::AlmostEquals ( T  a,
T  b 
)

◆ arena_delete_object()

template<typename T >
void google::protobuf::internal::arena_delete_object ( void *  object)

◆ arena_destruct_object()

template<typename T >
void google::protobuf::internal::arena_destruct_object ( void *  object)

◆ arena_free()

void google::protobuf::internal::arena_free ( void *  object,
size_t  size 
)
inline

◆ AssignDescriptors() [1/3]

Metadata PROTOBUF_EXPORT google::protobuf::internal::AssignDescriptors ( const DescriptorTable *(*)()  table,
internal::once_flag once,
const Metadata metadata 
)

◆ AssignDescriptors() [2/3]

void PROTOBUF_EXPORT google::protobuf::internal::AssignDescriptors ( const DescriptorTable table)

◆ AssignDescriptors() [3/3]

void PROTOBUF_EXPORT google::protobuf::internal::AssignDescriptors ( const DescriptorTable table,
bool  eager 
)

◆ bit_cast()

template<typename To , typename From >
To google::protobuf::internal::bit_cast ( const From &  from)
inline

◆ byteswap()

template<int >
void google::protobuf::internal::byteswap ( void *  p)

◆ byteswap< 1 >()

template<>
void google::protobuf::internal::byteswap< 1 > ( void *  p)

◆ byteswap< 4 >()

template<>
void google::protobuf::internal::byteswap< 4 > ( void *  p)

◆ byteswap< 8 >()

template<>
void google::protobuf::internal::byteswap< 8 > ( void *  p)

◆ CalculateReserve() [1/3]

template<typename Iter >
int google::protobuf::internal::CalculateReserve ( Iter  begin,
Iter  end 
)
inline

◆ CalculateReserve() [2/3]

template<typename Iter >
int google::protobuf::internal::CalculateReserve ( Iter  begin,
Iter  end,
std::forward_iterator_tag   
)
inline

◆ CalculateReserve() [3/3]

template<typename Iter >
int google::protobuf::internal::CalculateReserve ( Iter  ,
Iter  ,
std::input_iterator_tag   
)
inline

◆ CalculateReserveSize()

int google::protobuf::internal::CalculateReserveSize ( int  total_size,
int  new_size 
)
inline

◆ call_once()

template<typename... Args>
void google::protobuf::internal::call_once ( Args &&...  args)

◆ CallNoArgValidityFunc() [1/2]

static bool google::protobuf::internal::CallNoArgValidityFunc ( const void *  arg,
int  number 
)
static

◆ CallNoArgValidityFunc() [2/2]

static bool google::protobuf::internal::CallNoArgValidityFunc ( const void *  arg,
int  number 
)
static

◆ CheckNotNull()

template<typename T >
T * google::protobuf::internal::CheckNotNull ( const char *  ,
int  ,
const char *  name,
T val 
)

◆ ClearOneofField()

void google::protobuf::internal::ClearOneofField ( const ParseTableField field,
Arena arena,
MessageLite msg 
)
inline

◆ ComputeUnknownFieldsSize() [1/2]

PROTOBUF_EXPORT size_t google::protobuf::internal::ComputeUnknownFieldsSize ( const InternalMetadata metadata,
size_t  total_size,
CachedSize cached_size 
)

◆ ComputeUnknownFieldsSize() [2/2]

PROTOBUF_EXPORT size_t google::protobuf::internal::ComputeUnknownFieldsSize ( const InternalMetadataWithArena metadata,
size_t  total_size,
CachedSize cached_size 
)

◆ ComputeUnknownMessageSetItemsSize() [1/2]

size_t google::protobuf::internal::ComputeUnknownMessageSetItemsSize ( const std::string &  unknown_fields)
inline

◆ ComputeUnknownMessageSetItemsSize() [2/2]

size_t google::protobuf::internal::ComputeUnknownMessageSetItemsSize ( const UnknownFieldSet unknown_fields)
inline

◆ ConstructKey()

static std::string google::protobuf::internal::ConstructKey ( uint64  n)
static

◆ CopyConstructorHelper()

static void google::protobuf::internal::CopyConstructorHelper ( Arena arena,
Map< int32, int32 > *  m 
)
static

◆ cpp_type()

FieldDescriptor::CppType google::protobuf::internal::cpp_type ( FieldType  type)
inline

◆ CreateUnknownEnumValues()

bool google::protobuf::internal::CreateUnknownEnumValues ( const FieldDescriptor field)

◆ DateTimeToSeconds()

bool PROTOBUF_EXPORT google::protobuf::internal::DateTimeToSeconds ( const DateTime time,
int64 seconds 
)

◆ DECLARE_STREAM_OPERATOR()

google::protobuf::internal::DECLARE_STREAM_OPERATOR ( long  )

◆ DecodeTwoBytes()

uint32_t google::protobuf::internal::DecodeTwoBytes ( const char **  ptr)
inline

◆ DefaultLogHandler() [1/2]

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

◆ DefaultLogHandler() [2/2]

void google::protobuf::internal::DefaultLogHandler ( LogLevel  level,
const char *  filename,
int  line,
const string &  message 
)

◆ DestroyMessage()

PROTOBUF_EXPORT void google::protobuf::internal::DestroyMessage ( const void *  message)

◆ DestroyString()

PROTOBUF_EXPORT void google::protobuf::internal::DestroyString ( const void *  s)

◆ DeterministicSerialization()

template<typename T >
static std::string google::protobuf::internal::DeterministicSerialization ( const T t)
static

◆ DeterministicSerializationWithSerializePartialToCodedStream()

template<typename T >
static std::string google::protobuf::internal::DeterministicSerializationWithSerializePartialToCodedStream ( const T t)
static

◆ DeterministicSerializationWithSerializeToCodedStream()

template<typename T >
static std::string google::protobuf::internal::DeterministicSerializationWithSerializeToCodedStream ( const T t)
static

◆ down_cast() [1/2]

template<typename To , typename From >
To google::protobuf::internal::down_cast ( From &  f)
inline

◆ down_cast() [2/2]

template<typename To , typename From >
To google::protobuf::internal::down_cast ( From *  f)
inline

◆ DownCast() [1/2]

template<typename To , typename From >
To google::protobuf::internal::DownCast ( From &  f)
inline

◆ DownCast() [2/2]

template<typename To , typename From >
To google::protobuf::internal::DownCast ( From *  f)
inline

◆ DuplicateIfNonNull()

template<typename T >
T * google::protobuf::internal::DuplicateIfNonNull ( T message)

◆ DuplicateIfNonNullInternal()

PROTOBUF_EXPORT MessageLite * google::protobuf::internal::DuplicateIfNonNullInternal ( MessageLite message)

◆ ExpectTag()

template<uint32 tag>
bool google::protobuf::internal::ExpectTag ( const char *  ptr)

◆ ExtensionSerializer() [1/2]

PROTOBUF_EXPORT void google::protobuf::internal::ExtensionSerializer ( const MessageLite extendee,
const uint8_t ptr,
uint32_t  offset,
uint32_t  tag,
uint32_t  has_offset,
io::CodedOutputStream output 
)

◆ ExtensionSerializer() [2/2]

PROTOBUF_EXPORT void google::protobuf::internal::ExtensionSerializer ( const uint8 ptr,
uint32  offset,
uint32  tag,
uint32  has_offset,
io::CodedOutputStream output 
)

◆ fastmemcmp_inlined()

int google::protobuf::internal::fastmemcmp_inlined ( const char *  a,
const char *  b,
size_t  n 
)
inline

Definition at line 100 of file fastmem.h.

◆ field_type()

WireFormatLite::FieldType google::protobuf::internal::field_type ( FieldType  type)
inline

◆ FieldParser() [1/2]

template<typename T >
const PROTOBUF_MUST_USE_RESULT char* google::protobuf::internal::FieldParser ( uint64  tag,
T field_parser,
const char *  ptr,
ParseContext ctx 
)

◆ FieldParser() [2/2]

template<typename T >
const PROTOBUF_NODISCARD char* google::protobuf::internal::FieldParser ( uint64_t  tag,
T field_parser,
const char *  ptr,
ParseContext ctx 
)

◆ FixedParser()

template<typename T >
const char * google::protobuf::internal::FixedParser ( void *  object,
const char *  ptr,
ParseContext ctx 
)

◆ FormatTime()

std::string PROTOBUF_EXPORT google::protobuf::internal::FormatTime ( int64  seconds,
int32  nanos 
)

◆ FromIntSize()

size_t google::protobuf::internal::FromIntSize ( int  size)
inline

◆ Func()

static int google::protobuf::internal::Func ( int  i,
int  j 
)
static

◆ GenericSwap() [1/2]

void google::protobuf::internal::GenericSwap ( Message m1,
Message m2 
)

◆ GenericSwap() [2/2]

PROTOBUF_EXPORT void google::protobuf::internal::GenericSwap ( MessageLite m1,
MessageLite m2 
)

◆ Get()

template<typename T >
const T & google::protobuf::internal::Get ( const void *  ptr)

◆ GetAnyFieldDescriptors()

bool google::protobuf::internal::GetAnyFieldDescriptors ( const Message message,
const FieldDescriptor **  type_url_field,
const FieldDescriptor **  value_field 
)

◆ GetArena()

template<typename InternalMetadata >
Arena* google::protobuf::internal::GetArena ( MessageLite msg,
int64  arena_offset 
)
inline

◆ GetConstPointerAtOffset()

template<class To >
const To* google::protobuf::internal::GetConstPointerAtOffset ( const Message message,
uint32_t  offset 
)

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

◆ GetConstRefAtOffset()

template<class To >
const To& google::protobuf::internal::GetConstRefAtOffset ( const Message message,
uint32_t  offset 
)

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

◆ GetCurrentTime()

void PROTOBUF_EXPORT google::protobuf::internal::GetCurrentTime ( int64 seconds,
int32 nanos 
)

◆ GetEmptyString()

const PROTOBUF_EXPORT std::string & google::protobuf::internal::GetEmptyString ( )
inline

◆ GetEmptyStringAlreadyInited()

constexpr const PROTOBUF_EXPORT std::string & google::protobuf::internal::GetEmptyStringAlreadyInited ( )
inlineconstexpr

◆ GetExtensionSet()

ExtensionSet * google::protobuf::internal::GetExtensionSet ( MessageLite msg,
int64  extension_offset 
)
inline

◆ GetOwnedMessage()

template<typename T >
T * google::protobuf::internal::GetOwnedMessage ( Arena message_arena,
T submessage,
Arena submessage_arena 
)

◆ GetOwnedMessageInternal()

PROTOBUF_EXPORT MessageLite * google::protobuf::internal::GetOwnedMessageInternal ( Arena message_arena,
MessageLite submessage,
Arena submessage_arena 
)

◆ GetPointerAtOffset()

template<class To >
To* google::protobuf::internal::GetPointerAtOffset ( Message message,
uint32_t  offset 
)
inline

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

◆ GetReflectionOrDie() [1/2]

static const Reflection* google::protobuf::internal::GetReflectionOrDie ( const Message m)
static

◆ GetReflectionOrDie() [2/2]

static const Reflection* google::protobuf::internal::GetReflectionOrDie ( const Message m)
static

◆ GetTypeUrl()

std::string google::protobuf::internal::GetTypeUrl ( StringPiece  message_name,
StringPiece  type_url_prefix 
)

◆ GOOGLE_PROTOBUF_CAPABILITY()

class google::protobuf::internal::GOOGLE_PROTOBUF_CAPABILITY ( "mutex"  )

◆ HandleEnum() [1/2]

template<typename UnknownFieldHandler , typename InternalMetadata , Cardinality cardinality>
bool google::protobuf::internal::HandleEnum ( const ParseTable table,
io::CodedInputStream input,
MessageLite msg,
uint32 presence,
uint32  presence_index,
int64  offset,
uint32  tag,
int  field_number 
)
inline

◆ HandleEnum() [2/2]

template<typename UnknownFieldHandler , Cardinality cardinality>
bool google::protobuf::internal::HandleEnum ( const ParseTable table,
io::CodedInputStream input,
MessageLite msg,
uint32_t presence,
uint32_t  presence_index,
int64_t  offset,
uint32_t  tag,
int  field_number 
)
inline

◆ HandleString() [1/2]

template<typename UnknownFieldHandler , Cardinality cardinality, bool is_string_type, StringType ctype>
static bool google::protobuf::internal::HandleString ( io::CodedInputStream input,
MessageLite msg,
Arena arena,
uint32 has_bits,
uint32  has_bit_index,
int64  offset,
const void *  default_ptr,
const char *  field_name 
)
inlinestatic

◆ HandleString() [2/2]

template<typename UnknownFieldHandler , Cardinality cardinality, bool is_string_type, StringType ctype>
static bool google::protobuf::internal::HandleString ( io::CodedInputStream input,
MessageLite msg,
Arena arena,
uint32_t has_bits,
uint32_t  has_bit_index,
int64_t  offset,
const void *  default_ptr,
const char *  field_name 
)
inlinestatic

◆ implicit_cast()

template<typename To , typename From >
To google::protobuf::internal::implicit_cast ( From const f)
inline

◆ InitEnumParseWrapper() [1/2]

template<typename T , typename Metadata >
EnumParseWrapper<T, Metadata> google::protobuf::internal::InitEnumParseWrapper ( T map_field,
bool(*)(int is_valid,
uint32  field_num,
Metadata metadata 
)

◆ InitEnumParseWrapper() [2/2]

template<typename UnknownType , typename T >
EnumParseWrapper<UnknownType, T> google::protobuf::internal::InitEnumParseWrapper ( T map_field,
bool(*)(int is_valid,
uint32_t  field_num,
InternalMetadata metadata 
)

◆ InitializeEnumStrings()

PROTOBUF_EXPORT bool google::protobuf::internal::InitializeEnumStrings ( const EnumEntry enums,
const int sorted_indices,
size_t  size,
internal::ExplicitlyConstructed< std::string > *  enum_strings 
)

◆ InitImplicitWeakMessageDefaultInstance()

void google::protobuf::internal::InitImplicitWeakMessageDefaultInstance ( )

◆ InitProtobufDefaults()

PROTOBUF_EXPORT void google::protobuf::internal::InitProtobufDefaults ( )
inline

◆ InitProtobufDefaultsImpl() [1/2]

static bool google::protobuf::internal::InitProtobufDefaultsImpl ( )
static

◆ InitProtobufDefaultsImpl() [2/2]

static bool google::protobuf::internal::InitProtobufDefaultsImpl ( )
static

◆ InitProtobufDefaultsSlow()

PROTOBUF_EXPORT void google::protobuf::internal::InitProtobufDefaultsSlow ( )

◆ InitSCC()

void google::protobuf::internal::InitSCC ( SCCInfoBase scc)
inline

◆ InitSCCImpl()

PROTOBUF_EXPORT void google::protobuf::internal::InitSCCImpl ( SCCInfoBase scc)

◆ InlineGreedyStringParser()

PROTOBUF_EXPORT const PROTOBUF_NODISCARD char * google::protobuf::internal::InlineGreedyStringParser ( std::string *  s,
const char *  ptr,
ParseContext ctx 
)

◆ InlineGreedyStringParserUTF8()

PROTOBUF_EXPORT const PROTOBUF_MUST_USE_RESULT char * google::protobuf::internal::InlineGreedyStringParserUTF8 ( std::string *  s,
const char *  ptr,
ParseContext ctx,
const char *  field_name 
)

◆ InlineGreedyStringParserUTF8Verify()

const PROTOBUF_MUST_USE_RESULT char* google::protobuf::internal::InlineGreedyStringParserUTF8Verify ( std::string *  s,
const char *  ptr,
ParseContext ctx,
const char *  field_name 
)
inline

◆ INSTANTIATE_TEST_SUITE_P() [1/3]

google::protobuf::internal::INSTANTIATE_TEST_SUITE_P ( MapFieldBasePrimitiveTestInstance  ,
MapFieldBasePrimitiveTest  ,
testing::Values(true, false  
)

◆ INSTANTIATE_TEST_SUITE_P() [2/3]

google::protobuf::internal::INSTANTIATE_TEST_SUITE_P ( MapFieldStateTestInstance  ,
MapFieldStateTest  ,
::testing::Values(CLEAN, MAP_DIRTY, REPEATED_DIRTY)   
)

◆ INSTANTIATE_TEST_SUITE_P() [3/3]

google::protobuf::internal::INSTANTIATE_TEST_SUITE_P ( MapFieldStateTestInstance  ,
MapFieldStateTest  ,
testing::Combine(testing::Values(CLEAN, MAP_DIRTY, REPEATED_DIRTY), testing::Values(true, false))   
)

◆ InStateZero() [1/2]

static bool google::protobuf::internal::InStateZero ( const UTF8ScanObj st,
const uint8 Tbl 
)
inlinestatic

◆ InStateZero() [2/2]

static bool google::protobuf::internal::InStateZero ( const UTF8ScanObj st,
const uint8 Tbl 
)
inlinestatic

◆ Int()

static int google::protobuf::internal::Int ( const std::string &  value)
static

◆ InternalMetadata::DoClear< std::string >()

template<>
void google::protobuf::internal::InternalMetadata::DoClear< std::string > ( )

◆ InternalMetadata::DoMergeFrom< std::string >()

template<>
void google::protobuf::internal::InternalMetadata::DoMergeFrom< std::string > ( const std::string &  other)

◆ InternalMetadata::DoSwap< std::string >()

template<>
void google::protobuf::internal::InternalMetadata::DoSwap< std::string > ( std::string *  other)

◆ InternalSerializeMapEntry() [1/2]

static uint8_t* google::protobuf::internal::InternalSerializeMapEntry ( const FieldDescriptor field,
const MapKey key,
const MapValueConstRef value,
uint8_t target,
io::EpsCopyOutputStream stream 
)
static

◆ InternalSerializeMapEntry() [2/2]

static uint8* google::protobuf::internal::InternalSerializeMapEntry ( const FieldDescriptor field,
const MapKey key,
const MapValueRef value,
uint8 target,
io::EpsCopyOutputStream stream 
)
static

◆ InternalSerializeUnknownMessageSetItemsToArray() [1/2]

uint8_t * google::protobuf::internal::InternalSerializeUnknownMessageSetItemsToArray ( const std::string &  unknown_fields,
uint8 target,
io::EpsCopyOutputStream stream 
)
inline

◆ InternalSerializeUnknownMessageSetItemsToArray() [2/2]

uint8_t * google::protobuf::internal::InternalSerializeUnknownMessageSetItemsToArray ( const UnknownFieldSet unknown_fields,
uint8 target,
io::EpsCopyOutputStream stream 
)
inline

◆ IsConstHelper() [1/2]

template<typename T >
bool google::protobuf::internal::IsConstHelper ( const T )

◆ IsConstHelper() [2/2]

template<typename T >
bool google::protobuf::internal::IsConstHelper ( T )

◆ IsForwardIteratorHelper()

bool google::protobuf::internal::IsForwardIteratorHelper ( std::forward_iterator_tag  )

◆ IsMapValueMessageTyped() [1/2]

static bool google::protobuf::internal::IsMapValueMessageTyped ( const FieldDescriptor map_field)
static

◆ IsMapValueMessageTyped() [2/2]

static bool google::protobuf::internal::IsMapValueMessageTyped ( const FieldDescriptor map_field)
static

◆ IsNan()

template<typename T , typename std::enable_if< std::is_integral< T >::value, int >::type = 0>
bool google::protobuf::internal::IsNan ( T  val)

◆ IsNull()

template<int type>
bool google::protobuf::internal::IsNull ( const void *  ptr)

◆ IsNull< FieldMetadata::kInlinedType >()

◆ IsNull< WireFormatLite::TYPE_BYTES >()

◆ IsNull< WireFormatLite::TYPE_GROUP >()

◆ IsNull< WireFormatLite::TYPE_MESSAGE >()

◆ IsNull< WireFormatLite::TYPE_STRING >()

◆ IsOk() [1/2]

template<>
bool google::protobuf::internal::IsOk ( bool  status)
inline

◆ IsOk() [2/2]

template<typename T >
bool google::protobuf::internal::IsOk ( T  status)

◆ IsOneofPresent()

bool google::protobuf::internal::IsOneofPresent ( const void *  base,
uint32  offset,
uint32  tag 
)
inline

◆ IsPresent()

bool google::protobuf::internal::IsPresent ( const void *  base,
uint32  hasbit 
)
inline

◆ IsStructurallyValidUTF8() [1/3]

bool google::protobuf::internal::IsStructurallyValidUTF8 ( const char *  buf,
int  len 
)

◆ IsStructurallyValidUTF8() [2/3]

bool google::protobuf::internal::IsStructurallyValidUTF8 ( const std::string &  str)
inline

◆ IsStructurallyValidUTF8() [3/3]

bool google::protobuf::internal::IsStructurallyValidUTF8 ( StringPiece  str)
inline

Definition at line 132 of file protobuf/src/google/protobuf/stubs/common.h.

◆ LogIndexOutOfBounds()

void google::protobuf::internal::LogIndexOutOfBounds ( int  index,
int  size 
)

◆ LookUpEnumName()

PROTOBUF_EXPORT int google::protobuf::internal::LookUpEnumName ( const EnumEntry enums,
const int sorted_indices,
size_t  size,
int  value 
)

◆ LookUpEnumValue()

PROTOBUF_EXPORT bool google::protobuf::internal::LookUpEnumValue ( const EnumEntry enums,
size_t  size,
StringPiece  name,
int value 
)

◆ MapFieldSerializer()

template<typename MapFieldType , const SerializationTable * table>
void google::protobuf::internal::MapFieldSerializer ( const uint8 base,
uint32  offset,
uint32  tag,
uint32  has_offset,
io::CodedOutputStream output 
)

◆ MapKeyDataOnlyByteSize()

size_t google::protobuf::internal::MapKeyDataOnlyByteSize ( const FieldDescriptor field,
const MapKey value 
)
static

◆ MapTestForceDeterministic()

void google::protobuf::internal::MapTestForceDeterministic ( )

◆ MapValueRefDataOnlyByteSize() [1/2]

static size_t google::protobuf::internal::MapValueRefDataOnlyByteSize ( const FieldDescriptor field,
const MapValueConstRef value 
)
static

◆ MapValueRefDataOnlyByteSize() [2/2]

static size_t google::protobuf::internal::MapValueRefDataOnlyByteSize ( const FieldDescriptor field,
const MapValueRef value 
)
static

◆ MapValueSpaceUsedExcludingSelfLong() [1/3]

size_t google::protobuf::internal::MapValueSpaceUsedExcludingSelfLong ( bool  )
inline

◆ MapValueSpaceUsedExcludingSelfLong() [2/3]

size_t google::protobuf::internal::MapValueSpaceUsedExcludingSelfLong ( const std::string &  str)
inline

◆ MapValueSpaceUsedExcludingSelfLong() [3/3]

template<typename T , typename = decltype(std::declval<const T&>().SpaceUsedLong())>
size_t google::protobuf::internal::MapValueSpaceUsedExcludingSelfLong ( const T message)

◆ MaybeCreateLazyExtension()

PROTOBUF_ATTRIBUTE_WEAK ExtensionSet::LazyMessageExtension* google::protobuf::internal::MaybeCreateLazyExtension ( Arena arena)

◆ median()

template<typename Iterator >
static int64 google::protobuf::internal::median ( Iterator  i0,
Iterator  i1 
)
static

◆ memcpy_inlined()

void google::protobuf::internal::memcpy_inlined ( char *  dst,
const char *  src,
size_t  size 
)
inline

Definition at line 127 of file fastmem.h.

◆ memeq()

bool google::protobuf::internal::memeq ( const char *  a,
const char *  b,
size_t  n 
)
inline

Definition at line 67 of file fastmem.h.

◆ memswap()

template<int kSize>
std::enable_if<(kSize == 0), void>::type google::protobuf::internal::memswap ( char *  ,
char *   
)
inline

◆ MergeFromImpl() [1/4]

template<bool aliasing>
bool google::protobuf::internal::MergeFromImpl ( BoundedZCIS  input,
MessageLite msg,
MessageLite::ParseFlags  parse_flags 
)

◆ MergeFromImpl() [2/4]

template<bool alias, typename T >
bool google::protobuf::internal::MergeFromImpl ( const SourceWrapper< T > &  input,
MessageLite msg,
MessageLite::ParseFlags  parse_flags 
)

Definition at line 540 of file protobuf/src/google/protobuf/message_lite.h.

◆ MergeFromImpl() [3/4]

template<bool aliasing>
bool google::protobuf::internal::MergeFromImpl ( io::ZeroCopyInputStream input,
MessageLite msg,
MessageLite::ParseFlags  parse_flags 
)

◆ MergeFromImpl() [4/4]

template<bool aliasing>
bool google::protobuf::internal::MergeFromImpl ( StringPiece  input,
MessageLite msg,
MessageLite::ParseFlags  parse_flags 
)

◆ MergeFromImpl< false >() [1/3]

◆ MergeFromImpl< false >() [2/3]

◆ MergeFromImpl< false >() [3/3]

◆ MergeFromImpl< true >() [1/3]

◆ MergeFromImpl< true >() [2/3]

◆ MergeFromImpl< true >() [3/3]

◆ MergePartialFromCodedStream()

bool google::protobuf::internal::MergePartialFromCodedStream ( MessageLite msg,
const ParseTable table,
io::CodedInputStream input 
)

◆ MergePartialFromCodedStreamImpl() [1/2]

template<typename UnknownFieldHandler >
bool google::protobuf::internal::MergePartialFromCodedStreamImpl ( MessageLite msg,
const ParseTable table,
io::CodedInputStream input 
)

◆ MergePartialFromCodedStreamImpl() [2/2]

template<typename UnknownFieldHandler , typename InternalMetadata >
bool google::protobuf::internal::MergePartialFromCodedStreamImpl ( MessageLite msg,
const ParseTable table,
io::CodedInputStream input 
)

◆ MergePartialFromCodedStreamInlined() [1/2]

template<typename UnknownFieldHandler , uint32_t kMaxTag>
bool google::protobuf::internal::MergePartialFromCodedStreamInlined ( MessageLite msg,
const ParseTable table,
io::CodedInputStream input 
)

◆ MergePartialFromCodedStreamInlined() [2/2]

template<typename UnknownFieldHandler , typename InternalMetadata , uint32 kMaxTag>
bool google::protobuf::internal::MergePartialFromCodedStreamInlined ( MessageLite msg,
const ParseTable table,
io::CodedInputStream input 
)

◆ MergePartialFromCodedStreamLite()

bool google::protobuf::internal::MergePartialFromCodedStreamLite ( MessageLite msg,
const ParseTable table,
io::CodedInputStream input 
)

◆ MergePartialFromImpl() [1/4]

template<bool aliasing>
bool google::protobuf::internal::MergePartialFromImpl ( BoundedZCIS  input,
MessageLite msg 
)

◆ MergePartialFromImpl() [2/4]

template<bool alias, typename T >
bool google::protobuf::internal::MergePartialFromImpl ( const SourceWrapper< T > &  input,
MessageLite msg 
)

◆ MergePartialFromImpl() [3/4]

template<bool aliasing>
bool google::protobuf::internal::MergePartialFromImpl ( io::ZeroCopyInputStream input,
MessageLite msg 
)

◆ MergePartialFromImpl() [4/4]

template<bool aliasing>
bool google::protobuf::internal::MergePartialFromImpl ( StringPiece  input,
MessageLite msg 
)

◆ MergePartialFromImpl< false >() [1/3]

◆ MergePartialFromImpl< false >() [2/3]

◆ MergePartialFromImpl< false >() [3/3]

◆ MergePartialFromImpl< true >() [1/3]

◆ MergePartialFromImpl< true >() [2/3]

◆ MergePartialFromImpl< true >() [3/3]

◆ MutableField()

template<typename Type >
Type * google::protobuf::internal::MutableField ( MessageLite msg,
uint32 has_bits,
uint32  has_bit_index,
int64  offset 
)
inline

◆ NameOfEnum()

const std::string & google::protobuf::internal::NameOfEnum ( const EnumDescriptor descriptor,
int  value 
)

◆ NoLocaleStrtod()

double google::protobuf::internal::NoLocaleStrtod ( const char *  str,
char **  endptr 
)

◆ Now()

static int64 google::protobuf::internal::Now ( )
static

◆ NullLogHandler() [1/2]

void google::protobuf::internal::NullLogHandler ( LogLevel  ,
const char *  ,
int  ,
const std::string &   
)

◆ NullLogHandler() [2/2]

void google::protobuf::internal::NullLogHandler ( LogLevel  ,
const char *  ,
int  ,
const string &   
)

◆ OnShutdown()

PROTOBUF_EXPORT void google::protobuf::internal::OnShutdown ( void(*)()  func)

◆ OnShutdownDelete()

template<typename T >
T * google::protobuf::internal::OnShutdownDelete ( T p)

◆ OnShutdownDestroyMessage()

void google::protobuf::internal::OnShutdownDestroyMessage ( const void *  ptr)
inline

◆ OnShutdownDestroyString()

void google::protobuf::internal::OnShutdownDestroyString ( const std::string *  ptr)
inline

◆ OnShutdownRun()

PROTOBUF_EXPORT void google::protobuf::internal::OnShutdownRun ( void(*)(const void *)  f,
const void *  arg 
)

◆ PackedBoolParser()

PROTOBUF_EXPORT const PROTOBUF_NODISCARD char * google::protobuf::internal::PackedBoolParser ( void *  object,
const char *  ptr,
ParseContext ctx 
)

◆ PackedDoubleParser()

PROTOBUF_EXPORT const PROTOBUF_NODISCARD char * google::protobuf::internal::PackedDoubleParser ( void *  object,
const char *  ptr,
ParseContext ctx 
)

◆ PackedEnumParser() [1/4]

PROTOBUF_EXPORT const PROTOBUF_NODISCARD char * google::protobuf::internal::PackedEnumParser ( void *  object,
const char *  ptr,
ParseContext ctx 
)

◆ PackedEnumParser() [2/4]

template<typename T >
const PROTOBUF_NODISCARD char* google::protobuf::internal::PackedEnumParser ( void *  object,
const char *  ptr,
ParseContext ctx,
bool(*)(int is_valid,
InternalMetadata metadata,
int  field_num 
)

◆ PackedEnumParser() [3/4]

const PROTOBUF_EXPORT char * google::protobuf::internal::PackedEnumParser ( void *  object,
const char *  ptr,
ParseContext ctx,
bool(*)(int is_valid,
InternalMetadataWithArena metadata,
int  field_num 
)

◆ PackedEnumParser() [4/4]

PROTOBUF_EXPORT const PROTOBUF_MUST_USE_RESULT char * google::protobuf::internal::PackedEnumParser ( void *  object,
const char *  ptr,
ParseContext ctx,
bool(*)(int is_valid,
InternalMetadataWithArenaLite metadata,
int  field_num 
)

◆ PackedEnumParserArg() [1/3]

template<typename T >
const PROTOBUF_NODISCARD char* google::protobuf::internal::PackedEnumParserArg ( void *  object,
const char *  ptr,
ParseContext ctx,
bool(*)(const void *, int is_valid,
const void *  data,
InternalMetadata metadata,
int  field_num 
)

◆ PackedEnumParserArg() [2/3]

const PROTOBUF_EXPORT char * google::protobuf::internal::PackedEnumParserArg ( void *  object,
const char *  ptr,
ParseContext ctx,
bool(*)(const void *, int is_valid,
const void *  data,
InternalMetadataWithArena metadata,
int  field_num 
)

◆ PackedEnumParserArg() [3/3]

PROTOBUF_EXPORT const PROTOBUF_MUST_USE_RESULT char * google::protobuf::internal::PackedEnumParserArg ( void *  object,
const char *  ptr,
ParseContext ctx,
bool(*)(const void *, int is_valid,
const void *  data,
InternalMetadataWithArenaLite metadata,
int  field_num 
)

◆ PackedFixed32Parser()

PROTOBUF_EXPORT const PROTOBUF_NODISCARD char * google::protobuf::internal::PackedFixed32Parser ( void *  object,
const char *  ptr,
ParseContext ctx 
)

◆ PackedFixed64Parser()

PROTOBUF_EXPORT const PROTOBUF_NODISCARD char * google::protobuf::internal::PackedFixed64Parser ( void *  object,
const char *  ptr,
ParseContext ctx 
)

◆ PackedFloatParser()

PROTOBUF_EXPORT const PROTOBUF_NODISCARD char * google::protobuf::internal::PackedFloatParser ( void *  object,
const char *  ptr,
ParseContext ctx 
)

◆ PackedInt32Parser()

PROTOBUF_EXPORT const PROTOBUF_NODISCARD char * google::protobuf::internal::PackedInt32Parser ( void *  object,
const char *  ptr,
ParseContext ctx 
)

◆ PackedInt64Parser()

PROTOBUF_EXPORT const PROTOBUF_NODISCARD char * google::protobuf::internal::PackedInt64Parser ( void *  object,
const char *  ptr,
ParseContext ctx 
)

◆ PackedSFixed32Parser()

PROTOBUF_EXPORT const PROTOBUF_NODISCARD char * google::protobuf::internal::PackedSFixed32Parser ( void *  object,
const char *  ptr,
ParseContext ctx 
)

◆ PackedSFixed64Parser()

PROTOBUF_EXPORT const PROTOBUF_NODISCARD char * google::protobuf::internal::PackedSFixed64Parser ( void *  object,
const char *  ptr,
ParseContext ctx 
)

◆ PackedSInt32Parser()

PROTOBUF_EXPORT const PROTOBUF_NODISCARD char * google::protobuf::internal::PackedSInt32Parser ( void *  object,
const char *  ptr,
ParseContext ctx 
)

◆ PackedSInt64Parser()

PROTOBUF_EXPORT const PROTOBUF_NODISCARD char * google::protobuf::internal::PackedSInt64Parser ( void *  object,
const char *  ptr,
ParseContext ctx 
)

◆ PackedUInt32Parser()

PROTOBUF_EXPORT const PROTOBUF_NODISCARD char * google::protobuf::internal::PackedUInt32Parser ( void *  object,
const char *  ptr,
ParseContext ctx 
)

◆ PackedUInt64Parser()

PROTOBUF_EXPORT const PROTOBUF_NODISCARD char * google::protobuf::internal::PackedUInt64Parser ( void *  object,
const char *  ptr,
ParseContext ctx 
)

◆ ParseAnyTypeUrl() [1/4]

bool google::protobuf::internal::ParseAnyTypeUrl ( const std::string &  type_url,
std::string *  full_type_name 
)

◆ ParseAnyTypeUrl() [2/4]

bool google::protobuf::internal::ParseAnyTypeUrl ( const std::string &  type_url,
std::string *  url_prefix,
std::string *  full_type_name 
)

◆ ParseAnyTypeUrl() [3/4]

bool google::protobuf::internal::ParseAnyTypeUrl ( StringPiece  type_url,
std::string *  full_type_name 
)

Definition at line 93 of file protobuf/src/google/protobuf/any_lite.cc.

◆ ParseAnyTypeUrl() [4/4]

bool google::protobuf::internal::ParseAnyTypeUrl ( StringPiece  type_url,
std::string *  url_prefix,
std::string *  full_type_name 
)

Definition at line 80 of file protobuf/src/google/protobuf/any_lite.cc.

◆ ParseBigVarint()

const char * google::protobuf::internal::ParseBigVarint ( const char *  p,
uint64 out 
)
inline

◆ ParseMap()

template<typename Entry >
bool google::protobuf::internal::ParseMap ( io::CodedInputStream input,
void *  map_field 
)

◆ ParseMessageSetItemImpl()

template<typename MS >
bool google::protobuf::internal::ParseMessageSetItemImpl ( io::CodedInputStream input,
MS  ms 
)

◆ ParseNamedEnum() [1/2]

template<typename EnumType >
bool google::protobuf::internal::ParseNamedEnum ( const EnumDescriptor descriptor,
const std::string &  name,
EnumType *  value 
)

◆ ParseNamedEnum() [2/2]

bool google::protobuf::internal::ParseNamedEnum ( const EnumDescriptor descriptor,
const std::string &  name,
int value 
)

◆ ParseTime() [1/2]

bool PROTOBUF_EXPORT google::protobuf::internal::ParseTime ( const std::string &  value,
int64 seconds,
int32 nanos 
)

◆ ParseTime() [2/2]

bool PROTOBUF_EXPORT google::protobuf::internal::ParseTime ( const string &  value,
int64 seconds,
int32 nanos 
)

◆ PrintUTF8ErrorLog()

void google::protobuf::internal::PrintUTF8ErrorLog ( const char *  field_name,
const char *  operation_str,
bool  emit_stacktrace 
)

◆ Raw() [1/2]

template<typename Type >
const Type * google::protobuf::internal::Raw ( const MessageLite msg,
int64  offset 
)
inline

◆ Raw() [2/2]

template<typename Type >
Type * google::protobuf::internal::Raw ( MessageLite msg,
int64  offset 
)
inline

◆ ReadBOOL()

const char * google::protobuf::internal::ReadBOOL ( const char *  ptr,
bool value 
)
inline

◆ ReadBytesToString() [1/2]

static bool google::protobuf::internal::ReadBytesToString ( io::CodedInputStream input,
std::string *  value 
)
inlinestatic

◆ ReadBytesToString() [2/2]

static bool google::protobuf::internal::ReadBytesToString ( io::CodedInputStream input,
std::string *  value 
)
inlinestatic

◆ ReadDOUBLE()

const char * google::protobuf::internal::ReadDOUBLE ( const char *  ptr,
double *  value 
)
inline

◆ ReadENUM()

template<typename E >
const char * google::protobuf::internal::ReadENUM ( const char *  ptr,
E *  value 
)
inline

◆ ReadFIXED32()

const char * google::protobuf::internal::ReadFIXED32 ( const char *  ptr,
uint32 value 
)
inline

◆ ReadFIXED64()

const char * google::protobuf::internal::ReadFIXED64 ( const char *  ptr,
uint64 value 
)
inline

◆ ReadFLOAT()

const char * google::protobuf::internal::ReadFLOAT ( const char *  ptr,
float *  value 
)
inline

◆ ReadINT32()

const char * google::protobuf::internal::ReadINT32 ( const char *  ptr,
int32 value 
)
inline

◆ ReadINT64()

const char * google::protobuf::internal::ReadINT64 ( const char *  ptr,
int64 value 
)
inline

◆ ReadPackedVarintArray()

template<typename Add >
const char* google::protobuf::internal::ReadPackedVarintArray ( const char *  ptr,
const char *  end,
Add  add 
)

◆ ReadSFIXED32()

const char * google::protobuf::internal::ReadSFIXED32 ( const char *  ptr,
int32 value 
)
inline

◆ ReadSFIXED64()

const char * google::protobuf::internal::ReadSFIXED64 ( const char *  ptr,
int64 value 
)
inline

◆ ReadSINT32()

const char * google::protobuf::internal::ReadSINT32 ( const char *  ptr,
int32 value 
)
inline

◆ ReadSINT64()

const char * google::protobuf::internal::ReadSINT64 ( const char *  ptr,
int64 value 
)
inline

◆ ReadSize()

uint32_t google::protobuf::internal::ReadSize ( const char **  pp)
inline

◆ ReadSizeFallback()

PROTOBUF_EXPORT std::pair< const char *, int32_t > google::protobuf::internal::ReadSizeFallback ( const char *  p,
uint32  res 
)

◆ ReadTag()

const char * google::protobuf::internal::ReadTag ( const char *  p,
uint32 out,
uint32  max_tag = 0 
)
inline

◆ ReadTagFallback()

PROTOBUF_EXPORT std::pair< const char *, uint32_t > google::protobuf::internal::ReadTagFallback ( const char *  p,
uint32  res 
)

◆ ReadUINT32()

const char * google::protobuf::internal::ReadUINT32 ( const char *  ptr,
uint32 value 
)
inline

◆ ReadUINT64()

const char * google::protobuf::internal::ReadUINT64 ( const char *  ptr,
uint64 value 
)
inline

◆ ReadUnaligned()

template<typename F >
const char * google::protobuf::internal::ReadUnaligned ( const char *  ptr,
F *  value 
)
inline

◆ ReadVarint()

uint64 google::protobuf::internal::ReadVarint ( const char **  p)
inline

◆ ReadVarint32()

uint32_t google::protobuf::internal::ReadVarint32 ( const char **  p)
inline

◆ ReadVarint64()

uint64_t google::protobuf::internal::ReadVarint64 ( const char **  p)
inline

◆ ReadVarintZigZag32()

int32_t google::protobuf::internal::ReadVarintZigZag32 ( const char **  p)
inline

◆ ReadVarintZigZag64()

int64_t google::protobuf::internal::ReadVarintZigZag64 ( const char **  p)
inline

◆ real_type()

FieldDescriptor::Type google::protobuf::internal::real_type ( FieldType  type)
inline

◆ RegisterFileLevelMetadata()

void google::protobuf::internal::RegisterFileLevelMetadata ( const DescriptorTable table)

◆ ResetOneofField()

template<ProcessingType field_type>
void google::protobuf::internal::ResetOneofField ( const ParseTable table,
int  field_number,
Arena arena,
MessageLite msg,
uint32 oneof_case,
int64  offset,
const void *  default_ptr 
)
inline

◆ RunZeroArgFunc() [1/2]

static void google::protobuf::internal::RunZeroArgFunc ( const void *  arg)
static

◆ RunZeroArgFunc() [2/2]

static void google::protobuf::internal::RunZeroArgFunc ( const void *  arg)
static

◆ SecondsToDateTime()

bool PROTOBUF_EXPORT google::protobuf::internal::SecondsToDateTime ( int64  seconds,
DateTime time 
)

◆ SerializeGroupTo()

template<typename O >
void google::protobuf::internal::SerializeGroupTo ( const MessageLite msg,
const void *  table_ptr,
O *  output 
)

◆ SerializeInternal()

void google::protobuf::internal::SerializeInternal ( const uint8 base,
const FieldMetadata table,
int32  num_fields,
io::CodedOutputStream output 
)

◆ SerializeInternalToArray()

uint8_t * google::protobuf::internal::SerializeInternalToArray ( const uint8 base,
const FieldMetadata table,
int32  num_fields,
bool  is_deterministic,
uint8 buffer 
)

◆ SerializeMapKeyWithCachedSizes()

uint8_t * google::protobuf::internal::SerializeMapKeyWithCachedSizes ( const FieldDescriptor field,
const MapKey value,
uint8 target,
io::EpsCopyOutputStream stream 
)
static

◆ SerializeMapValueRefWithCachedSizes() [1/2]

static uint8_t* google::protobuf::internal::SerializeMapValueRefWithCachedSizes ( const FieldDescriptor field,
const MapValueConstRef value,
uint8_t target,
io::EpsCopyOutputStream stream 
)
static

◆ SerializeMapValueRefWithCachedSizes() [2/2]

static uint8* google::protobuf::internal::SerializeMapValueRefWithCachedSizes ( const FieldDescriptor field,
const MapValueRef value,
uint8 target,
io::EpsCopyOutputStream stream 
)
static

◆ SerializeMessageDispatch() [1/2]

void google::protobuf::internal::SerializeMessageDispatch ( const MessageLite msg,
const FieldMetadata field_table,
int  num_fields,
int32  cached_size,
ArrayOutput output 
)

◆ SerializeMessageDispatch() [2/2]

void google::protobuf::internal::SerializeMessageDispatch ( const MessageLite msg,
const FieldMetadata field_table,
int  num_fields,
int32  cached_size,
io::CodedOutputStream output 
)

◆ SerializeMessageNoTable() [1/2]

void google::protobuf::internal::SerializeMessageNoTable ( const MessageLite msg,
ArrayOutput output 
)

◆ SerializeMessageNoTable() [2/2]

void google::protobuf::internal::SerializeMessageNoTable ( const MessageLite msg,
io::CodedOutputStream output 
)

◆ SerializeMessageTo()

template<typename O >
void google::protobuf::internal::SerializeMessageTo ( const MessageLite msg,
const void *  table_ptr,
O *  output 
)

◆ SerializeNotImplemented()

void google::protobuf::internal::SerializeNotImplemented ( int  field)

◆ SerializeTo()

template<int type, typename O >
void google::protobuf::internal::SerializeTo ( const void *  ptr,
O *  output 
)

◆ SetBit()

void google::protobuf::internal::SetBit ( uint32 has_bits,
uint32  has_bit_index 
)
inline

◆ SetField()

template<typename Type >
void google::protobuf::internal::SetField ( MessageLite msg,
uint32 has_bits,
uint32  has_bit_index,
int64  offset,
Type  value 
)
inline

◆ SetMapKey()

template<typename T >
void google::protobuf::internal::SetMapKey ( MapKey map_key,
const T value 
)
inline

◆ SetMapKey< bool >()

template<>
void google::protobuf::internal::SetMapKey< bool > ( MapKey map_key,
const bool value 
)
inline

◆ SetMapKey< int32 >()

template<>
void google::protobuf::internal::SetMapKey< int32 > ( MapKey map_key,
const int32 value 
)
inline

◆ SetMapKey< int32_t >()

template<>
void google::protobuf::internal::SetMapKey< int32_t > ( MapKey map_key,
const int32_t value 
)
inline

Definition at line 80 of file protobuf/src/google/protobuf/map_field_inl.h.

◆ SetMapKey< int64 >()

template<>
void google::protobuf::internal::SetMapKey< int64 > ( MapKey map_key,
const int64 value 
)
inline

◆ SetMapKey< int64_t >()

template<>
void google::protobuf::internal::SetMapKey< int64_t > ( MapKey map_key,
const int64_t value 
)
inline

Definition at line 88 of file protobuf/src/google/protobuf/map_field_inl.h.

◆ SetMapKey< std::string >()

template<>
void google::protobuf::internal::SetMapKey< std::string > ( MapKey map_key,
const std::string &  value 
)
inline

◆ SetMapKey< uint32 >()

template<>
void google::protobuf::internal::SetMapKey< uint32 > ( MapKey map_key,
const uint32 value 
)
inline

◆ SetMapKey< uint32_t >()

template<>
void google::protobuf::internal::SetMapKey< uint32_t > ( MapKey map_key,
const uint32_t value 
)
inline

Definition at line 84 of file protobuf/src/google/protobuf/map_field_inl.h.

◆ SetMapKey< uint64 >()

template<>
void google::protobuf::internal::SetMapKey< uint64 > ( MapKey map_key,
const uint64 value 
)
inline

◆ SetMapKey< uint64_t >()

template<>
void google::protobuf::internal::SetMapKey< uint64_t > ( MapKey map_key,
const uint64_t value 
)
inline

Definition at line 92 of file protobuf/src/google/protobuf/map_field_inl.h.

◆ SetOneofField()

template<typename Type >
void google::protobuf::internal::SetOneofField ( MessageLite msg,
uint32 oneof_case,
uint32  oneof_case_index,
int64  offset,
int  field_number,
Type  value 
)
inline

◆ SetStrWithHeapBuffer()

void google::protobuf::internal::SetStrWithHeapBuffer ( std::string *  str,
ArenaStringPtr s 
)
inline

Definition at line 259 of file arenastring.cc.

◆ SpaceUsedInTable()

template<typename Key >
PROTOBUF_NOINLINE size_t google::protobuf::internal::SpaceUsedInTable ( void **  table,
size_t  num_buckets,
size_t  num_elements,
size_t  sizeof_node 
)

◆ SpaceUsedInValues() [1/2]

template<typename Map , typename = typename std::enable_if< !std::is_scalar<typename Map::key_type>::value || !std::is_scalar<typename Map::mapped_type>::value>::type>
size_t google::protobuf::internal::SpaceUsedInValues ( const Map map)

◆ SpaceUsedInValues() [2/2]

size_t google::protobuf::internal::SpaceUsedInValues ( const void *  )
inline

◆ StressTestIterators()

static void google::protobuf::internal::StressTestIterators ( int  n)
static

◆ StrFunc()

static std::string google::protobuf::internal::StrFunc ( int  i,
int  j 
)
static

◆ StrictUtf8Check() [1/2]

static bool google::protobuf::internal::StrictUtf8Check ( const FieldDescriptor field)
static

Definition at line 413 of file protobuf/src/google/protobuf/wire_format.cc.

◆ StrictUtf8Check() [2/2]

static bool google::protobuf::internal::StrictUtf8Check ( const FieldDescriptor field)
static

◆ StringParser()

const char * google::protobuf::internal::StringParser ( const char *  begin,
const char *  end,
void *  object,
ParseContext  
)

◆ StringSpaceUsedExcludingSelfLong()

PROTOBUF_EXPORT size_t google::protobuf::internal::StringSpaceUsedExcludingSelfLong ( const std::string &  str)

◆ StrongReference()

template<typename T >
void google::protobuf::internal::StrongReference ( const T var)

◆ SubMessagePrefix() [1/2]

static std::string google::protobuf::internal::SubMessagePrefix ( const std::string &  prefix,
const FieldDescriptor field,
int  index 
)
static

◆ SubMessagePrefix() [2/2]

static std::string google::protobuf::internal::SubMessagePrefix ( const std::string &  prefix,
const FieldDescriptor field,
int  index 
)
static

◆ SwapBlock()

template<typename T >
void google::protobuf::internal::SwapBlock ( char *  p,
char *  q 
)
inline

◆ SwapRepeatedPtrToNull()

void google::protobuf::internal::SwapRepeatedPtrToNull ( RepeatedPtrField< Message > **  from,
RepeatedPtrField< Message > **  to,
Arena from_arena,
Arena to_arena 
)

Definition at line 67 of file protobuf/src/google/protobuf/map_field.cc.

◆ TableEntryIsEmpty()

bool google::protobuf::internal::TableEntryIsEmpty ( void *const table,
size_t  b 
)
inline

◆ TableEntryIsList()

bool google::protobuf::internal::TableEntryIsList ( void *const table,
size_t  b 
)
inline

◆ TableEntryIsNonEmptyList()

bool google::protobuf::internal::TableEntryIsNonEmptyList ( void *const table,
size_t  b 
)
inline

◆ TableEntryIsTree()

bool google::protobuf::internal::TableEntryIsTree ( void *const table,
size_t  b 
)
inline

◆ TableSerialize()

void google::protobuf::internal::TableSerialize ( const MessageLite msg,
const SerializationTable table,
io::CodedOutputStream output 
)
inline

◆ TableSerializeToArray()

uint8_t * google::protobuf::internal::TableSerializeToArray ( const MessageLite msg,
const SerializationTable table,
bool  is_deterministic,
uint8 buffer 
)
inline

◆ TEST() [1/78]

google::protobuf::internal::TEST ( ArenaTest  ,
IsInitialized   
)

◆ TEST() [2/78]

google::protobuf::internal::TEST ( ArenaTest  ,
ParsingAndSerializingNoHeapAllocation   
)

◆ TEST() [3/78]

google::protobuf::internal::TEST ( ArenaTest  ,
ReflectionInTextFormat   
)

◆ TEST() [4/78]

google::protobuf::internal::TEST ( ArenaTest  ,
StringMapNoLeak   
)

◆ TEST() [5/78]

google::protobuf::internal::TEST ( GeneratedMapFieldReflectionTest  ,
Accessors   
)

◆ TEST() [6/78]

google::protobuf::internal::TEST ( GeneratedMapFieldReflectionTest  ,
ClearField   
)

◆ TEST() [7/78]

google::protobuf::internal::TEST ( GeneratedMapFieldReflectionTest  ,
EmbedProto2Message   
)

◆ TEST() [8/78]

google::protobuf::internal::TEST ( GeneratedMapFieldReflectionTest  ,
MapEntryClear   
)

◆ TEST() [9/78]

google::protobuf::internal::TEST ( GeneratedMapFieldReflectionTest  ,
MergeFromClearMapEntry   
)

◆ TEST() [10/78]

google::protobuf::internal::TEST ( GeneratedMapFieldReflectionTest  ,
MutableUnknownFields   
)

◆ TEST() [11/78]

google::protobuf::internal::TEST ( GeneratedMapFieldReflectionTest  ,
Proto2MapEntryClear   
)

◆ TEST() [12/78]

google::protobuf::internal::TEST ( GeneratedMapFieldReflectionTest  ,
ReleaseLast   
)

◆ TEST() [13/78]

google::protobuf::internal::TEST ( GeneratedMapFieldReflectionTest  ,
RemoveLast   
)

◆ TEST() [14/78]

google::protobuf::internal::TEST ( GeneratedMapFieldReflectionTest  ,
SetViaMapReflection   
)

◆ TEST() [15/78]

google::protobuf::internal::TEST ( GeneratedMapFieldReflectionTest  ,
SpaceUsed   
)

◆ TEST() [16/78]

google::protobuf::internal::TEST ( GeneratedMapFieldReflectionTest  ,
Swap   
)

◆ TEST() [17/78]

google::protobuf::internal::TEST ( GeneratedMapFieldReflectionTest  ,
SwapElements   
)

◆ TEST() [18/78]

google::protobuf::internal::TEST ( GeneratedMapFieldReflectionTest  ,
SwapFields   
)

◆ TEST() [19/78]

google::protobuf::internal::TEST ( GeneratedMapFieldReflectionTest  ,
SwapWithBothSet   
)

◆ TEST() [20/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
Accessors   
)

◆ TEST() [21/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
Clear   
)

◆ TEST() [22/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
ClearMessageMap   
)

◆ TEST() [23/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
CopyAssignmentOperator   
)

◆ TEST() [24/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
CopyConstructor   
)

◆ TEST() [25/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
CopyFrom   
)

◆ TEST() [26/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
CopyFromDynamicMessage   
)

◆ TEST() [27/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
CopyFromDynamicMessageMapReflection   
)

◆ TEST() [28/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
CopyFromMessageMap   
)

◆ TEST() [29/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
CorruptedWireFormat   
)

◆ TEST() [30/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
DuplicatedKeyWireFormat   
)

◆ TEST() [31/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
DuplicatedValueWireFormat   
)

◆ TEST() [32/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
DynamicMessageCopyFrom   
)

◆ TEST() [33/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
DynamicMessageCopyFromMapReflection   
)

◆ TEST() [34/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
DynamicMessageMergeFromDynamicMessage   
)

◆ TEST() [35/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
IsInitialized   
)

◆ TEST() [36/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
KeysValuesUnknownsWireFormat   
)

◆ TEST() [37/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
MergeFromMessageMap   
)

◆ TEST() [38/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
MessagesMustMerge   
)

◆ TEST() [39/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
MissedKeyWireFormat   
)

◆ TEST() [40/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
MissedValueTextFormat   
)

◆ TEST() [41/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
MissedValueWireFormat   
)

◆ TEST() [42/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
NonEmptyMergeFrom   
)

◆ TEST() [43/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
Proto2SetMapFieldsInitialized   
)

◆ TEST() [44/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
Proto2UnknownEnum   
)

◆ TEST() [45/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
SameTypeMaps   
)

◆ TEST() [46/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
SerializationToArray   
)

◆ TEST() [47/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
SerializationToStream   
)

◆ TEST() [48/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
SetMapFieldsInitialized   
)

◆ TEST() [49/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
StandardWireFormat   
)

◆ TEST() [50/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
SwapWithEmpty   
)

◆ TEST() [51/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
SwapWithOther   
)

◆ TEST() [52/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
SwapWithSelf   
)

◆ TEST() [53/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
SyncDynamicMapWithRepeatedField   
)

◆ TEST() [54/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
UnknownFieldWireFormat   
)

◆ TEST() [55/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
UnorderedWireFormat   
)

◆ TEST() [56/78]

google::protobuf::internal::TEST ( GeneratedMapFieldTest  ,
UpcastCopyFrom   
)

◆ TEST() [57/78]

google::protobuf::internal::TEST ( MapFieldTest  ,
ConstInit   
)

◆ TEST() [58/78]

google::protobuf::internal::TEST ( MapSerializationTest  ,
Deterministic   
)

◆ TEST() [59/78]

google::protobuf::internal::TEST ( MapSerializationTest  ,
DeterministicSubmessage   
)

◆ TEST() [60/78]

google::protobuf::internal::TEST ( MoveTest  ,
MoveAssignmentWorks   
)

◆ TEST() [61/78]

google::protobuf::internal::TEST ( MoveTest  ,
MoveConstructorWorks   
)

◆ TEST() [62/78]

google::protobuf::internal::TEST ( ReflectionOpsForMapFieldTest  ,
ClearMap   
)

◆ TEST() [63/78]

google::protobuf::internal::TEST ( ReflectionOpsForMapFieldTest  ,
IsInitialized   
)

◆ TEST() [64/78]

google::protobuf::internal::TEST ( ReflectionOpsForMapFieldTest  ,
MapCopy   
)

◆ TEST() [65/78]

google::protobuf::internal::TEST ( ReflectionOpsForMapFieldTest  ,
MapDiscardUnknownFields   
)

◆ TEST() [66/78]

google::protobuf::internal::TEST ( ReflectionOpsForMapFieldTest  ,
MapSanityCheck   
)

◆ TEST() [67/78]

google::protobuf::internal::TEST ( ReflectionOpsForMapFieldTest  ,
MergeMap   
)

◆ TEST() [68/78]

google::protobuf::internal::TEST ( TextFormatMapTest  ,
DynamicMessage   
)

◆ TEST() [69/78]

google::protobuf::internal::TEST ( TextFormatMapTest  ,
NoDisableIterator   
)

◆ TEST() [70/78]

google::protobuf::internal::TEST ( TextFormatMapTest  ,
NoDisableReflectionIterator   
)

◆ TEST() [71/78]

google::protobuf::internal::TEST ( TextFormatMapTest  ,
ParseCorruptedString   
)

◆ TEST() [72/78]

google::protobuf::internal::TEST ( TextFormatMapTest  ,
SerializeAndParse   
)

◆ TEST() [73/78]

google::protobuf::internal::TEST ( TextFormatMapTest  ,
Sorted   
)

◆ TEST() [74/78]

google::protobuf::internal::TEST ( WireFormatForMapFieldTest  ,
MapByteSize   
)

◆ TEST() [75/78]

google::protobuf::internal::TEST ( WireFormatForMapFieldTest  ,
MapParseHelpers   
)

◆ TEST() [76/78]

google::protobuf::internal::TEST ( WireFormatForMapFieldTest  ,
ParseMap   
)

◆ TEST() [77/78]

google::protobuf::internal::TEST ( WireFormatForMapFieldTest  ,
SerializeMap   
)

◆ TEST() [78/78]

google::protobuf::internal::TEST ( WireFormatForMapFieldTest  ,
SerializeMapDynamicMessage   
)

◆ TEST_F() [1/54]

google::protobuf::internal::TEST_F ( MapFieldBasePrimitiveTest  ,
Arena   
)

◆ TEST_F() [2/54]

google::protobuf::internal::TEST_F ( MapFieldBasePrimitiveTest  ,
GetRepeatedField   
)

◆ TEST_F() [3/54]

google::protobuf::internal::TEST_F ( MapFieldBasePrimitiveTest  ,
MutableRepeatedField   
)

◆ TEST_F() [4/54]

google::protobuf::internal::TEST_F ( MapFieldBasePrimitiveTest  ,
SpaceUsedExcludingSelf   
)

◆ TEST_F() [5/54]

google::protobuf::internal::TEST_F ( MapFieldInDynamicMessageTest  ,
DynamicMapReflection   
)

◆ TEST_F() [6/54]

google::protobuf::internal::TEST_F ( MapFieldInDynamicMessageTest  ,
MapEntryReferernceValidAfterSerialize   
)

◆ TEST_F() [7/54]

google::protobuf::internal::TEST_F ( MapFieldInDynamicMessageTest  ,
MapIndependentOffsets   
)

◆ TEST_F() [8/54]

google::protobuf::internal::TEST_F ( MapFieldInDynamicMessageTest  ,
MapSpaceUsed   
)

◆ TEST_F() [9/54]

google::protobuf::internal::TEST_F ( MapFieldInDynamicMessageTest  ,
MapValueReferernceValidAfterSerialize   
)

◆ TEST_F() [10/54]

google::protobuf::internal::TEST_F ( MapFieldInDynamicMessageTest  ,
RecursiveMap   
)

◆ TEST_F() [11/54]

google::protobuf::internal::TEST_F ( MapFieldReflectionTest  ,
MapSizeWithDuplicatedKey   
)

◆ TEST_F() [12/54]

google::protobuf::internal::TEST_F ( MapFieldReflectionTest  ,
RegularFields   
)

◆ TEST_F() [13/54]

google::protobuf::internal::TEST_F ( MapFieldReflectionTest  ,
RepeatedFieldRefForRegularFields   
)

◆ TEST_F() [14/54]

google::protobuf::internal::TEST_F ( MapFieldReflectionTest  ,
RepeatedFieldRefMergeFromAndSwap   
)

◆ TEST_F() [15/54]

google::protobuf::internal::TEST_F ( MapFieldReflectionTest  ,
UninitializedEntry   
)

◆ TEST_F() [16/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
Assigner   
)

◆ TEST_F() [17/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
BeginIsFast   
)

◆ TEST_F() [18/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
Clear   
)

◆ TEST_F() [19/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
ConstEnd   
)

◆ TEST_F() [20/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
ContainNotExist   
)

◆ TEST_F() [21/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
ConvertToStdMap   
)

◆ TEST_F() [22/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
ConvertToStdVectorOfPairs   
)

◆ TEST_F() [23/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
CopyAssignMapIterator   
)

◆ TEST_F() [24/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
CopyConstructorWithArena   
)

◆ TEST_F() [25/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
CopyConstructorWithoutArena   
)

◆ TEST_F() [26/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
CopyIteratorStressTest   
)

◆ TEST_F() [27/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
CountNonExist   
)

◆ TEST_F() [28/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
EqualRange   
)

◆ TEST_F() [29/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
EraseByIterator   
)

◆ TEST_F() [30/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
EraseMutipleByKey   
)

◆ TEST_F() [31/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
EraseRevalidates   
)

◆ TEST_F() [32/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
EraseSingleByIterator   
)

◆ TEST_F() [33/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
EraseSingleByKey   
)

◆ TEST_F() [34/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
GetReferenceFromIterator   
)

◆ TEST_F() [35/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
HashFlood   
)

◆ TEST_F() [36/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
ImmutableContainNotExist   
)

◆ TEST_F() [37/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
ImmutableFindNonExist   
)

◆ TEST_F() [38/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
InsertByInitializerList   
)

◆ TEST_F() [39/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
InsertByIterator   
)

◆ TEST_F() [40/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
InsertSingle   
)

◆ TEST_F() [41/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
IteratorBasic   
)

◆ TEST_F() [42/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
IteratorCategory   
)

◆ TEST_F() [43/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
IteratorConstness   
)

◆ TEST_F() [44/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
IteratorInvalidation   
)

◆ TEST_F() [45/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
IterConstructor   
)

◆ TEST_F() [46/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
MapKeyAssignment   
)

◆ TEST_F() [47/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
MutableAt   
)

◆ TEST_F() [48/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
MutableFindNonExist   
)

◆ TEST_F() [49/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
OperatorBracket   
)

◆ TEST_F() [50/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
OperatorBracketNonExist   
)

◆ TEST_F() [51/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
Rehash   
)

◆ TEST_F() [52/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
SwapArena   
)

◆ TEST_F() [53/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
SwapBasic   
)

◆ TEST_F() [54/54]

google::protobuf::internal::TEST_F ( MapImplTest  ,
ValidIteratorAfterErase   
)

◆ TEST_P() [1/17]

google::protobuf::internal::TEST_P ( MapFieldBasePrimitiveTest  ,
Arena   
)

◆ TEST_P() [2/17]

google::protobuf::internal::TEST_P ( MapFieldBasePrimitiveTest  ,
EnforceNoArena   
)

◆ TEST_P() [3/17]

google::protobuf::internal::TEST_P ( MapFieldBasePrimitiveTest  ,
GetRepeatedField   
)

◆ TEST_P() [4/17]

google::protobuf::internal::TEST_P ( MapFieldBasePrimitiveTest  ,
MutableRepeatedField   
)

◆ TEST_P() [5/17]

google::protobuf::internal::TEST_P ( MapFieldBasePrimitiveTest  ,
SpaceUsedExcludingSelf   
)

◆ TEST_P() [6/17]

google::protobuf::internal::TEST_P ( MapFieldStateTest  ,
Clear   
)

◆ TEST_P() [7/17]

google::protobuf::internal::TEST_P ( MapFieldStateTest  ,
GetMap   
)

◆ TEST_P() [8/17]

google::protobuf::internal::TEST_P ( MapFieldStateTest  ,
GetMapField   
)

◆ TEST_P() [9/17]

google::protobuf::internal::TEST_P ( MapFieldStateTest  ,
MergeFromClean   
)

◆ TEST_P() [10/17]

google::protobuf::internal::TEST_P ( MapFieldStateTest  ,
MergeFromMapDirty   
)

◆ TEST_P() [11/17]

google::protobuf::internal::TEST_P ( MapFieldStateTest  ,
MergeFromRepeatedDirty   
)

◆ TEST_P() [12/17]

google::protobuf::internal::TEST_P ( MapFieldStateTest  ,
MutableMap   
)

◆ TEST_P() [13/17]

google::protobuf::internal::TEST_P ( MapFieldStateTest  ,
MutableMapField   
)

◆ TEST_P() [14/17]

google::protobuf::internal::TEST_P ( MapFieldStateTest  ,
SpaceUsedExcludingSelf   
)

◆ TEST_P() [15/17]

google::protobuf::internal::TEST_P ( MapFieldStateTest  ,
SwapClean   
)

◆ TEST_P() [16/17]

google::protobuf::internal::TEST_P ( MapFieldStateTest  ,
SwapMapDirty   
)

◆ TEST_P() [17/17]

google::protobuf::internal::TEST_P ( MapFieldStateTest  ,
SwapRepeatedDirty   
)

◆ TestDeterministicSerialization()

static void google::protobuf::internal::TestDeterministicSerialization ( const protobuf_unittest::TestMaps &  t,
const std::string &  filename 
)
static

◆ TestEqualIterators()

template<typename Iter >
static void google::protobuf::internal::TestEqualIterators ( Iter  i0,
Iter  i1,
Iter  end 
)
static

◆ TestOldVersusNewIterator()

template<typename IteratorType >
static void google::protobuf::internal::TestOldVersusNewIterator ( int  skip,
Map< int, int > *  m 
)
static

◆ TestValidityForAllKeysExcept()

template<typename T , typename U >
static void google::protobuf::internal::TestValidityForAllKeysExcept ( int  key_to_avoid,
const T check_map,
const U &  map 
)
static

◆ ToCachedSize()

int google::protobuf::internal::ToCachedSize ( size_t  size)
inline

◆ ToIntSize()

int google::protobuf::internal::ToIntSize ( size_t  size)
inline

◆ UnalignedLoad()

template<typename T >
T google::protobuf::internal::UnalignedLoad ( const char *  p)

◆ UnknownFieldParse() [1/4]

const PROTOBUF_EXPORT char * google::protobuf::internal::UnknownFieldParse ( uint32  tag,
InternalMetadataWithArena metadata,
const char *  ptr,
ParseContext ctx 
)

◆ UnknownFieldParse() [2/4]

PROTOBUF_EXPORT const PROTOBUF_MUST_USE_RESULT char * google::protobuf::internal::UnknownFieldParse ( uint32  tag,
InternalMetadataWithArenaLite metadata,
const char *  ptr,
ParseContext ctx 
)

◆ UnknownFieldParse() [3/4]

PROTOBUF_EXPORT const PROTOBUF_NODISCARD char * google::protobuf::internal::UnknownFieldParse ( uint32  tag,
std::string *  unknown,
const char *  ptr,
ParseContext ctx 
)

◆ UnknownFieldParse() [4/4]

const PROTOBUF_EXPORT char * google::protobuf::internal::UnknownFieldParse ( uint64  tag,
UnknownFieldSet unknown,
const char *  ptr,
ParseContext ctx 
)

◆ UnknownFieldSerializerLite()

PROTOBUF_EXPORT void google::protobuf::internal::UnknownFieldSerializerLite ( const uint8 ptr,
uint32  offset,
uint32  tag,
uint32  has_offset,
io::CodedOutputStream output 
)

◆ UnknownFieldSetSerializer()

PROTOBUF_EXPORT void google::protobuf::internal::UnknownFieldSetSerializer ( const uint8 base,
uint32  offset,
uint32  tag,
uint32  has_offset,
io::CodedOutputStream output 
)

◆ UnknownGroupLiteParse()

PROTOBUF_EXPORT const PROTOBUF_NODISCARD char * google::protobuf::internal::UnknownGroupLiteParse ( std::string *  unknown,
const char *  ptr,
ParseContext ctx 
)

◆ UnknownGroupParse()

const PROTOBUF_EXPORT char * google::protobuf::internal::UnknownGroupParse ( UnknownFieldSet unknown,
const char *  ptr,
ParseContext ctx 
)

◆ UnwrapMapKey()

template<typename T >
T google::protobuf::internal::UnwrapMapKey ( const MapKey map_key)

◆ UnwrapMapKey< bool >()

template<>
bool google::protobuf::internal::UnwrapMapKey< bool > ( const MapKey map_key)
inline

◆ UnwrapMapKey< int32 >()

template<>
int32 google::protobuf::internal::UnwrapMapKey< int32 > ( const MapKey map_key)
inline

◆ UnwrapMapKey< int32_t >()

Definition at line 52 of file protobuf/src/google/protobuf/map_field_inl.h.

◆ UnwrapMapKey< int64 >()

template<>
int64 google::protobuf::internal::UnwrapMapKey< int64 > ( const MapKey map_key)
inline

◆ UnwrapMapKey< int64_t >()

Definition at line 60 of file protobuf/src/google/protobuf/map_field_inl.h.

◆ UnwrapMapKey< std::string >()

template<>
std::string google::protobuf::internal::UnwrapMapKey< std::string > ( const MapKey map_key)
inline

◆ UnwrapMapKey< uint32 >()

template<>
uint32 google::protobuf::internal::UnwrapMapKey< uint32 > ( const MapKey map_key)
inline

◆ UnwrapMapKey< uint32_t >()

Definition at line 56 of file protobuf/src/google/protobuf/map_field_inl.h.

◆ UnwrapMapKey< uint64 >()

template<>
uint64 google::protobuf::internal::UnwrapMapKey< uint64 > ( const MapKey map_key)
inline

◆ UnwrapMapKey< uint64_t >()

Definition at line 64 of file protobuf/src/google/protobuf/map_field_inl.h.

◆ UTF8CoerceToStructurallyValid() [1/2]

char * google::protobuf::internal::UTF8CoerceToStructurallyValid ( const StringPiece str,
char *  dst,
char  replace_char 
)

◆ UTF8CoerceToStructurallyValid() [2/2]

char * google::protobuf::internal::UTF8CoerceToStructurallyValid ( StringPiece  str,
char *  dst,
char  replace_char 
)

◆ UTF8GenericScan()

int google::protobuf::internal::UTF8GenericScan ( const UTF8ScanObj st,
const char *  str,
int  str_length,
int bytes_consumed 
)

◆ UTF8GenericScanFastAscii()

int google::protobuf::internal::UTF8GenericScanFastAscii ( const UTF8ScanObj st,
const char *  str,
int  str_length,
int bytes_consumed 
)

◆ UTF8SpnStructurallyValid() [1/2]

int google::protobuf::internal::UTF8SpnStructurallyValid ( const StringPiece str)

◆ UTF8SpnStructurallyValid() [2/2]

int google::protobuf::internal::UTF8SpnStructurallyValid ( StringPiece  str)

◆ ValidateEnumUsingDescriptor() [1/2]

static bool google::protobuf::internal::ValidateEnumUsingDescriptor ( const void *  arg,
int  number 
)
static

◆ ValidateEnumUsingDescriptor() [2/2]

static bool google::protobuf::internal::ValidateEnumUsingDescriptor ( const void *  arg,
int  number 
)
static

◆ VarintParse() [1/2]

template<typename T >
const PROTOBUF_MUST_USE_RESULT char* google::protobuf::internal::VarintParse ( const char *  p,
T out 
)

◆ VarintParse() [2/2]

template<typename T >
const PROTOBUF_NODISCARD char* google::protobuf::internal::VarintParse ( const char *  p,
T out 
)

◆ VarintParser()

template<typename T , bool sign>
const char * google::protobuf::internal::VarintParser ( void *  object,
const char *  ptr,
ParseContext ctx 
)

◆ VarintParseSlow() [1/2]

const char * google::protobuf::internal::VarintParseSlow ( const char *  p,
uint32  res,
uint32 out 
)
inline

◆ VarintParseSlow() [2/2]

const char * google::protobuf::internal::VarintParseSlow ( const char *  p,
uint32  res,
uint64 out 
)
inline

◆ VarintParseSlow32()

PROTOBUF_EXPORT std::pair< const char *, uint32_t > google::protobuf::internal::VarintParseSlow32 ( const char *  p,
uint32  res 
)

◆ VarintParseSlow64()

PROTOBUF_EXPORT std::pair< const char *, uint64_t > google::protobuf::internal::VarintParseSlow64 ( const char *  p,
uint32  res32 
)

◆ VarintSize() [1/2]

template<bool ZigZag, bool SignExtended, typename T >
static size_t google::protobuf::internal::VarintSize ( const T data,
const int  n 
)
static

◆ VarintSize() [2/2]

template<bool ZigZag, bool SignExtended, typename T >
static size_t google::protobuf::internal::VarintSize ( const T data,
const int  n 
)
static

◆ VarintSize64() [1/2]

template<bool ZigZag, typename T >
static size_t google::protobuf::internal::VarintSize64 ( const T data,
const int  n 
)
static

◆ VarintSize64() [2/2]

template<bool ZigZag, typename T >
static size_t google::protobuf::internal::VarintSize64 ( const T data,
const int  n 
)
static

◆ VerifyUTF8() [1/2]

bool google::protobuf::internal::VerifyUTF8 ( const std::string *  s,
const char *  field_name 
)
inline

◆ VerifyUTF8() [2/2]

PROTOBUF_EXPORT bool google::protobuf::internal::VerifyUTF8 ( StringPiece  str,
const char *  field_name 
)

◆ VerifyVersion()

void PROTOBUF_EXPORT google::protobuf::internal::VerifyVersion ( int  headerVersion,
int  minLibraryVersion,
const char *  filename 
)

◆ VersionString()

std::string PROTOBUF_EXPORT google::protobuf::internal::VersionString ( int  version)

◆ WireFormatLite::ReadPrimitive< bool, WireFormatLite::TYPE_BOOL >()

◆ WireFormatLite::ReadPrimitive< double, WireFormatLite::TYPE_DOUBLE >()

◆ WireFormatLite::ReadPrimitive< float, WireFormatLite::TYPE_FLOAT >()

◆ WireFormatLite::ReadPrimitive< int, WireFormatLite::TYPE_ENUM >()

◆ WireFormatLite::ReadPrimitive< int32, WireFormatLite::TYPE_INT32 >()

◆ WireFormatLite::ReadPrimitive< int32, WireFormatLite::TYPE_SFIXED32 >()

◆ WireFormatLite::ReadPrimitive< int32, WireFormatLite::TYPE_SINT32 >()

◆ WireFormatLite::ReadPrimitive< int32_t, WireFormatLite::TYPE_INT32 >()

◆ WireFormatLite::ReadPrimitive< int32_t, WireFormatLite::TYPE_SFIXED32 >()

◆ WireFormatLite::ReadPrimitive< int32_t, WireFormatLite::TYPE_SINT32 >()

◆ WireFormatLite::ReadPrimitive< int64, WireFormatLite::TYPE_INT64 >()

◆ WireFormatLite::ReadPrimitive< int64, WireFormatLite::TYPE_SFIXED64 >()

◆ WireFormatLite::ReadPrimitive< int64, WireFormatLite::TYPE_SINT64 >()

◆ WireFormatLite::ReadPrimitive< int64_t, WireFormatLite::TYPE_INT64 >()

◆ WireFormatLite::ReadPrimitive< int64_t, WireFormatLite::TYPE_SFIXED64 >()

◆ WireFormatLite::ReadPrimitive< int64_t, WireFormatLite::TYPE_SINT64 >()

◆ WireFormatLite::ReadPrimitive< uint32, WireFormatLite::TYPE_FIXED32 >()

◆ WireFormatLite::ReadPrimitive< uint32, WireFormatLite::TYPE_UINT32 >()

◆ WireFormatLite::ReadPrimitive< uint32_t, WireFormatLite::TYPE_FIXED32 >()

◆ WireFormatLite::ReadPrimitive< uint32_t, WireFormatLite::TYPE_UINT32 >()

◆ WireFormatLite::ReadPrimitive< uint64, WireFormatLite::TYPE_FIXED64 >()

◆ WireFormatLite::ReadPrimitive< uint64, WireFormatLite::TYPE_UINT64 >()

◆ WireFormatLite::ReadPrimitive< uint64_t, WireFormatLite::TYPE_FIXED64 >()

◆ WireFormatLite::ReadPrimitive< uint64_t, WireFormatLite::TYPE_UINT64 >()

◆ WireFormatLite::ReadPrimitiveFromArray< double, WireFormatLite::TYPE_DOUBLE >()

◆ WireFormatLite::ReadPrimitiveFromArray< float, WireFormatLite::TYPE_FLOAT >()

◆ WireFormatLite::ReadPrimitiveFromArray< int32, WireFormatLite::TYPE_SFIXED32 >()

◆ WireFormatLite::ReadPrimitiveFromArray< int32_t, WireFormatLite::TYPE_SFIXED32 >()

◆ WireFormatLite::ReadPrimitiveFromArray< int64, WireFormatLite::TYPE_SFIXED64 >()

◆ WireFormatLite::ReadPrimitiveFromArray< int64_t, WireFormatLite::TYPE_SFIXED64 >()

◆ WireFormatLite::ReadPrimitiveFromArray< uint32, WireFormatLite::TYPE_FIXED32 >()

◆ WireFormatLite::ReadPrimitiveFromArray< uint32_t, WireFormatLite::TYPE_FIXED32 >()

◆ WireFormatLite::ReadPrimitiveFromArray< uint64, WireFormatLite::TYPE_FIXED64 >()

◆ WireFormatLite::ReadPrimitiveFromArray< uint64_t, WireFormatLite::TYPE_FIXED64 >()

◆ WireFormatParser() [1/2]

template<typename T >
const PROTOBUF_MUST_USE_RESULT char* google::protobuf::internal::WireFormatParser ( T field_parser,
const char *  ptr,
ParseContext ctx 
)

◆ WireFormatParser() [2/2]

template<typename T >
const PROTOBUF_NODISCARD char* google::protobuf::internal::WireFormatParser ( T field_parser,
const char *  ptr,
ParseContext ctx 
)

◆ WriteArray() [1/2]

template<typename CType >
static void google::protobuf::internal::WriteArray ( const CType *  a,
int  n,
io::CodedOutputStream output 
)
static

◆ WriteArray() [2/2]

template<typename CType >
static void google::protobuf::internal::WriteArray ( const CType *  a,
int  n,
io::CodedOutputStream output 
)
static

◆ WriteLengthDelimited() [1/2]

PROTOBUF_EXPORT void google::protobuf::internal::WriteLengthDelimited ( uint32  num,
StringPiece  val,
std::string *  s 
)

◆ WriteLengthDelimited() [2/2]

void google::protobuf::internal::WriteLengthDelimited ( uint32  num,
StringPiece  val,
UnknownFieldSet s 
)
inline

◆ WriteLengthTo()

template<typename O >
void google::protobuf::internal::WriteLengthTo ( uint32  length,
O *  output 
)

◆ WriteTagTo()

template<typename O >
void google::protobuf::internal::WriteTagTo ( uint32  tag,
O *  output 
)

◆ WriteVarint() [1/3]

PROTOBUF_EXPORT void google::protobuf::internal::WriteVarint ( uint32  num,
uint64  val,
std::string *  s 
)

◆ WriteVarint() [2/3]

void google::protobuf::internal::WriteVarint ( uint32  num,
uint64  val,
UnknownFieldSet s 
)
inline

◆ WriteVarint() [3/3]

void google::protobuf::internal::WriteVarint ( uint64  val,
std::string *  s 
)
inline

Variable Documentation

◆ enable_debug_text_format_marker

PROTOBUF_EXPORT std::atomic< bool > google::protobuf::internal::enable_debug_text_format_marker

Definition at line 90 of file protobuf/src/google/protobuf/text_format.cc.

◆ fixed_address_empty_string

PROTOBUF_EXPORT ExplicitlyConstructed< std::string > google::protobuf::internal::fixed_address_empty_string {}

◆ implicit_weak_message_default_instance

ExplicitlyConstructed< ImplicitWeakMessage > google::protobuf::internal::implicit_weak_message_default_instance

◆ implicit_weak_message_once_init_

internal::once_flag google::protobuf::internal::implicit_weak_message_once_init_

◆ init_empty_string

PROTOBUF_ATTRIBUTE_INIT_PRIORITY std::true_type google::protobuf::internal.init_empty_string
static

◆ init_protobuf_defaults_state

PROTOBUF_EXPORT std::atomic< bool > google::protobuf::internal::init_protobuf_defaults_state {false}

◆ k0

int google::protobuf::internal.k0 = 812398771
static

◆ k1

int google::protobuf::internal.k1 = 1312938717
static

◆ k2

int google::protobuf::internal.k2 = 1321555333
static

◆ kAnyFullTypeName

const char google::protobuf::internal::kAnyFullTypeName = "google.protobuf.Any"

◆ kGlobalEmptyTable

PROTOBUF_EXPORT void *const google::protobuf::internal::kGlobalEmptyTable = {nullptr}

Definition at line 37 of file map.cc.

◆ kGlobalEmptyTableSize

constexpr size_t google::protobuf::internal.kGlobalEmptyTableSize = 1
constexpr

◆ kInt32MaxSize

constexpr size_t google::protobuf::internal.kInt32MaxSize = std::numeric_limits<int32_t>::max()
constexpr

◆ kInvalidMask [1/2]

constexpr const unsigned char google::protobuf::internal.kInvalidMask = 0x20
staticconstexpr

◆ kInvalidMask [2/2]

constexpr const unsigned char google::protobuf::internal.kInvalidMask = 0x20
staticconstexpr

◆ kMinHeaderVersionForLibrary [1/2]

const int google::protobuf::internal.kMinHeaderVersionForLibrary = 3009000
static

◆ kMinHeaderVersionForLibrary [2/2]

const int google::protobuf::internal.kMinHeaderVersionForLibrary = 3019000
static

Definition at line 93 of file protobuf/src/google/protobuf/stubs/common.h.

◆ kMinHeaderVersionForProtoc [1/2]

const int google::protobuf::internal.kMinHeaderVersionForProtoc = 3009000
static

◆ kMinHeaderVersionForProtoc [2/2]

const int google::protobuf::internal.kMinHeaderVersionForProtoc = 3019000
static

Definition at line 101 of file protobuf/src/google/protobuf/stubs/common.h.

◆ kMinRepeatedFieldAllocationSize

const int google::protobuf::internal.kMinRepeatedFieldAllocationSize = 4
static

◆ kNotPackedMask [1/2]

constexpr const unsigned char google::protobuf::internal.kNotPackedMask = 0x10
staticconstexpr

◆ kNotPackedMask [2/2]

constexpr const unsigned char google::protobuf::internal.kNotPackedMask = 0x10
staticconstexpr

◆ kOneofMask [1/2]

constexpr const unsigned char google::protobuf::internal.kOneofMask = 0x40
staticconstexpr

◆ kOneofMask [2/2]

constexpr const unsigned char google::protobuf::internal.kOneofMask = 0x40
staticconstexpr

◆ kRepeatedFieldLowerClampLimit

constexpr int google::protobuf::internal.kRepeatedFieldLowerClampLimit = 4
constexpr

◆ kRepeatedFieldUpperClampLimit

constexpr int google::protobuf::internal.kRepeatedFieldUpperClampLimit
constexpr
Initial value:

Definition at line 92 of file protobuf/src/google/protobuf/repeated_field.h.

◆ kRepeatedMask [1/2]

constexpr const unsigned char google::protobuf::internal.kRepeatedMask = 0x20
staticconstexpr

◆ kRepeatedMask [2/2]

constexpr const unsigned char google::protobuf::internal.kRepeatedMask = 0x20
staticconstexpr

◆ kTypeGoogleApisComPrefix

const char google::protobuf::internal::kTypeGoogleApisComPrefix = "type.googleapis.com/"

◆ kTypeGoogleProdComPrefix

const char google::protobuf::internal::kTypeGoogleProdComPrefix = "type.googleprod.com/"

◆ kTypeMask [1/2]

constexpr const unsigned char google::protobuf::internal.kTypeMask = 0x1f
staticconstexpr

◆ kTypeMask [2/2]

constexpr const unsigned char google::protobuf::internal.kTypeMask = 0x1f
staticconstexpr

◆ log_handler_ [1/2]

LogHandler* google::protobuf::internal.log_handler_ = &DefaultLogHandler
static

◆ log_handler_ [2/2]

LogHandler* google::protobuf::internal.log_handler_ = &DefaultLogHandler
static

◆ log_silencer_count_ [1/2]

std::atomic<int> google::protobuf::internal.log_silencer_count_ = ATOMIC_VAR_INIT(0)
static

◆ log_silencer_count_ [2/2]

std::atomic<int> google::protobuf::internal.log_silencer_count_ = ATOMIC_VAR_INIT(0)
static

◆ TailCallParseFunc

const typedef char*(* google::protobuf::internal.TailCallParseFunc) (PROTOBUF_TC_PARAM_DECL)

Definition at line 71 of file generated_message_tctable_decl.h.

◆ utf8acceptnonsurrogates [1/2]

const uint8 google::protobuf::internal.utf8acceptnonsurrogates[]
static

◆ utf8acceptnonsurrogates [2/2]

const uint8 google::protobuf::internal.utf8acceptnonsurrogates[]
static

◆ utf8acceptnonsurrogates_BYTES [1/2]

const unsigned int google::protobuf::internal.utf8acceptnonsurrogates_BYTES = 1
static

◆ utf8acceptnonsurrogates_BYTES [2/2]

const unsigned int google::protobuf::internal.utf8acceptnonsurrogates_BYTES = 1
static

◆ utf8acceptnonsurrogates_fast [1/2]

const unsigned char google::protobuf::internal.utf8acceptnonsurrogates_fast[256]
static
Initial value:
= {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
}

Definition at line 324 of file bloaty/third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc.

◆ utf8acceptnonsurrogates_fast [2/2]

const unsigned char google::protobuf::internal.utf8acceptnonsurrogates_fast[256]
static
Initial value:
= {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
}

Definition at line 324 of file protobuf/src/google/protobuf/stubs/structurally_valid.cc.

◆ utf8acceptnonsurrogates_HIADD [1/2]

const unsigned int google::protobuf::internal.utf8acceptnonsurrogates_HIADD = 0x00000000
static

◆ utf8acceptnonsurrogates_HIADD [2/2]

const unsigned int google::protobuf::internal.utf8acceptnonsurrogates_HIADD = 0x00000000
static

◆ utf8acceptnonsurrogates_LOSUB [1/2]

const unsigned int google::protobuf::internal.utf8acceptnonsurrogates_LOSUB = 0x20202020
static

◆ utf8acceptnonsurrogates_LOSUB [2/2]

const unsigned int google::protobuf::internal.utf8acceptnonsurrogates_LOSUB = 0x20202020
static

◆ utf8acceptnonsurrogates_MAX_EXPAND_X4 [1/2]

const unsigned int google::protobuf::internal.utf8acceptnonsurrogates_MAX_EXPAND_X4 = 0
static

◆ utf8acceptnonsurrogates_MAX_EXPAND_X4 [2/2]

const unsigned int google::protobuf::internal.utf8acceptnonsurrogates_MAX_EXPAND_X4 = 0
static

◆ utf8acceptnonsurrogates_obj [1/2]

const UTF8ScanObj google::protobuf::internal.utf8acceptnonsurrogates_obj
static

◆ utf8acceptnonsurrogates_obj [2/2]

const UTF8ScanObj google::protobuf::internal.utf8acceptnonsurrogates_obj
static

◆ utf8acceptnonsurrogates_remap_base [1/2]

const RemapEntry google::protobuf::internal.utf8acceptnonsurrogates_remap_base[]
static
Initial value:
= {
{0, 0, 0} }

Definition at line 317 of file bloaty/third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc.

◆ utf8acceptnonsurrogates_remap_base [2/2]

const RemapEntry google::protobuf::internal.utf8acceptnonsurrogates_remap_base[]
static
Initial value:
= {
{0, 0, 0} }

Definition at line 317 of file protobuf/src/google/protobuf/stubs/structurally_valid.cc.

◆ utf8acceptnonsurrogates_remap_string [1/2]

const unsigned char google::protobuf::internal.utf8acceptnonsurrogates_remap_string[]
static
Initial value:
= {
0 }

Definition at line 321 of file protobuf/src/google/protobuf/stubs/structurally_valid.cc.

◆ utf8acceptnonsurrogates_remap_string [2/2]

const unsigned char google::protobuf::internal.utf8acceptnonsurrogates_remap_string[]
static
Initial value:
= {
0 }

Definition at line 321 of file bloaty/third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc.

◆ utf8acceptnonsurrogates_SHIFT [1/2]

const unsigned int google::protobuf::internal.utf8acceptnonsurrogates_SHIFT = 8
static

◆ utf8acceptnonsurrogates_SHIFT [2/2]

const unsigned int google::protobuf::internal.utf8acceptnonsurrogates_SHIFT = 8
static

◆ utf8acceptnonsurrogates_STATE0 [1/2]

const unsigned int google::protobuf::internal.utf8acceptnonsurrogates_STATE0 = 0
static

◆ utf8acceptnonsurrogates_STATE0 [2/2]

const unsigned int google::protobuf::internal.utf8acceptnonsurrogates_STATE0 = 0
static

◆ utf8acceptnonsurrogates_STATE0_SIZE [1/2]

const unsigned int google::protobuf::internal.utf8acceptnonsurrogates_STATE0_SIZE = 256
static

◆ utf8acceptnonsurrogates_STATE0_SIZE [2/2]

const unsigned int google::protobuf::internal.utf8acceptnonsurrogates_STATE0_SIZE = 256
static

◆ utf8acceptnonsurrogates_TOTAL_SIZE [1/2]

const unsigned int google::protobuf::internal.utf8acceptnonsurrogates_TOTAL_SIZE = 2304
static

◆ utf8acceptnonsurrogates_TOTAL_SIZE [2/2]

const unsigned int google::protobuf::internal.utf8acceptnonsurrogates_TOTAL_SIZE = 2304
static
google::protobuf.internal::utf8acceptnonsurrogates_SHIFT
static const unsigned int utf8acceptnonsurrogates_SHIFT
Definition: bloaty/third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc:120
google::protobuf.internal::utf8acceptnonsurrogates_BYTES
static const unsigned int utf8acceptnonsurrogates_BYTES
Definition: bloaty/third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc:121
google::protobuf.internal::utf8acceptnonsurrogates_remap_base
static const RemapEntry utf8acceptnonsurrogates_remap_base[]
Definition: bloaty/third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc:317
google::protobuf.internal::true_type
integral_constant< bool, true > true_type
Definition: bloaty/third_party/protobuf/src/google/protobuf/stubs/template_util.h:89
google::protobuf.internal::utf8acceptnonsurrogates_fast
static const unsigned char utf8acceptnonsurrogates_fast[256]
Definition: bloaty/third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc:324
google::protobuf.internal::utf8acceptnonsurrogates_TOTAL_SIZE
static const unsigned int utf8acceptnonsurrogates_TOTAL_SIZE
Definition: bloaty/third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc:118
max
int max
Definition: bloaty/third_party/zlib/examples/enough.c:170
google::protobuf.internal::InitProtobufDefaultsSlow
void InitProtobufDefaultsSlow()
Definition: protobuf/src/google/protobuf/generated_message_util.cc:83
google::protobuf.internal::utf8acceptnonsurrogates_MAX_EXPAND_X4
static const unsigned int utf8acceptnonsurrogates_MAX_EXPAND_X4
Definition: bloaty/third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc:119
google::protobuf.internal::utf8acceptnonsurrogates
static const uint8 utf8acceptnonsurrogates[]
Definition: bloaty/third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc:125
google::protobuf.internal::utf8acceptnonsurrogates_STATE0
static const unsigned int utf8acceptnonsurrogates_STATE0
Definition: bloaty/third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc:116
google::protobuf.internal::utf8acceptnonsurrogates_LOSUB
static const unsigned int utf8acceptnonsurrogates_LOSUB
Definition: bloaty/third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc:122
google::protobuf.internal::utf8acceptnonsurrogates_HIADD
static const unsigned int utf8acceptnonsurrogates_HIADD
Definition: bloaty/third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc:123
google::protobuf.internal::utf8acceptnonsurrogates_STATE0_SIZE
static const unsigned int utf8acceptnonsurrogates_STATE0_SIZE
Definition: bloaty/third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc:117
google::protobuf.internal::utf8acceptnonsurrogates_remap_string
static const unsigned char utf8acceptnonsurrogates_remap_string[]
Definition: bloaty/third_party/protobuf/src/google/protobuf/stubs/structurally_valid.cc:321


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