OLD | NEW |
1 // Protocol Buffers - Google's data interchange format | 1 // Protocol Buffers - Google's data interchange format |
2 // Copyright 2008 Google Inc. All rights reserved. | 2 // Copyright 2008 Google Inc. All rights reserved. |
3 // https://developers.google.com/protocol-buffers/ | 3 // https://developers.google.com/protocol-buffers/ |
4 // | 4 // |
5 // Redistribution and use in source and binary forms, with or without | 5 // Redistribution and use in source and binary forms, with or without |
6 // modification, are permitted provided that the following conditions are | 6 // modification, are permitted provided that the following conditions are |
7 // met: | 7 // met: |
8 // | 8 // |
9 // * Redistributions of source code must retain the above copyright | 9 // * Redistributions of source code must retain the above copyright |
10 // notice, this list of conditions and the following disclaimer. | 10 // notice, this list of conditions and the following disclaimer. |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
88 private: | 88 private: |
89 const DescriptorPool* pool_; | 89 const DescriptorPool* pool_; |
90 MessageFactory* factory_; | 90 MessageFactory* factory_; |
91 const Descriptor* containing_type_; | 91 const Descriptor* containing_type_; |
92 }; | 92 }; |
93 | 93 |
94 void ExtensionSet::AppendToList( | 94 void ExtensionSet::AppendToList( |
95 const Descriptor* containing_type, | 95 const Descriptor* containing_type, |
96 const DescriptorPool* pool, | 96 const DescriptorPool* pool, |
97 std::vector<const FieldDescriptor*>* output) const { | 97 std::vector<const FieldDescriptor*>* output) const { |
98 for (ExtensionMap::const_iterator iter = extensions_.begin(); | 98 for (map<int, Extension>::const_iterator iter = extensions_.begin(); |
99 iter != extensions_.end(); ++iter) { | 99 iter != extensions_.end(); ++iter) { |
100 bool has = false; | 100 bool has = false; |
101 if (iter->second.is_repeated) { | 101 if (iter->second.is_repeated) { |
102 has = iter->second.GetSize() > 0; | 102 has = iter->second.GetSize() > 0; |
103 } else { | 103 } else { |
104 has = !iter->second.is_cleared; | 104 has = !iter->second.is_cleared; |
105 } | 105 } |
106 | 106 |
107 if (has) { | 107 if (has) { |
108 // TODO(kenton): Looking up each field by number is somewhat unfortunate. | 108 // TODO(kenton): Looking up each field by number is somewhat unfortunate. |
(...skipping 28 matching lines...) Expand all Loading... |
137 | 137 |
138 #define GOOGLE_DCHECK_TYPE(EXTENSION, LABEL, CPPTYPE)
\ | 138 #define GOOGLE_DCHECK_TYPE(EXTENSION, LABEL, CPPTYPE)
\ |
139 GOOGLE_DCHECK_EQ((EXTENSION).is_repeated ? FieldDescriptor::LABEL_REPEATED
\ | 139 GOOGLE_DCHECK_EQ((EXTENSION).is_repeated ? FieldDescriptor::LABEL_REPEATED
\ |
140 : FieldDescriptor::LABEL_OPTIONAL, \ | 140 : FieldDescriptor::LABEL_OPTIONAL, \ |
141 FieldDescriptor::LABEL_##LABEL); \ | 141 FieldDescriptor::LABEL_##LABEL); \ |
142 GOOGLE_DCHECK_EQ(cpp_type((EXTENSION).type), FieldDescriptor::CPPTYPE_##CPPTYP
E) | 142 GOOGLE_DCHECK_EQ(cpp_type((EXTENSION).type), FieldDescriptor::CPPTYPE_##CPPTYP
E) |
143 | 143 |
144 const MessageLite& ExtensionSet::GetMessage(int number, | 144 const MessageLite& ExtensionSet::GetMessage(int number, |
145 const Descriptor* message_type, | 145 const Descriptor* message_type, |
146 MessageFactory* factory) const { | 146 MessageFactory* factory) const { |
147 ExtensionMap::const_iterator iter = extensions_.find(number); | 147 map<int, Extension>::const_iterator iter = extensions_.find(number); |
148 if (iter == extensions_.end() || iter->second.is_cleared) { | 148 if (iter == extensions_.end() || iter->second.is_cleared) { |
149 // Not present. Return the default value. | 149 // Not present. Return the default value. |
150 return *factory->GetPrototype(message_type); | 150 return *factory->GetPrototype(message_type); |
151 } else { | 151 } else { |
152 GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE); | 152 GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE); |
153 if (iter->second.is_lazy) { | 153 if (iter->second.is_lazy) { |
154 return iter->second.lazymessage_value->GetMessage( | 154 return iter->second.lazymessage_value->GetMessage( |
155 *factory->GetPrototype(message_type)); | 155 *factory->GetPrototype(message_type)); |
156 } else { | 156 } else { |
157 return *iter->second.message_value; | 157 return *iter->second.message_value; |
(...skipping 22 matching lines...) Expand all Loading... |
180 return extension->lazymessage_value->MutableMessage( | 180 return extension->lazymessage_value->MutableMessage( |
181 *factory->GetPrototype(descriptor->message_type())); | 181 *factory->GetPrototype(descriptor->message_type())); |
182 } else { | 182 } else { |
183 return extension->message_value; | 183 return extension->message_value; |
184 } | 184 } |
185 } | 185 } |
186 } | 186 } |
187 | 187 |
188 MessageLite* ExtensionSet::ReleaseMessage(const FieldDescriptor* descriptor, | 188 MessageLite* ExtensionSet::ReleaseMessage(const FieldDescriptor* descriptor, |
189 MessageFactory* factory) { | 189 MessageFactory* factory) { |
190 ExtensionMap::iterator iter = extensions_.find(descriptor->number()); | 190 map<int, Extension>::iterator iter = extensions_.find(descriptor->number()); |
191 if (iter == extensions_.end()) { | 191 if (iter == extensions_.end()) { |
192 // Not present. Return NULL. | 192 // Not present. Return NULL. |
193 return NULL; | 193 return NULL; |
194 } else { | 194 } else { |
195 GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE); | 195 GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE); |
196 MessageLite* ret = NULL; | 196 MessageLite* ret = NULL; |
197 if (iter->second.is_lazy) { | 197 if (iter->second.is_lazy) { |
198 ret = iter->second.lazymessage_value->ReleaseMessage( | 198 ret = iter->second.lazymessage_value->ReleaseMessage( |
199 *factory->GetPrototype(descriptor->message_type())); | 199 *factory->GetPrototype(descriptor->message_type())); |
200 if (arena_ == NULL) { | 200 if (arena_ == NULL) { |
201 delete iter->second.lazymessage_value; | 201 delete iter->second.lazymessage_value; |
202 } | 202 } |
203 } else { | 203 } else { |
204 if (arena_ != NULL) { | 204 if (arena_ != NULL) { |
205 ret = (iter->second.message_value)->New(); | 205 ret = (iter->second.message_value)->New(); |
206 ret->CheckTypeAndMergeFrom(*(iter->second.message_value)); | 206 ret->CheckTypeAndMergeFrom(*(iter->second.message_value)); |
207 } else { | 207 } else { |
208 ret = iter->second.message_value; | 208 ret = iter->second.message_value; |
209 } | 209 } |
210 } | 210 } |
211 extensions_.erase(descriptor->number()); | 211 extensions_.erase(descriptor->number()); |
212 return ret; | 212 return ret; |
213 } | 213 } |
214 } | 214 } |
215 | 215 |
216 MessageLite* ExtensionSet::UnsafeArenaReleaseMessage( | |
217 const FieldDescriptor* descriptor, MessageFactory* factory) { | |
218 ExtensionMap::iterator iter = extensions_.find(descriptor->number()); | |
219 if (iter == extensions_.end()) { | |
220 // Not present. Return NULL. | |
221 return NULL; | |
222 } else { | |
223 GOOGLE_DCHECK_TYPE(iter->second, OPTIONAL, MESSAGE); | |
224 MessageLite* ret = NULL; | |
225 if (iter->second.is_lazy) { | |
226 ret = iter->second.lazymessage_value->UnsafeArenaReleaseMessage( | |
227 *factory->GetPrototype(descriptor->message_type())); | |
228 if (arena_ == NULL) { | |
229 delete iter->second.lazymessage_value; | |
230 } | |
231 } else { | |
232 ret = iter->second.message_value; | |
233 } | |
234 extensions_.erase(descriptor->number()); | |
235 return ret; | |
236 } | |
237 } | |
238 | |
239 ExtensionSet::Extension* ExtensionSet::MaybeNewRepeatedExtension(const FieldDesc
riptor* descriptor) { | 216 ExtensionSet::Extension* ExtensionSet::MaybeNewRepeatedExtension(const FieldDesc
riptor* descriptor) { |
240 Extension* extension; | 217 Extension* extension; |
241 if (MaybeNewExtension(descriptor->number(), descriptor, &extension)) { | 218 if (MaybeNewExtension(descriptor->number(), descriptor, &extension)) { |
242 extension->type = descriptor->type(); | 219 extension->type = descriptor->type(); |
243 GOOGLE_DCHECK_EQ(cpp_type(extension->type), FieldDescriptor::CPPTYPE_MESSAGE
); | 220 GOOGLE_DCHECK_EQ(cpp_type(extension->type), FieldDescriptor::CPPTYPE_MESSAGE
); |
244 extension->is_repeated = true; | 221 extension->is_repeated = true; |
245 extension->repeated_message_value = | 222 extension->repeated_message_value = |
246 ::google::protobuf::Arena::CreateMessage<RepeatedPtrField<MessageLite> >
(arena_); | 223 ::google::protobuf::Arena::CreateMessage<RepeatedPtrField<MessageLite> >
(arena_); |
247 } else { | 224 } else { |
248 GOOGLE_DCHECK_TYPE(*extension, REPEATED, MESSAGE); | 225 GOOGLE_DCHECK_TYPE(*extension, REPEATED, MESSAGE); |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
334 } else { | 311 } else { |
335 DescriptorPoolExtensionFinder finder(input->GetExtensionPool(), | 312 DescriptorPoolExtensionFinder finder(input->GetExtensionPool(), |
336 input->GetExtensionFactory(), | 313 input->GetExtensionFactory(), |
337 containing_type->GetDescriptor()); | 314 containing_type->GetDescriptor()); |
338 return ParseMessageSet(input, &finder, &skipper); | 315 return ParseMessageSet(input, &finder, &skipper); |
339 } | 316 } |
340 } | 317 } |
341 | 318 |
342 int ExtensionSet::SpaceUsedExcludingSelf() const { | 319 int ExtensionSet::SpaceUsedExcludingSelf() const { |
343 int total_size = | 320 int total_size = |
344 extensions_.size() * sizeof(ExtensionMap::value_type); | 321 extensions_.size() * sizeof(map<int, Extension>::value_type); |
345 for (ExtensionMap::const_iterator iter = extensions_.begin(), | 322 for (map<int, Extension>::const_iterator iter = extensions_.begin(), |
346 end = extensions_.end(); | 323 end = extensions_.end(); |
347 iter != end; | 324 iter != end; |
348 ++iter) { | 325 ++iter) { |
349 total_size += iter->second.SpaceUsedExcludingSelf(); | 326 total_size += iter->second.SpaceUsedExcludingSelf(); |
350 } | 327 } |
351 return total_size; | 328 return total_size; |
352 } | 329 } |
353 | 330 |
354 inline int ExtensionSet::RepeatedMessage_SpaceUsedExcludingSelf( | 331 inline int ExtensionSet::RepeatedMessage_SpaceUsedExcludingSelf( |
355 RepeatedPtrFieldBase* field) { | 332 RepeatedPtrFieldBase* field) { |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
402 default: | 379 default: |
403 // No extra storage costs for primitive types. | 380 // No extra storage costs for primitive types. |
404 break; | 381 break; |
405 } | 382 } |
406 } | 383 } |
407 return total_size; | 384 return total_size; |
408 } | 385 } |
409 | 386 |
410 // The Serialize*ToArray methods are only needed in the heavy library, as | 387 // The Serialize*ToArray methods are only needed in the heavy library, as |
411 // the lite library only generates SerializeWithCachedSizes. | 388 // the lite library only generates SerializeWithCachedSizes. |
412 uint8* ExtensionSet::SerializeWithCachedSizesToArray(int start_field_number, | 389 uint8* ExtensionSet::SerializeWithCachedSizesToArray( |
413 int end_field_number, | 390 int start_field_number, int end_field_number, |
414 uint8* target) const { | 391 uint8* target) const { |
415 return InternalSerializeWithCachedSizesToArray( | 392 map<int, Extension>::const_iterator iter; |
416 start_field_number, end_field_number, false, target); | 393 for (iter = extensions_.lower_bound(start_field_number); |
| 394 iter != extensions_.end() && iter->first < end_field_number; |
| 395 ++iter) { |
| 396 target = iter->second.SerializeFieldWithCachedSizesToArray(iter->first, |
| 397 target); |
| 398 } |
| 399 return target; |
417 } | 400 } |
418 | 401 |
419 uint8* ExtensionSet::SerializeMessageSetWithCachedSizesToArray( | 402 uint8* ExtensionSet::SerializeMessageSetWithCachedSizesToArray( |
420 uint8* target) const { | 403 uint8* target) const { |
421 return InternalSerializeMessageSetWithCachedSizesToArray(false, target); | 404 map<int, Extension>::const_iterator iter; |
422 } | 405 for (iter = extensions_.begin(); iter != extensions_.end(); ++iter) { |
423 | 406 target = iter->second.SerializeMessageSetItemWithCachedSizesToArray( |
424 uint8* ExtensionSet::InternalSerializeWithCachedSizesToArray( | 407 iter->first, target); |
425 int start_field_number, int end_field_number, | |
426 bool deterministic, uint8* target) const { | |
427 ExtensionMap::const_iterator iter; | |
428 for (iter = extensions_.lower_bound(start_field_number); | |
429 iter != extensions_.end() && iter->first < end_field_number; | |
430 ++iter) { | |
431 target = iter->second.InternalSerializeFieldWithCachedSizesToArray( | |
432 iter->first, deterministic, target); | |
433 } | 408 } |
434 return target; | 409 return target; |
435 } | 410 } |
436 | 411 |
437 uint8* ExtensionSet::InternalSerializeMessageSetWithCachedSizesToArray( | 412 uint8* ExtensionSet::Extension::SerializeFieldWithCachedSizesToArray( |
438 bool deterministic, uint8* target) const { | 413 int number, uint8* target) const { |
439 ExtensionMap::const_iterator iter; | |
440 for (iter = extensions_.begin(); iter != extensions_.end(); ++iter) { | |
441 target = iter->second.InternalSerializeMessageSetItemWithCachedSizesToArray( | |
442 iter->first, deterministic, target); | |
443 } | |
444 return target; | |
445 } | |
446 | |
447 uint8* ExtensionSet::Extension::InternalSerializeFieldWithCachedSizesToArray( | |
448 int number, bool deterministic, uint8* target) const { | |
449 if (is_repeated) { | 414 if (is_repeated) { |
450 if (is_packed) { | 415 if (is_packed) { |
451 if (cached_size == 0) return target; | 416 if (cached_size == 0) return target; |
452 | 417 |
453 target = WireFormatLite::WriteTagToArray(number, | 418 target = WireFormatLite::WriteTagToArray(number, |
454 WireFormatLite::WIRETYPE_LENGTH_DELIMITED, target); | 419 WireFormatLite::WIRETYPE_LENGTH_DELIMITED, target); |
455 target = WireFormatLite::WriteInt32NoTagToArray(cached_size, target); | 420 target = WireFormatLite::WriteInt32NoTagToArray(cached_size, target); |
456 | 421 |
457 switch (real_type(type)) { | 422 switch (real_type(type)) { |
458 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ | 423 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
505 HANDLE_TYPE( FIXED32, Fixed32, uint32); | 470 HANDLE_TYPE( FIXED32, Fixed32, uint32); |
506 HANDLE_TYPE( FIXED64, Fixed64, uint64); | 471 HANDLE_TYPE( FIXED64, Fixed64, uint64); |
507 HANDLE_TYPE(SFIXED32, SFixed32, int32); | 472 HANDLE_TYPE(SFIXED32, SFixed32, int32); |
508 HANDLE_TYPE(SFIXED64, SFixed64, int64); | 473 HANDLE_TYPE(SFIXED64, SFixed64, int64); |
509 HANDLE_TYPE( FLOAT, Float, float); | 474 HANDLE_TYPE( FLOAT, Float, float); |
510 HANDLE_TYPE( DOUBLE, Double, double); | 475 HANDLE_TYPE( DOUBLE, Double, double); |
511 HANDLE_TYPE( BOOL, Bool, bool); | 476 HANDLE_TYPE( BOOL, Bool, bool); |
512 HANDLE_TYPE( STRING, String, string); | 477 HANDLE_TYPE( STRING, String, string); |
513 HANDLE_TYPE( BYTES, Bytes, string); | 478 HANDLE_TYPE( BYTES, Bytes, string); |
514 HANDLE_TYPE( ENUM, Enum, enum); | 479 HANDLE_TYPE( ENUM, Enum, enum); |
515 #undef HANDLE_TYPE | |
516 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, LOWERCASE) \ | |
517 case FieldDescriptor::TYPE_##UPPERCASE: \ | |
518 for (int i = 0; i < repeated_##LOWERCASE##_value->size(); i++) { \ | |
519 target = WireFormatLite::InternalWrite##CAMELCASE##ToArray( \ | |
520 number, repeated_##LOWERCASE##_value->Get(i), \ | |
521 deterministic, target); \ | |
522 } \ | |
523 break | |
524 | |
525 HANDLE_TYPE( GROUP, Group, message); | 480 HANDLE_TYPE( GROUP, Group, message); |
526 HANDLE_TYPE( MESSAGE, Message, message); | 481 HANDLE_TYPE( MESSAGE, Message, message); |
527 #undef HANDLE_TYPE | 482 #undef HANDLE_TYPE |
528 } | 483 } |
529 } | 484 } |
530 } else if (!is_cleared) { | 485 } else if (!is_cleared) { |
531 switch (real_type(type)) { | 486 switch (real_type(type)) { |
532 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, VALUE) \ | 487 #define HANDLE_TYPE(UPPERCASE, CAMELCASE, VALUE) \ |
533 case FieldDescriptor::TYPE_##UPPERCASE: \ | 488 case FieldDescriptor::TYPE_##UPPERCASE: \ |
534 target = WireFormatLite::Write##CAMELCASE##ToArray( \ | 489 target = WireFormatLite::Write##CAMELCASE##ToArray( \ |
(...skipping 13 matching lines...) Expand all Loading... |
548 HANDLE_TYPE( FLOAT, Float, float_value); | 503 HANDLE_TYPE( FLOAT, Float, float_value); |
549 HANDLE_TYPE( DOUBLE, Double, double_value); | 504 HANDLE_TYPE( DOUBLE, Double, double_value); |
550 HANDLE_TYPE( BOOL, Bool, bool_value); | 505 HANDLE_TYPE( BOOL, Bool, bool_value); |
551 HANDLE_TYPE( STRING, String, *string_value); | 506 HANDLE_TYPE( STRING, String, *string_value); |
552 HANDLE_TYPE( BYTES, Bytes, *string_value); | 507 HANDLE_TYPE( BYTES, Bytes, *string_value); |
553 HANDLE_TYPE( ENUM, Enum, enum_value); | 508 HANDLE_TYPE( ENUM, Enum, enum_value); |
554 HANDLE_TYPE( GROUP, Group, *message_value); | 509 HANDLE_TYPE( GROUP, Group, *message_value); |
555 #undef HANDLE_TYPE | 510 #undef HANDLE_TYPE |
556 case FieldDescriptor::TYPE_MESSAGE: | 511 case FieldDescriptor::TYPE_MESSAGE: |
557 if (is_lazy) { | 512 if (is_lazy) { |
558 target = lazymessage_value->InternalWriteMessageToArray( | 513 target = lazymessage_value->WriteMessageToArray(number, target); |
559 number, deterministic, target); | |
560 } else { | 514 } else { |
561 target = WireFormatLite::InternalWriteMessageToArray( | 515 target = WireFormatLite::WriteMessageToArray( |
562 number, *message_value, deterministic, target); | 516 number, *message_value, target); |
563 } | 517 } |
564 break; | 518 break; |
565 } | 519 } |
566 } | 520 } |
567 return target; | 521 return target; |
568 } | 522 } |
569 | 523 |
570 uint8* | 524 uint8* ExtensionSet::Extension::SerializeMessageSetItemWithCachedSizesToArray( |
571 ExtensionSet::Extension::InternalSerializeMessageSetItemWithCachedSizesToArray( | 525 int number, |
572 int number, bool deterministic, uint8* target) const { | 526 uint8* target) const { |
573 if (type != WireFormatLite::TYPE_MESSAGE || is_repeated) { | 527 if (type != WireFormatLite::TYPE_MESSAGE || is_repeated) { |
574 // Not a valid MessageSet extension, but serialize it the normal way. | 528 // Not a valid MessageSet extension, but serialize it the normal way. |
575 GOOGLE_LOG(WARNING) << "Invalid message set extension."; | 529 GOOGLE_LOG(WARNING) << "Invalid message set extension."; |
576 return InternalSerializeFieldWithCachedSizesToArray(number, deterministic, | 530 return SerializeFieldWithCachedSizesToArray(number, target); |
577 target); | |
578 } | 531 } |
579 | 532 |
580 if (is_cleared) return target; | 533 if (is_cleared) return target; |
581 | 534 |
582 // Start group. | 535 // Start group. |
583 target = io::CodedOutputStream::WriteTagToArray( | 536 target = io::CodedOutputStream::WriteTagToArray( |
584 WireFormatLite::kMessageSetItemStartTag, target); | 537 WireFormatLite::kMessageSetItemStartTag, target); |
585 // Write type ID. | 538 // Write type ID. |
586 target = WireFormatLite::WriteUInt32ToArray( | 539 target = WireFormatLite::WriteUInt32ToArray( |
587 WireFormatLite::kMessageSetTypeIdNumber, number, target); | 540 WireFormatLite::kMessageSetTypeIdNumber, number, target); |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
649 // required int32 type_id = 2; | 602 // required int32 type_id = 2; |
650 // required data message = 3; | 603 // required data message = 3; |
651 | 604 |
652 uint32 last_type_id = 0; | 605 uint32 last_type_id = 0; |
653 | 606 |
654 // If we see message data before the type_id, we'll append it to this so | 607 // If we see message data before the type_id, we'll append it to this so |
655 // we can parse it later. | 608 // we can parse it later. |
656 string message_data; | 609 string message_data; |
657 | 610 |
658 while (true) { | 611 while (true) { |
659 const uint32 tag = input->ReadTagNoLastTag(); | 612 const uint32 tag = input->ReadTag(); |
660 if (tag == 0) return false; | 613 if (tag == 0) return false; |
661 | 614 |
662 switch (tag) { | 615 switch (tag) { |
663 case WireFormatLite::kMessageSetTypeIdTag: { | 616 case WireFormatLite::kMessageSetTypeIdTag: { |
664 uint32 type_id; | 617 uint32 type_id; |
665 if (!input->ReadVarint32(&type_id)) return false; | 618 if (!input->ReadVarint32(&type_id)) return false; |
666 last_type_id = type_id; | 619 last_type_id = type_id; |
667 | 620 |
668 if (!message_data.empty()) { | 621 if (!message_data.empty()) { |
669 // We saw some message data before the type_id. Have to parse it | 622 // We saw some message data before the type_id. Have to parse it |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
742 WireFormatLite::WriteMessageMaybeToArray( | 695 WireFormatLite::WriteMessageMaybeToArray( |
743 WireFormatLite::kMessageSetMessageNumber, | 696 WireFormatLite::kMessageSetMessageNumber, |
744 *message_value, | 697 *message_value, |
745 output); | 698 output); |
746 } | 699 } |
747 | 700 |
748 // End group. | 701 // End group. |
749 output->WriteTag(WireFormatLite::kMessageSetItemEndTag); | 702 output->WriteTag(WireFormatLite::kMessageSetItemEndTag); |
750 } | 703 } |
751 | 704 |
752 size_t ExtensionSet::Extension::MessageSetItemByteSize(int number) const { | 705 int ExtensionSet::Extension::MessageSetItemByteSize(int number) const { |
753 if (type != WireFormatLite::TYPE_MESSAGE || is_repeated) { | 706 if (type != WireFormatLite::TYPE_MESSAGE || is_repeated) { |
754 // Not a valid MessageSet extension, but compute the byte size for it the | 707 // Not a valid MessageSet extension, but compute the byte size for it the |
755 // normal way. | 708 // normal way. |
756 return ByteSize(number); | 709 return ByteSize(number); |
757 } | 710 } |
758 | 711 |
759 if (is_cleared) return 0; | 712 if (is_cleared) return 0; |
760 | 713 |
761 size_t our_size = WireFormatLite::kMessageSetItemTagsSize; | 714 int our_size = WireFormatLite::kMessageSetItemTagsSize; |
762 | 715 |
763 // type_id | 716 // type_id |
764 our_size += io::CodedOutputStream::VarintSize32(number); | 717 our_size += io::CodedOutputStream::VarintSize32(number); |
765 | 718 |
766 // message | 719 // message |
767 size_t message_size = 0; | 720 int message_size = 0; |
768 if (is_lazy) { | 721 if (is_lazy) { |
769 message_size = lazymessage_value->ByteSize(); | 722 message_size = lazymessage_value->ByteSize(); |
770 } else { | 723 } else { |
771 message_size = message_value->ByteSize(); | 724 message_size = message_value->ByteSize(); |
772 } | 725 } |
773 | 726 |
774 our_size += io::CodedOutputStream::VarintSize32(message_size); | 727 our_size += io::CodedOutputStream::VarintSize32(message_size); |
775 our_size += message_size; | 728 our_size += message_size; |
776 | 729 |
777 return our_size; | 730 return our_size; |
778 } | 731 } |
779 | 732 |
780 void ExtensionSet::SerializeMessageSetWithCachedSizes( | 733 void ExtensionSet::SerializeMessageSetWithCachedSizes( |
781 io::CodedOutputStream* output) const { | 734 io::CodedOutputStream* output) const { |
782 for (ExtensionMap::const_iterator iter = extensions_.begin(); | 735 for (map<int, Extension>::const_iterator iter = extensions_.begin(); |
783 iter != extensions_.end(); ++iter) { | 736 iter != extensions_.end(); ++iter) { |
784 iter->second.SerializeMessageSetItemWithCachedSizes(iter->first, output); | 737 iter->second.SerializeMessageSetItemWithCachedSizes(iter->first, output); |
785 } | 738 } |
786 } | 739 } |
787 | 740 |
788 size_t ExtensionSet::MessageSetByteSize() const { | 741 int ExtensionSet::MessageSetByteSize() const { |
789 size_t total_size = 0; | 742 int total_size = 0; |
790 | 743 |
791 for (ExtensionMap::const_iterator iter = extensions_.begin(); | 744 for (map<int, Extension>::const_iterator iter = extensions_.begin(); |
792 iter != extensions_.end(); ++iter) { | 745 iter != extensions_.end(); ++iter) { |
793 total_size += iter->second.MessageSetItemByteSize(iter->first); | 746 total_size += iter->second.MessageSetItemByteSize(iter->first); |
794 } | 747 } |
795 | 748 |
796 return total_size; | 749 return total_size; |
797 } | 750 } |
798 | 751 |
799 } // namespace internal | 752 } // namespace internal |
800 } // namespace protobuf | 753 } // namespace protobuf |
801 } // namespace google | 754 } // namespace google |
OLD | NEW |