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.h>
#include <google/protobuf/wire_format_lite_inl.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/unknown_field_set.h>

Namespaces
	google
	google::protobuf
	google.protobuf.internal

Macros
#define	HANDLE_PACKED_TYPE(TYPE, CPPTYPE, CPPTYPE_METHOD)
#define	HANDLE_TYPE(TYPE, CPPTYPE, CPPTYPE_METHOD)
#define	HANDLE_PRIMITIVE_TYPE(TYPE, CPPTYPE, TYPE_METHOD, CPPTYPE_METHOD)
#define	HANDLE_TYPE(TYPE, TYPE_METHOD, CPPTYPE_METHOD)
#define	HANDLE_TYPE(TYPE, TYPE_METHOD, CPPTYPE_METHOD)
#define	HANDLE_FIXED_TYPE(TYPE, TYPE_METHOD)

Macro Definition Documentation

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() ?                                         \
                message_reflection->GetRepeated##CPPTYPE_METHOD(             \
                  message, field, 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;