Namespaces
	internal

Classes
struct	add_reference

struct	add_reference< T & >

class	AllocatedRepeatedPtrFieldBackInsertIterator

struct	and_

struct	AtomicOps_x86CPUFeatureStruct

struct	big_

class	CodedOutputStreamFieldSkipper

struct	CompileAssert

struct	ElementCopier

struct	ElementCopier< Element, true >

class	EnumTypeTraits

class	ExtensionFinder

class	ExtensionIdentifier

struct	ExtensionInfo

class	ExtensionSet

class	FieldSkipper

class	FunctionClosure0

class	FunctionClosure1

class	FunctionClosure2

class	GeneratedExtensionFinder

class	GeneratedMessageReflection

class	GenericTypeHandler

struct	has_trivial_assign

struct	has_trivial_assign< A[N]>

struct	has_trivial_assign< std::pair< T, U > >

struct	has_trivial_constructor

struct	has_trivial_constructor< A[N]>

struct	has_trivial_constructor< const T >

struct	has_trivial_constructor< std::pair< T, U > >

struct	has_trivial_copy

struct	has_trivial_copy< A[N]>

struct	has_trivial_copy< const T >

struct	has_trivial_copy< std::pair< T, U > >

struct	has_trivial_destructor

struct	has_trivial_destructor< A[N]>

struct	has_trivial_destructor< const T >

struct	has_trivial_destructor< std::pair< T, U > >

struct	identity_

struct	if_

struct	if_< false, A, B >

struct	integral_constant

struct	is_convertible

struct	is_enum

struct	is_enum< const T >

struct	is_enum< const volatile T >

struct	is_enum< volatile T >

struct	is_floating_point

struct	is_floating_point< const T >

struct	is_floating_point< const volatile T >

struct	is_floating_point< double >

struct	is_floating_point< float >

struct	is_floating_point< long double >

struct	is_floating_point< volatile T >

struct	is_integral

struct	is_integral< bool >

struct	is_integral< char >

struct	is_integral< const T >

struct	is_integral< const volatile T >

struct	is_integral< int >

struct	is_integral< long >

struct	is_integral< short >

struct	is_integral< signed char >

struct	is_integral< unsigned char >

struct	is_integral< unsigned int >

struct	is_integral< unsigned long >

struct	is_integral< unsigned short >

struct	is_integral< volatile T >

struct	is_integral< wchar_t >

struct	is_pod

struct	is_pod< const T >

struct	is_pod< const volatile T >

struct	is_pod< volatile T >

struct	is_pointer

struct	is_pointer< const T >

struct	is_pointer< const volatile T >

struct	is_pointer< T * >

struct	is_pointer< volatile T >

struct	is_reference

struct	is_reference< T & >

struct	is_same

struct	is_same< T, T >

class	LogFinisher

class	LogMessage

class	MessageTypeTraits

class	MethodClosure0

class	MethodClosure1

class	MethodClosure2

class	Mutex

class	MutexLock

class	MutexLockMaybe

struct	or_

class	PrimitiveTypeTraits

class	ReflectionOps

struct	remove_const

struct	remove_const< T const >

struct	remove_cv

struct	remove_pointer

struct	remove_pointer< T * >

struct	remove_pointer< T *const >

struct	remove_pointer< T *const volatile >

struct	remove_pointer< T *volatile >

struct	remove_reference

struct	remove_reference< T & >

struct	remove_volatile

struct	remove_volatile< T volatile >

struct	RemoveConst

struct	RemoveConst< const T >

class	RepeatedEnumTypeTraits

class	RepeatedFieldBackInsertIterator

class	RepeatedMessageGenericTypeTraits

class	RepeatedMessageTypeTraits

class	RepeatedPrimitiveGenericTypeTraits

class	RepeatedPrimitiveTypeTraits

class	RepeatedPtrFieldBackInsertIterator

class	RepeatedPtrFieldBase

class	RepeatedPtrIterator

class	RepeatedPtrOverPtrsIterator

class	RepeatedStringTypeTraits

class	scoped_array

class	scoped_ptr

class	StringTypeHandler

class	StringTypeHandlerBase

class	StringTypeTraits

struct	type_equals_

struct	type_equals_< A, A >

class	UnknownFieldSetFieldSkipper

class	WireFormat

class	WireFormatLite

Typedefs
typedef uint8	FieldType

typedef bool	EnumValidityFunc (int number)

typedef bool	EnumValidityFuncWithArg (const void *arg, int number)

typedef int32	Atomic32

typedef intptr_t	AtomicWord

typedef Atomic32(*	LinuxKernelCmpxchgFunc )(Atomic32 old_value, Atomic32 new_value, volatile Atomic32 *ptr)

typedef void(*	LinuxKernelMemoryBarrierFunc )(void)

typedef MutexLock	ReaderMutexLock

typedef MutexLock	WriterMutexLock

typedef char	small_

typedef integral_constant < bool, true >	true_type

typedef integral_constant < bool, false >	false_type

typedef true_type	true_

typedef false_type	false_

Functions
string	ToString (int i)

string	ToString (string a)

void	InitializeDefaultRepeatedFields ()

void	DestroyDefaultRepeatedFields ()

LIBPROTOBUF_EXPORT bool	ParseNamedEnum (const EnumDescriptor descriptor, const string &name, int value)

template<typename EnumType >
bool	ParseNamedEnum (const EnumDescriptor descriptor, const string &name, EnumType value)

LIBPROTOBUF_EXPORT const string &	NameOfEnum (const EnumDescriptor *descriptor, int value)

