google::protobuf Namespace Reference

Namespaces
	compiler
	internal
	io
	strings

Classes
class	Closure
class	Descriptor
class	DescriptorDatabase
class	DescriptorPool
class	DescriptorPoolDatabase
class	DescriptorProto
class	DescriptorProto_ExtensionRange
class	DynamicMessageFactory
class	EncodedDescriptorDatabase
class	EnumDescriptor
class	EnumDescriptorProto
class	EnumOptions
class	EnumValueDescriptor
class	EnumValueDescriptorProto
class	EnumValueOptions
class	FieldDescriptor
class	FieldDescriptorProto
class	FieldOptions
class	FileDescriptor
class	FileDescriptorProto
class	FileDescriptorSet
class	FileOptions
class	GoogleOnceDynamic
struct	hash
struct	hash< const char * >
struct	hash< pair< First, Second > >
struct	hash< string >
class	hash_map
class	hash_set
struct	is_proto_enum
struct	is_proto_enum< ::Battlenet::JSON::Login::AuthenticationState >
struct	is_proto_enum< ::Battlenet::JSON::Login::FormType >
struct	is_proto_enum< ::bgs::protocol::account::v1::IdentityVerificationStatus >
struct	is_proto_enum< ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy >
struct	is_proto_enum< ::bgs::protocol::AttributeFilter_Operation >
struct	is_proto_enum< ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel >
struct	is_proto_enum< ::bgs::protocol::LogOption >
struct	is_proto_enum< ::bgs::protocol::presence::v1::FieldOperation_OperationType >
struct	is_proto_enum< ::google::protobuf::FieldDescriptorProto_Label >
struct	is_proto_enum< ::google::protobuf::FieldDescriptorProto_Type >
struct	is_proto_enum< ::google::protobuf::FieldOptions_CType >
struct	is_proto_enum< ::google::protobuf::FileOptions_OptimizeMode >
class	LogSilencer
class	MergedDescriptorDatabase
class	Message
class	MessageFactory
class	MessageLite
class	MessageOptions
struct	Metadata
class	MethodDescriptor
class	MethodDescriptorProto
class	MethodOptions
class	OneofDescriptor
class	OneofDescriptorProto
class	Reflection
singleton	RepeatedField
class	RepeatedPtrField
class	RpcChannel
class	RpcController
class	ScopedMemoryLog
class	Service
class	ServiceDescriptor
class	ServiceDescriptorProto
class	ServiceOptions
class	SimpleDescriptorDatabase
class	SourceCodeInfo
class	SourceCodeInfo_Location
struct	SourceLocation
struct	streq
class	TextFormat
class	UninterpretedOption
class	UninterpretedOption_NamePart
class	UnknownField
class	UnknownFieldSet

Typedefs
typedef unsigned int	uint
typedef int8_t	int8
typedef int16_t	int16
typedef int32_t	int32
typedef int64_t	int64
typedef uint8_t	uint8
typedef uint16_t	uint16
typedef uint32_t	uint32
typedef uint64_t	uint64
typedef void	LogHandler (LogLevel level, const char *filename, int line, const std::string &message)
typedef internal::AtomicWord	ProtobufOnceType

Enumerations
enum	FieldDescriptorProto_Type {   FieldDescriptorProto_Type_TYPE_DOUBLE = 1, FieldDescriptorProto_Type_TYPE_FLOAT = 2, FieldDescriptorProto_Type_TYPE_INT64 = 3, FieldDescriptorProto_Type_TYPE_UINT64 = 4,   FieldDescriptorProto_Type_TYPE_INT32 = 5, FieldDescriptorProto_Type_TYPE_FIXED64 = 6, FieldDescriptorProto_Type_TYPE_FIXED32 = 7, FieldDescriptorProto_Type_TYPE_BOOL = 8,   FieldDescriptorProto_Type_TYPE_STRING = 9, FieldDescriptorProto_Type_TYPE_GROUP = 10, FieldDescriptorProto_Type_TYPE_MESSAGE = 11, FieldDescriptorProto_Type_TYPE_BYTES = 12,   FieldDescriptorProto_Type_TYPE_UINT32 = 13, FieldDescriptorProto_Type_TYPE_ENUM = 14, FieldDescriptorProto_Type_TYPE_SFIXED32 = 15, FieldDescriptorProto_Type_TYPE_SFIXED64 = 16,   FieldDescriptorProto_Type_TYPE_SINT32 = 17, FieldDescriptorProto_Type_TYPE_SINT64 = 18 }
enum	FieldDescriptorProto_Label { FieldDescriptorProto_Label_LABEL_OPTIONAL = 1, FieldDescriptorProto_Label_LABEL_REQUIRED = 2, FieldDescriptorProto_Label_LABEL_REPEATED = 3 }
enum	FileOptions_OptimizeMode { FileOptions_OptimizeMode_SPEED = 1, FileOptions_OptimizeMode_CODE_SIZE = 2, FileOptions_OptimizeMode_LITE_RUNTIME = 3 }
enum	FieldOptions_CType { FieldOptions_CType_STRING = 0, FieldOptions_CType_CORD = 1, FieldOptions_CType_STRING_PIECE = 2 }
enum	LogLevel {   LOGLEVEL_INFO, LOGLEVEL_WARNING, LOGLEVEL_ERROR, LOGLEVEL_FATAL,   LOGLEVEL_DFATAL = LOGLEVEL_FATAL }
enum	{ ONCE_STATE_UNINITIALIZED = 0, ONCE_STATE_EXECUTING_CLOSURE = 1, ONCE_STATE_DONE = 2 }

Functions
bool	ascii_isalnum (char c)
bool	ascii_isdigit (char c)
bool	HasPrefixString (const string &str, const string &prefix)
string	StripPrefixString (const string &str, const string &prefix)
bool	HasSuffixString (const string &str, const string &suffix)
string	StripSuffixString (const string &str, const string &suffix)
LIBPROTOBUF_EXPORT void	StripString (string *s, const char *remove, char replacewith)
void	LowerString (string *s)
void	UpperString (string *s)
string	ToUpper (const string &s)
LIBPROTOBUF_EXPORT string	StringReplace (const string &s, const string &oldsub, const string &newsub, bool replace_all)
LIBPROTOBUF_EXPORT void	SplitStringUsing (const string &full, const char *delim, vector< string > *res)
LIBPROTOBUF_EXPORT void	SplitStringAllowEmpty (const string &full, const char *delim, vector< string > *result)
vector< string >	Split (const string &full, const char *delim, bool skip_empty=true)
LIBPROTOBUF_EXPORT void	JoinStrings (const vector< string > &components, const char *delim, string *result)
string	JoinStrings (const vector< string > &components, const char *delim)
LIBPROTOBUF_EXPORT int	UnescapeCEscapeSequences (const char *source, char *dest)
LIBPROTOBUF_EXPORT int	UnescapeCEscapeSequences (const char *source, char *dest, vector< string > *errors)
LIBPROTOBUF_EXPORT int	UnescapeCEscapeString (const string &src, string *dest)
LIBPROTOBUF_EXPORT int	UnescapeCEscapeString (const string &src, string *dest, vector< string > *errors)
LIBPROTOBUF_EXPORT string	UnescapeCEscapeString (const string &src)
LIBPROTOBUF_EXPORT int	CEscapeString (const char *src, int src_len, char *dest, int dest_len)
LIBPROTOBUF_EXPORT string	CEscape (const string &src)
LIBPROTOBUF_EXPORT int32	strto32_adaptor (const char *nptr, char **endptr, int base)
LIBPROTOBUF_EXPORT uint32	strtou32_adaptor (const char *nptr, char **endptr, int base)
int32	strto32 (const char *nptr, char **endptr, int base)
uint32	strtou32 (const char *nptr, char **endptr, int base)
int64	strto64 (const char *nptr, char **endptr, int base)
uint64	strtou64 (const char *nptr, char **endptr, int base)
LIBPROTOBUF_EXPORT bool	safe_int (string text, int32 *value_p)
bool	safe_strto32 (string text, int32 *value)
LIBPROTOBUF_EXPORT char *	FastInt32ToBuffer (int32 i, char *buffer)
LIBPROTOBUF_EXPORT char *	FastInt64ToBuffer (int64 i, char *buffer)
char *	FastUInt32ToBuffer (uint32 i, char *buffer)
char *	FastUInt64ToBuffer (uint64 i, char *buffer)
LIBPROTOBUF_EXPORT char *	FastHexToBuffer (int i, char *buffer)
LIBPROTOBUF_EXPORT char *	FastHex64ToBuffer (uint64 i, char *buffer)
LIBPROTOBUF_EXPORT char *	FastHex32ToBuffer (uint32 i, char *buffer)
char *	FastIntToBuffer (int i, char *buffer)
char *	FastUIntToBuffer (unsigned int i, char *buffer)
char *	FastLongToBuffer (long i, char *buffer)
char *	FastULongToBuffer (unsigned long i, char *buffer)
LIBPROTOBUF_EXPORT char *	FastInt32ToBufferLeft (int32 i, char *buffer)
LIBPROTOBUF_EXPORT char *	FastUInt32ToBufferLeft (uint32 i, char *buffer)
LIBPROTOBUF_EXPORT char *	FastInt64ToBufferLeft (int64 i, char *buffer)
LIBPROTOBUF_EXPORT char *	FastUInt64ToBufferLeft (uint64 i, char *buffer)
LIBPROTOBUF_EXPORT string	SimpleItoa (int i)
LIBPROTOBUF_EXPORT string	SimpleItoa (unsigned int i)
LIBPROTOBUF_EXPORT string	SimpleItoa (long i)
LIBPROTOBUF_EXPORT string	SimpleItoa (unsigned long i)
LIBPROTOBUF_EXPORT string	SimpleItoa (long long i)
LIBPROTOBUF_EXPORT string	SimpleItoa (unsigned long long i)
LIBPROTOBUF_EXPORT string	SimpleDtoa (double value)
LIBPROTOBUF_EXPORT string	SimpleFtoa (float value)
LIBPROTOBUF_EXPORT char *	DoubleToBuffer (double i, char *buffer)
LIBPROTOBUF_EXPORT char *	FloatToBuffer (float i, char *buffer)
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
string	StrCat (const T1 &a, const T2 &b, const T3 &c, const T4 &d, const T5 &e)
template<typename T1 , typename T2 , typename T3 , typename T4 >
string	StrCat (const T1 &a, const T2 &b, const T3 &c, const T4 &d)
template<typename T1 , typename T2 , typename T3 >
string	StrCat (const T1 &a, const T2 &b, const T3 &c)
template<typename T1 , typename T2 >
string	StrCat (const T1 &a, const T2 &b)
template<typename Iterator >
void	Join (Iterator start, Iterator end, const char *delim, string *result)
template<typename Range >
string	Join (const Range &components, const char *delim)
LIBPROTOBUF_EXPORT string	ToHex (uint64 num)
	PROTOBUF_DEFINE_ARRAY_ACCESSOR (Descriptor, extension_range, const Descriptor::ExtensionRange *) PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor
