wire_format.cc File Reference

#include <stack>
#include <string>
#include <vector>
#include <google/protobuf/wire_format.h>
#include <google/protobuf/stubs/logging.h>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/stringprintf.h>
#include <google/protobuf/descriptor.pb.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/io/zero_copy_stream.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/dynamic_message.h>
#include <google/protobuf/map_field.h>
#include <google/protobuf/map_field_inl.h>
#include <google/protobuf/unknown_field_set.h>
#include <google/protobuf/port_def.inc>

Include dependency graph for wire_format.cc:

Go to the source code of this file.

Classes
class	google::protobuf.internal::MapKeySorter::MapKeyComparator
class	google::protobuf.internal::MapKeySorter

Namespaces
	google
	google::protobuf
	google.protobuf.internal

Macros
#define	CASE_TYPE(CppType, CamelCppType)
#define	CASE_TYPE(FieldType, CamelFieldType, CamelCppType)
#define	CASE_TYPE(FieldType, CamelFieldType, CamelCppType)
#define	CASE_TYPE(FieldType, CamelFieldType, CamelCppType)
#define	CASE_TYPE(FieldType, CamelFieldType, CamelCppType)
#define	FIXED_CASE_TYPE(FieldType, CamelFieldType)
#define	FIXED_CASE_TYPE(FieldType, CamelFieldType)
#define	HANDLE_FIXED_TYPE(TYPE, TYPE_METHOD)
#define	HANDLE_PACKED_TYPE(TYPE, CPPTYPE, CPPTYPE_METHOD)
#define	HANDLE_PRIMITIVE_TYPE(TYPE, CPPTYPE, TYPE_METHOD, CPPTYPE_METHOD)
#define	HANDLE_TYPE(TYPE, CPPTYPE, CPPTYPE_METHOD)
#define	HANDLE_TYPE(TYPE, TYPE_METHOD, CPPTYPE_METHOD)
#define	HANDLE_TYPE(TYPE, TYPE_METHOD, CPPTYPE_METHOD)

Functions
static size_t	google.protobuf.internal::MapKeyDataOnlyByteSize (const FieldDescriptor *field, const MapKey &value)
static size_t	google.protobuf.internal::MapValueRefDataOnlyByteSize (const FieldDescriptor *field, const MapValueRef &value)
static void	google.protobuf.internal::SerializeMapEntry (const FieldDescriptor *field, const MapKey &key, const MapValueRef &value, io::CodedOutputStream *output)
static void	google.protobuf.internal::SerializeMapKeyWithCachedSizes (const FieldDescriptor *field, const MapKey &value, io::CodedOutputStream *output)
static void	google.protobuf.internal::SerializeMapValueRefWithCachedSizes (const FieldDescriptor *field, const MapValueRef &value, io::CodedOutputStream *output)
static bool	google.protobuf.internal::StrictUtf8Check (const FieldDescriptor *field)

Variables
const size_t	kMapEntryTagByteSize = 2

Macro Definition Documentation

CASE_TYPE [1/5]

#define CASE_TYPE	(		CppType,
			CamelCppType
	)

Value:

  case FieldDescriptor::CPPTYPE_##CppType: {                            \
    return a.Get##CamelCppType##Value() < b.Get##CamelCppType##Value(); \
  }

CASE_TYPE [2/5]

#define CASE_TYPE	(		FieldType,
			CamelFieldType,
			CamelCppType
	)

Value:

  case FieldDescriptor::TYPE_##FieldType:                                      \
    WireFormatLite::Write##CamelFieldType(1, value.Get##CamelCppType##Value(), \
                                          output);                             \
    break;

CASE_TYPE [3/5]

#define CASE_TYPE	(		FieldType,
			CamelFieldType,
			CamelCppType
	)

Value:

  case FieldDescriptor::TYPE_##FieldType:                                      \
    WireFormatLite::Write##CamelFieldType(2, value.Get##CamelCppType##Value(), \
                                          output);                             \
    break;

CASE_TYPE [4/5]

#define CASE_TYPE	(		FieldType,
			CamelFieldType,
			CamelCppType
	)

Value:

  case FieldDescriptor::TYPE_##FieldType:                  \
    return WireFormatLite::CamelFieldType##Size(           \
        value.Get##CamelCppType##Value());

CASE_TYPE [5/5]

#define CASE_TYPE	(		FieldType,
			CamelFieldType,
			CamelCppType
	)

Value:

  case FieldDescriptor::TYPE_##FieldType:                  \
    return WireFormatLite::CamelFieldType##Size(           \
        value.Get##CamelCppType##Value());

FIXED_CASE_TYPE [1/2]