template<typename To , typename From >
To	dynamic_cast_if_available (From from)

LIBPROTOBUF_EXPORT double	Infinity ()

LIBPROTOBUF_EXPORT double	NaN ()

LIBPROTOBUF_EXPORT void	InitEmptyString ()

LIBPROTOBUF_EXPORTconst::std::string &	GetEmptyStringAlreadyInited ()

LIBPROTOBUF_EXPORTconst::std::string &	GetEmptyString ()

LIBPROTOBUF_EXPORT int	StringSpaceUsedExcludingSelf (const string &str)

template<class Type >
bool	AllAreInitialized (const Type &t)

void	LogIndexOutOfBounds (int index, int size)

template<typename Iter >
int	CalculateReserve (Iter begin, Iter end, std::forward_iterator_tag)

template<typename Iter >
int	CalculateReserve (Iter, Iter, std::input_iterator_tag)

template<typename Iter >
int	CalculateReserve (Iter begin, Iter end)

Atomic32	NoBarrier_CompareAndSwap (volatile Atomic32 *ptr, Atomic32 old_value, Atomic32 new_value)

Atomic32	NoBarrier_AtomicExchange (volatile Atomic32 *ptr, Atomic32 new_value)

Atomic32	NoBarrier_AtomicIncrement (volatile Atomic32 *ptr, Atomic32 increment)

Atomic32	Barrier_AtomicIncrement (volatile Atomic32 *ptr, Atomic32 increment)

Atomic32	Acquire_CompareAndSwap (volatile Atomic32 *ptr, Atomic32 old_value, Atomic32 new_value)

Atomic32	Release_CompareAndSwap (volatile Atomic32 *ptr, Atomic32 old_value, Atomic32 new_value)

void	MemoryBarrier ()

void	NoBarrier_Store (volatile Atomic32 *ptr, Atomic32 value)

void	Acquire_Store (volatile Atomic32 *ptr, Atomic32 value)

void	Release_Store (volatile Atomic32 *ptr, Atomic32 value)

Atomic32	NoBarrier_Load (volatile const Atomic32 *ptr)

Atomic32	Acquire_Load (volatile const Atomic32 *ptr)

Atomic32	Release_Load (volatile const Atomic32 *ptr)

Atomic64	NoBarrier_CompareAndSwap (volatile Atomic64 *ptr, Atomic64 old_value, Atomic64 new_value)

Atomic64	NoBarrier_AtomicExchange (volatile Atomic64 *ptr, Atomic64 new_value)

Atomic64	NoBarrier_AtomicIncrement (volatile Atomic64 *ptr, Atomic64 increment)

Atomic64	Barrier_AtomicIncrement (volatile Atomic64 *ptr, Atomic64 increment)

Atomic64	Acquire_CompareAndSwap (volatile Atomic64 *ptr, Atomic64 old_value, Atomic64 new_value)

Atomic64	Release_CompareAndSwap (volatile Atomic64 *ptr, Atomic64 old_value, Atomic64 new_value)

void	NoBarrier_Store (volatile Atomic64 *ptr, Atomic64 value)

void	Acquire_Store (volatile Atomic64 *ptr, Atomic64 value)

void	Release_Store (volatile Atomic64 *ptr, Atomic64 value)

Atomic64	NoBarrier_Load (volatile const Atomic64 *ptr)

Atomic64	Acquire_Load (volatile const Atomic64 *ptr)

Atomic64	Release_Load (volatile const Atomic64 *ptr)

LinuxKernelCmpxchgFunc pLinuxKernelCmpxchg	__attribute__ ((weak))

Atomic32	QNXCmpxchg (Atomic32 old_value, Atomic32 new_value, volatile Atomic32 *ptr)

AtomicWord	NoBarrier_CompareAndSwap (volatile AtomicWord *ptr, AtomicWord old_value, AtomicWord new_value)

AtomicWord	NoBarrier_AtomicExchange (volatile AtomicWord *ptr, AtomicWord new_value)

AtomicWord	NoBarrier_AtomicIncrement (volatile AtomicWord *ptr, AtomicWord increment)

AtomicWord	Barrier_AtomicIncrement (volatile AtomicWord *ptr, AtomicWord increment)

AtomicWord	Acquire_CompareAndSwap (volatile AtomicWord *ptr, AtomicWord old_value, AtomicWord new_value)

AtomicWord	Release_CompareAndSwap (volatile AtomicWord *ptr, AtomicWord old_value, AtomicWord new_value)

void	NoBarrier_Store (volatile AtomicWord *ptr, AtomicWord value)

void	Acquire_Store (volatile AtomicWord *ptr, AtomicWord value)

void	Release_Store (volatile AtomicWord *ptr, AtomicWord value)

AtomicWord	NoBarrier_Load (volatile const AtomicWord *ptr)

AtomicWord	Acquire_Load (volatile const AtomicWord *ptr)

AtomicWord	Release_Load (volatile const AtomicWord *ptr)

Atomic32	Acquire_AtomicExchange (volatile Atomic32 *ptr, Atomic32 new_value)

Atomic32	Release_AtomicExchange (volatile Atomic32 *ptr, Atomic32 new_value)

Atomic64	Acquire_AtomicExchange (volatile Atomic64 *ptr, Atomic64 new_value)

Atomic64	Release_AtomicExchange (volatile Atomic64 *ptr, Atomic64 new_value)

void LIBPROTOBUF_EXPORT	VerifyVersion (int headerVersion, int minLibraryVersion, const char *filename)