const FieldDescriptor *	PROTOBUF_DEFINE_OPTIONS_ACCESSOR (Descriptor, MessageOptions)
	PROTOBUF_DEFINE_ACCESSOR (FieldDescriptor, containing_oneof, const OneofDescriptor *) PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor
const FieldDescriptor *	PROTOBUF_DEFINE_ACCESSOR (FieldDescriptor, default_value_enum, const EnumValueDescriptor *) PROTOBUF_DEFINE_ARRAY_ACCESSOR(EnumDescriptor
const FieldDescriptor const EnumValueDescriptor *	PROTOBUF_DEFINE_OPTIONS_ACCESSOR (EnumDescriptor, EnumOptions)
	PROTOBUF_DEFINE_ARRAY_ACCESSOR (ServiceDescriptor, method, const MethodDescriptor *) PROTOBUF_DEFINE_OPTIONS_ACCESSOR(ServiceDescriptor
	PROTOBUF_DEFINE_OPTIONS_ACCESSOR (MethodDescriptor, MethodOptions)
	PROTOBUF_DEFINE_OPTIONS_ACCESSOR (FileDescriptor, FileOptions)
	PROTOBUF_DEFINE_ARRAY_ACCESSOR (FileDescriptor, service, const ServiceDescriptor *) PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor
void LIBPROTOBUF_EXPORT	protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto ()
void	protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto ()
void	protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto ()
LIBPROTOBUF_EXPORT bool	FieldDescriptorProto_Type_IsValid (int value)
LIBPROTOBUF_EXPORTconst::google::protobuf::EnumDescriptor *	FieldDescriptorProto_Type_descriptor ()
const ::std::string &	FieldDescriptorProto_Type_Name (FieldDescriptorProto_Type value)
bool	FieldDescriptorProto_Type_Parse (const ::std::string &name, FieldDescriptorProto_Type *value)
LIBPROTOBUF_EXPORT bool	FieldDescriptorProto_Label_IsValid (int value)
LIBPROTOBUF_EXPORTconst::google::protobuf::EnumDescriptor *	FieldDescriptorProto_Label_descriptor ()
const ::std::string &	FieldDescriptorProto_Label_Name (FieldDescriptorProto_Label value)
bool	FieldDescriptorProto_Label_Parse (const ::std::string &name, FieldDescriptorProto_Label *value)
LIBPROTOBUF_EXPORT bool	FileOptions_OptimizeMode_IsValid (int value)
LIBPROTOBUF_EXPORTconst::google::protobuf::EnumDescriptor *	FileOptions_OptimizeMode_descriptor ()
const ::std::string &	FileOptions_OptimizeMode_Name (FileOptions_OptimizeMode value)
bool	FileOptions_OptimizeMode_Parse (const ::std::string &name, FileOptions_OptimizeMode *value)
LIBPROTOBUF_EXPORT bool	FieldOptions_CType_IsValid (int value)
LIBPROTOBUF_EXPORTconst::google::protobuf::EnumDescriptor *	FieldOptions_CType_descriptor ()
const ::std::string &	FieldOptions_CType_Name (FieldOptions_CType value)
bool	FieldOptions_CType_Parse (const ::std::string &name, FieldOptions_CType *value)
template<>
const EnumDescriptor *	GetEnumDescriptor< ::google::protobuf::FieldDescriptorProto_Type > ()
template<>
const EnumDescriptor *	GetEnumDescriptor< ::google::protobuf::FieldDescriptorProto_Label > ()
template<>
const EnumDescriptor *	GetEnumDescriptor< ::google::protobuf::FileOptions_OptimizeMode > ()
template<>
const EnumDescriptor *	GetEnumDescriptor< ::google::protobuf::FieldOptions_CType > ()
template<typename E >
const EnumDescriptor *	GetEnumDescriptor ()
template<typename T >
internal::RepeatedFieldBackInsertIterator < T >	RepeatedFieldBackInserter (RepeatedField< T > *const mutable_field)
template<typename T >
internal::RepeatedPtrFieldBackInsertIterator < T >	RepeatedPtrFieldBackInserter (RepeatedPtrField< T > *const mutable_field)
template<typename T >
internal::RepeatedPtrFieldBackInsertIterator < T >	RepeatedFieldBackInserter (RepeatedPtrField< T > *const mutable_field)
template<typename T >
internal::AllocatedRepeatedPtrFieldBackInsertIterator < T >	AllocatedRepeatedPtrFieldBackInserter (RepeatedPtrField< T > *const mutable_field)
LIBPROTOBUF_EXPORT LogHandler *	SetLogHandler (LogHandler *new_func)
Closure *	NewCallback (void(*function)())
Closure *	NewPermanentCallback (void(*function)())
template<typename Class >
Closure *	NewCallback (Class *object, void(Class::*method)())
template<typename Class >
Closure *	NewPermanentCallback (Class *object, void(Class::*method)())
template<typename Arg1 >
Closure *	NewCallback (void(*function)(Arg1), Arg1 arg1)
template<typename Arg1 >
Closure *	NewPermanentCallback (void(*function)(Arg1), Arg1 arg1)
template<typename Class , typename Arg1 >
Closure *	NewCallback (Class *object, void(Class::*method)(Arg1), Arg1 arg1)
template<typename Class , typename Arg1 >
Closure *	NewPermanentCallback (Class *object, void(Class::*method)(Arg1), Arg1 arg1)
template<typename Arg1 , typename Arg2 >
Closure *	NewCallback (void(*function)(Arg1, Arg2), Arg1 arg1, Arg2 arg2)
template<typename Arg1 , typename Arg2 >
Closure *	NewPermanentCallback (void(*function)(Arg1, Arg2), Arg1 arg1, Arg2 arg2)
template<typename Class , typename Arg1 , typename Arg2 >
Closure *	NewCallback (Class *object, void(Class::*method)(Arg1, Arg2), Arg1 arg1, Arg2 arg2)
template<typename Class , typename Arg1 , typename Arg2 >
Closure *	NewPermanentCallback (Class *object, void(Class::*method)(Arg1, Arg2), Arg1 arg1, Arg2 arg2)
void LIBPROTOBUF_EXPORT	DoNothing ()
LIBPROTOBUF_EXPORT uint32	ghtonl (uint32 x)
LIBPROTOBUF_EXPORT void	ShutdownProtobufLibrary ()
template<class Collection >
const Collection::value_type::second_type &	FindOrDie (const Collection &collection, const typename Collection::value_type::first_type &key)
template<class Collection >
Collection::value_type::second_type &	FindOrDie (Collection &collection, const typename Collection::value_type::first_type &key)
template<class Collection >
const Collection::value_type::second_type &	FindOrDieNoPrint (const Collection &collection, const typename Collection::value_type::first_type &key)
template<class Collection >
Collection::value_type::second_type &	FindOrDieNoPrint (Collection &collection, const typename Collection::value_type::first_type &key)
template<class Collection >
const Collection::value_type::second_type &	FindWithDefault (const Collection &collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &value)
template<class Collection >
const Collection::value_type::second_type *	FindOrNull (const Collection &collection, const typename Collection::value_type::first_type &key)
template<class Collection >
Collection::value_type::second_type *	FindOrNull (Collection &collection, const typename Collection::value_type::first_type &key)
template<class Collection >
Collection::value_type::second_type	FindPtrOrNull (const Collection &collection, const typename Collection::value_type::first_type &key)
template<class Collection >
Collection::value_type::second_type	FindPtrOrNull (Collection &collection, const typename Collection::value_type::first_type &key)
template<class Collection >
Collection::value_type::second_type::element_type *	FindLinkedPtrOrNull (const Collection &collection, const typename Collection::value_type::first_type &key)
template<class Collection >
Collection::value_type::second_type::element_type &	FindLinkedPtrOrDie (const Collection &collection, const typename Collection::value_type::first_type &key)
template<class Collection , class Key , class Value >
bool	FindCopy (const Collection &collection, const Key &key, Value *const value)
template<class Collection , class Key >
bool	ContainsKey (const Collection &collection, const Key &key)
template<class Collection , class Key , class Value >
bool	ContainsKeyValuePair (const Collection &collection, const Key &key, const Value &value)
template<class Collection >
bool	InsertOrUpdate (Collection *const collection, const typename Collection::value_type &vt)
template<class Collection >
bool	InsertOrUpdate (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &value)
template<class Collection , class InputIterator >
void	InsertOrUpdateMany (Collection *const collection, InputIterator first, InputIterator last)
template<class Collection >
bool	InsertAndDeleteExisting (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &value)
template<class Collection >
bool	InsertIfNotPresent (Collection *const collection, const typename Collection::value_type &vt)
template<class Collection >
bool	InsertIfNotPresent (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &value)
template<class Collection >
void	InsertOrDie (Collection *const collection, const typename Collection::value_type &value)
template<class Collection >
void	InsertOrDieNoPrint (Collection *const collection, const typename Collection::value_type &value)
template<class Collection >
void	InsertOrDie (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &data)
template<class Collection >
void	InsertOrDieNoPrint (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &data)
template<class Collection >
Collection::value_type::second_type &	InsertKeyOrDie (Collection *const collection, const typename Collection::value_type::first_type &key)
template<class Collection >
Collection::value_type::second_type &	LookupOrInsert (Collection *const collection, const typename Collection::value_type &vt)
template<class Collection >
Collection::value_type::second_type &	LookupOrInsert (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &value)
template<typename Sequence , typename Collection >
void	AddTokenCounts (const Sequence &sequence, const typename Collection::value_type::second_type &increment, Collection *const count_map)
template<class Collection >
Collection::value_type::second_type &	LookupOrInsertNew (Collection *const collection, const typename Collection::value_type::first_type &key)
template<class Collection , class Arg >
Collection::value_type::second_type &	LookupOrInsertNew (Collection *const collection, const typename Collection::value_type::first_type &key, const Arg &arg)
template<class Collection >
Collection::value_type::second_type::element_type *	LookupOrInsertNewLinkedPtr (Collection *const collection, const typename Collection::value_type::first_type &key)
template<class Collection , class Arg >
Collection::value_type::second_type::element_type *	LookupOrInsertNewLinkedPtr (Collection *const collection, const typename Collection::value_type::first_type &key, const Arg &arg)
template<class Collection >
Collection::value_type::second_type &	LookupOrInsertNewSharedPtr (Collection *const collection, const typename Collection::value_type::first_type &key)
template<class Collection , class Arg >
Collection::value_type::second_type &	LookupOrInsertNewSharedPtr (Collection *const collection, const typename Collection::value_type::first_type &key, const Arg &arg)
template<class Collection >
bool	UpdateReturnCopy (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &value, typename Collection::value_type::second_type *previous)
template<class Collection >
bool	UpdateReturnCopy (Collection *const collection, const typename Collection::value_type &vt, typename Collection::value_type::second_type *previous)
template<class Collection >
Collection::value_type::second_type *const	InsertOrReturnExisting (Collection *const collection, const typename Collection::value_type &vt)
template<class Collection >
Collection::value_type::second_type *const	InsertOrReturnExisting (Collection *const collection, const typename Collection::value_type::first_type &key, const typename Collection::value_type::second_type &data)
template<class Collection >
Collection::value_type::second_type	EraseKeyReturnValuePtr (Collection *const collection, const typename Collection::value_type::first_type &key)
template<class MapContainer , class KeyContainer >
void	InsertKeysFromMap (const MapContainer &map_container, KeyContainer *key_container)
template<class MapContainer , class KeyContainer >
void	AppendKeysFromMap (const MapContainer &map_container, KeyContainer *key_container)
template<class MapContainer , class KeyType >
void	AppendKeysFromMap (const MapContainer &map_container, vector< KeyType > *key_container)
template<class MapContainer , class ValueContainer >
void	AppendValuesFromMap (const MapContainer &map_container, ValueContainer *value_container)
template<class MapContainer , class ValueType >
void	AppendValuesFromMap (const MapContainer &map_container, vector< ValueType > *value_container)
LIBPROTOBUF_EXPORT void	GoogleOnceInitImpl (ProtobufOnceType *once, Closure *closure)
void	GoogleOnceInit (ProtobufOnceType *once, void(*init_func)())
template<typename Arg >
void	GoogleOnceInit (ProtobufOnceType *once, void(*init_func)(Arg *), Arg *arg)
template<class ForwardIterator >
void	STLDeleteContainerPointers (ForwardIterator begin, ForwardIterator end)
void	STLStringResizeUninitialized (string *s, size_t new_size)
char *	string_as_array (string *str)
template<class T >
void	STLDeleteElements (T *container)
template<class T >
void	STLDeleteValues (T *v)
LIBPROTOBUF_EXPORT string	StringPrintf (const char *format,...)
LIBPROTOBUF_EXPORT const string &	SStringPrintf (string *dst, const char *format,...)
LIBPROTOBUF_EXPORT void	StringAppendF (string *dst, const char *format,...)
LIBPROTOBUF_EXPORT void	StringAppendV (string *dst, const char *format, va_list ap)
LIBPROTOBUF_EXPORT string	StringPrintfVector (const char *format, const vector< string > &v)
string	TestSourceDir ()
string	TestTempDir ()
void	CaptureTestStdout ()
void	CaptureTestStderr ()
string	GetCapturedTestStdout ()
string	GetCapturedTestStderr ()
template<>
const EnumDescriptor *	GetEnumDescriptor< ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy > ()
template<>
const EnumDescriptor *	GetEnumDescriptor< ::bgs::protocol::account::v1::IdentityVerificationStatus > ()
template<>
const EnumDescriptor *	GetEnumDescriptor< ::bgs::protocol::AttributeFilter_Operation > ()
template<>
const EnumDescriptor *	GetEnumDescriptor< ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel > ()
template<>
const EnumDescriptor *	GetEnumDescriptor< ::bgs::protocol::LogOption > ()
template<>
const EnumDescriptor *	GetEnumDescriptor< ::bgs::protocol::presence::v1::FieldOperation_OperationType > ()
template<>
const EnumDescriptor *	GetEnumDescriptor< ::Battlenet::JSON::Login::FormType > ()
template<>
const EnumDescriptor *	GetEnumDescriptor< ::Battlenet::JSON::Login::AuthenticationState > ()

Variables
static const int	kFastToBufferSize = 32
static const int	kDoubleToBufferSize = 32
static const int	kFloatToBufferSize = 24
	extension
	experimental_map_key
const FieldDescriptor	value
	ServiceOptions
const FieldDescriptorProto_Type	FieldDescriptorProto_Type_Type_MIN = FieldDescriptorProto_Type_TYPE_DOUBLE
const FieldDescriptorProto_Type	FieldDescriptorProto_Type_Type_MAX = FieldDescriptorProto_Type_TYPE_SINT64
const int	FieldDescriptorProto_Type_Type_ARRAYSIZE = FieldDescriptorProto_Type_Type_MAX + 1
const FieldDescriptorProto_Label	FieldDescriptorProto_Label_Label_MIN = FieldDescriptorProto_Label_LABEL_OPTIONAL
const FieldDescriptorProto_Label	FieldDescriptorProto_Label_Label_MAX = FieldDescriptorProto_Label_LABEL_REPEATED
const int	FieldDescriptorProto_Label_Label_ARRAYSIZE = FieldDescriptorProto_Label_Label_MAX + 1
const FileOptions_OptimizeMode	FileOptions_OptimizeMode_OptimizeMode_MIN = FileOptions_OptimizeMode_SPEED
const FileOptions_OptimizeMode	FileOptions_OptimizeMode_OptimizeMode_MAX = FileOptions_OptimizeMode_LITE_RUNTIME
const int	FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE = FileOptions_OptimizeMode_OptimizeMode_MAX + 1
const FieldOptions_CType	FieldOptions_CType_CType_MIN = FieldOptions_CType_STRING
const FieldOptions_CType	FieldOptions_CType_CType_MAX = FieldOptions_CType_STRING_PIECE
const int	FieldOptions_CType_CType_ARRAYSIZE = FieldOptions_CType_CType_MAX + 1
static const int32	kint32max = 0x7FFFFFFF
static const int32	kint32min = -kint32max - 1
static const int64	kint64max = GOOGLE_LONGLONG(0x7FFFFFFFFFFFFFFF)
static const int64	kint64min = -kint64max - 1
static const uint32	kuint32max = 0xFFFFFFFFu
static const uint64	kuint64max = GOOGLE_ULONGLONG(0xFFFFFFFFFFFFFFFF)
LIBPROTOBUF_EXPORT const int	kStringPrintfVectorMaxArgs
static const int	kFastToBufferSize = 32
static const int	kDoubleToBufferSize = 32
static const int	kFloatToBufferSize = 24
static const LogLevel	ERROR = LOGLEVEL_ERROR
static const LogLevel	WARNING = LOGLEVEL_WARNING

Typedef Documentation

typedef int16_t google::protobuf::int16

typedef int32_t google::protobuf::int32

typedef int64_t google::protobuf::int64

typedef int8_t google::protobuf::int8

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

typedef internal::AtomicWord google::protobuf::ProtobufOnceType

typedef unsigned int google::protobuf::uint

typedef uint16_t google::protobuf::uint16

typedef uint32_t google::protobuf::uint32

typedef uint64_t google::protobuf::uint64

typedef uint8_t google::protobuf::uint8

Enumeration Type Documentation

anonymous enum

Enumerator
ONCE_STATE_UNINITIALIZED
ONCE_STATE_EXECUTING_CLOSURE
ONCE_STATE_DONE

 {
 ONCE_STATE_UNINITIALIZED = 0,
 ONCE_STATE_EXECUTING_CLOSURE = 1,
 ONCE_STATE_DONE = 2
};

enum google::protobuf::FieldDescriptorProto_Label

Enumerator
FieldDescriptorProto_Label_LABEL_OPTIONAL
FieldDescriptorProto_Label_LABEL_REQUIRED
FieldDescriptorProto_Label_LABEL_REPEATED

 {
 FieldDescriptorProto_Label_LABEL_OPTIONAL = 1,
 FieldDescriptorProto_Label_LABEL_REQUIRED = 2,
 FieldDescriptorProto_Label_LABEL_REPEATED = 3
};

enum google::protobuf::FieldDescriptorProto_Type

Enumerator
FieldDescriptorProto_Type_TYPE_DOUBLE
FieldDescriptorProto_Type_TYPE_FLOAT
FieldDescriptorProto_Type_TYPE_INT64
FieldDescriptorProto_Type_TYPE_UINT64
FieldDescriptorProto_Type_TYPE_INT32
FieldDescriptorProto_Type_TYPE_FIXED64
FieldDescriptorProto_Type_TYPE_FIXED32
FieldDescriptorProto_Type_TYPE_BOOL
FieldDescriptorProto_Type_TYPE_STRING
FieldDescriptorProto_Type_TYPE_GROUP
FieldDescriptorProto_Type_TYPE_MESSAGE
FieldDescriptorProto_Type_TYPE_BYTES
FieldDescriptorProto_Type_TYPE_UINT32
FieldDescriptorProto_Type_TYPE_ENUM
FieldDescriptorProto_Type_TYPE_SFIXED32
FieldDescriptorProto_Type_TYPE_SFIXED64
FieldDescriptorProto_Type_TYPE_SINT32
FieldDescriptorProto_Type_TYPE_SINT64

 {
 FieldDescriptorProto_Type_TYPE_DOUBLE = 1,
 FieldDescriptorProto_Type_TYPE_FLOAT = 2,
 FieldDescriptorProto_Type_TYPE_INT64 = 3,
 FieldDescriptorProto_Type_TYPE_UINT64 = 4,
 FieldDescriptorProto_Type_TYPE_INT32 = 5,
 FieldDescriptorProto_Type_TYPE_FIXED64 = 6,
 FieldDescriptorProto_Type_TYPE_FIXED32 = 7,
 FieldDescriptorProto_Type_TYPE_BOOL = 8,
 FieldDescriptorProto_Type_TYPE_STRING = 9,
 FieldDescriptorProto_Type_TYPE_GROUP = 10,
 FieldDescriptorProto_Type_TYPE_MESSAGE = 11,
 FieldDescriptorProto_Type_TYPE_BYTES = 12,
 FieldDescriptorProto_Type_TYPE_UINT32 = 13,
 FieldDescriptorProto_Type_TYPE_ENUM = 14,
 FieldDescriptorProto_Type_TYPE_SFIXED32 = 15,
 FieldDescriptorProto_Type_TYPE_SFIXED64 = 16,
 FieldDescriptorProto_Type_TYPE_SINT32 = 17,
 FieldDescriptorProto_Type_TYPE_SINT64 = 18
};

enum google::protobuf::FieldOptions_CType

Enumerator
FieldOptions_CType_STRING
FieldOptions_CType_CORD
FieldOptions_CType_STRING_PIECE

 {
 FieldOptions_CType_STRING = 0,
 FieldOptions_CType_CORD = 1,
 FieldOptions_CType_STRING_PIECE = 2
};

enum google::protobuf::FileOptions_OptimizeMode

Enumerator
FileOptions_OptimizeMode_SPEED
FileOptions_OptimizeMode_CODE_SIZE
FileOptions_OptimizeMode_LITE_RUNTIME

 {
 FileOptions_OptimizeMode_SPEED = 1,
 FileOptions_OptimizeMode_CODE_SIZE = 2,
 FileOptions_OptimizeMode_LITE_RUNTIME = 3
};

enum google::protobuf::LogLevel

Enumerator
LOGLEVEL_INFO
LOGLEVEL_WARNING
LOGLEVEL_ERROR
LOGLEVEL_FATAL
LOGLEVEL_DFATAL

 {
 LOGLEVEL_INFO, // Informational. This is never actually used by
 // libprotobuf.
 LOGLEVEL_WARNING, // Warns about issues that, although not technically a
 // problem now, could cause problems in the future. For
 // example, a // warning will be printed when parsing a
 // message that is near the message size limit.
 LOGLEVEL_ERROR, // An error occurred which should never happen during
 // normal use.
 LOGLEVEL_FATAL, // An error occurred from which the library cannot
 // recover. This usually indicates a programming error
 // in the code which calls the library, especially when
 // compiled in debug mode.

#ifdef NDEBUG
 LOGLEVEL_DFATAL = LOGLEVEL_ERROR
#else
 LOGLEVEL_DFATAL = LOGLEVEL_FATAL
#endif
};

Function Documentation

template<typename Sequence , typename Collection >

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

 {
 for (typename Sequence::const_iterator it = sequence.begin();
 it != sequence.end(); ++it) {
 typename Collection::value_type::second_type& value =
 LookupOrInsert(count_map, *it,
 typename Collection::value_type::second_type());
 value += increment;
 }
}

Here is the call graph for this function:

template<typename T >

internal::AllocatedRepeatedPtrFieldBackInsertIterator<T> google::protobuf::AllocatedRepeatedPtrFieldBackInserter

(

RepeatedPtrField< T > *const

mutable_field

)

 {
 return internal::AllocatedRepeatedPtrFieldBackInsertIterator<T>(
 mutable_field);
}

template<class MapContainer , class KeyContainer >

void google::protobuf::AppendKeysFromMap	(	const MapContainer &	map_container,
		KeyContainer *	key_container
	)

 {
 GOOGLE_CHECK(key_container != NULL);
 for (typename MapContainer::const_iterator it = map_container.begin();
 it != map_container.end(); ++it) {
 key_container->push_back(it->first);
 }
}

template<class MapContainer , class KeyType >

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

 {
 GOOGLE_CHECK(key_container != NULL);
 // We now have the opportunity to call reserve(). Calling reserve() every
 // time is a bad idea for some use cases: libstdc++'s implementation of
 // vector<>::reserve() resizes the vector's backing store to exactly the
 // given size (unless it's already at least that big). Because of this,
 // the use case that involves appending a lot of small maps (total size
 // N) one by one to a vector would be O(N^2). But never calling reserve()
 // loses the opportunity to improve the use case of adding from a large
 // map to an empty vector (this improves performance by up to 33%). A
 // number of heuristics are possible; see the discussion in
 // cl/34081696. Here we use the simplest one.
 if (key_container->empty()) {
 key_container->reserve(map_container.size());
 }
 for (typename MapContainer::const_iterator it = map_container.begin();
 it != map_container.end(); ++it) {
 key_container->push_back(it->first);
 }
}

template<class MapContainer , class ValueContainer >

void google::protobuf::AppendValuesFromMap	(	const MapContainer &	map_container,
		ValueContainer *	value_container
	)

 {
 GOOGLE_CHECK(value_container != NULL);
 for (typename MapContainer::const_iterator it = map_container.begin();
 it != map_container.end(); ++it) {
 value_container->push_back(it->second);
 }
}

template<class MapContainer , class ValueType >

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

 {
 GOOGLE_CHECK(value_container != NULL);
 // See AppendKeysFromMap for why this is done.
 if (value_container->empty()) {
 value_container->reserve(map_container.size());
 }
 for (typename MapContainer::const_iterator it = map_container.begin();
 it != map_container.end(); ++it) {
 value_container->push_back(it->second);
 }
}

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

inline

 {
 return ('a' <= c && c <= 'z') ||
 ('A' <= c && c <= 'Z') ||
 ('0' <= c && c <= '9');
}

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

inline

 {
 return ('0' <= c && c <= '9');
}

void google::protobuf::CaptureTestStderr

(

)

void google::protobuf::CaptureTestStdout

(

)

LIBPROTOBUF_EXPORT string google::protobuf::CEscape

(

const string &

src

)

Here is the caller graph for this function:

LIBPROTOBUF_EXPORT int google::protobuf::CEscapeString	(	const char *	src,
		int	src_len,
		char *	dest,
		int	dest_len
	)

template<class Collection , class Key >

bool google::protobuf::ContainsKey	(	const Collection &	collection,
		const Key &	key
	)

 {
 return collection.find(key) != collection.end();
}

template<class Collection , class Key , class Value >

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

 {
 typedef typename Collection::const_iterator const_iterator;
 std::pair<const_iterator, const_iterator> range = collection.equal_range(key);
 for (const_iterator it = range.first; it != range.second; ++it) {
 if (it->second == value) {
 return true;
 }
 }
 return false;
}

void LIBPROTOBUF_EXPORT google::protobuf::DoNothing

(

)

LIBPROTOBUF_EXPORT char * google::protobuf::DoubleToBuffer	(	double	i,
		char *	buffer
	)

template<class Collection >

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

 {
 typename Collection::iterator it = collection->find(key);
 if (it == collection->end()) {
 return NULL;
 }
 typename Collection::value_type::second_type v = it->second;
 collection->erase(it);
 return v;
}

LIBPROTOBUF_EXPORT char * google::protobuf::FastHex32ToBuffer	(	uint32	i,
		char *	buffer
	)

LIBPROTOBUF_EXPORT char * google::protobuf::FastHex64ToBuffer	(	uint64	i,
		char *	buffer
	)

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

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

Here is the caller graph for this function:

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

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

Here is the caller graph for this function:

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

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

inline

 {
 return (sizeof(i) == 4 ?
 FastInt32ToBuffer(i, buffer) : FastInt64ToBuffer(i, buffer));
}

Here is the call graph for this function:

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

inline

 {
 return (sizeof(i) == 4 ?
 FastInt32ToBuffer(i, buffer) : FastInt64ToBuffer(i, buffer));
}

Here is the call graph for this function:

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

inline

 {
 FastUInt32ToBufferLeft(i, buffer);
 return buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

LIBPROTOBUF_EXPORT char * google::protobuf::FastUInt32ToBufferLeft	(	uint32	i,
		char *	buffer
	)

Here is the caller graph for this function:

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

inline

 {
 FastUInt64ToBufferLeft(i, buffer);
 return buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

LIBPROTOBUF_EXPORT char * google::protobuf::FastUInt64ToBufferLeft	(	uint64	i,
		char *	buffer
	)

Here is the caller graph for this function:

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

inline

 {
 return (sizeof(i) == 4 ?
 FastUInt32ToBuffer(i, buffer) : FastUInt64ToBuffer(i, buffer));
}

Here is the call graph for this function:

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

inline

 {
 return (sizeof(i) == 4 ?
 FastUInt32ToBuffer(i, buffer) : FastUInt64ToBuffer(i, buffer));
}

Here is the call graph for this function:

LIBPROTOBUF_EXPORTconst ::google::protobuf::EnumDescriptor* google::protobuf::FieldDescriptorProto_Label_descriptor

(

)

Here is the caller graph for this function:

LIBPROTOBUF_EXPORT bool google::protobuf::FieldDescriptorProto_Label_IsValid

(

int

value

)

Here is the caller graph for this function:

const ::std::string& google::protobuf::FieldDescriptorProto_Label_Name ( FieldDescriptorProto_Label  value )

inline

 {
 return ::google::protobuf::internal::NameOfEnum(
 FieldDescriptorProto_Label_descriptor(), value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool google::protobuf::FieldDescriptorProto_Label_Parse ( const ::std::string &  name, FieldDescriptorProto_Label *  value  )

inline

 {
 return ::google::protobuf::internal::ParseNamedEnum<FieldDescriptorProto_Label>(
 FieldDescriptorProto_Label_descriptor(), name, value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

LIBPROTOBUF_EXPORTconst ::google::protobuf::EnumDescriptor* google::protobuf::FieldDescriptorProto_Type_descriptor

(

)

Here is the caller graph for this function:

LIBPROTOBUF_EXPORT bool google::protobuf::FieldDescriptorProto_Type_IsValid

(

int

value

)

Here is the caller graph for this function:

const ::std::string& google::protobuf::FieldDescriptorProto_Type_Name ( FieldDescriptorProto_Type  value )

inline

 {
 return ::google::protobuf::internal::NameOfEnum(
 FieldDescriptorProto_Type_descriptor(), value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool google::protobuf::FieldDescriptorProto_Type_Parse ( const ::std::string &  name, FieldDescriptorProto_Type *  value  )

inline

 {
 return ::google::protobuf::internal::ParseNamedEnum<FieldDescriptorProto_Type>(
 FieldDescriptorProto_Type_descriptor(), name, value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

LIBPROTOBUF_EXPORTconst ::google::protobuf::EnumDescriptor* google::protobuf::FieldOptions_CType_descriptor

(

)

Here is the caller graph for this function:

LIBPROTOBUF_EXPORT bool google::protobuf::FieldOptions_CType_IsValid

(

int

value

)

Here is the caller graph for this function:

const ::std::string& google::protobuf::FieldOptions_CType_Name ( FieldOptions_CType  value )

inline

 {
 return ::google::protobuf::internal::NameOfEnum(
 FieldOptions_CType_descriptor(), value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool google::protobuf::FieldOptions_CType_Parse ( const ::std::string &  name, FieldOptions_CType *  value  )

inline

                                                      {
  return ::google::protobuf::internal::ParseNamedEnum<FieldOptions_CType>(
    FieldOptions_CType_descriptor(), name, value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

LIBPROTOBUF_EXPORTconst ::google::protobuf::EnumDescriptor* google::protobuf::FileOptions_OptimizeMode_descriptor

(

)

Here is the caller graph for this function:

LIBPROTOBUF_EXPORT bool google::protobuf::FileOptions_OptimizeMode_IsValid

(

int

value

)

Here is the caller graph for this function:

const ::std::string& google::protobuf::FileOptions_OptimizeMode_Name ( FileOptions_OptimizeMode  value )

inline

                                                                                      {
  return ::google::protobuf::internal::NameOfEnum(
    FileOptions_OptimizeMode_descriptor(), value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool google::protobuf::FileOptions_OptimizeMode_Parse ( const ::std::string &  name, FileOptions_OptimizeMode *  value  )

inline

                                                            {
  return ::google::protobuf::internal::ParseNamedEnum<FileOptions_OptimizeMode>(
    FileOptions_OptimizeMode_descriptor(), name, value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<class Collection , class Key , class Value >

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

                                  {
  typename Collection::const_iterator it = collection.find(key);
  if (it == collection.end()) {
    return false;
  }
  if (value) {
    *value = it->second;
  }
  return true;
}

template<class Collection >

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

                                                                       {
  typename Collection::const_iterator it = collection.find(key);
  CHECK(it != collection.end()) <<  "key not found: " << key;
  // Since linked_ptr::operator*() is a const member returning a non const,
  // we do not need a version of this function taking a non const collection.
  return *it->second;
}

template<class Collection >

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

                                                                        {
  typename Collection::const_iterator it = collection.find(key);
  if (it == collection.end()) {
    return 0;
  }
  // Since linked_ptr::get() is a const member returning a non const,
  // we do not need a version of this function taking a non const collection.
  return it->second.get();
}

template<class Collection >

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

                                                              {
  typename Collection::const_iterator it = collection.find(key);
  GOOGLE_CHECK(it != collection.end()) << "Map key not found: " << key;
  return it->second;
}

template<class Collection >

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

                                                              {
  typename Collection::iterator it = collection.find(key);
  GOOGLE_CHECK(it != collection.end()) << "Map key not found: " << key;
  return it->second;
}

template<class Collection >

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

                                                                     {
  typename Collection::const_iterator it = collection.find(key);
  GOOGLE_CHECK(it != collection.end()) << "Map key not found";
  return it->second;
}

template<class Collection >

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

                                                                     {
  typename Collection::iterator it = collection.find(key);
  GOOGLE_CHECK(it != collection.end()) << "Map key not found";
  return it->second;
}

template<class Collection >

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

                                                               {
  typename Collection::const_iterator it = collection.find(key);
  if (it == collection.end()) {
    return 0;
  }
  return &it->second;
}

template<class Collection >

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

                                                               {
  typename Collection::iterator it = collection.find(key);
  if (it == collection.end()) {
    return 0;
  }
  return &it->second;
}

template<class Collection >

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

                                                                  {
  typename Collection::const_iterator it = collection.find(key);
  if (it == collection.end()) {
    return typename Collection::value_type::second_type();
  }
  return it->second;
}

template<class Collection >

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

                                                                  {
  typename Collection::iterator it = collection.find(key);
  if (it == collection.end()) {
    return typename Collection::value_type::second_type();
  }
  return it->second;
}

template<class Collection >

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

                                                                       {
  typename Collection::const_iterator it = collection.find(key);
  if (it == collection.end()) {
    return value;
  }
  return it->second;
}

LIBPROTOBUF_EXPORT char * google::protobuf::FloatToBuffer	(	float	i,
		char *	buffer
	)

string google::protobuf::GetCapturedTestStderr

(

)

string google::protobuf::GetCapturedTestStdout

(

)

template<typename E >

const EnumDescriptor* google::protobuf::GetEnumDescriptor

(

)

template<>

const EnumDescriptor* google::protobuf::GetEnumDescriptor< ::Battlenet::JSON::Login::AuthenticationState > ( )

inline

                                                                                         {
  return ::Battlenet::JSON::Login::AuthenticationState_descriptor();
}

Here is the call graph for this function:

template<>

const EnumDescriptor* google::protobuf::GetEnumDescriptor< ::Battlenet::JSON::Login::FormType > ( )

inline

                                                                              {
  return ::Battlenet::JSON::Login::FormType_descriptor();
}

Here is the call graph for this function:

template<>

const EnumDescriptor* google::protobuf::GetEnumDescriptor< ::bgs::protocol::account::v1::IdentityVerificationStatus > ( )

inline

                                                                                                  {
  return ::bgs::protocol::account::v1::IdentityVerificationStatus_descriptor();
}

Here is the call graph for this function:

template<>

const EnumDescriptor* google::protobuf::GetEnumDescriptor< ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy > ( )

inline

                                                                                                   {
  return ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy_descriptor();
}

Here is the call graph for this function:

template<>

const EnumDescriptor* google::protobuf::GetEnumDescriptor< ::bgs::protocol::AttributeFilter_Operation > ( )

inline

                                                                                        {
  return ::bgs::protocol::AttributeFilter_Operation_descriptor();
}

Here is the call graph for this function:

template<>

const EnumDescriptor* google::protobuf::GetEnumDescriptor< ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel > ( )

inline

                                                                                                 {
  return ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel_descriptor();
}

Here is the call graph for this function:

template<>

const EnumDescriptor* google::protobuf::GetEnumDescriptor< ::bgs::protocol::LogOption > ( )

inline

                                                                        {
  return ::bgs::protocol::LogOption_descriptor();
}

Here is the call graph for this function:

template<>

const EnumDescriptor* google::protobuf::GetEnumDescriptor< ::bgs::protocol::presence::v1::FieldOperation_OperationType > ( )

inline

                                                                                                     {
  return ::bgs::protocol::presence::v1::FieldOperation_OperationType_descriptor();
}

Here is the call graph for this function:

template<>

const EnumDescriptor* google::protobuf::GetEnumDescriptor< ::google::protobuf::FieldDescriptorProto_Label > ( )

inline

                                                                                            {
  return ::google::protobuf::FieldDescriptorProto_Label_descriptor();
}

Here is the call graph for this function:

template<>

const EnumDescriptor* google::protobuf::GetEnumDescriptor< ::google::protobuf::FieldDescriptorProto_Type > ( )

inline

                                                                                           {
  return ::google::protobuf::FieldDescriptorProto_Type_descriptor();
}

Here is the call graph for this function:

template<>

const EnumDescriptor* google::protobuf::GetEnumDescriptor< ::google::protobuf::FieldOptions_CType > ( )

inline

                                                                                    {
  return ::google::protobuf::FieldOptions_CType_descriptor();
}

Here is the call graph for this function:

template<>

const EnumDescriptor* google::protobuf::GetEnumDescriptor< ::google::protobuf::FileOptions_OptimizeMode > ( )

inline

                                                                                          {
  return ::google::protobuf::FileOptions_OptimizeMode_descriptor();
}

Here is the call graph for this function:

LIBPROTOBUF_EXPORT uint32 google::protobuf::ghtonl

(

uint32

x

)

void google::protobuf::GoogleOnceInit ( ProtobufOnceType *  once, void(*)()  init_func  )

inline

                                                                        {
  if (internal::Acquire_Load(once) != ONCE_STATE_DONE) {
    internal::FunctionClosure0 func(init_func, false);
    GoogleOnceInitImpl(once, &func);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename Arg >

void google::protobuf::GoogleOnceInit ( ProtobufOnceType *  once, void(*)(Arg *)  init_func, Arg *  arg  )

inline

              {
  if (internal::Acquire_Load(once) != ONCE_STATE_DONE) {
    internal::FunctionClosure1<Arg*> func(init_func, false, arg);
    GoogleOnceInitImpl(once, &func);
  }
}

Here is the call graph for this function:

LIBPROTOBUF_EXPORT void google::protobuf::GoogleOnceInitImpl	(	ProtobufOnceType *	once,
		Closure *	closure
	)

Here is the caller graph for this function:

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

inline

                                                  {
  return str.size() >= prefix.size() &&
         str.compare(0, prefix.size(), prefix) == 0;
}

Here is the caller graph for this function:

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

inline

                                                  {
  return str.size() >= suffix.size() &&
         str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
}

Here is the caller graph for this function:

template<class Collection >

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

                                                           {
  std::pair<typename Collection::iterator, bool> ret =
      collection->insert(typename Collection::value_type(key, value));
  if (!ret.second) {
    delete ret.first->second;
    ret.first->second = value;
    return false;
  }
  return true;
}

template<class Collection >

bool google::protobuf::InsertIfNotPresent	(	Collection *const	collection,
		const typename Collection::value_type &	vt
	)

                                                                 {
  return collection->insert(vt).second;
}

Here is the caller graph for this function:

template<class Collection >

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

                                                           {
  return InsertIfNotPresent(
      collection, typename Collection::value_type(key, value));
}

Here is the call graph for this function:

template<class Collection >

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

                                                        {
  typedef typename Collection::value_type value_type;
  std::pair<typename Collection::iterator, bool> res =
      collection->insert(value_type(key, typename value_type::second_type()));
  GOOGLE_CHECK(res.second) << "duplicate key: " << key;
  return res.first->second;
}

template<class MapContainer , class KeyContainer >

void google::protobuf::InsertKeysFromMap	(	const MapContainer &	map_container,
		KeyContainer *	key_container
	)

                                                    {
  GOOGLE_CHECK(key_container != NULL);
  for (typename MapContainer::const_iterator it = map_container.begin();
       it != map_container.end(); ++it) {
    key_container->insert(it->first);
  }
}

template<class Collection >

void google::protobuf::InsertOrDie	(	Collection *const	collection,
		const typename Collection::value_type &	value
	)

                                                             {
  CHECK(InsertIfNotPresent(collection, value)) << "duplicate value: " << value;
}

Here is the call graph for this function:

template<class Collection >

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

                                                                       {
  typedef typename Collection::value_type value_type;
  GOOGLE_CHECK(InsertIfNotPresent(collection, key, data))
      << "duplicate key: " << key;
}

Here is the call graph for this function:

template<class Collection >

void google::protobuf::InsertOrDieNoPrint	(	Collection *const	collection,
		const typename Collection::value_type &	value
	)

                                                                    {
  CHECK(InsertIfNotPresent(collection, value)) << "duplicate value.";
}

Here is the call graph for this function:

template<class Collection >

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

                                                          {
  typedef typename Collection::value_type value_type;
  GOOGLE_CHECK(InsertIfNotPresent(collection, key, data)) << "duplicate key.";
}

Here is the call graph for this function:

template<class Collection >

Collection::value_type::second_type* const google::protobuf::InsertOrReturnExisting	(	Collection *const	collection,
		const typename Collection::value_type &	vt
	)

                                                                {
  std::pair<typename Collection::iterator, bool> ret = collection->insert(vt);
  if (ret.second) {
    return NULL;  // Inserted, no existing previous value.
  } else {
    return &ret.first->second;  // Return address of already existing value.
  }
}

Here is the caller graph for this function:

template<class Collection >

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

                                                          {
  return InsertOrReturnExisting(collection,
                                typename Collection::value_type(key, data));
}

Here is the call graph for this function:

template<class Collection >

bool google::protobuf::InsertOrUpdate	(	Collection *const	collection,
		const typename Collection::value_type &	vt
	)

                                                             {
  std::pair<typename Collection::iterator, bool> ret = collection->insert(vt);
  if (!ret.second) {
    // update
    ret.first->second = vt.second;
    return false;
  }
  return true;
}

Here is the caller graph for this function:

template<class Collection >

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

                                                                           {
  return InsertOrUpdate(
      collection, typename Collection::value_type(key, value));
}

Here is the call graph for this function:

template<class Collection , class InputIterator >

void google::protobuf::InsertOrUpdateMany	(	Collection *const	collection,
		InputIterator	first,
		InputIterator	last
	)

                                                                 {
  for (; first != last; ++first) {
    InsertOrUpdate(collection, *first);
  }
}

Here is the call graph for this function:

template<typename Iterator >

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

                                             {
  for (Iterator it = start; it != end; ++it) {
    if (it != start) {
      result->append(delim);
    }
    result->append(internal::ToString(*it));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename Range >

string google::protobuf::Join	(	const Range &	components,
		const char *	delim
	)

                               {
  string result;
  Join(components.begin(), components.end(), delim, &result);
  return result;
}

Here is the call graph for this function:

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

Here is the caller graph for this function:

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

inline

                                             {
  string result;
  JoinStrings(components, delim, &result);
  return result;
}

Here is the call graph for this function:

template<class Collection >

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

                                                        {
  return collection->insert(vt).first->second;
}

Here is the caller graph for this function:

template<class Collection >

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

                                                                      {
  return LookupOrInsert(
      collection, typename Collection::value_type(key, value));
}

Here is the call graph for this function:

template<class Collection >

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

                                                                      {
  typedef typename std::iterator_traits<
    typename Collection::value_type::second_type>::value_type Element;
  std::pair<typename Collection::iterator, bool> ret =
      collection->insert(typename Collection::value_type(
          key,
          static_cast<typename Collection::value_type::second_type>(NULL)));
  if (ret.second) {
    ret.first->second = new Element();
  }
  return ret.first->second;
}

template<class Collection , class Arg >

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

                                  {
  typedef typename std::iterator_traits<
    typename Collection::value_type::second_type>::value_type Element;
  std::pair<typename Collection::iterator, bool> ret =
      collection->insert(typename Collection::value_type(
          key,
          static_cast<typename Collection::value_type::second_type>(NULL)));
  if (ret.second) {
    ret.first->second = new Element(arg);
  }
  return ret.first->second;
}

template<class Collection >

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

                                                        {
  typedef typename Collection::value_type::second_type Value;
  std::pair<typename Collection::iterator, bool> ret =
      collection->insert(typename Collection::value_type(key, Value()));
  if (ret.second) {
    ret.first->second.reset(new typename Value::element_type);
  }
  return ret.first->second.get();
}

template<class Collection , class Arg >

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

                    {
  typedef typename Collection::value_type::second_type Value;
  std::pair<typename Collection::iterator, bool> ret =
      collection->insert(typename Collection::value_type(key, Value()));
  if (ret.second) {
    ret.first->second.reset(new typename Value::element_type(arg));
  }
  return ret.first->second.get();
}

template<class Collection >

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

                                                        {
  typedef typename Collection::value_type::second_type SharedPtr;
  typedef typename Collection::value_type::second_type::element_type Element;
  std::pair<typename Collection::iterator, bool> ret =
      collection->insert(typename Collection::value_type(key, SharedPtr()));
  if (ret.second) {
    ret.first->second.reset(new Element());
  }
  return ret.first->second;
}

template<class Collection , class Arg >

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

                    {
  typedef typename Collection::value_type::second_type SharedPtr;
  typedef typename Collection::value_type::second_type::element_type Element;
  std::pair<typename Collection::iterator, bool> ret =
      collection->insert(typename Collection::value_type(key, SharedPtr()));
  if (ret.second) {
    ret.first->second.reset(new Element(arg));
  }
  return ret.first->second;
}

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

inline

                                    {
  string::iterator end = s->end();
  for (string::iterator i = s->begin(); i != end; ++i) {
    // tolower() changes based on locale.  We don't want this!
    if ('A' <= *i && *i <= 'Z') *i += 'a' - 'A';
  }
}

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

inline

                                                {
  return new internal::FunctionClosure0(function, true);
}

template<typename Class >

Closure* google::protobuf::NewCallback ( Class *  object, void(Class::*)()  method  )

inline

                                                                  {
  return new internal::MethodClosure0<Class>(object, method, true);
}

template<typename Arg1 >

Closure* google::protobuf::NewCallback ( void(*)(Arg1)  function, Arg1  arg1  )

inline

                                       {
  return new internal::FunctionClosure1<Arg1>(function, true, arg1);
}

template<typename Class , typename Arg1 >

Closure* google::protobuf::NewCallback ( Class *  object, void(Class::*)(Arg1)  method, Arg1  arg1  )

inline

                                       {
  return new internal::MethodClosure1<Class, Arg1>(object, method, true, arg1);
}

template<typename Arg1 , typename Arg2 >

Closure* google::protobuf::NewCallback ( void(*)(Arg1, Arg2)  function, Arg1  arg1, Arg2  arg2  )

inline

                                                  {
  return new internal::FunctionClosure2<Arg1, Arg2>(
    function, true, arg1, arg2);
}

template<typename Class , typename Arg1 , typename Arg2 >

Closure* google::protobuf::NewCallback ( Class *  object, void(Class::*)(Arg1, Arg2)  method, Arg1  arg1, Arg2  arg2  )

inline

                                                  {
  return new internal::MethodClosure2<Class, Arg1, Arg2>(
    object, method, true, arg1, arg2);
}

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

inline

                                                         {
  return new internal::FunctionClosure0(function, false);
}

template<typename Class >

Closure* google::protobuf::NewPermanentCallback ( Class *  object, void(Class::*)()  method  )

inline

                                                                           {
  return new internal::MethodClosure0<Class>(object, method, false);
}

template<typename Arg1 >

Closure* google::protobuf::NewPermanentCallback ( void(*)(Arg1)  function, Arg1  arg1  )

inline

                                                {
  return new internal::FunctionClosure1<Arg1>(function, false, arg1);
}

template<typename Class , typename Arg1 >

Closure* google::protobuf::NewPermanentCallback ( Class *  object, void(Class::*)(Arg1)  method, Arg1  arg1  )

inline

                                                {
  return new internal::MethodClosure1<Class, Arg1>(object, method, false, arg1);
}

template<typename Arg1 , typename Arg2 >

Closure* google::protobuf::NewPermanentCallback ( void(*)(Arg1, Arg2)  function, Arg1  arg1, Arg2  arg2  )

inline

                                                           {
  return new internal::FunctionClosure2<Arg1, Arg2>(
    function, false, arg1, arg2);
}

template<typename Class , typename Arg1 , typename Arg2 >

Closure* google::protobuf::NewPermanentCallback ( Class *  object, void(Class::*)(Arg1, Arg2)  method, Arg1  arg1, Arg2  arg2  )

inline

                          {
  return new internal::MethodClosure2<Class, Arg1, Arg2>(
    object, method, false, arg1, arg2);
}

void LIBPROTOBUF_EXPORT google::protobuf::protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto

(

)

void google::protobuf::protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto

(

)

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

const FieldDescriptor* google::protobuf::PROTOBUF_DEFINE_ACCESSOR	(	FieldDescriptor	,
		default_value_enum	,
		const EnumValueDescriptor *
	)

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

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

google::protobuf::PROTOBUF_DEFINE_ARRAY_ACCESSOR	(	FileDescriptor	,
		service	,
		const ServiceDescriptor *
	)

const FieldDescriptor* google::protobuf::PROTOBUF_DEFINE_OPTIONS_ACCESSOR	(	Descriptor	,
		MessageOptions
	)

const FieldDescriptor const EnumValueDescriptor* google::protobuf::PROTOBUF_DEFINE_OPTIONS_ACCESSOR	(	EnumDescriptor	,
		EnumOptions
	)

google::protobuf::PROTOBUF_DEFINE_OPTIONS_ACCESSOR	(	MethodDescriptor	,
		MethodOptions
	)

google::protobuf::PROTOBUF_DEFINE_OPTIONS_ACCESSOR	(	FileDescriptor	,
		FileOptions
	)

void google::protobuf::protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto

(

)

template<typename T >

internal::RepeatedFieldBackInsertIterator<T> google::protobuf::RepeatedFieldBackInserter

(

RepeatedField< T > *const

mutable_field

)

                                                                 {
  return internal::RepeatedFieldBackInsertIterator<T>(mutable_field);
}

template<typename T >

internal::RepeatedPtrFieldBackInsertIterator<T> google::protobuf::RepeatedFieldBackInserter

(

RepeatedPtrField< T > *const

mutable_field

)

                                                                    {
  return internal::RepeatedPtrFieldBackInsertIterator<T>(mutable_field);
}

template<typename T >

internal::RepeatedPtrFieldBackInsertIterator<T> google::protobuf::RepeatedPtrFieldBackInserter

(

RepeatedPtrField< T > *const

mutable_field

)

                                                                       {
  return internal::RepeatedPtrFieldBackInsertIterator<T>(mutable_field);
}

LIBPROTOBUF_EXPORT bool google::protobuf::safe_int	(	string	text,
		int32 *	value_p
	)

Here is the caller graph for this function:

bool google::protobuf::safe_strto32 ( string  text, int32 *  value  )

inline

                                                    {
  return safe_int(text, value);
}

Here is the call graph for this function:

LIBPROTOBUF_EXPORT LogHandler* google::protobuf::SetLogHandler

(

LogHandler *

new_func

)

LIBPROTOBUF_EXPORT void google::protobuf::ShutdownProtobufLibrary

(

)

Here is the caller graph for this function:

LIBPROTOBUF_EXPORT string google::protobuf::SimpleDtoa

(

double

value

)

LIBPROTOBUF_EXPORT string google::protobuf::SimpleFtoa

(

float

value

)

LIBPROTOBUF_EXPORT string google::protobuf::SimpleItoa

(

int

i

)

Here is the caller graph for this function:

LIBPROTOBUF_EXPORT string google::protobuf::SimpleItoa

(

unsigned int

i

)

LIBPROTOBUF_EXPORT string google::protobuf::SimpleItoa

(

long

i

)

LIBPROTOBUF_EXPORT string google::protobuf::SimpleItoa

(

unsigned long

i

)

LIBPROTOBUF_EXPORT string google::protobuf::SimpleItoa

(

long long

i

)

LIBPROTOBUF_EXPORT string google::protobuf::SimpleItoa

(

unsigned long long

i

)

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

inline

                                                                   {
  vector<string> result;
  if (skip_empty) {
    SplitStringUsing(full, delim, &result);
  } else {
    SplitStringAllowEmpty(full, delim, &result);
  }
  return result;
}

Here is the call graph for this function:

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

Here is the caller graph for this function:

LIBPROTOBUF_EXPORT void google::protobuf::SplitStringUsing	(	const string &	full,
		const char *	delim,
		vector< string > *	res
	)

Here is the caller graph for this function:

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

template<class ForwardIterator >

void google::protobuf::STLDeleteContainerPointers	(	ForwardIterator	begin,
		ForwardIterator	end
	)

                                                     {
  while (begin != end) {
    ForwardIterator temp = begin;
    ++begin;
    delete *temp;
  }
}

Here is the caller graph for this function:

template<class T >

void google::protobuf::STLDeleteElements

(

T *

container

)

                                     {
  if (!container) return;
  STLDeleteContainerPointers(container->begin(), container->end());
  container->clear();
}

Here is the call graph for this function:

template<class T >

void google::protobuf::STLDeleteValues

(

T *

v

)

                           {
  if (!v) return;
  for (typename T::iterator i = v->begin(); i != v->end(); ++i) {
    delete i->second;
  }
  v->clear();
}

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

inline

                                                                     {
  s->resize(new_size);
}

Here is the caller graph for this function:

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >

string google::protobuf::StrCat	(	const T1 &	a,
		const T2 &	b,
		const T3 &	c,
		const T4 &	d,
		const T5 &	e
	)

                                                                     {
  return internal::ToString(a) + internal::ToString(b) +
      internal::ToString(c) + internal::ToString(d) + internal::ToString(e);
}

Here is the call graph for this function:

template<typename T1 , typename T2 , typename T3 , typename T4 >

string google::protobuf::StrCat	(	const T1 &	a,
		const T2 &	b,
		const T3 &	c,
		const T4 &	d
	)

                                                        {
  return internal::ToString(a) + internal::ToString(b) +
      internal::ToString(c) + internal::ToString(d);
}

Here is the call graph for this function:

template<typename T1 , typename T2 , typename T3 >

string google::protobuf::StrCat	(	const T1 &	a,
		const T2 &	b,
		const T3 &	c
	)

                                                     {
  return internal::ToString(a) + internal::ToString(b) +
      internal::ToString(c);
}

Here is the call graph for this function:

template<typename T1 , typename T2 >

string google::protobuf::StrCat	(	const T1 &	a,
		const T2 &	b
	)

                                        {
  return internal::ToString(a) + internal::ToString(b);
}

Here is the call graph for this function:

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

inline

                                          {
  // DO NOT USE const_cast<char*>(str->data())! See the unittest for why.
  return str->empty() ? NULL : &*str->begin();
}

Here is the caller graph for this function:

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

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

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

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

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

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

inline

                                                                         {
  if (HasPrefixString(str, prefix)) {
    return str.substr(prefix.size());
  } else {
    return str;
  }
}

Here is the call graph for this function:

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

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

inline

                                                                         {
  if (HasSuffixString(str, suffix)) {
    return str.substr(0, str.size() - suffix.size());
  } else {
    return str;
  }
}

Here is the call graph for this function:

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

inline

                                                                {
  if (sizeof(int32) == sizeof(long))
    return strtol(nptr, endptr, base);
  else
    return strto32_adaptor(nptr, endptr, base);
}

Here is the call graph for this function:

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

Here is the caller graph for this function:

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

inline

                                                                {
  GOOGLE_COMPILE_ASSERT(sizeof(int64) == sizeof(long long),
                        sizeof_int64_is_not_sizeof_long_long);
  return strtoll(nptr, endptr, base);
}

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

inline

                                                                  {
  if (sizeof(uint32) == sizeof(unsigned long))
    return strtoul(nptr, endptr, base);
  else
    return strtou32_adaptor(nptr, endptr, base);
}

Here is the call graph for this function:

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

Here is the caller graph for this function:

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

inline

                                                                  {
  GOOGLE_COMPILE_ASSERT(sizeof(uint64) == sizeof(unsigned long long),
                        sizeof_uint64_is_not_sizeof_long_long);
  return strtoull(nptr, endptr, base);
}

string google::protobuf::TestSourceDir

(

)

string google::protobuf::TestTempDir

(

)

LIBPROTOBUF_EXPORT string google::protobuf::ToHex

(

uint64

num

)

Here is the caller graph for this function:

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

inline

                                       {
  string out = s;
  UpperString(&out);
  return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

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

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

LIBPROTOBUF_EXPORT string google::protobuf::UnescapeCEscapeString

(

const string &

src

)

template<class Collection >

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

                                                                          {
  std::pair<typename Collection::iterator, bool> ret =
      collection->insert(typename Collection::value_type(key, value));
  if (!ret.second) {
    // update
    if (previous) {
      *previous = ret.first->second;
    }
    ret.first->second = value;
    return true;
  }
  return false;
}

template<class Collection >

bool google::protobuf::UpdateReturnCopy	(	Collection *const	collection,
		const typename Collection::value_type &	vt,
		typename Collection::value_type::second_type *	previous
	)

                                                                          {
  std::pair<typename Collection::iterator, bool> ret = collection->insert(vt);
  if (!ret.second) {
    // update
    if (previous) {
      *previous = ret.first->second;
    }
    ret.first->second = vt.second;
    return true;
  }
  return false;
}

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

inline

                                    {
  string::iterator end = s->end();
  for (string::iterator i = s->begin(); i != end; ++i) {
    // toupper() changes based on locale.  We don't want this!
    if ('a' <= *i && *i <= 'z') *i += 'A' - 'a';
  }
}

Here is the caller graph for this function:

Variable Documentation

const LogLevel google::protobuf::ERROR = LOGLEVEL_ERROR

static

google::protobuf::experimental_map_key

google::protobuf::extension

const int google::protobuf::FieldDescriptorProto_Label_Label_ARRAYSIZE = FieldDescriptorProto_Label_Label_MAX + 1

const FieldDescriptorProto_Label google::protobuf::FieldDescriptorProto_Label_Label_MAX = FieldDescriptorProto_Label_LABEL_REPEATED

const FieldDescriptorProto_Label google::protobuf::FieldDescriptorProto_Label_Label_MIN = FieldDescriptorProto_Label_LABEL_OPTIONAL

const int google::protobuf::FieldDescriptorProto_Type_Type_ARRAYSIZE = FieldDescriptorProto_Type_Type_MAX + 1

const FieldDescriptorProto_Type google::protobuf::FieldDescriptorProto_Type_Type_MAX = FieldDescriptorProto_Type_TYPE_SINT64

const FieldDescriptorProto_Type google::protobuf::FieldDescriptorProto_Type_Type_MIN = FieldDescriptorProto_Type_TYPE_DOUBLE

const int google::protobuf::FieldOptions_CType_CType_ARRAYSIZE = FieldOptions_CType_CType_MAX + 1

const FieldOptions_CType google::protobuf::FieldOptions_CType_CType_MAX = FieldOptions_CType_STRING_PIECE

const FieldOptions_CType google::protobuf::FieldOptions_CType_CType_MIN = FieldOptions_CType_STRING

const int google::protobuf::FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE = FileOptions_OptimizeMode_OptimizeMode_MAX + 1

const FileOptions_OptimizeMode google::protobuf::FileOptions_OptimizeMode_OptimizeMode_MAX = FileOptions_OptimizeMode_LITE_RUNTIME

const FileOptions_OptimizeMode google::protobuf::FileOptions_OptimizeMode_OptimizeMode_MIN = FileOptions_OptimizeMode_SPEED

const int google::protobuf::kDoubleToBufferSize = 32

static

const int google::protobuf::kDoubleToBufferSize = 32

static

const int google::protobuf::kFastToBufferSize = 32

static

const int google::protobuf::kFastToBufferSize = 32

static

const int google::protobuf::kFloatToBufferSize = 24

static

const int google::protobuf::kFloatToBufferSize = 24

static

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

static

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

static

const int64 google::protobuf::kint64max = GOOGLE_LONGLONG(0x7FFFFFFFFFFFFFFF)

static

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

static

LIBPROTOBUF_EXPORT const int google::protobuf::kStringPrintfVectorMaxArgs

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

static

const uint64 google::protobuf::kuint64max = GOOGLE_ULONGLONG(0xFFFFFFFFFFFFFFFF)

static

google::protobuf::ServiceOptions

const FieldDescriptor google::protobuf::value

const LogLevel google::protobuf::WARNING = LOGLEVEL_WARNING

static