#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/wire_format_lite_inl.h>
-namespace google {
+#include <google/protobuf/port_def.inc>
+
const size_t kMapEntryTagByteSize = 2;
+namespace google {
namespace protobuf {
namespace internal {
// ===================================================================
-bool UnknownFieldSetFieldSkipper::SkipField(
- io::CodedInputStream* input, uint32 tag) {
+bool UnknownFieldSetFieldSkipper::SkipField(io::CodedInputStream* input,
+ uint32 tag) {
return WireFormat::SkipField(input, tag, unknown_fields_);
}
return WireFormat::SkipMessage(input, unknown_fields_);
}
-void UnknownFieldSetFieldSkipper::SkipUnknownEnum(
- int field_number, int value) {
+void UnknownFieldSetFieldSkipper::SkipUnknownEnum(int field_number, int value) {
unknown_fields_->AddVarint(field_number, value);
}
}
case WireFormatLite::WIRETYPE_START_GROUP: {
if (!input->IncrementRecursionDepth()) return false;
- if (!SkipMessage(input, (unknown_fields == NULL) ?
- NULL : unknown_fields->AddGroup(number))) {
+ if (!SkipMessage(input, (unknown_fields == NULL)
+ ? NULL
+ : unknown_fields->AddGroup(number))) {
return false;
}
input->DecrementRecursionDepth();
// Check that the ending tag matched the starting tag.
- if (!input->LastTagWas(WireFormatLite::MakeTag(
- WireFormatLite::GetTagFieldNumber(tag),
- WireFormatLite::WIRETYPE_END_GROUP))) {
+ if (!input->LastTagWas(
+ WireFormatLite::MakeTag(WireFormatLite::GetTagFieldNumber(tag),
+ WireFormatLite::WIRETYPE_END_GROUP))) {
return false;
}
return true;
io::CodedInputStream::Limit limit = input->PushLimit(length);
while (input->BytesUntilLimit() > 0) {
int value;
- if (!google::protobuf::internal::WireFormatLite::ReadPrimitive<
- int, WireFormatLite::TYPE_ENUM>(input, &value)) {
+ if (!WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
+ input, &value)) {
return false;
}
if (is_valid == NULL || is_valid(value)) {
return true;
}
-
void WireFormat::SerializeUnknownFields(const UnknownFieldSet& unknown_fields,
io::CodedOutputStream* output) {
for (int i = 0; i < unknown_fields.field_count(); i++) {
const UnknownField& field = unknown_fields.field(i);
switch (field.type()) {
case UnknownField::TYPE_VARINT:
- output->WriteVarint32(WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_VARINT));
+ output->WriteVarint32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_VARINT));
output->WriteVarint64(field.varint());
break;
case UnknownField::TYPE_FIXED32:
- output->WriteVarint32(WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_FIXED32));
+ output->WriteVarint32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_FIXED32));
output->WriteLittleEndian32(field.fixed32());
break;
case UnknownField::TYPE_FIXED64:
- output->WriteVarint32(WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_FIXED64));
+ output->WriteVarint32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_FIXED64));
output->WriteLittleEndian64(field.fixed64());
break;
case UnknownField::TYPE_LENGTH_DELIMITED:
- output->WriteVarint32(WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED));
+ output->WriteVarint32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED));
output->WriteVarint32(field.length_delimited().size());
output->WriteRawMaybeAliased(field.length_delimited().data(),
field.length_delimited().size());
break;
case UnknownField::TYPE_GROUP:
- output->WriteVarint32(WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_START_GROUP));
+ output->WriteVarint32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_START_GROUP));
SerializeUnknownFields(field.group(), output);
- output->WriteVarint32(WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_END_GROUP));
+ output->WriteVarint32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_END_GROUP));
break;
}
}
}
uint8* WireFormat::SerializeUnknownFieldsToArray(
- const UnknownFieldSet& unknown_fields,
- uint8* target) {
+ const UnknownFieldSet& unknown_fields, uint8* target) {
for (int i = 0; i < unknown_fields.field_count(); i++) {
const UnknownField& field = unknown_fields.field(i);
switch (field.type()) {
case UnknownField::TYPE_VARINT:
- target = WireFormatLite::WriteInt64ToArray(
- field.number(), field.varint(), target);
+ target = WireFormatLite::WriteInt64ToArray(field.number(),
+ field.varint(), target);
break;
case UnknownField::TYPE_FIXED32:
- target = WireFormatLite::WriteFixed32ToArray(
- field.number(), field.fixed32(), target);
+ target = WireFormatLite::WriteFixed32ToArray(field.number(),
+ field.fixed32(), target);
break;
case UnknownField::TYPE_FIXED64:
- target = WireFormatLite::WriteFixed64ToArray(
- field.number(), field.fixed64(), target);
+ target = WireFormatLite::WriteFixed64ToArray(field.number(),
+ field.fixed64(), target);
break;
case UnknownField::TYPE_LENGTH_DELIMITED:
target = WireFormatLite::WriteBytesToArray(
}
void WireFormat::SerializeUnknownMessageSetItems(
- const UnknownFieldSet& unknown_fields,
- io::CodedOutputStream* output) {
+ const UnknownFieldSet& unknown_fields, io::CodedOutputStream* output) {
for (int i = 0; i < unknown_fields.field_count(); i++) {
const UnknownField& field = unknown_fields.field(i);
// The only unknown fields that are allowed to exist in a MessageSet are
}
uint8* WireFormat::SerializeUnknownMessageSetItemsToArray(
- const UnknownFieldSet& unknown_fields,
- uint8* target) {
+ const UnknownFieldSet& unknown_fields, uint8* target) {
for (int i = 0; i < unknown_fields.field_count(); i++) {
const UnknownField& field = unknown_fields.field(i);
// Write type ID.
target = io::CodedOutputStream::WriteTagToArray(
WireFormatLite::kMessageSetTypeIdTag, target);
- target = io::CodedOutputStream::WriteVarint32ToArray(
- field.number(), target);
+ target =
+ io::CodedOutputStream::WriteVarint32ToArray(field.number(), target);
// Write message.
target = io::CodedOutputStream::WriteTagToArray(
switch (field.type()) {
case UnknownField::TYPE_VARINT:
- size += io::CodedOutputStream::VarintSize32(
- WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_VARINT));
+ size += io::CodedOutputStream::VarintSize32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_VARINT));
size += io::CodedOutputStream::VarintSize64(field.varint());
break;
case UnknownField::TYPE_FIXED32:
- size += io::CodedOutputStream::VarintSize32(
- WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_FIXED32));
+ size += io::CodedOutputStream::VarintSize32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_FIXED32));
size += sizeof(int32);
break;
case UnknownField::TYPE_FIXED64:
- size += io::CodedOutputStream::VarintSize32(
- WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_FIXED64));
+ size += io::CodedOutputStream::VarintSize32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_FIXED64));
size += sizeof(int64);
break;
case UnknownField::TYPE_LENGTH_DELIMITED:
- size += io::CodedOutputStream::VarintSize32(
- WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED));
+ size += io::CodedOutputStream::VarintSize32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_LENGTH_DELIMITED));
size += io::CodedOutputStream::VarintSize32(
field.length_delimited().size());
size += field.length_delimited().size();
break;
case UnknownField::TYPE_GROUP:
- size += io::CodedOutputStream::VarintSize32(
- WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_START_GROUP));
+ size += io::CodedOutputStream::VarintSize32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_START_GROUP));
size += ComputeUnknownFieldsSize(field.group());
- size += io::CodedOutputStream::VarintSize32(
- WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_END_GROUP));
+ size += io::CodedOutputStream::VarintSize32(WireFormatLite::MakeTag(
+ field.number(), WireFormatLite::WIRETYPE_END_GROUP));
break;
}
}
const Descriptor* descriptor = message->GetDescriptor();
const Reflection* message_reflection = message->GetReflection();
- while(true) {
+ while (true) {
uint32 tag = input->ReadTag();
if (tag == 0) {
// End of input. This is a valid place to end, so return true.
if (input->GetExtensionPool() == NULL) {
field = message_reflection->FindKnownExtensionByNumber(field_number);
} else {
- field = input->GetExtensionPool()
- ->FindExtensionByNumber(descriptor, field_number);
+ field = input->GetExtensionPool()->FindExtensionByNumber(
+ descriptor, field_number);
}
}
// If that failed, but we're a MessageSet, and this is the tag for a
// MessageSet item, then parse that.
- if (field == NULL &&
- descriptor->options().message_set_wire_format() &&
+ if (field == NULL && descriptor->options().message_set_wire_format() &&
tag == WireFormatLite::kMessageSetItemStartTag) {
if (!ParseAndMergeMessageSetItem(input, message)) {
return false;
UnknownFieldSet* unknown_fields) {
uint32 length;
if (!input->ReadVarint32(&length)) return false;
- return input->ReadString(
- unknown_fields->AddLengthDelimited(field_number), length);
+ return input->ReadString(unknown_fields->AddLengthDelimited(field_number),
+ length);
}
bool WireFormat::ParseAndMergeMessageSetField(uint32 field_number,
bool WireFormat::ParseAndMergeField(
uint32 tag,
- const FieldDescriptor* field, // May be NULL for unknown
- Message* message,
- io::CodedInputStream* input) {
+ const FieldDescriptor* field, // May be NULL for unknown
+ Message* message, io::CodedInputStream* input) {
const Reflection* message_reflection = message->GetReflection();
enum { UNKNOWN, NORMAL_FORMAT, PACKED_FORMAT } value_format;
value_format = NORMAL_FORMAT;
} else if (field->is_packable() &&
WireFormatLite::GetTagWireType(tag) ==
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
+ WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
value_format = PACKED_FORMAT;
} else {
// We don't recognize this field. Either the field number is unknown
switch (field->type()) {
#define HANDLE_PACKED_TYPE(TYPE, CPPTYPE, CPPTYPE_METHOD) \
- 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; \
- }
+ 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_PACKED_TYPE( INT32, int32, Int32)
- HANDLE_PACKED_TYPE( INT64, int64, Int64)
- HANDLE_PACKED_TYPE(SINT32, int32, Int32)
- HANDLE_PACKED_TYPE(SINT64, int64, Int64)
+ HANDLE_PACKED_TYPE(INT32, int32, Int32)
+ HANDLE_PACKED_TYPE(INT64, int64, Int64)
+ HANDLE_PACKED_TYPE(SINT32, int32, Int32)
+ HANDLE_PACKED_TYPE(SINT64, int64, Int64)
HANDLE_PACKED_TYPE(UINT32, uint32, UInt32)
HANDLE_PACKED_TYPE(UINT64, uint64, UInt64)
- HANDLE_PACKED_TYPE( FIXED32, uint32, UInt32)
- HANDLE_PACKED_TYPE( FIXED64, uint64, UInt64)
- HANDLE_PACKED_TYPE(SFIXED32, int32, Int32)
- HANDLE_PACKED_TYPE(SFIXED64, int64, Int64)
+ HANDLE_PACKED_TYPE(FIXED32, uint32, UInt32)
+ HANDLE_PACKED_TYPE(FIXED64, uint64, UInt64)
+ HANDLE_PACKED_TYPE(SFIXED32, int32, Int32)
+ HANDLE_PACKED_TYPE(SFIXED64, int64, Int64)
- HANDLE_PACKED_TYPE(FLOAT , float , Float )
+ HANDLE_PACKED_TYPE(FLOAT, float, Float)
HANDLE_PACKED_TYPE(DOUBLE, double, Double)
HANDLE_PACKED_TYPE(BOOL, bool, Bool)
while (input->BytesUntilLimit() > 0) {
int value;
if (!WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
- input, &value)) return false;
+ input, &value))
+ return false;
if (message->GetDescriptor()->file()->syntax() ==
FileDescriptor::SYNTAX_PROTO3) {
message_reflection->AddEnumValue(message, field, value);
// The enum value is not one of the known values. Add it to the
// UnknownFieldSet.
int64 sign_extended_value = static_cast<int64>(value);
- message_reflection->MutableUnknownFields(message)
- ->AddVarint(
- WireFormatLite::GetTagFieldNumber(tag),
- sign_extended_value);
+ message_reflection->MutableUnknownFields(message)->AddVarint(
+ WireFormatLite::GetTagFieldNumber(tag), sign_extended_value);
}
}
}
// Non-packed value (value_format == NORMAL_FORMAT)
switch (field->type()) {
#define HANDLE_TYPE(TYPE, CPPTYPE, CPPTYPE_METHOD) \
- 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; \
- }
+ 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( INT32, int32, Int32)
- HANDLE_TYPE( INT64, int64, Int64)
- HANDLE_TYPE(SINT32, int32, Int32)
- HANDLE_TYPE(SINT64, int64, Int64)
+ HANDLE_TYPE(INT32, int32, Int32)
+ HANDLE_TYPE(INT64, int64, Int64)
+ HANDLE_TYPE(SINT32, int32, Int32)
+ HANDLE_TYPE(SINT64, int64, Int64)
HANDLE_TYPE(UINT32, uint32, UInt32)
HANDLE_TYPE(UINT64, uint64, UInt64)
- HANDLE_TYPE( FIXED32, uint32, UInt32)
- HANDLE_TYPE( FIXED64, uint64, UInt64)
- HANDLE_TYPE(SFIXED32, int32, Int32)
- HANDLE_TYPE(SFIXED64, int64, Int64)
+ HANDLE_TYPE(FIXED32, uint32, UInt32)
+ HANDLE_TYPE(FIXED64, uint64, UInt64)
+ HANDLE_TYPE(SFIXED32, int32, Int32)
+ HANDLE_TYPE(SFIXED64, int64, Int64)
- HANDLE_TYPE(FLOAT , float , Float )
+ HANDLE_TYPE(FLOAT, float, Float)
HANDLE_TYPE(DOUBLE, double, Double)
HANDLE_TYPE(BOOL, bool, Bool)
case FieldDescriptor::TYPE_ENUM: {
int value;
if (!WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
- input, &value)) return false;
- if (message->GetDescriptor()->file()->syntax() ==
- FileDescriptor::SYNTAX_PROTO3) {
- if (field->is_repeated()) {
- message_reflection->AddEnumValue(message, field, value);
- } else {
- message_reflection->SetEnumValue(message, field, value);
- }
+ input, &value))
+ return false;
+ if (field->is_repeated()) {
+ message_reflection->AddEnumValue(message, field, value);
} else {
- const EnumValueDescriptor* enum_value =
- field->enum_type()->FindValueByNumber(value);
- if (enum_value != NULL) {
- if (field->is_repeated()) {
- message_reflection->AddEnum(message, field, enum_value);
- } else {
- message_reflection->SetEnum(message, field, enum_value);
- }
- } else {
- // The enum value is not one of the known values. Add it to the
- // UnknownFieldSet.
- int64 sign_extended_value = static_cast<int64>(value);
- message_reflection->MutableUnknownFields(message)
- ->AddVarint(
- WireFormatLite::GetTagFieldNumber(tag),
- sign_extended_value);
- }
+ message_reflection->SetEnumValue(message, field, value);
}
break;
}
// Handle strings separately so that we can optimize the ctype=CORD case.
case FieldDescriptor::TYPE_STRING: {
bool strict_utf8_check = StrictUtf8Check(field);
- string value;
+ std::string value;
if (!WireFormatLite::ReadString(input, &value)) return false;
if (strict_utf8_check) {
- if (!WireFormatLite::VerifyUtf8String(
- value.data(), value.length(), WireFormatLite::PARSE,
- field->full_name().c_str())) {
+ if (!WireFormatLite::VerifyUtf8String(value.data(), value.length(),
+ WireFormatLite::PARSE,
+ field->full_name().c_str())) {
return false;
}
} else {
}
case FieldDescriptor::TYPE_BYTES: {
- string value;
+ std::string value;
if (!WireFormatLite::ReadBytes(input, &value)) return false;
if (field->is_repeated()) {
message_reflection->AddString(message, field, value);
return true;
}
-bool WireFormat::ParseAndMergeMessageSetItem(
- io::CodedInputStream* input,
- Message* message) {
- const Reflection* message_reflection = message->GetReflection();
-
- // This method parses a group which should contain two fields:
- // required int32 type_id = 2;
- // required data message = 3;
-
- uint32 last_type_id = 0;
-
- // Once we see a type_id, we'll look up the FieldDescriptor for the
- // extension.
- const FieldDescriptor* field = NULL;
-
- // If we see message data before the type_id, we'll append it to this so
- // we can parse it later.
- string message_data;
-
- while (true) {
- uint32 tag = input->ReadTag();
- if (tag == 0) return false;
-
- switch (tag) {
- case WireFormatLite::kMessageSetTypeIdTag: {
- uint32 type_id;
- if (!input->ReadVarint32(&type_id)) return false;
- last_type_id = type_id;
- field = message_reflection->FindKnownExtensionByNumber(type_id);
-
- if (!message_data.empty()) {
- // We saw some message data before the type_id. Have to parse it
- // now.
- io::ArrayInputStream raw_input(message_data.data(),
- message_data.size());
- io::CodedInputStream sub_input(&raw_input);
- if (!ParseAndMergeMessageSetField(last_type_id, field, message,
- &sub_input)) {
- return false;
- }
- message_data.clear();
- }
-
- break;
- }
-
- case WireFormatLite::kMessageSetMessageTag: {
- if (last_type_id == 0) {
- // We haven't seen a type_id yet. Append this data to message_data.
- string temp;
- uint32 length;
- if (!input->ReadVarint32(&length)) return false;
- if (!input->ReadString(&temp, length)) return false;
- io::StringOutputStream output_stream(&message_data);
- io::CodedOutputStream coded_output(&output_stream);
- coded_output.WriteVarint32(length);
- coded_output.WriteString(temp);
- } else {
- // Already saw type_id, so we can parse this directly.
- if (!ParseAndMergeMessageSetField(last_type_id, field, message,
- input)) {
- return false;
- }
- }
+bool WireFormat::ParseAndMergeMessageSetItem(io::CodedInputStream* input,
+ Message* message) {
+ struct MSReflective {
+ bool ParseField(int type_id, io::CodedInputStream* input) {
+ const FieldDescriptor* field =
+ message_reflection->FindKnownExtensionByNumber(type_id);
+ return ParseAndMergeMessageSetField(type_id, field, message, input);
+ }
- break;
- }
+ bool SkipField(uint32 tag, io::CodedInputStream* input) {
+ return WireFormat::SkipField(input, tag, NULL);
+ }
- case WireFormatLite::kMessageSetItemEndTag: {
- return true;
- }
+ const Reflection* message_reflection;
+ Message* message;
+ };
- default: {
- if (!SkipField(input, tag, NULL)) return false;
- }
- }
- }
+ return ParseMessageSetItemImpl(
+ input, MSReflective{message->GetReflection(), message});
}
// ===================================================================
-void WireFormat::SerializeWithCachedSizes(
- const Message& message,
- int size, io::CodedOutputStream* output) {
+void WireFormat::SerializeWithCachedSizes(const Message& message, int size,
+ io::CodedOutputStream* output) {
const Descriptor* descriptor = message.GetDescriptor();
const Reflection* message_reflection = message.GetReflection();
int expected_endpoint = output->ByteCount() + size;
SerializeUnknownMessageSetItems(
message_reflection->GetUnknownFields(message), output);
} else {
- SerializeUnknownFields(
- message_reflection->GetUnknownFields(message), output);
+ SerializeUnknownFields(message_reflection->GetUnknownFields(message),
+ output);
}
GOOGLE_CHECK_EQ(output->ByteCount(), expected_endpoint)
- << ": Protocol message serialized to a size different from what was "
- "originally expected. Perhaps it was modified by another thread "
- "during serialization?";
+ << ": Protocol message serialized to a size different from what was "
+ "originally expected. Perhaps it was modified by another thread "
+ "during serialization?";
}
static void SerializeMapKeyWithCachedSizes(const FieldDescriptor* field,
SerializeMapValueRefWithCachedSizes(value_field, value, output);
}
-void WireFormat::SerializeFieldWithCachedSizes(
- const FieldDescriptor* field,
- const Message& message,
- io::CodedOutputStream* output) {
+void WireFormat::SerializeFieldWithCachedSizes(const FieldDescriptor* field,
+ const Message& message,
+ io::CodedOutputStream* output) {
const Reflection* message_reflection = message.GetReflection();
if (field->is_extension() &&
// internal state and existing references that came from map reflection remain
// valid for both reading and writing.
if (field->is_map()) {
- MapFieldBase* map_field =
- message_reflection->MapData(const_cast<Message*>(&message), field);
+ const MapFieldBase* map_field =
+ message_reflection->GetMapData(message, field);
if (map_field->IsMapValid()) {
if (output->IsSerializationDeterministic()) {
std::vector<MapKey> sorted_key_list =
const bool is_packed = field->is_packed();
if (is_packed && count > 0) {
WireFormatLite::WriteTag(field->number(),
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+ WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
const size_t data_size = FieldDataOnlyByteSize(field, message);
output->WriteVarint32(data_size);
}
for (int j = 0; j < count; j++) {
switch (field->type()) {
-#define HANDLE_PRIMITIVE_TYPE(TYPE, CPPTYPE, TYPE_METHOD, CPPTYPE_METHOD) \
- 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; \
- }
+#define HANDLE_PRIMITIVE_TYPE(TYPE, CPPTYPE, TYPE_METHOD, CPPTYPE_METHOD) \
+ 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_PRIMITIVE_TYPE( INT32, int32, Int32, Int32)
- HANDLE_PRIMITIVE_TYPE( INT64, int64, Int64, Int64)
- HANDLE_PRIMITIVE_TYPE(SINT32, int32, SInt32, Int32)
- HANDLE_PRIMITIVE_TYPE(SINT64, int64, SInt64, Int64)
+ HANDLE_PRIMITIVE_TYPE(INT32, int32, Int32, Int32)
+ HANDLE_PRIMITIVE_TYPE(INT64, int64, Int64, Int64)
+ HANDLE_PRIMITIVE_TYPE(SINT32, int32, SInt32, Int32)
+ HANDLE_PRIMITIVE_TYPE(SINT64, int64, SInt64, Int64)
HANDLE_PRIMITIVE_TYPE(UINT32, uint32, UInt32, UInt32)
HANDLE_PRIMITIVE_TYPE(UINT64, uint64, UInt64, UInt64)
- HANDLE_PRIMITIVE_TYPE( FIXED32, uint32, Fixed32, UInt32)
- HANDLE_PRIMITIVE_TYPE( FIXED64, uint64, Fixed64, UInt64)
- HANDLE_PRIMITIVE_TYPE(SFIXED32, int32, SFixed32, Int32)
- HANDLE_PRIMITIVE_TYPE(SFIXED64, int64, SFixed64, Int64)
+ HANDLE_PRIMITIVE_TYPE(FIXED32, uint32, Fixed32, UInt32)
+ HANDLE_PRIMITIVE_TYPE(FIXED64, uint64, Fixed64, UInt64)
+ HANDLE_PRIMITIVE_TYPE(SFIXED32, int32, SFixed32, Int32)
+ HANDLE_PRIMITIVE_TYPE(SFIXED64, int64, SFixed64, Int64)
- HANDLE_PRIMITIVE_TYPE(FLOAT , float , Float , Float )
+ HANDLE_PRIMITIVE_TYPE(FLOAT, float, Float, Float)
HANDLE_PRIMITIVE_TYPE(DOUBLE, double, Double, Double)
HANDLE_PRIMITIVE_TYPE(BOOL, bool, Bool, Bool)
#undef HANDLE_PRIMITIVE_TYPE
-#define HANDLE_TYPE(TYPE, TYPE_METHOD, CPPTYPE_METHOD) \
- 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;
+#define HANDLE_TYPE(TYPE, TYPE_METHOD, CPPTYPE_METHOD) \
+ 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(GROUP , Group , Message)
+ HANDLE_TYPE(GROUP, Group, Message)
HANDLE_TYPE(MESSAGE, Message, Message)
#undef HANDLE_TYPE
case FieldDescriptor::TYPE_ENUM: {
- const EnumValueDescriptor* value = field->is_repeated() ?
- message_reflection->GetRepeatedEnum(message, field, j) :
- message_reflection->GetEnum(message, field);
+ const EnumValueDescriptor* value =
+ field->is_repeated()
+ ? message_reflection->GetRepeatedEnum(message, field, j)
+ : message_reflection->GetEnum(message, field);
if (is_packed) {
WireFormatLite::WriteEnumNoTag(value->number(), output);
} else {
// instead of copying.
case FieldDescriptor::TYPE_STRING: {
bool strict_utf8_check = StrictUtf8Check(field);
- string scratch;
- const string& value = field->is_repeated() ?
- message_reflection->GetRepeatedStringReference(
- message, field, j, &scratch) :
- message_reflection->GetStringReference(message, field, &scratch);
+ std::string scratch;
+ const std::string& value =
+ field->is_repeated()
+ ? message_reflection->GetRepeatedStringReference(message, field,
+ j, &scratch)
+ : message_reflection->GetStringReference(message, field,
+ &scratch);
if (strict_utf8_check) {
WireFormatLite::VerifyUtf8String(value.data(), value.length(),
WireFormatLite::SERIALIZE,
}
case FieldDescriptor::TYPE_BYTES: {
- string scratch;
- const string& value = field->is_repeated() ?
- message_reflection->GetRepeatedStringReference(
- message, field, j, &scratch) :
- message_reflection->GetStringReference(message, field, &scratch);
+ std::string scratch;
+ const std::string& value =
+ field->is_repeated()
+ ? message_reflection->GetRepeatedStringReference(message, field,
+ j, &scratch)
+ : message_reflection->GetStringReference(message, field,
+ &scratch);
WireFormatLite::WriteBytes(field->number(), value, output);
break;
}
}
void WireFormat::SerializeMessageSetItemWithCachedSizes(
- const FieldDescriptor* field,
- const Message& message,
+ const FieldDescriptor* field, const Message& message,
io::CodedOutputStream* output) {
const Reflection* message_reflection = message.GetReflection();
if (descriptor->options().message_set_wire_format()) {
our_size += ComputeUnknownMessageSetItemsSize(
- message_reflection->GetUnknownFields(message));
+ message_reflection->GetUnknownFields(message));
} else {
- our_size += ComputeUnknownFieldsSize(
- message_reflection->GetUnknownFields(message));
+ our_size +=
+ ComputeUnknownFieldsSize(message_reflection->GetUnknownFields(message));
}
return our_size;
}
-size_t WireFormat::FieldByteSize(
- const FieldDescriptor* field,
- const Message& message) {
+size_t WireFormat::FieldByteSize(const FieldDescriptor* field,
+ const Message& message) {
const Reflection* message_reflection = message.GetReflection();
if (field->is_extension() &&
return 0;
}
-size_t WireFormat::FieldDataOnlyByteSize(
- const FieldDescriptor* field,
- const Message& message) {
+size_t WireFormat::FieldDataOnlyByteSize(const FieldDescriptor* field,
+ const Message& message) {
const Reflection* message_reflection = message.GetReflection();
size_t data_size = 0;
if (field->is_map()) {
- MapFieldBase* map_field =
- message_reflection->MapData(const_cast<Message*>(&message), field);
+ const MapFieldBase* map_field =
+ message_reflection->GetMapData(message, field);
if (map_field->IsMapValid()) {
MapIterator iter(const_cast<Message*>(&message), field);
MapIterator end(const_cast<Message*>(&message), field);
}
switch (field->type()) {
-#define HANDLE_TYPE(TYPE, TYPE_METHOD, CPPTYPE_METHOD) \
- 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;
+#define HANDLE_TYPE(TYPE, TYPE_METHOD, CPPTYPE_METHOD) \
+ 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;
-#define HANDLE_FIXED_TYPE(TYPE, TYPE_METHOD) \
- case FieldDescriptor::TYPE_##TYPE: \
- data_size += count * WireFormatLite::k##TYPE_METHOD##Size; \
- break;
+#define HANDLE_FIXED_TYPE(TYPE, TYPE_METHOD) \
+ case FieldDescriptor::TYPE_##TYPE: \
+ data_size += count * WireFormatLite::k##TYPE_METHOD##Size; \
+ break;
- HANDLE_TYPE( INT32, Int32, Int32)
- HANDLE_TYPE( INT64, Int64, Int64)
- HANDLE_TYPE(SINT32, SInt32, Int32)
- HANDLE_TYPE(SINT64, SInt64, Int64)
+ HANDLE_TYPE(INT32, Int32, Int32)
+ HANDLE_TYPE(INT64, Int64, Int64)
+ HANDLE_TYPE(SINT32, SInt32, Int32)
+ HANDLE_TYPE(SINT64, SInt64, Int64)
HANDLE_TYPE(UINT32, UInt32, UInt32)
HANDLE_TYPE(UINT64, UInt64, UInt64)
- HANDLE_FIXED_TYPE( FIXED32, Fixed32)
- HANDLE_FIXED_TYPE( FIXED64, Fixed64)
+ HANDLE_FIXED_TYPE(FIXED32, Fixed32)
+ HANDLE_FIXED_TYPE(FIXED64, Fixed64)
HANDLE_FIXED_TYPE(SFIXED32, SFixed32)
HANDLE_FIXED_TYPE(SFIXED64, SFixed64)
- HANDLE_FIXED_TYPE(FLOAT , Float )
+ HANDLE_FIXED_TYPE(FLOAT, Float)
HANDLE_FIXED_TYPE(DOUBLE, Double)
HANDLE_FIXED_TYPE(BOOL, Bool)
- HANDLE_TYPE(GROUP , Group , Message)
+ HANDLE_TYPE(GROUP, Group, Message)
HANDLE_TYPE(MESSAGE, Message, Message)
#undef HANDLE_TYPE
#undef HANDLE_FIXED_TYPE
if (field->is_repeated()) {
for (int j = 0; j < count; j++) {
data_size += WireFormatLite::EnumSize(
- message_reflection->GetRepeatedEnum(message, field, j)->number());
+ message_reflection->GetRepeatedEnum(message, field, j)->number());
}
} else {
data_size += WireFormatLite::EnumSize(
- message_reflection->GetEnum(message, field)->number());
+ message_reflection->GetEnum(message, field)->number());
}
break;
}
case FieldDescriptor::TYPE_STRING:
case FieldDescriptor::TYPE_BYTES: {
for (int j = 0; j < count; j++) {
- string scratch;
- const string& value = field->is_repeated() ?
- message_reflection->GetRepeatedStringReference(
- message, field, j, &scratch) :
- message_reflection->GetStringReference(message, field, &scratch);
+ std::string scratch;
+ const std::string& value =
+ field->is_repeated()
+ ? message_reflection->GetRepeatedStringReference(message, field,
+ j, &scratch)
+ : message_reflection->GetStringReference(message, field,
+ &scratch);
data_size += WireFormatLite::StringSize(value);
}
break;
return data_size;
}
-size_t WireFormat::MessageSetItemByteSize(
- const FieldDescriptor* field,
- const Message& message) {
+size_t WireFormat::MessageSetItemByteSize(const FieldDescriptor* field,
+ const Message& message) {
const Reflection* message_reflection = message.GetReflection();
size_t our_size = WireFormatLite::kMessageSetItemTagsSize;
projects / platform / upstream / protobuf.git / blobdiff