std::string LIBPROTOBUF_EXPORT	VersionString (int version)

template<typename To , typename From >
To	implicit_cast (From const &f)

template<typename To , typename From >
To	down_cast (From *f)

template<typename T >
T *	CheckNotNull (const char , int, const char name, T *val)

LIBPROTOBUF_EXPORT bool	IsStructurallyValidUTF8 (const char *buf, int len)

LIBPROTOBUF_EXPORT void	OnShutdown (void(*func)())

template<>
bool	WireFormatLite::ReadPrimitive< int32, WireFormatLite::TYPE_INT32 > (io::CodedInputStream input, int32 value)

template<>
bool	WireFormatLite::ReadPrimitive< int64, WireFormatLite::TYPE_INT64 > (io::CodedInputStream input, int64 value)

template<>
bool	WireFormatLite::ReadPrimitive< uint32, WireFormatLite::TYPE_UINT32 > (io::CodedInputStream input, uint32 value)

template<>
bool	WireFormatLite::ReadPrimitive< uint64, WireFormatLite::TYPE_UINT64 > (io::CodedInputStream input, uint64 value)

template<>
bool	WireFormatLite::ReadPrimitive< int32, WireFormatLite::TYPE_SINT32 > (io::CodedInputStream input, int32 value)

template<>
bool	WireFormatLite::ReadPrimitive< int64, WireFormatLite::TYPE_SINT64 > (io::CodedInputStream input, int64 value)

template<>
bool	WireFormatLite::ReadPrimitive< uint32, WireFormatLite::TYPE_FIXED32 > (io::CodedInputStream input, uint32 value)

template<>
bool	WireFormatLite::ReadPrimitive< uint64, WireFormatLite::TYPE_FIXED64 > (io::CodedInputStream input, uint64 value)

template<>
bool	WireFormatLite::ReadPrimitive< int32, WireFormatLite::TYPE_SFIXED32 > (io::CodedInputStream input, int32 value)

template<>
bool	WireFormatLite::ReadPrimitive< int64, WireFormatLite::TYPE_SFIXED64 > (io::CodedInputStream input, int64 value)

template<>
bool	WireFormatLite::ReadPrimitive< float, WireFormatLite::TYPE_FLOAT > (io::CodedInputStream input, float value)

template<>
bool	WireFormatLite::ReadPrimitive< double, WireFormatLite::TYPE_DOUBLE > (io::CodedInputStream input, double value)

template<>
bool	WireFormatLite::ReadPrimitive< bool, WireFormatLite::TYPE_BOOL > (io::CodedInputStream input, bool value)

template<>
bool	WireFormatLite::ReadPrimitive< int, WireFormatLite::TYPE_ENUM > (io::CodedInputStream input, int value)

template<>
const uint8 *	WireFormatLite::ReadPrimitiveFromArray< uint32, WireFormatLite::TYPE_FIXED32 > (const uint8 buffer, uint32 value)

template<>
const uint8 *	WireFormatLite::ReadPrimitiveFromArray< uint64, WireFormatLite::TYPE_FIXED64 > (const uint8 buffer, uint64 value)

template<>
const uint8 *	WireFormatLite::ReadPrimitiveFromArray< int32, WireFormatLite::TYPE_SFIXED32 > (const uint8 buffer, int32 value)

template<>
const uint8 *	WireFormatLite::ReadPrimitiveFromArray< int64, WireFormatLite::TYPE_SFIXED64 > (const uint8 buffer, int64 value)

template<>
const uint8 *	WireFormatLite::ReadPrimitiveFromArray< float, WireFormatLite::TYPE_FLOAT > (const uint8 buffer, float value)

template<>
const uint8 *	WireFormatLite::ReadPrimitiveFromArray< double, WireFormatLite::TYPE_DOUBLE > (const uint8 buffer, double value)

	READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE (uint32, TYPE_FIXED32)

	READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE (uint64, TYPE_FIXED64)

	READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE (int32, TYPE_SFIXED32)

	READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE (int64, TYPE_SFIXED64)

	READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE (float, TYPE_FLOAT)

	READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE (double, TYPE_DOUBLE)

Variables
LIBPROTOBUF_EXPORTconst::std::string *	empty_string_

LIBPROTOBUF_EXPORT ProtobufOnceType	empty_string_once_init_

static const int	kMinRepeatedFieldAllocationSize = 4

struct AtomicOps_x86CPUFeatureStruct	AtomicOps_Internalx86CPUFeatures

static const int	kMinHeaderVersionForLibrary = 2006000

static const int	kMinHeaderVersionForProtoc = 2006000

Typedef Documentation

typedef int32 google::protobuf::internal::Atomic32

typedef intptr_t google::protobuf::internal::AtomicWord

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

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

typedef false_type google::protobuf::internal::false_

typedef integral_constant<bool, false> google::protobuf::internal::false_type

typedef uint8 google::protobuf::internal::FieldType

typedef Atomic32(* google::protobuf::internal::LinuxKernelCmpxchgFunc)(Atomic32 old_value, Atomic32 new_value, volatile Atomic32 *ptr)

typedef void(* google::protobuf::internal::LinuxKernelMemoryBarrierFunc)(void)

typedef MutexLock google::protobuf::internal::ReaderMutexLock

typedef char google::protobuf::internal::small_

typedef true_type google::protobuf::internal::true_

typedef integral_constant<bool, true> google::protobuf::internal::true_type

typedef MutexLock google::protobuf::internal::WriterMutexLock

Function Documentation

