1// Protocol Buffers - Google's data interchange format 2// Copyright 2008 Google Inc. All rights reserved. 3// http://code.google.com/p/protobuf/ 4// 5// Redistribution and use in source and binary forms, with or without 6// modification, are permitted provided that the following conditions are 7// met: 8// 9// * Redistributions of source code must retain the above copyright 10// notice, this list of conditions and the following disclaimer. 11// * Redistributions in binary form must reproduce the above 12// copyright notice, this list of conditions and the following disclaimer 13// in the documentation and/or other materials provided with the 14// distribution. 15// * Neither the name of Google Inc. nor the names of its 16// contributors may be used to endorse or promote products derived from 17// this software without specific prior written permission. 18// 19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31// Author: kenton@google.com (Kenton Varda) 32// Based on original Protocol Buffers design by 33// Sanjay Ghemawat, Jeff Dean, and others. 34 35#include <algorithm> 36#include <google/protobuf/descriptor.pb.h> 37#include <google/protobuf/generated_message_reflection.h> 38#include <google/protobuf/descriptor.h> 39#include <google/protobuf/repeated_field.h> 40#include <google/protobuf/extension_set.h> 41#include <google/protobuf/generated_message_util.h> 42#include <google/protobuf/stubs/common.h> 43 44namespace google { 45namespace protobuf { 46namespace internal { 47 48bool ParseNamedEnum(const EnumDescriptor* descriptor, 49 const string& name, 50 int* value) { 51 const EnumValueDescriptor* d = descriptor->FindValueByName(name); 52 if (d == NULL) return false; 53 *value = d->number(); 54 return true; 55} 56 57const string& NameOfEnum(const EnumDescriptor* descriptor, int value) { 58 const EnumValueDescriptor* d = descriptor->FindValueByNumber(value); 59 return (d == NULL ? GetEmptyString() : d->name()); 60} 61 62// =================================================================== 63// Helpers for reporting usage errors (e.g. trying to use GetInt32() on 64// a string field). 65 66namespace { 67 68void ReportReflectionUsageError( 69 const Descriptor* descriptor, const FieldDescriptor* field, 70 const char* method, const char* description) { 71 GOOGLE_LOG(FATAL) 72 << "Protocol Buffer reflection usage error:\n" 73 " Method : google::protobuf::Reflection::" << method << "\n" 74 " Message type: " << descriptor->full_name() << "\n" 75 " Field : " << field->full_name() << "\n" 76 " Problem : " << description; 77} 78 79const char* cpptype_names_[FieldDescriptor::MAX_CPPTYPE + 1] = { 80 "INVALID_CPPTYPE", 81 "CPPTYPE_INT32", 82 "CPPTYPE_INT64", 83 "CPPTYPE_UINT32", 84 "CPPTYPE_UINT64", 85 "CPPTYPE_DOUBLE", 86 "CPPTYPE_FLOAT", 87 "CPPTYPE_BOOL", 88 "CPPTYPE_ENUM", 89 "CPPTYPE_STRING", 90 "CPPTYPE_MESSAGE" 91}; 92 93static void ReportReflectionUsageTypeError( 94 const Descriptor* descriptor, const FieldDescriptor* field, 95 const char* method, 96 FieldDescriptor::CppType expected_type) { 97 GOOGLE_LOG(FATAL) 98 << "Protocol Buffer reflection usage error:\n" 99 " Method : google::protobuf::Reflection::" << method << "\n" 100 " Message type: " << descriptor->full_name() << "\n" 101 " Field : " << field->full_name() << "\n" 102 " Problem : Field is not the right type for this message:\n" 103 " Expected : " << cpptype_names_[expected_type] << "\n" 104 " Field type: " << cpptype_names_[field->cpp_type()]; 105} 106 107static void ReportReflectionUsageEnumTypeError( 108 const Descriptor* descriptor, const FieldDescriptor* field, 109 const char* method, const EnumValueDescriptor* value) { 110 GOOGLE_LOG(FATAL) 111 << "Protocol Buffer reflection usage error:\n" 112 " Method : google::protobuf::Reflection::" << method << "\n" 113 " Message type: " << descriptor->full_name() << "\n" 114 " Field : " << field->full_name() << "\n" 115 " Problem : Enum value did not match field type:\n" 116 " Expected : " << field->enum_type()->full_name() << "\n" 117 " Actual : " << value->full_name(); 118} 119 120#define USAGE_CHECK(CONDITION, METHOD, ERROR_DESCRIPTION) \ 121 if (!(CONDITION)) \ 122 ReportReflectionUsageError(descriptor_, field, #METHOD, ERROR_DESCRIPTION) 123#define USAGE_CHECK_EQ(A, B, METHOD, ERROR_DESCRIPTION) \ 124 USAGE_CHECK((A) == (B), METHOD, ERROR_DESCRIPTION) 125#define USAGE_CHECK_NE(A, B, METHOD, ERROR_DESCRIPTION) \ 126 USAGE_CHECK((A) != (B), METHOD, ERROR_DESCRIPTION) 127 128#define USAGE_CHECK_TYPE(METHOD, CPPTYPE) \ 129 if (field->cpp_type() != FieldDescriptor::CPPTYPE_##CPPTYPE) \ 130 ReportReflectionUsageTypeError(descriptor_, field, #METHOD, \ 131 FieldDescriptor::CPPTYPE_##CPPTYPE) 132 133#define USAGE_CHECK_ENUM_VALUE(METHOD) \ 134 if (value->type() != field->enum_type()) \ 135 ReportReflectionUsageEnumTypeError(descriptor_, field, #METHOD, value) 136 137#define USAGE_CHECK_MESSAGE_TYPE(METHOD) \ 138 USAGE_CHECK_EQ(field->containing_type(), descriptor_, \ 139 METHOD, "Field does not match message type."); 140#define USAGE_CHECK_SINGULAR(METHOD) \ 141 USAGE_CHECK_NE(field->label(), FieldDescriptor::LABEL_REPEATED, METHOD, \ 142 "Field is repeated; the method requires a singular field.") 143#define USAGE_CHECK_REPEATED(METHOD) \ 144 USAGE_CHECK_EQ(field->label(), FieldDescriptor::LABEL_REPEATED, METHOD, \ 145 "Field is singular; the method requires a repeated field.") 146 147#define USAGE_CHECK_ALL(METHOD, LABEL, CPPTYPE) \ 148 USAGE_CHECK_MESSAGE_TYPE(METHOD); \ 149 USAGE_CHECK_##LABEL(METHOD); \ 150 USAGE_CHECK_TYPE(METHOD, CPPTYPE) 151 152} // namespace 153 154// =================================================================== 155 156GeneratedMessageReflection::GeneratedMessageReflection( 157 const Descriptor* descriptor, 158 const Message* default_instance, 159 const int offsets[], 160 int has_bits_offset, 161 int unknown_fields_offset, 162 int extensions_offset, 163 const DescriptorPool* descriptor_pool, 164 MessageFactory* factory, 165 int object_size) 166 : descriptor_ (descriptor), 167 default_instance_ (default_instance), 168 offsets_ (offsets), 169 has_bits_offset_ (has_bits_offset), 170 unknown_fields_offset_(unknown_fields_offset), 171 extensions_offset_(extensions_offset), 172 object_size_ (object_size), 173 descriptor_pool_ ((descriptor_pool == NULL) ? 174 DescriptorPool::generated_pool() : 175 descriptor_pool), 176 message_factory_ (factory) { 177} 178 179GeneratedMessageReflection::~GeneratedMessageReflection() {} 180 181const UnknownFieldSet& GeneratedMessageReflection::GetUnknownFields( 182 const Message& message) const { 183 const void* ptr = reinterpret_cast<const uint8*>(&message) + 184 unknown_fields_offset_; 185 return *reinterpret_cast<const UnknownFieldSet*>(ptr); 186} 187UnknownFieldSet* GeneratedMessageReflection::MutableUnknownFields( 188 Message* message) const { 189 void* ptr = reinterpret_cast<uint8*>(message) + unknown_fields_offset_; 190 return reinterpret_cast<UnknownFieldSet*>(ptr); 191} 192 193int GeneratedMessageReflection::SpaceUsed(const Message& message) const { 194 // object_size_ already includes the in-memory representation of each field 195 // in the message, so we only need to account for additional memory used by 196 // the fields. 197 int total_size = object_size_; 198 199 total_size += GetUnknownFields(message).SpaceUsedExcludingSelf(); 200 201 if (extensions_offset_ != -1) { 202 total_size += GetExtensionSet(message).SpaceUsedExcludingSelf(); 203 } 204 205 for (int i = 0; i < descriptor_->field_count(); i++) { 206 const FieldDescriptor* field = descriptor_->field(i); 207 208 if (field->is_repeated()) { 209 switch (field->cpp_type()) { 210#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \ 211 case FieldDescriptor::CPPTYPE_##UPPERCASE : \ 212 total_size += GetRaw<RepeatedField<LOWERCASE> >(message, field) \ 213 .SpaceUsedExcludingSelf(); \ 214 break 215 216 HANDLE_TYPE( INT32, int32); 217 HANDLE_TYPE( INT64, int64); 218 HANDLE_TYPE(UINT32, uint32); 219 HANDLE_TYPE(UINT64, uint64); 220 HANDLE_TYPE(DOUBLE, double); 221 HANDLE_TYPE( FLOAT, float); 222 HANDLE_TYPE( BOOL, bool); 223 HANDLE_TYPE( ENUM, int); 224#undef HANDLE_TYPE 225 226 case FieldDescriptor::CPPTYPE_STRING: 227 switch (field->options().ctype()) { 228 default: // TODO(kenton): Support other string reps. 229 case FieldOptions::STRING: 230 total_size += GetRaw<RepeatedPtrField<string> >(message, field) 231 .SpaceUsedExcludingSelf(); 232 break; 233 } 234 break; 235 236 case FieldDescriptor::CPPTYPE_MESSAGE: 237 // We don't know which subclass of RepeatedPtrFieldBase the type is, 238 // so we use RepeatedPtrFieldBase directly. 239 total_size += 240 GetRaw<RepeatedPtrFieldBase>(message, field) 241 .SpaceUsedExcludingSelf<GenericTypeHandler<Message> >(); 242 break; 243 } 244 } else { 245 switch (field->cpp_type()) { 246 case FieldDescriptor::CPPTYPE_INT32 : 247 case FieldDescriptor::CPPTYPE_INT64 : 248 case FieldDescriptor::CPPTYPE_UINT32: 249 case FieldDescriptor::CPPTYPE_UINT64: 250 case FieldDescriptor::CPPTYPE_DOUBLE: 251 case FieldDescriptor::CPPTYPE_FLOAT : 252 case FieldDescriptor::CPPTYPE_BOOL : 253 case FieldDescriptor::CPPTYPE_ENUM : 254 // Field is inline, so we've already counted it. 255 break; 256 257 case FieldDescriptor::CPPTYPE_STRING: { 258 switch (field->options().ctype()) { 259 default: // TODO(kenton): Support other string reps. 260 case FieldOptions::STRING: { 261 const string* ptr = GetField<const string*>(message, field); 262 263 // Initially, the string points to the default value stored in 264 // the prototype. Only count the string if it has been changed 265 // from the default value. 266 const string* default_ptr = DefaultRaw<const string*>(field); 267 268 if (ptr != default_ptr) { 269 // string fields are represented by just a pointer, so also 270 // include sizeof(string) as well. 271 total_size += sizeof(*ptr) + StringSpaceUsedExcludingSelf(*ptr); 272 } 273 break; 274 } 275 } 276 break; 277 } 278 279 case FieldDescriptor::CPPTYPE_MESSAGE: 280 if (&message == default_instance_) { 281 // For singular fields, the prototype just stores a pointer to the 282 // external type's prototype, so there is no extra memory usage. 283 } else { 284 const Message* sub_message = GetRaw<const Message*>(message, field); 285 if (sub_message != NULL) { 286 total_size += sub_message->SpaceUsed(); 287 } 288 } 289 break; 290 } 291 } 292 } 293 294 return total_size; 295} 296 297void GeneratedMessageReflection::Swap( 298 Message* message1, 299 Message* message2) const { 300 if (message1 == message2) return; 301 302 // TODO(kenton): Other Reflection methods should probably check this too. 303 GOOGLE_CHECK_EQ(message1->GetReflection(), this) 304 << "First argument to Swap() (of type \"" 305 << message1->GetDescriptor()->full_name() 306 << "\") is not compatible with this reflection object (which is for type \"" 307 << descriptor_->full_name() 308 << "\"). Note that the exact same class is required; not just the same " 309 "descriptor."; 310 GOOGLE_CHECK_EQ(message2->GetReflection(), this) 311 << "Second argument to Swap() (of type \"" 312 << message2->GetDescriptor()->full_name() 313 << "\") is not compatible with this reflection object (which is for type \"" 314 << descriptor_->full_name() 315 << "\"). Note that the exact same class is required; not just the same " 316 "descriptor."; 317 318 uint32* has_bits1 = MutableHasBits(message1); 319 uint32* has_bits2 = MutableHasBits(message2); 320 int has_bits_size = (descriptor_->field_count() + 31) / 32; 321 322 for (int i = 0; i < has_bits_size; i++) { 323 std::swap(has_bits1[i], has_bits2[i]); 324 } 325 326 for (int i = 0; i < descriptor_->field_count(); i++) { 327 const FieldDescriptor* field = descriptor_->field(i); 328 if (field->is_repeated()) { 329 switch (field->cpp_type()) { 330#define SWAP_ARRAYS(CPPTYPE, TYPE) \ 331 case FieldDescriptor::CPPTYPE_##CPPTYPE: \ 332 MutableRaw<RepeatedField<TYPE> >(message1, field)->Swap( \ 333 MutableRaw<RepeatedField<TYPE> >(message2, field)); \ 334 break; 335 336 SWAP_ARRAYS(INT32 , int32 ); 337 SWAP_ARRAYS(INT64 , int64 ); 338 SWAP_ARRAYS(UINT32, uint32); 339 SWAP_ARRAYS(UINT64, uint64); 340 SWAP_ARRAYS(FLOAT , float ); 341 SWAP_ARRAYS(DOUBLE, double); 342 SWAP_ARRAYS(BOOL , bool ); 343 SWAP_ARRAYS(ENUM , int ); 344#undef SWAP_ARRAYS 345 346 case FieldDescriptor::CPPTYPE_STRING: 347 case FieldDescriptor::CPPTYPE_MESSAGE: 348 MutableRaw<RepeatedPtrFieldBase>(message1, field)->Swap( 349 MutableRaw<RepeatedPtrFieldBase>(message2, field)); 350 break; 351 352 default: 353 GOOGLE_LOG(FATAL) << "Unimplemented type: " << field->cpp_type(); 354 } 355 } else { 356 switch (field->cpp_type()) { 357#define SWAP_VALUES(CPPTYPE, TYPE) \ 358 case FieldDescriptor::CPPTYPE_##CPPTYPE: \ 359 std::swap(*MutableRaw<TYPE>(message1, field), \ 360 *MutableRaw<TYPE>(message2, field)); \ 361 break; 362 363 SWAP_VALUES(INT32 , int32 ); 364 SWAP_VALUES(INT64 , int64 ); 365 SWAP_VALUES(UINT32, uint32); 366 SWAP_VALUES(UINT64, uint64); 367 SWAP_VALUES(FLOAT , float ); 368 SWAP_VALUES(DOUBLE, double); 369 SWAP_VALUES(BOOL , bool ); 370 SWAP_VALUES(ENUM , int ); 371#undef SWAP_VALUES 372 case FieldDescriptor::CPPTYPE_MESSAGE: 373 std::swap(*MutableRaw<Message*>(message1, field), 374 *MutableRaw<Message*>(message2, field)); 375 break; 376 377 case FieldDescriptor::CPPTYPE_STRING: 378 switch (field->options().ctype()) { 379 default: // TODO(kenton): Support other string reps. 380 case FieldOptions::STRING: 381 std::swap(*MutableRaw<string*>(message1, field), 382 *MutableRaw<string*>(message2, field)); 383 break; 384 } 385 break; 386 387 default: 388 GOOGLE_LOG(FATAL) << "Unimplemented type: " << field->cpp_type(); 389 } 390 } 391 } 392 393 if (extensions_offset_ != -1) { 394 MutableExtensionSet(message1)->Swap(MutableExtensionSet(message2)); 395 } 396 397 MutableUnknownFields(message1)->Swap(MutableUnknownFields(message2)); 398} 399 400// ------------------------------------------------------------------- 401 402bool GeneratedMessageReflection::HasField(const Message& message, 403 const FieldDescriptor* field) const { 404 USAGE_CHECK_MESSAGE_TYPE(HasField); 405 USAGE_CHECK_SINGULAR(HasField); 406 407 if (field->is_extension()) { 408 return GetExtensionSet(message).Has(field->number()); 409 } else { 410 return HasBit(message, field); 411 } 412} 413 414int GeneratedMessageReflection::FieldSize(const Message& message, 415 const FieldDescriptor* field) const { 416 USAGE_CHECK_MESSAGE_TYPE(FieldSize); 417 USAGE_CHECK_REPEATED(FieldSize); 418 419 if (field->is_extension()) { 420 return GetExtensionSet(message).ExtensionSize(field->number()); 421 } else { 422 switch (field->cpp_type()) { 423#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \ 424 case FieldDescriptor::CPPTYPE_##UPPERCASE : \ 425 return GetRaw<RepeatedField<LOWERCASE> >(message, field).size() 426 427 HANDLE_TYPE( INT32, int32); 428 HANDLE_TYPE( INT64, int64); 429 HANDLE_TYPE(UINT32, uint32); 430 HANDLE_TYPE(UINT64, uint64); 431 HANDLE_TYPE(DOUBLE, double); 432 HANDLE_TYPE( FLOAT, float); 433 HANDLE_TYPE( BOOL, bool); 434 HANDLE_TYPE( ENUM, int); 435#undef HANDLE_TYPE 436 437 case FieldDescriptor::CPPTYPE_STRING: 438 case FieldDescriptor::CPPTYPE_MESSAGE: 439 return GetRaw<RepeatedPtrFieldBase>(message, field).size(); 440 } 441 442 GOOGLE_LOG(FATAL) << "Can't get here."; 443 return 0; 444 } 445} 446 447void GeneratedMessageReflection::ClearField( 448 Message* message, const FieldDescriptor* field) const { 449 USAGE_CHECK_MESSAGE_TYPE(ClearField); 450 451 if (field->is_extension()) { 452 MutableExtensionSet(message)->ClearExtension(field->number()); 453 } else if (!field->is_repeated()) { 454 if (HasBit(*message, field)) { 455 ClearBit(message, field); 456 457 // We need to set the field back to its default value. 458 switch (field->cpp_type()) { 459#define CLEAR_TYPE(CPPTYPE, TYPE) \ 460 case FieldDescriptor::CPPTYPE_##CPPTYPE: \ 461 *MutableRaw<TYPE>(message, field) = \ 462 field->default_value_##TYPE(); \ 463 break; 464 465 CLEAR_TYPE(INT32 , int32 ); 466 CLEAR_TYPE(INT64 , int64 ); 467 CLEAR_TYPE(UINT32, uint32); 468 CLEAR_TYPE(UINT64, uint64); 469 CLEAR_TYPE(FLOAT , float ); 470 CLEAR_TYPE(DOUBLE, double); 471 CLEAR_TYPE(BOOL , bool ); 472#undef CLEAR_TYPE 473 474 case FieldDescriptor::CPPTYPE_ENUM: 475 *MutableRaw<int>(message, field) = 476 field->default_value_enum()->number(); 477 break; 478 479 case FieldDescriptor::CPPTYPE_STRING: { 480 switch (field->options().ctype()) { 481 default: // TODO(kenton): Support other string reps. 482 case FieldOptions::STRING: 483 const string* default_ptr = DefaultRaw<const string*>(field); 484 string** value = MutableRaw<string*>(message, field); 485 if (*value != default_ptr) { 486 if (field->has_default_value()) { 487 (*value)->assign(field->default_value_string()); 488 } else { 489 (*value)->clear(); 490 } 491 } 492 break; 493 } 494 break; 495 } 496 497 case FieldDescriptor::CPPTYPE_MESSAGE: 498 (*MutableRaw<Message*>(message, field))->Clear(); 499 break; 500 } 501 } 502 } else { 503 switch (field->cpp_type()) { 504#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \ 505 case FieldDescriptor::CPPTYPE_##UPPERCASE : \ 506 MutableRaw<RepeatedField<LOWERCASE> >(message, field)->Clear(); \ 507 break 508 509 HANDLE_TYPE( INT32, int32); 510 HANDLE_TYPE( INT64, int64); 511 HANDLE_TYPE(UINT32, uint32); 512 HANDLE_TYPE(UINT64, uint64); 513 HANDLE_TYPE(DOUBLE, double); 514 HANDLE_TYPE( FLOAT, float); 515 HANDLE_TYPE( BOOL, bool); 516 HANDLE_TYPE( ENUM, int); 517#undef HANDLE_TYPE 518 519 case FieldDescriptor::CPPTYPE_STRING: { 520 switch (field->options().ctype()) { 521 default: // TODO(kenton): Support other string reps. 522 case FieldOptions::STRING: 523 MutableRaw<RepeatedPtrField<string> >(message, field)->Clear(); 524 break; 525 } 526 break; 527 } 528 529 case FieldDescriptor::CPPTYPE_MESSAGE: { 530 // We don't know which subclass of RepeatedPtrFieldBase the type is, 531 // so we use RepeatedPtrFieldBase directly. 532 MutableRaw<RepeatedPtrFieldBase>(message, field) 533 ->Clear<GenericTypeHandler<Message> >(); 534 break; 535 } 536 } 537 } 538} 539 540void GeneratedMessageReflection::RemoveLast( 541 Message* message, 542 const FieldDescriptor* field) const { 543 USAGE_CHECK_MESSAGE_TYPE(RemoveLast); 544 USAGE_CHECK_REPEATED(RemoveLast); 545 546 if (field->is_extension()) { 547 MutableExtensionSet(message)->RemoveLast(field->number()); 548 } else { 549 switch (field->cpp_type()) { 550#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \ 551 case FieldDescriptor::CPPTYPE_##UPPERCASE : \ 552 MutableRaw<RepeatedField<LOWERCASE> >(message, field)->RemoveLast(); \ 553 break 554 555 HANDLE_TYPE( INT32, int32); 556 HANDLE_TYPE( INT64, int64); 557 HANDLE_TYPE(UINT32, uint32); 558 HANDLE_TYPE(UINT64, uint64); 559 HANDLE_TYPE(DOUBLE, double); 560 HANDLE_TYPE( FLOAT, float); 561 HANDLE_TYPE( BOOL, bool); 562 HANDLE_TYPE( ENUM, int); 563#undef HANDLE_TYPE 564 565 case FieldDescriptor::CPPTYPE_STRING: 566 switch (field->options().ctype()) { 567 default: // TODO(kenton): Support other string reps. 568 case FieldOptions::STRING: 569 MutableRaw<RepeatedPtrField<string> >(message, field)->RemoveLast(); 570 break; 571 } 572 break; 573 574 case FieldDescriptor::CPPTYPE_MESSAGE: 575 MutableRaw<RepeatedPtrFieldBase>(message, field) 576 ->RemoveLast<GenericTypeHandler<Message> >(); 577 break; 578 } 579 } 580} 581 582Message* GeneratedMessageReflection::ReleaseLast( 583 Message* message, 584 const FieldDescriptor* field) const { 585 USAGE_CHECK_ALL(ReleaseLast, REPEATED, MESSAGE); 586 587 if (field->is_extension()) { 588 return static_cast<Message*>( 589 MutableExtensionSet(message)->ReleaseLast(field->number())); 590 } else { 591 return MutableRaw<RepeatedPtrFieldBase>(message, field) 592 ->ReleaseLast<GenericTypeHandler<Message> >(); 593 } 594} 595 596void GeneratedMessageReflection::SwapElements( 597 Message* message, 598 const FieldDescriptor* field, 599 int index1, 600 int index2) const { 601 USAGE_CHECK_MESSAGE_TYPE(Swap); 602 USAGE_CHECK_REPEATED(Swap); 603 604 if (field->is_extension()) { 605 MutableExtensionSet(message)->SwapElements(field->number(), index1, index2); 606 } else { 607 switch (field->cpp_type()) { 608#define HANDLE_TYPE(UPPERCASE, LOWERCASE) \ 609 case FieldDescriptor::CPPTYPE_##UPPERCASE : \ 610 MutableRaw<RepeatedField<LOWERCASE> >(message, field) \ 611 ->SwapElements(index1, index2); \ 612 break 613 614 HANDLE_TYPE( INT32, int32); 615 HANDLE_TYPE( INT64, int64); 616 HANDLE_TYPE(UINT32, uint32); 617 HANDLE_TYPE(UINT64, uint64); 618 HANDLE_TYPE(DOUBLE, double); 619 HANDLE_TYPE( FLOAT, float); 620 HANDLE_TYPE( BOOL, bool); 621 HANDLE_TYPE( ENUM, int); 622#undef HANDLE_TYPE 623 624 case FieldDescriptor::CPPTYPE_STRING: 625 case FieldDescriptor::CPPTYPE_MESSAGE: 626 MutableRaw<RepeatedPtrFieldBase>(message, field) 627 ->SwapElements(index1, index2); 628 break; 629 } 630 } 631} 632 633namespace { 634// Comparison functor for sorting FieldDescriptors by field number. 635struct FieldNumberSorter { 636 bool operator()(const FieldDescriptor* left, 637 const FieldDescriptor* right) const { 638 return left->number() < right->number(); 639 } 640}; 641} // namespace 642 643void GeneratedMessageReflection::ListFields( 644 const Message& message, 645 vector<const FieldDescriptor*>* output) const { 646 output->clear(); 647 648 // Optimization: The default instance never has any fields set. 649 if (&message == default_instance_) return; 650 651 for (int i = 0; i < descriptor_->field_count(); i++) { 652 const FieldDescriptor* field = descriptor_->field(i); 653 if (field->is_repeated()) { 654 if (FieldSize(message, field) > 0) { 655 output->push_back(field); 656 } 657 } else { 658 if (HasBit(message, field)) { 659 output->push_back(field); 660 } 661 } 662 } 663 664 if (extensions_offset_ != -1) { 665 GetExtensionSet(message).AppendToList(descriptor_, descriptor_pool_, 666 output); 667 } 668 669 // ListFields() must sort output by field number. 670 sort(output->begin(), output->end(), FieldNumberSorter()); 671} 672 673// ------------------------------------------------------------------- 674 675#undef DEFINE_PRIMITIVE_ACCESSORS 676#define DEFINE_PRIMITIVE_ACCESSORS(TYPENAME, TYPE, PASSTYPE, CPPTYPE) \ 677 PASSTYPE GeneratedMessageReflection::Get##TYPENAME( \ 678 const Message& message, const FieldDescriptor* field) const { \ 679 USAGE_CHECK_ALL(Get##TYPENAME, SINGULAR, CPPTYPE); \ 680 if (field->is_extension()) { \ 681 return GetExtensionSet(message).Get##TYPENAME( \ 682 field->number(), field->default_value_##PASSTYPE()); \ 683 } else { \ 684 return GetField<TYPE>(message, field); \ 685 } \ 686 } \ 687 \ 688 void GeneratedMessageReflection::Set##TYPENAME( \ 689 Message* message, const FieldDescriptor* field, \ 690 PASSTYPE value) const { \ 691 USAGE_CHECK_ALL(Set##TYPENAME, SINGULAR, CPPTYPE); \ 692 if (field->is_extension()) { \ 693 return MutableExtensionSet(message)->Set##TYPENAME( \ 694 field->number(), field->type(), value, field); \ 695 } else { \ 696 SetField<TYPE>(message, field, value); \ 697 } \ 698 } \ 699 \ 700 PASSTYPE GeneratedMessageReflection::GetRepeated##TYPENAME( \ 701 const Message& message, \ 702 const FieldDescriptor* field, int index) const { \ 703 USAGE_CHECK_ALL(GetRepeated##TYPENAME, REPEATED, CPPTYPE); \ 704 if (field->is_extension()) { \ 705 return GetExtensionSet(message).GetRepeated##TYPENAME( \ 706 field->number(), index); \ 707 } else { \ 708 return GetRepeatedField<TYPE>(message, field, index); \ 709 } \ 710 } \ 711 \ 712 void GeneratedMessageReflection::SetRepeated##TYPENAME( \ 713 Message* message, const FieldDescriptor* field, \ 714 int index, PASSTYPE value) const { \ 715 USAGE_CHECK_ALL(SetRepeated##TYPENAME, REPEATED, CPPTYPE); \ 716 if (field->is_extension()) { \ 717 MutableExtensionSet(message)->SetRepeated##TYPENAME( \ 718 field->number(), index, value); \ 719 } else { \ 720 SetRepeatedField<TYPE>(message, field, index, value); \ 721 } \ 722 } \ 723 \ 724 void GeneratedMessageReflection::Add##TYPENAME( \ 725 Message* message, const FieldDescriptor* field, \ 726 PASSTYPE value) const { \ 727 USAGE_CHECK_ALL(Add##TYPENAME, REPEATED, CPPTYPE); \ 728 if (field->is_extension()) { \ 729 MutableExtensionSet(message)->Add##TYPENAME( \ 730 field->number(), field->type(), field->options().packed(), value, \ 731 field); \ 732 } else { \ 733 AddField<TYPE>(message, field, value); \ 734 } \ 735 } 736 737DEFINE_PRIMITIVE_ACCESSORS(Int32 , int32 , int32 , INT32 ) 738DEFINE_PRIMITIVE_ACCESSORS(Int64 , int64 , int64 , INT64 ) 739DEFINE_PRIMITIVE_ACCESSORS(UInt32, uint32, uint32, UINT32) 740DEFINE_PRIMITIVE_ACCESSORS(UInt64, uint64, uint64, UINT64) 741DEFINE_PRIMITIVE_ACCESSORS(Float , float , float , FLOAT ) 742DEFINE_PRIMITIVE_ACCESSORS(Double, double, double, DOUBLE) 743DEFINE_PRIMITIVE_ACCESSORS(Bool , bool , bool , BOOL ) 744#undef DEFINE_PRIMITIVE_ACCESSORS 745 746// ------------------------------------------------------------------- 747 748string GeneratedMessageReflection::GetString( 749 const Message& message, const FieldDescriptor* field) const { 750 USAGE_CHECK_ALL(GetString, SINGULAR, STRING); 751 if (field->is_extension()) { 752 return GetExtensionSet(message).GetString(field->number(), 753 field->default_value_string()); 754 } else { 755 switch (field->options().ctype()) { 756 default: // TODO(kenton): Support other string reps. 757 case FieldOptions::STRING: 758 return *GetField<const string*>(message, field); 759 } 760 761 GOOGLE_LOG(FATAL) << "Can't get here."; 762 return GetEmptyString(); // Make compiler happy. 763 } 764} 765 766const string& GeneratedMessageReflection::GetStringReference( 767 const Message& message, 768 const FieldDescriptor* field, string* scratch) const { 769 USAGE_CHECK_ALL(GetStringReference, SINGULAR, STRING); 770 if (field->is_extension()) { 771 return GetExtensionSet(message).GetString(field->number(), 772 field->default_value_string()); 773 } else { 774 switch (field->options().ctype()) { 775 default: // TODO(kenton): Support other string reps. 776 case FieldOptions::STRING: 777 return *GetField<const string*>(message, field); 778 } 779 780 GOOGLE_LOG(FATAL) << "Can't get here."; 781 return GetEmptyString(); // Make compiler happy. 782 } 783} 784 785 786void GeneratedMessageReflection::SetString( 787 Message* message, const FieldDescriptor* field, 788 const string& value) const { 789 USAGE_CHECK_ALL(SetString, SINGULAR, STRING); 790 if (field->is_extension()) { 791 return MutableExtensionSet(message)->SetString(field->number(), 792 field->type(), value, field); 793 } else { 794 switch (field->options().ctype()) { 795 default: // TODO(kenton): Support other string reps. 796 case FieldOptions::STRING: { 797 string** ptr = MutableField<string*>(message, field); 798 if (*ptr == DefaultRaw<const string*>(field)) { 799 *ptr = new string(value); 800 } else { 801 (*ptr)->assign(value); 802 } 803 break; 804 } 805 } 806 } 807} 808 809 810string GeneratedMessageReflection::GetRepeatedString( 811 const Message& message, const FieldDescriptor* field, int index) const { 812 USAGE_CHECK_ALL(GetRepeatedString, REPEATED, STRING); 813 if (field->is_extension()) { 814 return GetExtensionSet(message).GetRepeatedString(field->number(), index); 815 } else { 816 switch (field->options().ctype()) { 817 default: // TODO(kenton): Support other string reps. 818 case FieldOptions::STRING: 819 return GetRepeatedPtrField<string>(message, field, index); 820 } 821 822 GOOGLE_LOG(FATAL) << "Can't get here."; 823 return GetEmptyString(); // Make compiler happy. 824 } 825} 826 827const string& GeneratedMessageReflection::GetRepeatedStringReference( 828 const Message& message, const FieldDescriptor* field, 829 int index, string* scratch) const { 830 USAGE_CHECK_ALL(GetRepeatedStringReference, REPEATED, STRING); 831 if (field->is_extension()) { 832 return GetExtensionSet(message).GetRepeatedString(field->number(), index); 833 } else { 834 switch (field->options().ctype()) { 835 default: // TODO(kenton): Support other string reps. 836 case FieldOptions::STRING: 837 return GetRepeatedPtrField<string>(message, field, index); 838 } 839 840 GOOGLE_LOG(FATAL) << "Can't get here."; 841 return GetEmptyString(); // Make compiler happy. 842 } 843} 844 845 846void GeneratedMessageReflection::SetRepeatedString( 847 Message* message, const FieldDescriptor* field, 848 int index, const string& value) const { 849 USAGE_CHECK_ALL(SetRepeatedString, REPEATED, STRING); 850 if (field->is_extension()) { 851 MutableExtensionSet(message)->SetRepeatedString( 852 field->number(), index, value); 853 } else { 854 switch (field->options().ctype()) { 855 default: // TODO(kenton): Support other string reps. 856 case FieldOptions::STRING: 857 *MutableRepeatedField<string>(message, field, index) = value; 858 break; 859 } 860 } 861} 862 863 864void GeneratedMessageReflection::AddString( 865 Message* message, const FieldDescriptor* field, 866 const string& value) const { 867 USAGE_CHECK_ALL(AddString, REPEATED, STRING); 868 if (field->is_extension()) { 869 MutableExtensionSet(message)->AddString(field->number(), 870 field->type(), value, field); 871 } else { 872 switch (field->options().ctype()) { 873 default: // TODO(kenton): Support other string reps. 874 case FieldOptions::STRING: 875 *AddField<string>(message, field) = value; 876 break; 877 } 878 } 879} 880 881 882// ------------------------------------------------------------------- 883 884const EnumValueDescriptor* GeneratedMessageReflection::GetEnum( 885 const Message& message, const FieldDescriptor* field) const { 886 USAGE_CHECK_ALL(GetEnum, SINGULAR, ENUM); 887 888 int value; 889 if (field->is_extension()) { 890 value = GetExtensionSet(message).GetEnum( 891 field->number(), field->default_value_enum()->number()); 892 } else { 893 value = GetField<int>(message, field); 894 } 895 const EnumValueDescriptor* result = 896 field->enum_type()->FindValueByNumber(value); 897 GOOGLE_CHECK(result != NULL) << "Value " << value << " is not valid for field " 898 << field->full_name() << " of type " 899 << field->enum_type()->full_name() << "."; 900 return result; 901} 902 903void GeneratedMessageReflection::SetEnum( 904 Message* message, const FieldDescriptor* field, 905 const EnumValueDescriptor* value) const { 906 USAGE_CHECK_ALL(SetEnum, SINGULAR, ENUM); 907 USAGE_CHECK_ENUM_VALUE(SetEnum); 908 909 if (field->is_extension()) { 910 MutableExtensionSet(message)->SetEnum(field->number(), field->type(), 911 value->number(), field); 912 } else { 913 SetField<int>(message, field, value->number()); 914 } 915} 916 917const EnumValueDescriptor* GeneratedMessageReflection::GetRepeatedEnum( 918 const Message& message, const FieldDescriptor* field, int index) const { 919 USAGE_CHECK_ALL(GetRepeatedEnum, REPEATED, ENUM); 920 921 int value; 922 if (field->is_extension()) { 923 value = GetExtensionSet(message).GetRepeatedEnum(field->number(), index); 924 } else { 925 value = GetRepeatedField<int>(message, field, index); 926 } 927 const EnumValueDescriptor* result = 928 field->enum_type()->FindValueByNumber(value); 929 GOOGLE_CHECK(result != NULL) << "Value " << value << " is not valid for field " 930 << field->full_name() << " of type " 931 << field->enum_type()->full_name() << "."; 932 return result; 933} 934 935void GeneratedMessageReflection::SetRepeatedEnum( 936 Message* message, 937 const FieldDescriptor* field, int index, 938 const EnumValueDescriptor* value) const { 939 USAGE_CHECK_ALL(SetRepeatedEnum, REPEATED, ENUM); 940 USAGE_CHECK_ENUM_VALUE(SetRepeatedEnum); 941 942 if (field->is_extension()) { 943 MutableExtensionSet(message)->SetRepeatedEnum( 944 field->number(), index, value->number()); 945 } else { 946 SetRepeatedField<int>(message, field, index, value->number()); 947 } 948} 949 950void GeneratedMessageReflection::AddEnum( 951 Message* message, const FieldDescriptor* field, 952 const EnumValueDescriptor* value) const { 953 USAGE_CHECK_ALL(AddEnum, REPEATED, ENUM); 954 USAGE_CHECK_ENUM_VALUE(AddEnum); 955 956 if (field->is_extension()) { 957 MutableExtensionSet(message)->AddEnum(field->number(), field->type(), 958 field->options().packed(), 959 value->number(), field); 960 } else { 961 AddField<int>(message, field, value->number()); 962 } 963} 964 965// ------------------------------------------------------------------- 966 967const Message& GeneratedMessageReflection::GetMessage( 968 const Message& message, const FieldDescriptor* field, 969 MessageFactory* factory) const { 970 USAGE_CHECK_ALL(GetMessage, SINGULAR, MESSAGE); 971 972 if (factory == NULL) factory = message_factory_; 973 974 if (field->is_extension()) { 975 return static_cast<const Message&>( 976 GetExtensionSet(message).GetMessage( 977 field->number(), field->message_type(), factory)); 978 } else { 979 const Message* result; 980 result = GetRaw<const Message*>(message, field); 981 if (result == NULL) { 982 result = DefaultRaw<const Message*>(field); 983 } 984 return *result; 985 } 986} 987 988Message* GeneratedMessageReflection::MutableMessage( 989 Message* message, const FieldDescriptor* field, 990 MessageFactory* factory) const { 991 USAGE_CHECK_ALL(MutableMessage, SINGULAR, MESSAGE); 992 993 if (factory == NULL) factory = message_factory_; 994 995 if (field->is_extension()) { 996 return static_cast<Message*>( 997 MutableExtensionSet(message)->MutableMessage(field, factory)); 998 } else { 999 Message* result; 1000 Message** result_holder = MutableField<Message*>(message, field); 1001 if (*result_holder == NULL) { 1002 const Message* default_message = DefaultRaw<const Message*>(field); 1003 *result_holder = default_message->New(); 1004 } 1005 result = *result_holder; 1006 return result; 1007 } 1008} 1009 1010Message* GeneratedMessageReflection::ReleaseMessage( 1011 Message* message, 1012 const FieldDescriptor* field, 1013 MessageFactory* factory) const { 1014 USAGE_CHECK_ALL(ReleaseMessage, SINGULAR, MESSAGE); 1015 1016 if (factory == NULL) factory = message_factory_; 1017 1018 if (field->is_extension()) { 1019 return static_cast<Message*>( 1020 MutableExtensionSet(message)->ReleaseMessage(field, factory)); 1021 } else { 1022 ClearBit(message, field); 1023 Message** result = MutableRaw<Message*>(message, field); 1024 Message* ret = *result; 1025 *result = NULL; 1026 return ret; 1027 } 1028} 1029 1030const Message& GeneratedMessageReflection::GetRepeatedMessage( 1031 const Message& message, const FieldDescriptor* field, int index) const { 1032 USAGE_CHECK_ALL(GetRepeatedMessage, REPEATED, MESSAGE); 1033 1034 if (field->is_extension()) { 1035 return static_cast<const Message&>( 1036 GetExtensionSet(message).GetRepeatedMessage(field->number(), index)); 1037 } else { 1038 return GetRaw<RepeatedPtrFieldBase>(message, field) 1039 .Get<GenericTypeHandler<Message> >(index); 1040 } 1041} 1042 1043Message* GeneratedMessageReflection::MutableRepeatedMessage( 1044 Message* message, const FieldDescriptor* field, int index) const { 1045 USAGE_CHECK_ALL(MutableRepeatedMessage, REPEATED, MESSAGE); 1046 1047 if (field->is_extension()) { 1048 return static_cast<Message*>( 1049 MutableExtensionSet(message)->MutableRepeatedMessage( 1050 field->number(), index)); 1051 } else { 1052 return MutableRaw<RepeatedPtrFieldBase>(message, field) 1053 ->Mutable<GenericTypeHandler<Message> >(index); 1054 } 1055} 1056 1057Message* GeneratedMessageReflection::AddMessage( 1058 Message* message, const FieldDescriptor* field, 1059 MessageFactory* factory) const { 1060 USAGE_CHECK_ALL(AddMessage, REPEATED, MESSAGE); 1061 1062 if (factory == NULL) factory = message_factory_; 1063 1064 if (field->is_extension()) { 1065 return static_cast<Message*>( 1066 MutableExtensionSet(message)->AddMessage(field, factory)); 1067 } else { 1068 // We can't use AddField<Message>() because RepeatedPtrFieldBase doesn't 1069 // know how to allocate one. 1070 RepeatedPtrFieldBase* repeated = 1071 MutableRaw<RepeatedPtrFieldBase>(message, field); 1072 Message* result = repeated->AddFromCleared<GenericTypeHandler<Message> >(); 1073 if (result == NULL) { 1074 // We must allocate a new object. 1075 const Message* prototype; 1076 if (repeated->size() == 0) { 1077 prototype = factory->GetPrototype(field->message_type()); 1078 } else { 1079 prototype = &repeated->Get<GenericTypeHandler<Message> >(0); 1080 } 1081 result = prototype->New(); 1082 repeated->AddAllocated<GenericTypeHandler<Message> >(result); 1083 } 1084 return result; 1085 } 1086} 1087 1088void* GeneratedMessageReflection::MutableRawRepeatedField( 1089 Message* message, const FieldDescriptor* field, 1090 FieldDescriptor::CppType cpptype, 1091 int ctype, const Descriptor* desc) const { 1092 USAGE_CHECK_REPEATED("MutableRawRepeatedField"); 1093 if (field->cpp_type() != cpptype) 1094 ReportReflectionUsageTypeError(descriptor_, 1095 field, "MutableRawRepeatedField", cpptype); 1096 if (ctype >= 0) 1097 GOOGLE_CHECK_EQ(field->options().ctype(), ctype) << "subtype mismatch"; 1098 if (desc != NULL) 1099 GOOGLE_CHECK_EQ(field->message_type(), desc) << "wrong submessage type"; 1100 if (field->is_extension()) 1101 return MutableExtensionSet(message)->MutableRawRepeatedField( 1102 field->number()); 1103 else 1104 return reinterpret_cast<uint8*>(message) + offsets_[field->index()]; 1105} 1106 1107// ----------------------------------------------------------------------------- 1108 1109const FieldDescriptor* GeneratedMessageReflection::FindKnownExtensionByName( 1110 const string& name) const { 1111 if (extensions_offset_ == -1) return NULL; 1112 1113 const FieldDescriptor* result = descriptor_pool_->FindExtensionByName(name); 1114 if (result != NULL && result->containing_type() == descriptor_) { 1115 return result; 1116 } 1117 1118 if (descriptor_->options().message_set_wire_format()) { 1119 // MessageSet extensions may be identified by type name. 1120 const Descriptor* type = descriptor_pool_->FindMessageTypeByName(name); 1121 if (type != NULL) { 1122 // Look for a matching extension in the foreign type's scope. 1123 for (int i = 0; i < type->extension_count(); i++) { 1124 const FieldDescriptor* extension = type->extension(i); 1125 if (extension->containing_type() == descriptor_ && 1126 extension->type() == FieldDescriptor::TYPE_MESSAGE && 1127 extension->is_optional() && 1128 extension->message_type() == type) { 1129 // Found it. 1130 return extension; 1131 } 1132 } 1133 } 1134 } 1135 1136 return NULL; 1137} 1138 1139const FieldDescriptor* GeneratedMessageReflection::FindKnownExtensionByNumber( 1140 int number) const { 1141 if (extensions_offset_ == -1) return NULL; 1142 return descriptor_pool_->FindExtensionByNumber(descriptor_, number); 1143} 1144 1145// =================================================================== 1146// Some private helpers. 1147 1148// These simple template accessors obtain pointers (or references) to 1149// the given field. 1150template <typename Type> 1151inline const Type& GeneratedMessageReflection::GetRaw( 1152 const Message& message, const FieldDescriptor* field) const { 1153 const void* ptr = reinterpret_cast<const uint8*>(&message) + 1154 offsets_[field->index()]; 1155 return *reinterpret_cast<const Type*>(ptr); 1156} 1157 1158template <typename Type> 1159inline Type* GeneratedMessageReflection::MutableRaw( 1160 Message* message, const FieldDescriptor* field) const { 1161 void* ptr = reinterpret_cast<uint8*>(message) + offsets_[field->index()]; 1162 return reinterpret_cast<Type*>(ptr); 1163} 1164 1165template <typename Type> 1166inline const Type& GeneratedMessageReflection::DefaultRaw( 1167 const FieldDescriptor* field) const { 1168 const void* ptr = reinterpret_cast<const uint8*>(default_instance_) + 1169 offsets_[field->index()]; 1170 return *reinterpret_cast<const Type*>(ptr); 1171} 1172 1173inline const uint32* GeneratedMessageReflection::GetHasBits( 1174 const Message& message) const { 1175 const void* ptr = reinterpret_cast<const uint8*>(&message) + has_bits_offset_; 1176 return reinterpret_cast<const uint32*>(ptr); 1177} 1178inline uint32* GeneratedMessageReflection::MutableHasBits( 1179 Message* message) const { 1180 void* ptr = reinterpret_cast<uint8*>(message) + has_bits_offset_; 1181 return reinterpret_cast<uint32*>(ptr); 1182} 1183 1184inline const ExtensionSet& GeneratedMessageReflection::GetExtensionSet( 1185 const Message& message) const { 1186 GOOGLE_DCHECK_NE(extensions_offset_, -1); 1187 const void* ptr = reinterpret_cast<const uint8*>(&message) + 1188 extensions_offset_; 1189 return *reinterpret_cast<const ExtensionSet*>(ptr); 1190} 1191inline ExtensionSet* GeneratedMessageReflection::MutableExtensionSet( 1192 Message* message) const { 1193 GOOGLE_DCHECK_NE(extensions_offset_, -1); 1194 void* ptr = reinterpret_cast<uint8*>(message) + extensions_offset_; 1195 return reinterpret_cast<ExtensionSet*>(ptr); 1196} 1197 1198// Simple accessors for manipulating has_bits_. 1199inline bool GeneratedMessageReflection::HasBit( 1200 const Message& message, const FieldDescriptor* field) const { 1201 return GetHasBits(message)[field->index() / 32] & 1202 (1 << (field->index() % 32)); 1203} 1204 1205inline void GeneratedMessageReflection::SetBit( 1206 Message* message, const FieldDescriptor* field) const { 1207 MutableHasBits(message)[field->index() / 32] |= (1 << (field->index() % 32)); 1208} 1209 1210inline void GeneratedMessageReflection::ClearBit( 1211 Message* message, const FieldDescriptor* field) const { 1212 MutableHasBits(message)[field->index() / 32] &= ~(1 << (field->index() % 32)); 1213} 1214 1215// Template implementations of basic accessors. Inline because each 1216// template instance is only called from one location. These are 1217// used for all types except messages. 1218template <typename Type> 1219inline const Type& GeneratedMessageReflection::GetField( 1220 const Message& message, const FieldDescriptor* field) const { 1221 return GetRaw<Type>(message, field); 1222} 1223 1224template <typename Type> 1225inline void GeneratedMessageReflection::SetField( 1226 Message* message, const FieldDescriptor* field, const Type& value) const { 1227 *MutableRaw<Type>(message, field) = value; 1228 SetBit(message, field); 1229} 1230 1231template <typename Type> 1232inline Type* GeneratedMessageReflection::MutableField( 1233 Message* message, const FieldDescriptor* field) const { 1234 SetBit(message, field); 1235 return MutableRaw<Type>(message, field); 1236} 1237 1238template <typename Type> 1239inline const Type& GeneratedMessageReflection::GetRepeatedField( 1240 const Message& message, const FieldDescriptor* field, int index) const { 1241 return GetRaw<RepeatedField<Type> >(message, field).Get(index); 1242} 1243 1244template <typename Type> 1245inline const Type& GeneratedMessageReflection::GetRepeatedPtrField( 1246 const Message& message, const FieldDescriptor* field, int index) const { 1247 return GetRaw<RepeatedPtrField<Type> >(message, field).Get(index); 1248} 1249 1250template <typename Type> 1251inline void GeneratedMessageReflection::SetRepeatedField( 1252 Message* message, const FieldDescriptor* field, 1253 int index, Type value) const { 1254 MutableRaw<RepeatedField<Type> >(message, field)->Set(index, value); 1255} 1256 1257template <typename Type> 1258inline Type* GeneratedMessageReflection::MutableRepeatedField( 1259 Message* message, const FieldDescriptor* field, int index) const { 1260 RepeatedPtrField<Type>* repeated = 1261 MutableRaw<RepeatedPtrField<Type> >(message, field); 1262 return repeated->Mutable(index); 1263} 1264 1265template <typename Type> 1266inline void GeneratedMessageReflection::AddField( 1267 Message* message, const FieldDescriptor* field, const Type& value) const { 1268 MutableRaw<RepeatedField<Type> >(message, field)->Add(value); 1269} 1270 1271template <typename Type> 1272inline Type* GeneratedMessageReflection::AddField( 1273 Message* message, const FieldDescriptor* field) const { 1274 RepeatedPtrField<Type>* repeated = 1275 MutableRaw<RepeatedPtrField<Type> >(message, field); 1276 return repeated->Add(); 1277} 1278 1279} // namespace internal 1280} // namespace protobuf 1281} // namespace google 1282