/thirdparty/breakpad/third_party/protobuf/protobuf/src/google/protobuf/wire_format.cc
http://github.com/tomahawk-player/tomahawk · C++ · 1069 lines · 827 code · 144 blank · 98 comment · 155 complexity · 21ec333087711b3d30a42abc592ab3b7 MD5 · raw file
- // Protocol Buffers - Google's data interchange format
- // Copyright 2008 Google Inc. All rights reserved.
- // http://code.google.com/p/protobuf/
- //
- // Redistribution and use in source and binary forms, with or without
- // modification, are permitted provided that the following conditions are
- // met:
- //
- // * Redistributions of source code must retain the above copyright
- // notice, this list of conditions and the following disclaimer.
- // * Redistributions in binary form must reproduce the above
- // copyright notice, this list of conditions and the following disclaimer
- // in the documentation and/or other materials provided with the
- // distribution.
- // * Neither the name of Google Inc. nor the names of its
- // contributors may be used to endorse or promote products derived from
- // this software without specific prior written permission.
- //
- // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- // Author: kenton@google.com (Kenton Varda)
- // Based on original Protocol Buffers design by
- // Sanjay Ghemawat, Jeff Dean, and others.
- #include <stack>
- #include <string>
- #include <vector>
- #include <google/protobuf/wire_format.h>
- #include <google/protobuf/stubs/common.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>
- namespace google {
- namespace protobuf {
- namespace internal {
- using internal::WireFormatLite;
- namespace {
- // This function turns out to be convenient when using some macros later.
- inline int GetEnumNumber(const EnumValueDescriptor* descriptor) {
- return descriptor->number();
- }
- } // anonymous namespace
- // ===================================================================
- bool UnknownFieldSetFieldSkipper::SkipField(
- io::CodedInputStream* input, uint32 tag) {
- return WireFormat::SkipField(input, tag, unknown_fields_);
- }
- bool UnknownFieldSetFieldSkipper::SkipMessage(io::CodedInputStream* input) {
- return WireFormat::SkipMessage(input, unknown_fields_);
- }
- void UnknownFieldSetFieldSkipper::SkipUnknownEnum(
- int field_number, int value) {
- unknown_fields_->AddVarint(field_number, value);
- }
- bool WireFormat::SkipField(io::CodedInputStream* input, uint32 tag,
- UnknownFieldSet* unknown_fields) {
- int number = WireFormatLite::GetTagFieldNumber(tag);
- switch (WireFormatLite::GetTagWireType(tag)) {
- case WireFormatLite::WIRETYPE_VARINT: {
- uint64 value;
- if (!input->ReadVarint64(&value)) return false;
- if (unknown_fields != NULL) unknown_fields->AddVarint(number, value);
- return true;
- }
- case WireFormatLite::WIRETYPE_FIXED64: {
- uint64 value;
- if (!input->ReadLittleEndian64(&value)) return false;
- if (unknown_fields != NULL) unknown_fields->AddFixed64(number, value);
- return true;
- }
- case WireFormatLite::WIRETYPE_LENGTH_DELIMITED: {
- uint32 length;
- if (!input->ReadVarint32(&length)) return false;
- if (unknown_fields == NULL) {
- if (!input->Skip(length)) return false;
- } else {
- if (!input->ReadString(unknown_fields->AddLengthDelimited(number),
- length)) {
- return false;
- }
- }
- return true;
- }
- case WireFormatLite::WIRETYPE_START_GROUP: {
- if (!input->IncrementRecursionDepth()) return false;
- 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))) {
- return false;
- }
- return true;
- }
- case WireFormatLite::WIRETYPE_END_GROUP: {
- return false;
- }
- case WireFormatLite::WIRETYPE_FIXED32: {
- uint32 value;
- if (!input->ReadLittleEndian32(&value)) return false;
- if (unknown_fields != NULL) unknown_fields->AddFixed32(number, value);
- return true;
- }
- default: {
- return false;
- }
- }
- }
- bool WireFormat::SkipMessage(io::CodedInputStream* input,
- UnknownFieldSet* unknown_fields) {
- while(true) {
- uint32 tag = input->ReadTag();
- if (tag == 0) {
- // End of input. This is a valid place to end, so return true.
- return true;
- }
- WireFormatLite::WireType wire_type = WireFormatLite::GetTagWireType(tag);
- if (wire_type == WireFormatLite::WIRETYPE_END_GROUP) {
- // Must be the end of the message.
- return true;
- }
- if (!SkipField(input, tag, unknown_fields)) return false;
- }
- }
- 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->WriteVarint64(field.varint());
- break;
- case UnknownField::TYPE_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->WriteLittleEndian64(field.fixed64());
- break;
- case UnknownField::TYPE_LENGTH_DELIMITED:
- output->WriteVarint32(WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED));
- output->WriteVarint32(field.length_delimited().size());
- output->WriteString(field.length_delimited());
- break;
- case UnknownField::TYPE_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));
- break;
- }
- }
- }
- uint8* WireFormat::SerializeUnknownFieldsToArray(
- 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);
- break;
- case UnknownField::TYPE_FIXED32:
- target = WireFormatLite::WriteFixed32ToArray(
- field.number(), field.fixed32(), target);
- break;
- case UnknownField::TYPE_FIXED64:
- target = WireFormatLite::WriteFixed64ToArray(
- field.number(), field.fixed64(), target);
- break;
- case UnknownField::TYPE_LENGTH_DELIMITED:
- target = WireFormatLite::WriteBytesToArray(
- field.number(), field.length_delimited(), target);
- break;
- case UnknownField::TYPE_GROUP:
- target = WireFormatLite::WriteTagToArray(
- field.number(), WireFormatLite::WIRETYPE_START_GROUP, target);
- target = SerializeUnknownFieldsToArray(field.group(), target);
- target = WireFormatLite::WriteTagToArray(
- field.number(), WireFormatLite::WIRETYPE_END_GROUP, target);
- break;
- }
- }
- return target;
- }
- void WireFormat::SerializeUnknownMessageSetItems(
- 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
- // messages, which are length-delimited.
- if (field.type() == UnknownField::TYPE_LENGTH_DELIMITED) {
- const string& data = field.length_delimited();
- // Start group.
- output->WriteVarint32(WireFormatLite::kMessageSetItemStartTag);
- // Write type ID.
- output->WriteVarint32(WireFormatLite::kMessageSetTypeIdTag);
- output->WriteVarint32(field.number());
- // Write message.
- output->WriteVarint32(WireFormatLite::kMessageSetMessageTag);
- output->WriteVarint32(data.size());
- output->WriteString(data);
- // End group.
- output->WriteVarint32(WireFormatLite::kMessageSetItemEndTag);
- }
- }
- }
- uint8* WireFormat::SerializeUnknownMessageSetItemsToArray(
- const UnknownFieldSet& unknown_fields,
- uint8* target) {
- 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
- // messages, which are length-delimited.
- if (field.type() == UnknownField::TYPE_LENGTH_DELIMITED) {
- const string& data = field.length_delimited();
- // Start group.
- target = io::CodedOutputStream::WriteTagToArray(
- WireFormatLite::kMessageSetItemStartTag, target);
- // Write type ID.
- target = io::CodedOutputStream::WriteTagToArray(
- WireFormatLite::kMessageSetTypeIdTag, target);
- target = io::CodedOutputStream::WriteVarint32ToArray(
- field.number(), target);
- // Write message.
- target = io::CodedOutputStream::WriteTagToArray(
- WireFormatLite::kMessageSetMessageTag, target);
- target = io::CodedOutputStream::WriteVarint32ToArray(data.size(), target);
- target = io::CodedOutputStream::WriteStringToArray(data, target);
- // End group.
- target = io::CodedOutputStream::WriteTagToArray(
- WireFormatLite::kMessageSetItemEndTag, target);
- }
- }
- return target;
- }
- int WireFormat::ComputeUnknownFieldsSize(
- const UnknownFieldSet& unknown_fields) {
- int size = 0;
- for (int i = 0; i < unknown_fields.field_count(); i++) {
- const UnknownField& field = unknown_fields.field(i);
- switch (field.type()) {
- case UnknownField::TYPE_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 += sizeof(int32);
- break;
- case UnknownField::TYPE_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(
- 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 += ComputeUnknownFieldsSize(field.group());
- size += io::CodedOutputStream::VarintSize32(
- WireFormatLite::MakeTag(field.number(),
- WireFormatLite::WIRETYPE_END_GROUP));
- break;
- }
- }
- return size;
- }
- int WireFormat::ComputeUnknownMessageSetItemsSize(
- const UnknownFieldSet& unknown_fields) {
- int size = 0;
- 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
- // messages, which are length-delimited.
- if (field.type() == UnknownField::TYPE_LENGTH_DELIMITED) {
- size += WireFormatLite::kMessageSetItemTagsSize;
- size += io::CodedOutputStream::VarintSize32(field.number());
- size += io::CodedOutputStream::VarintSize32(
- field.length_delimited().size());
- size += field.length_delimited().size();
- }
- }
- return size;
- }
- // ===================================================================
- bool WireFormat::ParseAndMergePartial(io::CodedInputStream* input,
- Message* message) {
- const Descriptor* descriptor = message->GetDescriptor();
- const Reflection* message_reflection = message->GetReflection();
- while(true) {
- uint32 tag = input->ReadTag();
- if (tag == 0) {
- // End of input. This is a valid place to end, so return true.
- return true;
- }
- if (WireFormatLite::GetTagWireType(tag) ==
- WireFormatLite::WIRETYPE_END_GROUP) {
- // Must be the end of the message.
- return true;
- }
- const FieldDescriptor* field = NULL;
- if (descriptor != NULL) {
- int field_number = WireFormatLite::GetTagFieldNumber(tag);
- field = descriptor->FindFieldByNumber(field_number);
- // If that failed, check if the field is an extension.
- if (field == NULL && descriptor->IsExtensionNumber(field_number)) {
- if (input->GetExtensionPool() == NULL) {
- field = message_reflection->FindKnownExtensionByNumber(field_number);
- } else {
- 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() &&
- tag == WireFormatLite::kMessageSetItemStartTag) {
- if (!ParseAndMergeMessageSetItem(input, message)) {
- return false;
- }
- continue; // Skip ParseAndMergeField(); already taken care of.
- }
- }
- if (!ParseAndMergeField(tag, field, message, input)) {
- return false;
- }
- }
- }
- bool WireFormat::ParseAndMergeField(
- uint32 tag,
- 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;
- if (field == NULL) {
- value_format = UNKNOWN;
- } else if (WireFormatLite::GetTagWireType(tag) ==
- WireTypeForFieldType(field->type())) {
- value_format = NORMAL_FORMAT;
- } else if (field->is_packable() &&
- WireFormatLite::GetTagWireType(tag) ==
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
- value_format = PACKED_FORMAT;
- } else {
- // We don't recognize this field. Either the field number is unknown
- // or the wire type doesn't match. Put it in our unknown field set.
- value_format = UNKNOWN;
- }
- if (value_format == UNKNOWN) {
- return SkipField(input, tag,
- message_reflection->MutableUnknownFields(message));
- } else if (value_format == PACKED_FORMAT) {
- uint32 length;
- if (!input->ReadVarint32(&length)) return false;
- io::CodedInputStream::Limit limit = input->PushLimit(length);
- 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; \
- }
- 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(FLOAT , float , Float )
- HANDLE_PACKED_TYPE(DOUBLE, double, Double)
- HANDLE_PACKED_TYPE(BOOL, bool, Bool)
- #undef HANDLE_PACKED_TYPE
- case FieldDescriptor::TYPE_ENUM: {
- while (input->BytesUntilLimit() > 0) {
- int value;
- if (!WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
- input, &value)) return false;
- const EnumValueDescriptor* enum_value =
- field->enum_type()->FindValueByNumber(value);
- if (enum_value != NULL) {
- message_reflection->AddEnum(message, field, enum_value);
- }
- }
- break;
- }
- case FieldDescriptor::TYPE_STRING:
- case FieldDescriptor::TYPE_GROUP:
- case FieldDescriptor::TYPE_MESSAGE:
- case FieldDescriptor::TYPE_BYTES:
- // Can't have packed fields of these types: these should be caught by
- // the protocol compiler.
- return false;
- break;
- }
- input->PopLimit(limit);
- } else {
- // 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; \
- }
- 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(FLOAT , float , Float )
- HANDLE_TYPE(DOUBLE, double, Double)
- HANDLE_TYPE(BOOL, bool, Bool)
- #undef HANDLE_TYPE
- case FieldDescriptor::TYPE_ENUM: {
- int value;
- if (!WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
- input, &value)) return false;
- 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);
- }
- break;
- }
- // Handle strings separately so that we can optimize the ctype=CORD case.
- case FieldDescriptor::TYPE_STRING: {
- string value;
- if (!WireFormatLite::ReadString(input, &value)) return false;
- VerifyUTF8String(value.data(), value.length(), PARSE);
- if (field->is_repeated()) {
- message_reflection->AddString(message, field, value);
- } else {
- message_reflection->SetString(message, field, value);
- }
- break;
- }
- case FieldDescriptor::TYPE_BYTES: {
- string value;
- if (!WireFormatLite::ReadBytes(input, &value)) return false;
- if (field->is_repeated()) {
- message_reflection->AddString(message, field, value);
- } else {
- message_reflection->SetString(message, field, value);
- }
- break;
- }
- case FieldDescriptor::TYPE_GROUP: {
- Message* sub_message;
- if (field->is_repeated()) {
- sub_message = message_reflection->AddMessage(
- message, field, input->GetExtensionFactory());
- } else {
- sub_message = message_reflection->MutableMessage(
- message, field, input->GetExtensionFactory());
- }
- if (!WireFormatLite::ReadGroup(WireFormatLite::GetTagFieldNumber(tag),
- input, sub_message))
- return false;
- break;
- }
- case FieldDescriptor::TYPE_MESSAGE: {
- Message* sub_message;
- if (field->is_repeated()) {
- sub_message = message_reflection->AddMessage(
- message, field, input->GetExtensionFactory());
- } else {
- sub_message = message_reflection->MutableMessage(
- message, field, input->GetExtensionFactory());
- }
- if (!WireFormatLite::ReadMessage(input, sub_message)) return false;
- break;
- }
- }
- }
- 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;
- // Once we see a type_id, we'll construct a fake tag for this extension
- // which is the tag it would have had under the proto2 extensions wire
- // format.
- uint32 fake_tag = 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. This will probably never happen in practice,
- // as no MessageSet encoder I know of writes the message before the type ID.
- // But, it's technically valid so we should allow it.
- // TODO(kenton): Use a Cord instead? Do I care?
- 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;
- fake_tag = WireFormatLite::MakeTag(
- type_id, WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
- 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 (!ParseAndMergeField(fake_tag, field, message,
- &sub_input)) {
- return false;
- }
- message_data.clear();
- }
- break;
- }
- case WireFormatLite::kMessageSetMessageTag: {
- if (fake_tag == 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;
- message_data.append(temp);
- } else {
- // Already saw type_id, so we can parse this directly.
- if (!ParseAndMergeField(fake_tag, field, message, input)) {
- return false;
- }
- }
- break;
- }
- case WireFormatLite::kMessageSetItemEndTag: {
- return true;
- }
- default: {
- if (!SkipField(input, tag, NULL)) return false;
- }
- }
- }
- }
- // ===================================================================
- 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;
- vector<const FieldDescriptor*> fields;
- message_reflection->ListFields(message, &fields);
- for (int i = 0; i < fields.size(); i++) {
- SerializeFieldWithCachedSizes(fields[i], message, output);
- }
- if (descriptor->options().message_set_wire_format()) {
- SerializeUnknownMessageSetItems(
- message_reflection->GetUnknownFields(message), output);
- } else {
- 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?";
- }
- void WireFormat::SerializeFieldWithCachedSizes(
- const FieldDescriptor* field,
- const Message& message,
- io::CodedOutputStream* output) {
- const Reflection* message_reflection = message.GetReflection();
- if (field->is_extension() &&
- field->containing_type()->options().message_set_wire_format() &&
- field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
- !field->is_repeated()) {
- SerializeMessageSetItemWithCachedSizes(field, message, output);
- return;
- }
- int count = 0;
- if (field->is_repeated()) {
- count = message_reflection->FieldSize(message, field);
- } else if (message_reflection->HasField(message, field)) {
- count = 1;
- }
- const bool is_packed = field->options().packed();
- if (is_packed && count > 0) {
- WireFormatLite::WriteTag(field->number(),
- WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
- const int 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; \
- }
- 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(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() ? \
- message_reflection->GetRepeated##CPPTYPE_METHOD( \
- message, field, j) : \
- message_reflection->Get##CPPTYPE_METHOD(message, field), \
- output); \
- break;
- 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);
- if (is_packed) {
- WireFormatLite::WriteEnumNoTag(value->number(), output);
- } else {
- WireFormatLite::WriteEnum(field->number(), value->number(), output);
- }
- break;
- }
- // Handle strings separately so that we can get string references
- // instead of copying.
- case FieldDescriptor::TYPE_STRING: {
- string scratch;
- const string& value = field->is_repeated() ?
- message_reflection->GetRepeatedStringReference(
- message, field, j, &scratch) :
- message_reflection->GetStringReference(message, field, &scratch);
- VerifyUTF8String(value.data(), value.length(), SERIALIZE);
- WireFormatLite::WriteString(field->number(), value, output);
- break;
- }
- 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);
- WireFormatLite::WriteBytes(field->number(), value, output);
- break;
- }
- }
- }
- }
- void WireFormat::SerializeMessageSetItemWithCachedSizes(
- const FieldDescriptor* field,
- const Message& message,
- io::CodedOutputStream* output) {
- const Reflection* message_reflection = message.GetReflection();
- // Start group.
- output->WriteVarint32(WireFormatLite::kMessageSetItemStartTag);
- // Write type ID.
- output->WriteVarint32(WireFormatLite::kMessageSetTypeIdTag);
- output->WriteVarint32(field->number());
- // Write message.
- output->WriteVarint32(WireFormatLite::kMessageSetMessageTag);
- const Message& sub_message = message_reflection->GetMessage(message, field);
- output->WriteVarint32(sub_message.GetCachedSize());
- sub_message.SerializeWithCachedSizes(output);
- // End group.
- output->WriteVarint32(WireFormatLite::kMessageSetItemEndTag);
- }
- // ===================================================================
- int WireFormat::ByteSize(const Message& message) {
- const Descriptor* descriptor = message.GetDescriptor();
- const Reflection* message_reflection = message.GetReflection();
- int our_size = 0;
- vector<const FieldDescriptor*> fields;
- message_reflection->ListFields(message, &fields);
- for (int i = 0; i < fields.size(); i++) {
- our_size += FieldByteSize(fields[i], message);
- }
- if (descriptor->options().message_set_wire_format()) {
- our_size += ComputeUnknownMessageSetItemsSize(
- message_reflection->GetUnknownFields(message));
- } else {
- our_size += ComputeUnknownFieldsSize(
- message_reflection->GetUnknownFields(message));
- }
- return our_size;
- }
- int WireFormat::FieldByteSize(
- const FieldDescriptor* field,
- const Message& message) {
- const Reflection* message_reflection = message.GetReflection();
- if (field->is_extension() &&
- field->containing_type()->options().message_set_wire_format() &&
- field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
- !field->is_repeated()) {
- return MessageSetItemByteSize(field, message);
- }
- int count = 0;
- if (field->is_repeated()) {
- count = message_reflection->FieldSize(message, field);
- } else if (message_reflection->HasField(message, field)) {
- count = 1;
- }
- const int data_size = FieldDataOnlyByteSize(field, message);
- int our_size = data_size;
- if (field->options().packed()) {
- if (data_size > 0) {
- // Packed fields get serialized like a string, not their native type.
- // Technically this doesn't really matter; the size only changes if it's
- // a GROUP
- our_size += TagSize(field->number(), FieldDescriptor::TYPE_STRING);
- our_size += io::CodedOutputStream::VarintSize32(data_size);
- }
- } else {
- our_size += count * TagSize(field->number(), field->type());
- }
- return our_size;
- }
- int WireFormat::FieldDataOnlyByteSize(
- const FieldDescriptor* field,
- const Message& message) {
- const Reflection* message_reflection = message.GetReflection();
- int count = 0;
- if (field->is_repeated()) {
- count = message_reflection->FieldSize(message, field);
- } else if (message_reflection->HasField(message, field)) {
- count = 1;
- }
- int data_size = 0;
- 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_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(UINT32, UInt32, UInt32)
- HANDLE_TYPE(UINT64, UInt64, UInt64)
- 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(DOUBLE, Double)
- HANDLE_FIXED_TYPE(BOOL, Bool)
- HANDLE_TYPE(GROUP , Group , Message)
- HANDLE_TYPE(MESSAGE, Message, Message)
- #undef HANDLE_TYPE
- #undef HANDLE_FIXED_TYPE
- case FieldDescriptor::TYPE_ENUM: {
- if (field->is_repeated()) {
- for (int j = 0; j < count; j++) {
- data_size += WireFormatLite::EnumSize(
- message_reflection->GetRepeatedEnum(message, field, j)->number());
- }
- } else {
- data_size += WireFormatLite::EnumSize(
- message_reflection->GetEnum(message, field)->number());
- }
- break;
- }
- // Handle strings separately so that we can get string references
- // instead of copying.
- 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);
- data_size += WireFormatLite::StringSize(value);
- }
- break;
- }
- }
- return data_size;
- }
- int WireFormat::MessageSetItemByteSize(
- const FieldDescriptor* field,
- const Message& message) {
- const Reflection* message_reflection = message.GetReflection();
- int our_size = WireFormatLite::kMessageSetItemTagsSize;
- // type_id
- our_size += io::CodedOutputStream::VarintSize32(field->number());
- // message
- const Message& sub_message = message_reflection->GetMessage(message, field);
- int message_size = sub_message.ByteSize();
- our_size += io::CodedOutputStream::VarintSize32(message_size);
- our_size += message_size;
- return our_size;
- }
- void WireFormat::VerifyUTF8StringFallback(const char* data,
- int size,
- Operation op) {
- if (!IsStructurallyValidUTF8(data, size)) {
- const char* operation_str = NULL;
- switch (op) {
- case PARSE:
- operation_str = "parsing";
- break;
- case SERIALIZE:
- operation_str = "serializing";
- break;
- // no default case: have the compiler warn if a case is not covered.
- }
- GOOGLE_LOG(ERROR) << "Encountered string containing invalid UTF-8 data while "
- << operation_str
- << " protocol buffer. Strings must contain only UTF-8; "
- "use the 'bytes' type for raw bytes.";
- }
- }
- } // namespace internal
- } // namespace protobuf
- } // namespace google