LinuxKernelMemoryBarrierFunc pLinuxKernelMemoryBarrier google::protobuf::internal::__attribute__ ( (weak) )

Initial value:

=

(LinuxKernelMemoryBarrierFunc) 0xffff0fa0

google::protobuf::internal::LinuxKernelMemoryBarrierFunc

void(* LinuxKernelMemoryBarrierFunc)(void)

Definition: atomicops_internals_arm_gcc.h:53

Atomic32 google::protobuf::internal::Acquire_AtomicExchange	(	volatile Atomic32 *	ptr,
		Atomic32	new_value
	)

inline

  {
  return __tsan_atomic32_exchange(ptr, new_value,
  __tsan_memory_order_acquire);
 }

Atomic64 google::protobuf::internal::Acquire_AtomicExchange	(	volatile Atomic64 *	ptr,
		Atomic64	new_value
	)

inline

  {
  return __tsan_atomic64_exchange(ptr, new_value, __tsan_memory_order_acquire);
 }

AtomicWord google::protobuf::internal::Acquire_CompareAndSwap	(	volatile AtomicWord *	ptr,
		AtomicWord	old_value,
		AtomicWord	new_value
	)

inline

  {
  return Acquire_CompareAndSwap(
  reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value);
 }

Here is the call graph for this function:

Atomic32 google::protobuf::internal::Acquire_CompareAndSwap	(	volatile Atomic32 *	ptr,
		Atomic32	old_value,
		Atomic32	new_value
	)