#define FIXED_CASE_TYPE	(		FieldType,
			CamelFieldType
	)

Value:

  case FieldDescriptor::TYPE_##FieldType:          \
    return WireFormatLite::k##CamelFieldType##Size;

FIXED_CASE_TYPE [2/2]

#define FIXED_CASE_TYPE	(		FieldType,
			CamelFieldType
	)

Value:

  case FieldDescriptor::TYPE_##FieldType:          \
    return WireFormatLite::k##CamelFieldType##Size;

HANDLE_FIXED_TYPE

#define HANDLE_FIXED_TYPE	(		TYPE,
			TYPE_METHOD
	)

Value:

  case FieldDescriptor::TYPE_##TYPE:                           \
    data_size += count * WireFormatLite::k##TYPE_METHOD##Size; \
    break;

HANDLE_PACKED_TYPE

#define HANDLE_PACKED_TYPE	(		TYPE,
			CPPTYPE,
			CPPTYPE_METHOD
	)

Value:

  case FieldDescriptor::TYPE_##TYPE: {                                         \
    while (input->BytesUntilLimit() > 0) {                                     \
      CPPTYPE value;                                                           \
      if (!WireFormatLite::ReadPrimitive<CPPTYPE,                              \
                                         WireFormatLite::TYPE_##TYPE>(input,   \
                                                                      &value)) \
        return false;                                                          \
      message_reflection->Add##CPPTYPE_METHOD(message, field, value);          \
    }                                                                          \
    break;                                                                     \
  }

HANDLE_PRIMITIVE_TYPE

#define HANDLE_PRIMITIVE_TYPE	(		TYPE,
			CPPTYPE,
			TYPE_METHOD,
			CPPTYPE_METHOD
	)

Value:

  case FieldDescriptor::TYPE_##TYPE: {                                        \
    const CPPTYPE value =                                                     \
        field->is_repeated()                                                  \
            ? message_reflection->GetRepeated##CPPTYPE_METHOD(message, field, \
                                                              j)              \
            : message_reflection->Get##CPPTYPE_METHOD(message, field);        \
    if (is_packed) {                                                          \
      WireFormatLite::Write##TYPE_METHOD##NoTag(value, output);               \
    } else {                                                                  \
      WireFormatLite::Write##TYPE_METHOD(field->number(), value, output);     \
    }                                                                         \
    break;                                                                    \
  }

HANDLE_TYPE [1/3]

#define HANDLE_TYPE	(		TYPE,
			CPPTYPE,
			CPPTYPE_METHOD
	)

Value:

  case FieldDescriptor::TYPE_##TYPE: {                                        \
    CPPTYPE value;                                                            \
    if (!WireFormatLite::ReadPrimitive<CPPTYPE, WireFormatLite::TYPE_##TYPE>( \
            input, &value))                                                   \
      return false;                                                           \
    if (field->is_repeated()) {                                               \
      message_reflection->Add##CPPTYPE_METHOD(message, field, value);         \
    } else {                                                                  \
      message_reflection->Set##CPPTYPE_METHOD(message, field, value);         \
    }                                                                         \
    break;                                                                    \
  }

HANDLE_TYPE [2/3]

#define HANDLE_TYPE	(		TYPE,
			TYPE_METHOD,
			CPPTYPE_METHOD
	)

Value:

  case FieldDescriptor::TYPE_##TYPE:                                           \
    WireFormatLite::Write##TYPE_METHOD(                                        \
        field->number(),                                                       \
        field->is_repeated()                                                   \
            ? (map_entries.empty()                                             \
                   ? message_reflection->GetRepeated##CPPTYPE_METHOD(message,  \
                                                                     field, j) \
                   : *map_entries[j])                                          \
            : message_reflection->Get##CPPTYPE_METHOD(message, field),         \
        output);                                                               \
    break;

HANDLE_TYPE [3/3]

#define HANDLE_TYPE	(		TYPE,
			TYPE_METHOD,
			CPPTYPE_METHOD
	)

Value:

  case FieldDescriptor::TYPE_##TYPE:                                        \
    if (field->is_repeated()) {                                             \
      for (int j = 0; j < count; j++) {                                     \
        data_size += WireFormatLite::TYPE_METHOD##Size(                     \
            message_reflection->GetRepeated##CPPTYPE_METHOD(message, field, \
                                                            j));            \
      }                                                                     \
    } else {                                                                \
      data_size += WireFormatLite::TYPE_METHOD##Size(                       \
          message_reflection->Get##CPPTYPE_METHOD(message, field));         \
    }                                                                       \
    break;

Variable Documentation

kMapEntryTagByteSize

const size_t kMapEntryTagByteSize = 2

Definition at line 57 of file wire_format.cc.