inline

  {
  Atomic32 prev = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
  MemoryBarrier();
 
  return prev;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Atomic64 google::protobuf::internal::Acquire_CompareAndSwap	(	volatile Atomic64 *	ptr,
		Atomic64	old_value,
		Atomic64	new_value
	)

inline

  {
  Atomic64 prev = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
  MemoryBarrier();
 
  return prev;
 }

Here is the call graph for this function:

AtomicWord google::protobuf::internal::Acquire_Load ( volatile const AtomicWord * ptr )

inline

  {
  return Acquire_Load(reinterpret_cast<volatile const Atomic32*>(ptr));
 }

Here is the call graph for this function:

Atomic32 google::protobuf::internal::Acquire_Load ( volatile const Atomic32 * ptr )

inline

  {
  Atomic32 value;
 
  __asm__ __volatile__ ( // NOLINT
  "ldar %w[value], %[ptr] \n\t"
  : [value]"=r" (value)
  : [ptr]"Q" (*ptr)
  : "memory"
  ); // NOLINT
 
  return value;
 }

Here is the caller graph for this function:

Atomic64 google::protobuf::internal::Acquire_Load ( volatile const Atomic64 * ptr )

inline

  {
  Atomic64 value;
 
  __asm__ __volatile__ ( // NOLINT
  "ldar %x[value], %[ptr] \n\t"
  : [value]"=r" (value)
  : [ptr]"Q" (*ptr)
  : "memory"
  ); // NOLINT
 
  return value;
 }

void google::protobuf::internal::Acquire_Store	(	volatile AtomicWord *	ptr,
		AtomicWord	value
	)

inline

  {
  return Acquire_Store(reinterpret_cast<volatile Atomic32*>(ptr), value);
 }

Here is the call graph for this function:

void google::protobuf::internal::Acquire_Store	(	volatile Atomic32 *	ptr,
		Atomic32	value
	)

inline

  {
  *ptr = value;
  MemoryBarrier();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void google::protobuf::internal::Acquire_Store	(	volatile Atomic64 *	ptr,
		Atomic64	value
	)

inline

  {
  *ptr = value;
  MemoryBarrier();
 }

Here is the call graph for this function:

template<class Type >

bool google::protobuf::internal::AllAreInitialized ( const Type & t )

  {
  for (int i = t.size(); --i >= 0; ) {
  if (!t.Get(i).IsInitialized()) return false;
  }
  return true;
 }

AtomicWord google::protobuf::internal::Barrier_AtomicIncrement	(	volatile AtomicWord *	ptr,
		AtomicWord	increment
	)

inline

  {
  return Barrier_AtomicIncrement(
  reinterpret_cast<volatile Atomic32*>(ptr), increment);
 }

Here is the call graph for this function:

Atomic32 google::protobuf::internal::Barrier_AtomicIncrement	(	volatile Atomic32 *	ptr,
		Atomic32	increment
	)

inline

  {
  MemoryBarrier();
  Atomic32 result = NoBarrier_AtomicIncrement(ptr, increment);
  MemoryBarrier();
 
  return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Atomic64 google::protobuf::internal::Barrier_AtomicIncrement	(	volatile Atomic64 *	ptr,
		Atomic64	increment
	)

inline

  {
  MemoryBarrier();
  Atomic64 result = NoBarrier_AtomicIncrement(ptr, increment);
  MemoryBarrier();
 
  return result;
 }

Here is the call graph for this function:

template<typename Iter >

int google::protobuf::internal::CalculateReserve	(	Iter	begin,
		Iter	end,
		std::forward_iterator_tag
	)

inline

  {
  return std::distance(begin, end);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename Iter >

int google::protobuf::internal::CalculateReserve	(	Iter	,
		Iter	,
		std::input_iterator_tag
	)

inline

  {
  return -1;
 }

template<typename Iter >

int google::protobuf::internal::CalculateReserve	(	Iter	begin,
		Iter	end
	)

inline

  {
  typedef typename std::iterator_traits<Iter>::iterator_category Category;
  return CalculateReserve(begin, end, Category());
 }

Here is the call graph for this function:

template<typename T >

T* google::protobuf::internal::CheckNotNull	(	const char *	,
		int	,
		const char *	name,
		T *	val
	)

  {
  if (val == NULL) {
  GOOGLE_LOG(FATAL) << name;
  }
  return val;
 }

void google::protobuf::internal::DestroyDefaultRepeatedFields ( )

template<typename To , typename From >

To google::protobuf::internal::down_cast ( From * f )

inline

  { // so we only accept pointers
  // Ensures that To is a sub-type of From *. This test is here only
  // for compile-time type checking, and has no overhead in an
  // optimized build at run-time, as it will be optimized away
  // completely.
  if (false) {
  implicit_cast<From*, To>(0);
  }
 
 #if !defined(NDEBUG) && !defined(GOOGLE_PROTOBUF_NO_RTTI)
  assert(f == NULL || dynamic_cast<To>(f) != NULL); // RTTI: debug mode only!
 #endif
  return static_cast<To>(f);
 }

Here is the call graph for this function:

template<typename To , typename From >

To google::protobuf::internal::dynamic_cast_if_available ( From from )

inline

  {
 #if defined(GOOGLE_PROTOBUF_NO_RTTI) || (defined(_MSC_VER)&&!defined(_CPPRTTI))
  return NULL;
 #else
  return dynamic_cast<To>(from);
 #endif
 }

LIBPROTOBUF_EXPORTconst ::std::string& google::protobuf::internal::GetEmptyString ( )

inline

  {
  ::google::protobuf::GoogleOnceInit(&empty_string_once_init_, &InitEmptyString);
  return GetEmptyStringAlreadyInited();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

LIBPROTOBUF_EXPORTconst ::std::string& google::protobuf::internal::GetEmptyStringAlreadyInited ( )

inline

  {
  assert(empty_string_ != NULL);
  return *empty_string_;
 }

template<typename To , typename From >

To google::protobuf::internal::implicit_cast ( From const & f )

inline

  {
  return f;
 }

Here is the caller graph for this function:

LIBPROTOBUF_EXPORT double google::protobuf::internal::Infinity ( )

LIBPROTOBUF_EXPORT void google::protobuf::internal::InitEmptyString ( )

Here is the caller graph for this function:

void google::protobuf::internal::InitializeDefaultRepeatedFields ( )

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

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

void google::protobuf::internal::MemoryBarrier ( void )

inline

  {
  __asm__ __volatile__ ("dmb ish" ::: "memory"); // NOLINT
 }

Here is the caller graph for this function:

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

Here is the caller graph for this function:

LIBPROTOBUF_EXPORT double google::protobuf::internal::NaN ( )

AtomicWord google::protobuf::internal::NoBarrier_AtomicExchange	(	volatile AtomicWord *	ptr,
		AtomicWord	new_value
	)

inline

  {
  return NoBarrier_AtomicExchange(
  reinterpret_cast<volatile Atomic32*>(ptr), new_value);
 }

Here is the call graph for this function:

Atomic32 google::protobuf::internal::NoBarrier_AtomicExchange	(	volatile Atomic32 *	ptr,
		Atomic32	new_value
	)

inline

  {
  Atomic32 result;
  int32_t temp;
 
  __asm__ __volatile__ ( // NOLINT
  "0: \n\t"
  "ldxr %w[result], %[ptr] \n\t" // Load the previous value.
  "stxr %w[temp], %w[new_value], %[ptr] \n\t" // Try to store the new value.
  "cbnz %w[temp], 0b \n\t" // Retry if it did not work.
  : [result]"=&r" (result),
  [temp]"=&r" (temp),
  [ptr]"+Q" (*ptr)
  : [new_value]"r" (new_value)
  : "memory"
  ); // NOLINT
 
  return result;
 }

Here is the caller graph for this function:

Atomic64 google::protobuf::internal::NoBarrier_AtomicExchange	(	volatile Atomic64 *	ptr,
		Atomic64	new_value
	)

inline

  {
  Atomic64 result;
  int32_t temp;
 
  __asm__ __volatile__ ( // NOLINT
  "0: \n\t"
  "ldxr %[result], %[ptr] \n\t"
  "stxr %w[temp], %[new_value], %[ptr] \n\t"
  "cbnz %w[temp], 0b \n\t"
  : [result]"=&r" (result),
  [temp]"=&r" (temp),
  [ptr]"+Q" (*ptr)
  : [new_value]"r" (new_value)
  : "memory"
  ); // NOLINT
 
  return result;
 }

AtomicWord google::protobuf::internal::NoBarrier_AtomicIncrement	(	volatile AtomicWord *	ptr,
		AtomicWord	increment
	)

inline

  {
  return NoBarrier_AtomicIncrement(
  reinterpret_cast<volatile Atomic32*>(ptr), increment);
 }

Here is the call graph for this function:

Atomic32 google::protobuf::internal::NoBarrier_AtomicIncrement	(	volatile Atomic32 *	ptr,
		Atomic32	increment
	)

inline

  {
  Atomic32 result;
  int32_t temp;
 
  __asm__ __volatile__ ( // NOLINT
  "0: \n\t"
  "ldxr %w[result], %[ptr] \n\t" // Load the previous value.
  "add %w[result], %w[result], %w[increment]\n\t"
  "stxr %w[temp], %w[result], %[ptr] \n\t" // Try to store the result.
  "cbnz %w[temp], 0b \n\t" // Retry on failure.
  : [result]"=&r" (result),
  [temp]"=&r" (temp),
  [ptr]"+Q" (*ptr)
  : [increment]"IJr" (increment)
  : "memory"
  ); // NOLINT
 
  return result;
 }

Here is the caller graph for this function:

Atomic64 google::protobuf::internal::NoBarrier_AtomicIncrement	(	volatile Atomic64 *	ptr,
		Atomic64	increment
	)

inline

  {
  Atomic64 result;
  int32_t temp;
 
  __asm__ __volatile__ ( // NOLINT
  "0: \n\t"
  "ldxr %[result], %[ptr] \n\t"
  "add %[result], %[result], %[increment] \n\t"
  "stxr %w[temp], %[result], %[ptr] \n\t"
  "cbnz %w[temp], 0b \n\t"
  : [result]"=&r" (result),
  [temp]"=&r" (temp),
  [ptr]"+Q" (*ptr)
  : [increment]"IJr" (increment)
  : "memory"
  ); // NOLINT
 
  return result;
 }

AtomicWord google::protobuf::internal::NoBarrier_CompareAndSwap	(	volatile AtomicWord *	ptr,
		AtomicWord	old_value,
		AtomicWord	new_value
	)

inline

  {
  return NoBarrier_CompareAndSwap(
  reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value);
 }

Here is the call graph for this function:

Atomic32 google::protobuf::internal::NoBarrier_CompareAndSwap	(	volatile Atomic32 *	ptr,
		Atomic32	old_value,
		Atomic32	new_value
	)

inline

  {
  Atomic32 prev;
  int32_t temp;
 
  __asm__ __volatile__ ( // NOLINT
  "0: \n\t"
  "ldxr %w[prev], %[ptr] \n\t" // Load the previous value.
  "cmp %w[prev], %w[old_value] \n\t"
  "bne 1f \n\t"
  "stxr %w[temp], %w[new_value], %[ptr] \n\t" // Try to store the new value.
  "cbnz %w[temp], 0b \n\t" // Retry if it did not work.
  "1: \n\t"
  : [prev]"=&r" (prev),
  [temp]"=&r" (temp),
  [ptr]"+Q" (*ptr)
  : [old_value]"IJr" (old_value),
  [new_value]"r" (new_value)
  : "cc", "memory"
  ); // NOLINT
 
  return prev;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Atomic64 google::protobuf::internal::NoBarrier_CompareAndSwap	(	volatile Atomic64 *	ptr,
		Atomic64	old_value,
		Atomic64	new_value
	)

inline

  {
  Atomic64 prev;
  int32_t temp;
 
  __asm__ __volatile__ ( // NOLINT
  "0: \n\t"
  "ldxr %[prev], %[ptr] \n\t"
  "cmp %[prev], %[old_value] \n\t"
  "bne 1f \n\t"
  "stxr %w[temp], %[new_value], %[ptr] \n\t"
  "cbnz %w[temp], 0b \n\t"
  "1: \n\t"
  : [prev]"=&r" (prev),
  [temp]"=&r" (temp),
  [ptr]"+Q" (*ptr)
  : [old_value]"IJr" (old_value),
  [new_value]"r" (new_value)
  : "cc", "memory"
  ); // NOLINT
 
  return prev;
 }

Here is the call graph for this function:

AtomicWord google::protobuf::internal::NoBarrier_Load ( volatile const AtomicWord * ptr )

inline

  {
  return NoBarrier_Load(reinterpret_cast<volatile const Atomic32*>(ptr));
 }

Here is the call graph for this function:

Atomic32 google::protobuf::internal::NoBarrier_Load ( volatile const Atomic32 * ptr )

inline

  {
  return *ptr;
 }

Here is the caller graph for this function:

Atomic64 google::protobuf::internal::NoBarrier_Load ( volatile const Atomic64 * ptr )

inline

  {
  return *ptr;
 }

void google::protobuf::internal::NoBarrier_Store	(	volatile AtomicWord *	ptr,
		AtomicWord	value
	)

inline

  {
  NoBarrier_Store(reinterpret_cast<volatile Atomic32*>(ptr), value);
 }

Here is the call graph for this function:

void google::protobuf::internal::NoBarrier_Store	(	volatile Atomic32 *	ptr,
		Atomic32	value
	)

inline

  {
  *ptr = value;
 }

Here is the caller graph for this function:

void google::protobuf::internal::NoBarrier_Store	(	volatile Atomic64 *	ptr,
		Atomic64	value
	)

inline

  {
  *ptr = value;
 }

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

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

Here is the caller graph for this function:

template<typename EnumType >

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

  {
  int tmp;
  if (!ParseNamedEnum(descriptor, name, &tmp)) return false;
  *value = static_cast<EnumType>(tmp);
  return true;
 }

Here is the call graph for this function:

Atomic32 google::protobuf::internal::QNXCmpxchg	(	Atomic32	old_value,
		Atomic32	new_value,
		volatile Atomic32 *	ptr
	)

inline

  {
  return static_cast<Atomic32>(
  _smp_cmpxchg((volatile unsigned *)ptr,
  (unsigned)old_value,
  (unsigned)new_value));
 }

google::protobuf::internal::READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE	(	uint32	,
		TYPE_FIXED32
	)

google::protobuf::internal::READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE	(	uint64	,
		TYPE_FIXED64
	)

google::protobuf::internal::READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE	(	int32	,
		TYPE_SFIXED32
	)

google::protobuf::internal::READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE	(	int64	,
		TYPE_SFIXED64
	)

google::protobuf::internal::READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE	(	float	,
		TYPE_FLOAT
	)

google::protobuf::internal::READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE	(	double	,
		TYPE_DOUBLE
	)

Atomic32 google::protobuf::internal::Release_AtomicExchange	(	volatile Atomic32 *	ptr,
		Atomic32	new_value
	)

inline

  {
  return __tsan_atomic32_exchange(ptr, new_value,
  __tsan_memory_order_release);
 }

Atomic64 google::protobuf::internal::Release_AtomicExchange	(	volatile Atomic64 *	ptr,
		Atomic64	new_value
	)

inline

  {
  return __tsan_atomic64_exchange(ptr, new_value, __tsan_memory_order_release);
 }

AtomicWord google::protobuf::internal::Release_CompareAndSwap	(	volatile AtomicWord *	ptr,
		AtomicWord	old_value,
		AtomicWord	new_value
	)

inline

  {
  return Release_CompareAndSwap(
  reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value);
 }

Here is the call graph for this function:

Atomic32 google::protobuf::internal::Release_CompareAndSwap	(	volatile Atomic32 *	ptr,
		Atomic32	old_value,
		Atomic32	new_value
	)

inline

  {
  MemoryBarrier();
  Atomic32 prev = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
 
  return prev;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Atomic64 google::protobuf::internal::Release_CompareAndSwap	(	volatile Atomic64 *	ptr,
		Atomic64	old_value,
		Atomic64	new_value
	)

inline

  {
  MemoryBarrier();
  Atomic64 prev = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
 
  return prev;
 }

Here is the call graph for this function:

AtomicWord google::protobuf::internal::Release_Load ( volatile const AtomicWord * ptr )

inline

  {
  return Release_Load(reinterpret_cast<volatile const Atomic32*>(ptr));
 }

Here is the call graph for this function:

Atomic32 google::protobuf::internal::Release_Load ( volatile const Atomic32 * ptr )

inline

  {
  MemoryBarrier();
  return *ptr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Atomic64 google::protobuf::internal::Release_Load ( volatile const Atomic64 * ptr )

inline

                                                            {
   MemoryBarrier();
   return *ptr;
 }

Here is the call graph for this function:

void google::protobuf::internal::Release_Store	(	volatile AtomicWord *	ptr,
		AtomicWord	value
	)

inline

                                                                       {
   return Release_Store(reinterpret_cast<volatile Atomic32*>(ptr), value);
 }

Here is the call graph for this function:

void google::protobuf::internal::Release_Store	(	volatile Atomic32 *	ptr,
		Atomic32	value
	)

inline

                                                                   {
   __asm__ __volatile__ (  // NOLINT
     "stlr %w[value], %[ptr]  \n\t"
     : [ptr]"=Q" (*ptr)
     : [value]"r" (value)
     : "memory"
   );  // NOLINT
 }

Here is the caller graph for this function:

void google::protobuf::internal::Release_Store	(	volatile Atomic64 *	ptr,
		Atomic64	value
	)

inline

                                                                   {
   __asm__ __volatile__ (  // NOLINT
     "stlr %x[value], %[ptr]  \n\t"
     : [ptr]"=Q" (*ptr)
     : [value]"r" (value)
     : "memory"
   );  // NOLINT
 }

LIBPROTOBUF_EXPORT int google::protobuf::internal::StringSpaceUsedExcludingSelf ( const string & str )

Here is the caller graph for this function:

string google::protobuf::internal::ToString ( int i )

inline

                               {
   return SimpleItoa(i);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

string google::protobuf::internal::ToString ( string a )

inline

                                  {
   return a;
 }

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

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

template<>

bool google::protobuf::internal::WireFormatLite::ReadPrimitive< bool, WireFormatLite::TYPE_BOOL >	(	io::CodedInputStream *	input,
		bool *	value
	)

inline

                  {
   uint64 temp;
   if (!input->ReadVarint64(&temp)) return false;
   *value = temp != 0;
   return true;
 }

template<>

bool google::protobuf::internal::WireFormatLite::ReadPrimitive< double, WireFormatLite::TYPE_DOUBLE >	(	io::CodedInputStream *	input,
		double *	value
	)

inline

                    {
   uint64 temp;
   if (!input->ReadLittleEndian64(&temp)) return false;
   *value = DecodeDouble(temp);
   return true;
 }

template<>

bool google::protobuf::internal::WireFormatLite::ReadPrimitive< float, WireFormatLite::TYPE_FLOAT >	(	io::CodedInputStream *	input,
		float *	value
	)

inline

                   {
   uint32 temp;
   if (!input->ReadLittleEndian32(&temp)) return false;
   *value = DecodeFloat(temp);
   return true;
 }

template<>

bool google::protobuf::internal::WireFormatLite::ReadPrimitive< int, WireFormatLite::TYPE_ENUM >	(	io::CodedInputStream *	input,
		int *	value
	)

inline

                 {
   uint32 temp;
   if (!input->ReadVarint32(&temp)) return false;
   *value = static_cast<int>(temp);
   return true;
 }

template<>

bool google::protobuf::internal::WireFormatLite::ReadPrimitive< int32, WireFormatLite::TYPE_INT32 >	(	io::CodedInputStream *	input,
		int32 *	value
	)

inline

                   {
   uint32 temp;
   if (!input->ReadVarint32(&temp)) return false;
   *value = static_cast<int32>(temp);
   return true;
 }

template<>

bool google::protobuf::internal::WireFormatLite::ReadPrimitive< int32, WireFormatLite::TYPE_SFIXED32 >	(	io::CodedInputStream *	input,
		int32 *	value
	)

inline

                   {
   uint32 temp;
   if (!input->ReadLittleEndian32(&temp)) return false;
   *value = static_cast<int32>(temp);
   return true;
 }

template<>

bool google::protobuf::internal::WireFormatLite::ReadPrimitive< int32, WireFormatLite::TYPE_SINT32 >	(	io::CodedInputStream *	input,
		int32 *	value
	)

inline

                   {
   uint32 temp;
   if (!input->ReadVarint32(&temp)) return false;
   *value = ZigZagDecode32(temp);
   return true;
 }

template<>

bool google::protobuf::internal::WireFormatLite::ReadPrimitive< int64, WireFormatLite::TYPE_INT64 >	(	io::CodedInputStream *	input,
		int64 *	value
	)

inline

                   {
   uint64 temp;
   if (!input->ReadVarint64(&temp)) return false;
   *value = static_cast<int64>(temp);
   return true;
 }

template<>

bool google::protobuf::internal::WireFormatLite::ReadPrimitive< int64, WireFormatLite::TYPE_SFIXED64 >	(	io::CodedInputStream *	input,
		int64 *	value
	)

inline

                   {
   uint64 temp;
   if (!input->ReadLittleEndian64(&temp)) return false;
   *value = static_cast<int64>(temp);
   return true;
 }

template<>

bool google::protobuf::internal::WireFormatLite::ReadPrimitive< int64, WireFormatLite::TYPE_SINT64 >	(	io::CodedInputStream *	input,
		int64 *	value
	)

inline

                   {
   uint64 temp;
   if (!input->ReadVarint64(&temp)) return false;
   *value = ZigZagDecode64(temp);
   return true;
 }

template<>

bool google::protobuf::internal::WireFormatLite::ReadPrimitive< uint32, WireFormatLite::TYPE_FIXED32 >	(	io::CodedInputStream *	input,
		uint32 *	value
	)

inline

                    {
   return input->ReadLittleEndian32(value);
 }

template<>

bool google::protobuf::internal::WireFormatLite::ReadPrimitive< uint32, WireFormatLite::TYPE_UINT32 >	(	io::CodedInputStream *	input,
		uint32 *	value
	)

inline

                    {
   return input->ReadVarint32(value);
 }

template<>

bool google::protobuf::internal::WireFormatLite::ReadPrimitive< uint64, WireFormatLite::TYPE_FIXED64 >	(	io::CodedInputStream *	input,
		uint64 *	value
	)

inline

                    {
   return input->ReadLittleEndian64(value);
 }

template<>

bool google::protobuf::internal::WireFormatLite::ReadPrimitive< uint64, WireFormatLite::TYPE_UINT64 >	(	io::CodedInputStream *	input,
		uint64 *	value
	)

inline

                    {
   return input->ReadVarint64(value);
 }

template<>

const uint8* google::protobuf::internal::WireFormatLite::ReadPrimitiveFromArray< double, WireFormatLite::TYPE_DOUBLE >	(	const uint8 *	buffer,
		double *	value
	)

inline

                    {
   uint64 temp;
   buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
   *value = DecodeDouble(temp);
   return buffer;
 }

Here is the call graph for this function:

template<>

const uint8* google::protobuf::internal::WireFormatLite::ReadPrimitiveFromArray< float, WireFormatLite::TYPE_FLOAT >	(	const uint8 *	buffer,
		float *	value
	)

inline

                   {
   uint32 temp;
   buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
   *value = DecodeFloat(temp);
   return buffer;
 }

Here is the call graph for this function:

template<>

const uint8* google::protobuf::internal::WireFormatLite::ReadPrimitiveFromArray< int32, WireFormatLite::TYPE_SFIXED32 >	(	const uint8 *	buffer,
		int32 *	value
	)

inline

                   {
   uint32 temp;
   buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
   *value = static_cast<int32>(temp);
   return buffer;
 }

Here is the call graph for this function:

template<>

const uint8* google::protobuf::internal::WireFormatLite::ReadPrimitiveFromArray< int64, WireFormatLite::TYPE_SFIXED64 >	(	const uint8 *	buffer,
		int64 *	value
	)

inline

                   {
   uint64 temp;
   buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
   *value = static_cast<int64>(temp);
   return buffer;
 }

Here is the call graph for this function:

template<>

const uint8* google::protobuf::internal::WireFormatLite::ReadPrimitiveFromArray< uint32, WireFormatLite::TYPE_FIXED32 >	(	const uint8 *	buffer,
		uint32 *	value
	)

inline

                    {
   return io::CodedInputStream::ReadLittleEndian32FromArray(buffer, value);
 }

Here is the call graph for this function:

template<>

const uint8* google::protobuf::internal::WireFormatLite::ReadPrimitiveFromArray< uint64, WireFormatLite::TYPE_FIXED64 >	(	const uint8 *	buffer,
		uint64 *	value
	)

inline

                    {
   return io::CodedInputStream::ReadLittleEndian64FromArray(buffer, value);
 }

Here is the call graph for this function:

Variable Documentation

struct AtomicOps_x86CPUFeatureStruct google::protobuf::internal::AtomicOps_Internalx86CPUFeatures

LIBPROTOBUF_EXPORTconst ::std::string* google::protobuf::internal::empty_string_

LIBPROTOBUF_EXPORT ProtobufOnceType google::protobuf::internal::empty_string_once_init_

const int google::protobuf::internal::kMinHeaderVersionForLibrary = 2006000

static

const int google::protobuf::internal::kMinHeaderVersionForProtoc = 2006000

static

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

static

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation