/thirdparty/breakpad/third_party/protobuf/protobuf/src/google/protobuf/generated_message_reflection.cc

http://github.com/tomahawk-player/tomahawk · C++ · 1228 lines · 1001 code · 150 blank · 77 comment · 160 complexity · d0ddf6e221c7b4f0ed97a726f08ad4e9 MD5 · raw file

  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. // Author: kenton@google.com (Kenton Varda)
  31. // Based on original Protocol Buffers design by
  32. // Sanjay Ghemawat, Jeff Dean, and others.
  33. #include <algorithm>
  34. #include <google/protobuf/generated_message_reflection.h>
  35. #include <google/protobuf/descriptor.h>
  36. #include <google/protobuf/descriptor.pb.h>
  37. #include <google/protobuf/repeated_field.h>
  38. #include <google/protobuf/extension_set.h>
  39. #include <google/protobuf/generated_message_util.h>
  40. #include <google/protobuf/stubs/common.h>
  41. namespace google {
  42. namespace protobuf {
  43. namespace internal {
  44. int StringSpaceUsedExcludingSelf(const string& str) {
  45. const void* start = &str;
  46. const void* end = &str + 1;
  47. if (start <= str.data() && str.data() <= end) {
  48. // The string's data is stored inside the string object itself.
  49. return 0;
  50. } else {
  51. return str.capacity();
  52. }
  53. }
  54. bool ParseNamedEnum(const EnumDescriptor* descriptor,
  55. const string& name,
  56. int* value) {
  57. const EnumValueDescriptor* d = descriptor->FindValueByName(name);
  58. if (d == NULL) return false;
  59. *value = d->number();
  60. return true;
  61. }
  62. const string& NameOfEnum(const EnumDescriptor* descriptor, int value) {
  63. const EnumValueDescriptor* d = descriptor->FindValueByNumber(value);
  64. return (d == NULL ? kEmptyString : d->name());
  65. }
  66. // ===================================================================
  67. // Helpers for reporting usage errors (e.g. trying to use GetInt32() on
  68. // a string field).
  69. namespace {
  70. void ReportReflectionUsageError(
  71. const Descriptor* descriptor, const FieldDescriptor* field,
  72. const char* method, const char* description) {
  73. GOOGLE_LOG(FATAL)
  74. << "Protocol Buffer reflection usage error:\n"
  75. " Method : google::protobuf::Reflection::" << method << "\n"
  76. " Message type: " << descriptor->full_name() << "\n"
  77. " Field : " << field->full_name() << "\n"
  78. " Problem : " << description;
  79. }
  80. const char* cpptype_names_[FieldDescriptor::MAX_CPPTYPE + 1] = {
  81. "INVALID_CPPTYPE",
  82. "CPPTYPE_INT32",
  83. "CPPTYPE_INT64",
  84. "CPPTYPE_UINT32",
  85. "CPPTYPE_UINT64",
  86. "CPPTYPE_DOUBLE",
  87. "CPPTYPE_FLOAT",
  88. "CPPTYPE_BOOL",
  89. "CPPTYPE_ENUM",
  90. "CPPTYPE_STRING",
  91. "CPPTYPE_MESSAGE"
  92. };
  93. static 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. static void ReportReflectionUsageEnumTypeError(
  107. const Descriptor* descriptor, const FieldDescriptor* field,
  108. const char* method, const EnumValueDescriptor* value) {
  109. GOOGLE_LOG(FATAL)
  110. << "Protocol Buffer reflection usage error:\n"
  111. " Method : google::protobuf::Reflection::" << method << "\n"
  112. " Message type: " << descriptor->full_name() << "\n"
  113. " Field : " << field->full_name() << "\n"
  114. " Problem : Enum value did not match field type:\n"
  115. " Expected : " << field->enum_type()->full_name() << "\n"
  116. " Actual : " << value->full_name();
  117. }
  118. #define USAGE_CHECK(CONDITION, METHOD, ERROR_DESCRIPTION) \
  119. if (!(CONDITION)) \
  120. ReportReflectionUsageError(descriptor_, field, #METHOD, ERROR_DESCRIPTION)
  121. #define USAGE_CHECK_EQ(A, B, METHOD, ERROR_DESCRIPTION) \
  122. USAGE_CHECK((A) == (B), METHOD, ERROR_DESCRIPTION)
  123. #define USAGE_CHECK_NE(A, B, METHOD, ERROR_DESCRIPTION) \
  124. USAGE_CHECK((A) != (B), METHOD, ERROR_DESCRIPTION)
  125. #define USAGE_CHECK_TYPE(METHOD, CPPTYPE) \
  126. if (field->cpp_type() != FieldDescriptor::CPPTYPE_##CPPTYPE) \
  127. ReportReflectionUsageTypeError(descriptor_, field, #METHOD, \
  128. FieldDescriptor::CPPTYPE_##CPPTYPE)
  129. #define USAGE_CHECK_ENUM_VALUE(METHOD) \
  130. if (value->type() != field->enum_type()) \
  131. ReportReflectionUsageEnumTypeError(descriptor_, field, #METHOD, value)
  132. #define USAGE_CHECK_MESSAGE_TYPE(METHOD) \
  133. USAGE_CHECK_EQ(field->containing_type(), descriptor_, \
  134. METHOD, "Field does not match message type.");
  135. #define USAGE_CHECK_SINGULAR(METHOD) \
  136. USAGE_CHECK_NE(field->label(), FieldDescriptor::LABEL_REPEATED, METHOD, \
  137. "Field is repeated; the method requires a singular field.")
  138. #define USAGE_CHECK_REPEATED(METHOD) \
  139. USAGE_CHECK_EQ(field->label(), FieldDescriptor::LABEL_REPEATED, METHOD, \
  140. "Field is singular; the method requires a repeated field.")
  141. #define USAGE_CHECK_ALL(METHOD, LABEL, CPPTYPE) \
  142. USAGE_CHECK_MESSAGE_TYPE(METHOD); \
  143. USAGE_CHECK_##LABEL(METHOD); \
  144. USAGE_CHECK_TYPE(METHOD, CPPTYPE)
  145. } // namespace
  146. // ===================================================================
  147. GeneratedMessageReflection::GeneratedMessageReflection(
  148. const Descriptor* descriptor,
  149. const Message* default_instance,
  150. const int offsets[],
  151. int has_bits_offset,
  152. int unknown_fields_offset,
  153. int extensions_offset,
  154. const DescriptorPool* descriptor_pool,
  155. MessageFactory* factory,
  156. int object_size)
  157. : descriptor_ (descriptor),
  158. default_instance_ (default_instance),
  159. offsets_ (offsets),
  160. has_bits_offset_ (has_bits_offset),
  161. unknown_fields_offset_(unknown_fields_offset),
  162. extensions_offset_(extensions_offset),
  163. object_size_ (object_size),
  164. descriptor_pool_ ((descriptor_pool == NULL) ?
  165. DescriptorPool::generated_pool() :
  166. descriptor_pool),
  167. message_factory_ (factory) {
  168. }
  169. GeneratedMessageReflection::~GeneratedMessageReflection() {}
  170. const UnknownFieldSet& GeneratedMessageReflection::GetUnknownFields(
  171. const Message& message) const {
  172. const void* ptr = reinterpret_cast<const uint8*>(&message) +
  173. unknown_fields_offset_;
  174. return *reinterpret_cast<const UnknownFieldSet*>(ptr);
  175. }
  176. UnknownFieldSet* GeneratedMessageReflection::MutableUnknownFields(
  177. Message* message) const {
  178. void* ptr = reinterpret_cast<uint8*>(message) + unknown_fields_offset_;
  179. return reinterpret_cast<UnknownFieldSet*>(ptr);
  180. }
  181. int GeneratedMessageReflection::SpaceUsed(const Message& message) const {
  182. // object_size_ already includes the in-memory representation of each field
  183. // in the message, so we only need to account for additional memory used by
  184. // the fields.
  185. int total_size = object_size_;
  186. total_size += GetUnknownFields(message).SpaceUsedExcludingSelf();
  187. if (extensions_offset_ != -1) {
  188. total_size += GetExtensionSet(message).SpaceUsedExcludingSelf();
  189. }
  190. for (int i = 0; i < descriptor_->field_count(); i++) {
  191. const FieldDescriptor* field = descriptor_->field(i);
  192. if (field->is_repeated()) {
  193. switch (field->cpp_type()) {
  194. #define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
  195. case FieldDescriptor::CPPTYPE_##UPPERCASE : \
  196. total_size += GetRaw<RepeatedField<LOWERCASE> >(message, field) \
  197. .SpaceUsedExcludingSelf(); \
  198. break
  199. HANDLE_TYPE( INT32, int32);
  200. HANDLE_TYPE( INT64, int64);
  201. HANDLE_TYPE(UINT32, uint32);
  202. HANDLE_TYPE(UINT64, uint64);
  203. HANDLE_TYPE(DOUBLE, double);
  204. HANDLE_TYPE( FLOAT, float);
  205. HANDLE_TYPE( BOOL, bool);
  206. HANDLE_TYPE( ENUM, int);
  207. #undef HANDLE_TYPE
  208. case FieldDescriptor::CPPTYPE_STRING:
  209. switch (field->options().ctype()) {
  210. default: // TODO(kenton): Support other string reps.
  211. case FieldOptions::STRING:
  212. total_size += GetRaw<RepeatedPtrField<string> >(message, field)
  213. .SpaceUsedExcludingSelf();
  214. break;
  215. }
  216. break;
  217. case FieldDescriptor::CPPTYPE_MESSAGE:
  218. // We don't know which subclass of RepeatedPtrFieldBase the type is,
  219. // so we use RepeatedPtrFieldBase directly.
  220. total_size +=
  221. GetRaw<RepeatedPtrFieldBase>(message, field)
  222. .SpaceUsedExcludingSelf<GenericTypeHandler<Message> >();
  223. break;
  224. }
  225. } else {
  226. switch (field->cpp_type()) {
  227. case FieldDescriptor::CPPTYPE_INT32 :
  228. case FieldDescriptor::CPPTYPE_INT64 :
  229. case FieldDescriptor::CPPTYPE_UINT32:
  230. case FieldDescriptor::CPPTYPE_UINT64:
  231. case FieldDescriptor::CPPTYPE_DOUBLE:
  232. case FieldDescriptor::CPPTYPE_FLOAT :
  233. case FieldDescriptor::CPPTYPE_BOOL :
  234. case FieldDescriptor::CPPTYPE_ENUM :
  235. // Field is inline, so we've already counted it.
  236. break;
  237. case FieldDescriptor::CPPTYPE_STRING: {
  238. switch (field->options().ctype()) {
  239. default: // TODO(kenton): Support other string reps.
  240. case FieldOptions::STRING: {
  241. const string* ptr = GetField<const string*>(message, field);
  242. // Initially, the string points to the default value stored in
  243. // the prototype. Only count the string if it has been changed
  244. // from the default value.
  245. const string* default_ptr = DefaultRaw<const string*>(field);
  246. if (ptr != default_ptr) {
  247. // string fields are represented by just a pointer, so also
  248. // include sizeof(string) as well.
  249. total_size += sizeof(*ptr) + StringSpaceUsedExcludingSelf(*ptr);
  250. }
  251. break;
  252. }
  253. }
  254. break;
  255. }
  256. case FieldDescriptor::CPPTYPE_MESSAGE:
  257. if (&message == default_instance_) {
  258. // For singular fields, the prototype just stores a pointer to the
  259. // external type's prototype, so there is no extra memory usage.
  260. } else {
  261. const Message* sub_message = GetRaw<const Message*>(message, field);
  262. if (sub_message != NULL) {
  263. total_size += sub_message->SpaceUsed();
  264. }
  265. }
  266. break;
  267. }
  268. }
  269. }
  270. return total_size;
  271. }
  272. void GeneratedMessageReflection::Swap(
  273. Message* message1,
  274. Message* message2) const {
  275. if (message1 == message2) return;
  276. // TODO(kenton): Other Reflection methods should probably check this too.
  277. GOOGLE_CHECK_EQ(message1->GetReflection(), this)
  278. << "First argument to Swap() (of type \""
  279. << message1->GetDescriptor()->full_name()
  280. << "\") is not compatible with this reflection object (which is for type \""
  281. << descriptor_->full_name()
  282. << "\"). Note that the exact same class is required; not just the same "
  283. "descriptor.";
  284. GOOGLE_CHECK_EQ(message2->GetReflection(), this)
  285. << "Second argument to Swap() (of type \""
  286. << message1->GetDescriptor()->full_name()
  287. << "\") is not compatible with this reflection object (which is for type \""
  288. << descriptor_->full_name()
  289. << "\"). Note that the exact same class is required; not just the same "
  290. "descriptor.";
  291. uint32* has_bits1 = MutableHasBits(message1);
  292. uint32* has_bits2 = MutableHasBits(message2);
  293. int has_bits_size = (descriptor_->field_count() + 31) / 32;
  294. for (int i = 0; i < has_bits_size; i++) {
  295. std::swap(has_bits1[i], has_bits2[i]);
  296. }
  297. for (int i = 0; i < descriptor_->field_count(); i++) {
  298. const FieldDescriptor* field = descriptor_->field(i);
  299. if (field->is_repeated()) {
  300. switch (field->cpp_type()) {
  301. #define SWAP_ARRAYS(CPPTYPE, TYPE) \
  302. case FieldDescriptor::CPPTYPE_##CPPTYPE: \
  303. MutableRaw<RepeatedField<TYPE> >(message1, field)->Swap( \
  304. MutableRaw<RepeatedField<TYPE> >(message2, field)); \
  305. break;
  306. SWAP_ARRAYS(INT32 , int32 );
  307. SWAP_ARRAYS(INT64 , int64 );
  308. SWAP_ARRAYS(UINT32, uint32);
  309. SWAP_ARRAYS(UINT64, uint64);
  310. SWAP_ARRAYS(FLOAT , float );
  311. SWAP_ARRAYS(DOUBLE, double);
  312. SWAP_ARRAYS(BOOL , bool );
  313. SWAP_ARRAYS(ENUM , int );
  314. #undef SWAP_ARRAYS
  315. case FieldDescriptor::CPPTYPE_STRING:
  316. case FieldDescriptor::CPPTYPE_MESSAGE:
  317. MutableRaw<RepeatedPtrFieldBase>(message1, field)->Swap(
  318. MutableRaw<RepeatedPtrFieldBase>(message2, field));
  319. break;
  320. default:
  321. GOOGLE_LOG(FATAL) << "Unimplemented type: " << field->cpp_type();
  322. }
  323. } else {
  324. switch (field->cpp_type()) {
  325. #define SWAP_VALUES(CPPTYPE, TYPE) \
  326. case FieldDescriptor::CPPTYPE_##CPPTYPE: \
  327. std::swap(*MutableRaw<TYPE>(message1, field), \
  328. *MutableRaw<TYPE>(message2, field)); \
  329. break;
  330. SWAP_VALUES(INT32 , int32 );
  331. SWAP_VALUES(INT64 , int64 );
  332. SWAP_VALUES(UINT32, uint32);
  333. SWAP_VALUES(UINT64, uint64);
  334. SWAP_VALUES(FLOAT , float );
  335. SWAP_VALUES(DOUBLE, double);
  336. SWAP_VALUES(BOOL , bool );
  337. SWAP_VALUES(ENUM , int );
  338. SWAP_VALUES(MESSAGE, Message*);
  339. #undef SWAP_VALUES
  340. case FieldDescriptor::CPPTYPE_STRING:
  341. switch (field->options().ctype()) {
  342. default: // TODO(kenton): Support other string reps.
  343. case FieldOptions::STRING:
  344. std::swap(*MutableRaw<string*>(message1, field),
  345. *MutableRaw<string*>(message2, field));
  346. break;
  347. }
  348. break;
  349. default:
  350. GOOGLE_LOG(FATAL) << "Unimplemented type: " << field->cpp_type();
  351. }
  352. }
  353. }
  354. if (extensions_offset_ != -1) {
  355. MutableExtensionSet(message1)->Swap(MutableExtensionSet(message2));
  356. }
  357. MutableUnknownFields(message1)->Swap(MutableUnknownFields(message2));
  358. }
  359. // -------------------------------------------------------------------
  360. bool GeneratedMessageReflection::HasField(const Message& message,
  361. const FieldDescriptor* field) const {
  362. USAGE_CHECK_MESSAGE_TYPE(HasField);
  363. USAGE_CHECK_SINGULAR(HasField);
  364. if (field->is_extension()) {
  365. return GetExtensionSet(message).Has(field->number());
  366. } else {
  367. return HasBit(message, field);
  368. }
  369. }
  370. int GeneratedMessageReflection::FieldSize(const Message& message,
  371. const FieldDescriptor* field) const {
  372. USAGE_CHECK_MESSAGE_TYPE(FieldSize);
  373. USAGE_CHECK_REPEATED(FieldSize);
  374. if (field->is_extension()) {
  375. return GetExtensionSet(message).ExtensionSize(field->number());
  376. } else {
  377. switch (field->cpp_type()) {
  378. #define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
  379. case FieldDescriptor::CPPTYPE_##UPPERCASE : \
  380. return GetRaw<RepeatedField<LOWERCASE> >(message, field).size()
  381. HANDLE_TYPE( INT32, int32);
  382. HANDLE_TYPE( INT64, int64);
  383. HANDLE_TYPE(UINT32, uint32);
  384. HANDLE_TYPE(UINT64, uint64);
  385. HANDLE_TYPE(DOUBLE, double);
  386. HANDLE_TYPE( FLOAT, float);
  387. HANDLE_TYPE( BOOL, bool);
  388. HANDLE_TYPE( ENUM, int);
  389. #undef HANDLE_TYPE
  390. case FieldDescriptor::CPPTYPE_STRING:
  391. case FieldDescriptor::CPPTYPE_MESSAGE:
  392. return GetRaw<RepeatedPtrFieldBase>(message, field).size();
  393. }
  394. GOOGLE_LOG(FATAL) << "Can't get here.";
  395. return 0;
  396. }
  397. }
  398. void GeneratedMessageReflection::ClearField(
  399. Message* message, const FieldDescriptor* field) const {
  400. USAGE_CHECK_MESSAGE_TYPE(ClearField);
  401. if (field->is_extension()) {
  402. MutableExtensionSet(message)->ClearExtension(field->number());
  403. } else if (!field->is_repeated()) {
  404. if (HasBit(*message, field)) {
  405. ClearBit(message, field);
  406. // We need to set the field back to its default value.
  407. switch (field->cpp_type()) {
  408. #define CLEAR_TYPE(CPPTYPE, TYPE) \
  409. case FieldDescriptor::CPPTYPE_##CPPTYPE: \
  410. *MutableRaw<TYPE>(message, field) = \
  411. field->default_value_##TYPE(); \
  412. break;
  413. CLEAR_TYPE(INT32 , int32 );
  414. CLEAR_TYPE(INT64 , int64 );
  415. CLEAR_TYPE(UINT32, uint32);
  416. CLEAR_TYPE(UINT64, uint64);
  417. CLEAR_TYPE(FLOAT , float );
  418. CLEAR_TYPE(DOUBLE, double);
  419. CLEAR_TYPE(BOOL , bool );
  420. #undef CLEAR_TYPE
  421. case FieldDescriptor::CPPTYPE_ENUM:
  422. *MutableRaw<int>(message, field) =
  423. field->default_value_enum()->number();
  424. break;
  425. case FieldDescriptor::CPPTYPE_STRING: {
  426. switch (field->options().ctype()) {
  427. default: // TODO(kenton): Support other string reps.
  428. case FieldOptions::STRING:
  429. const string* default_ptr = DefaultRaw<const string*>(field);
  430. string** value = MutableRaw<string*>(message, field);
  431. if (*value != default_ptr) {
  432. if (field->has_default_value()) {
  433. (*value)->assign(field->default_value_string());
  434. } else {
  435. (*value)->clear();
  436. }
  437. }
  438. break;
  439. }
  440. break;
  441. }
  442. case FieldDescriptor::CPPTYPE_MESSAGE:
  443. (*MutableRaw<Message*>(message, field))->Clear();
  444. break;
  445. }
  446. }
  447. } else {
  448. switch (field->cpp_type()) {
  449. #define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
  450. case FieldDescriptor::CPPTYPE_##UPPERCASE : \
  451. MutableRaw<RepeatedField<LOWERCASE> >(message, field)->Clear(); \
  452. break
  453. HANDLE_TYPE( INT32, int32);
  454. HANDLE_TYPE( INT64, int64);
  455. HANDLE_TYPE(UINT32, uint32);
  456. HANDLE_TYPE(UINT64, uint64);
  457. HANDLE_TYPE(DOUBLE, double);
  458. HANDLE_TYPE( FLOAT, float);
  459. HANDLE_TYPE( BOOL, bool);
  460. HANDLE_TYPE( ENUM, int);
  461. #undef HANDLE_TYPE
  462. case FieldDescriptor::CPPTYPE_STRING: {
  463. switch (field->options().ctype()) {
  464. default: // TODO(kenton): Support other string reps.
  465. case FieldOptions::STRING:
  466. MutableRaw<RepeatedPtrField<string> >(message, field)->Clear();
  467. break;
  468. }
  469. break;
  470. }
  471. case FieldDescriptor::CPPTYPE_MESSAGE: {
  472. // We don't know which subclass of RepeatedPtrFieldBase the type is,
  473. // so we use RepeatedPtrFieldBase directly.
  474. MutableRaw<RepeatedPtrFieldBase>(message, field)
  475. ->Clear<GenericTypeHandler<Message> >();
  476. break;
  477. }
  478. }
  479. }
  480. }
  481. void GeneratedMessageReflection::RemoveLast(
  482. Message* message,
  483. const FieldDescriptor* field) const {
  484. USAGE_CHECK_MESSAGE_TYPE(RemoveLast);
  485. USAGE_CHECK_REPEATED(RemoveLast);
  486. if (field->is_extension()) {
  487. MutableExtensionSet(message)->RemoveLast(field->number());
  488. } else {
  489. switch (field->cpp_type()) {
  490. #define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
  491. case FieldDescriptor::CPPTYPE_##UPPERCASE : \
  492. MutableRaw<RepeatedField<LOWERCASE> >(message, field)->RemoveLast(); \
  493. break
  494. HANDLE_TYPE( INT32, int32);
  495. HANDLE_TYPE( INT64, int64);
  496. HANDLE_TYPE(UINT32, uint32);
  497. HANDLE_TYPE(UINT64, uint64);
  498. HANDLE_TYPE(DOUBLE, double);
  499. HANDLE_TYPE( FLOAT, float);
  500. HANDLE_TYPE( BOOL, bool);
  501. HANDLE_TYPE( ENUM, int);
  502. #undef HANDLE_TYPE
  503. case FieldDescriptor::CPPTYPE_STRING:
  504. switch (field->options().ctype()) {
  505. default: // TODO(kenton): Support other string reps.
  506. case FieldOptions::STRING:
  507. MutableRaw<RepeatedPtrField<string> >(message, field)->RemoveLast();
  508. break;
  509. }
  510. break;
  511. case FieldDescriptor::CPPTYPE_MESSAGE:
  512. MutableRaw<RepeatedPtrFieldBase>(message, field)
  513. ->RemoveLast<GenericTypeHandler<Message> >();
  514. break;
  515. }
  516. }
  517. }
  518. void GeneratedMessageReflection::SwapElements(
  519. Message* message,
  520. const FieldDescriptor* field,
  521. int index1,
  522. int index2) const {
  523. USAGE_CHECK_MESSAGE_TYPE(Swap);
  524. USAGE_CHECK_REPEATED(Swap);
  525. if (field->is_extension()) {
  526. MutableExtensionSet(message)->SwapElements(field->number(), index1, index2);
  527. } else {
  528. switch (field->cpp_type()) {
  529. #define HANDLE_TYPE(UPPERCASE, LOWERCASE) \
  530. case FieldDescriptor::CPPTYPE_##UPPERCASE : \
  531. MutableRaw<RepeatedField<LOWERCASE> >(message, field) \
  532. ->SwapElements(index1, index2); \
  533. break
  534. HANDLE_TYPE( INT32, int32);
  535. HANDLE_TYPE( INT64, int64);
  536. HANDLE_TYPE(UINT32, uint32);
  537. HANDLE_TYPE(UINT64, uint64);
  538. HANDLE_TYPE(DOUBLE, double);
  539. HANDLE_TYPE( FLOAT, float);
  540. HANDLE_TYPE( BOOL, bool);
  541. HANDLE_TYPE( ENUM, int);
  542. #undef HANDLE_TYPE
  543. case FieldDescriptor::CPPTYPE_STRING:
  544. case FieldDescriptor::CPPTYPE_MESSAGE:
  545. MutableRaw<RepeatedPtrFieldBase>(message, field)
  546. ->SwapElements(index1, index2);
  547. break;
  548. }
  549. }
  550. }
  551. namespace {
  552. // Comparison functor for sorting FieldDescriptors by field number.
  553. struct FieldNumberSorter {
  554. bool operator()(const FieldDescriptor* left,
  555. const FieldDescriptor* right) const {
  556. return left->number() < right->number();
  557. }
  558. };
  559. } // namespace
  560. void GeneratedMessageReflection::ListFields(
  561. const Message& message,
  562. vector<const FieldDescriptor*>* output) const {
  563. output->clear();
  564. // Optimization: The default instance never has any fields set.
  565. if (&message == default_instance_) return;
  566. for (int i = 0; i < descriptor_->field_count(); i++) {
  567. const FieldDescriptor* field = descriptor_->field(i);
  568. if (field->is_repeated()) {
  569. if (FieldSize(message, field) > 0) {
  570. output->push_back(field);
  571. }
  572. } else {
  573. if (HasBit(message, field)) {
  574. output->push_back(field);
  575. }
  576. }
  577. }
  578. if (extensions_offset_ != -1) {
  579. GetExtensionSet(message).AppendToList(descriptor_, descriptor_pool_,
  580. output);
  581. }
  582. // ListFields() must sort output by field number.
  583. sort(output->begin(), output->end(), FieldNumberSorter());
  584. }
  585. // -------------------------------------------------------------------
  586. #undef DEFINE_PRIMITIVE_ACCESSORS
  587. #define DEFINE_PRIMITIVE_ACCESSORS(TYPENAME, TYPE, PASSTYPE, CPPTYPE) \
  588. PASSTYPE GeneratedMessageReflection::Get##TYPENAME( \
  589. const Message& message, const FieldDescriptor* field) const { \
  590. USAGE_CHECK_ALL(Get##TYPENAME, SINGULAR, CPPTYPE); \
  591. if (field->is_extension()) { \
  592. return GetExtensionSet(message).Get##TYPENAME( \
  593. field->number(), field->default_value_##PASSTYPE()); \
  594. } else { \
  595. return GetField<TYPE>(message, field); \
  596. } \
  597. } \
  598. \
  599. void GeneratedMessageReflection::Set##TYPENAME( \
  600. Message* message, const FieldDescriptor* field, \
  601. PASSTYPE value) const { \
  602. USAGE_CHECK_ALL(Set##TYPENAME, SINGULAR, CPPTYPE); \
  603. if (field->is_extension()) { \
  604. return MutableExtensionSet(message)->Set##TYPENAME( \
  605. field->number(), field->type(), value, field); \
  606. } else { \
  607. SetField<TYPE>(message, field, value); \
  608. } \
  609. } \
  610. \
  611. PASSTYPE GeneratedMessageReflection::GetRepeated##TYPENAME( \
  612. const Message& message, \
  613. const FieldDescriptor* field, int index) const { \
  614. USAGE_CHECK_ALL(GetRepeated##TYPENAME, REPEATED, CPPTYPE); \
  615. if (field->is_extension()) { \
  616. return GetExtensionSet(message).GetRepeated##TYPENAME( \
  617. field->number(), index); \
  618. } else { \
  619. return GetRepeatedField<TYPE>(message, field, index); \
  620. } \
  621. } \
  622. \
  623. void GeneratedMessageReflection::SetRepeated##TYPENAME( \
  624. Message* message, const FieldDescriptor* field, \
  625. int index, PASSTYPE value) const { \
  626. USAGE_CHECK_ALL(SetRepeated##TYPENAME, REPEATED, CPPTYPE); \
  627. if (field->is_extension()) { \
  628. MutableExtensionSet(message)->SetRepeated##TYPENAME( \
  629. field->number(), index, value); \
  630. } else { \
  631. SetRepeatedField<TYPE>(message, field, index, value); \
  632. } \
  633. } \
  634. \
  635. void GeneratedMessageReflection::Add##TYPENAME( \
  636. Message* message, const FieldDescriptor* field, \
  637. PASSTYPE value) const { \
  638. USAGE_CHECK_ALL(Add##TYPENAME, REPEATED, CPPTYPE); \
  639. if (field->is_extension()) { \
  640. MutableExtensionSet(message)->Add##TYPENAME( \
  641. field->number(), field->type(), field->options().packed(), value, \
  642. field); \
  643. } else { \
  644. AddField<TYPE>(message, field, value); \
  645. } \
  646. }
  647. DEFINE_PRIMITIVE_ACCESSORS(Int32 , int32 , int32 , INT32 )
  648. DEFINE_PRIMITIVE_ACCESSORS(Int64 , int64 , int64 , INT64 )
  649. DEFINE_PRIMITIVE_ACCESSORS(UInt32, uint32, uint32, UINT32)
  650. DEFINE_PRIMITIVE_ACCESSORS(UInt64, uint64, uint64, UINT64)
  651. DEFINE_PRIMITIVE_ACCESSORS(Float , float , float , FLOAT )
  652. DEFINE_PRIMITIVE_ACCESSORS(Double, double, double, DOUBLE)
  653. DEFINE_PRIMITIVE_ACCESSORS(Bool , bool , bool , BOOL )
  654. #undef DEFINE_PRIMITIVE_ACCESSORS
  655. // -------------------------------------------------------------------
  656. string GeneratedMessageReflection::GetString(
  657. const Message& message, const FieldDescriptor* field) const {
  658. USAGE_CHECK_ALL(GetString, SINGULAR, STRING);
  659. if (field->is_extension()) {
  660. return GetExtensionSet(message).GetString(field->number(),
  661. field->default_value_string());
  662. } else {
  663. switch (field->options().ctype()) {
  664. default: // TODO(kenton): Support other string reps.
  665. case FieldOptions::STRING:
  666. return *GetField<const string*>(message, field);
  667. }
  668. GOOGLE_LOG(FATAL) << "Can't get here.";
  669. return kEmptyString; // Make compiler happy.
  670. }
  671. }
  672. const string& GeneratedMessageReflection::GetStringReference(
  673. const Message& message,
  674. const FieldDescriptor* field, string* scratch) const {
  675. USAGE_CHECK_ALL(GetStringReference, SINGULAR, STRING);
  676. if (field->is_extension()) {
  677. return GetExtensionSet(message).GetString(field->number(),
  678. field->default_value_string());
  679. } else {
  680. switch (field->options().ctype()) {
  681. default: // TODO(kenton): Support other string reps.
  682. case FieldOptions::STRING:
  683. return *GetField<const string*>(message, field);
  684. }
  685. GOOGLE_LOG(FATAL) << "Can't get here.";
  686. return kEmptyString; // Make compiler happy.
  687. }
  688. }
  689. void GeneratedMessageReflection::SetString(
  690. Message* message, const FieldDescriptor* field,
  691. const string& value) const {
  692. USAGE_CHECK_ALL(SetString, SINGULAR, STRING);
  693. if (field->is_extension()) {
  694. return MutableExtensionSet(message)->SetString(field->number(),
  695. field->type(), value, field);
  696. } else {
  697. switch (field->options().ctype()) {
  698. default: // TODO(kenton): Support other string reps.
  699. case FieldOptions::STRING: {
  700. string** ptr = MutableField<string*>(message, field);
  701. if (*ptr == DefaultRaw<const string*>(field)) {
  702. *ptr = new string(value);
  703. } else {
  704. (*ptr)->assign(value);
  705. }
  706. break;
  707. }
  708. }
  709. }
  710. }
  711. string GeneratedMessageReflection::GetRepeatedString(
  712. const Message& message, const FieldDescriptor* field, int index) const {
  713. USAGE_CHECK_ALL(GetRepeatedString, REPEATED, STRING);
  714. if (field->is_extension()) {
  715. return GetExtensionSet(message).GetRepeatedString(field->number(), index);
  716. } else {
  717. switch (field->options().ctype()) {
  718. default: // TODO(kenton): Support other string reps.
  719. case FieldOptions::STRING:
  720. return GetRepeatedPtrField<string>(message, field, index);
  721. }
  722. GOOGLE_LOG(FATAL) << "Can't get here.";
  723. return kEmptyString; // Make compiler happy.
  724. }
  725. }
  726. const string& GeneratedMessageReflection::GetRepeatedStringReference(
  727. const Message& message, const FieldDescriptor* field,
  728. int index, string* scratch) const {
  729. USAGE_CHECK_ALL(GetRepeatedStringReference, REPEATED, STRING);
  730. if (field->is_extension()) {
  731. return GetExtensionSet(message).GetRepeatedString(field->number(), index);
  732. } else {
  733. switch (field->options().ctype()) {
  734. default: // TODO(kenton): Support other string reps.
  735. case FieldOptions::STRING:
  736. return GetRepeatedPtrField<string>(message, field, index);
  737. }
  738. GOOGLE_LOG(FATAL) << "Can't get here.";
  739. return kEmptyString; // Make compiler happy.
  740. }
  741. }
  742. void GeneratedMessageReflection::SetRepeatedString(
  743. Message* message, const FieldDescriptor* field,
  744. int index, const string& value) const {
  745. USAGE_CHECK_ALL(SetRepeatedString, REPEATED, STRING);
  746. if (field->is_extension()) {
  747. MutableExtensionSet(message)->SetRepeatedString(
  748. field->number(), index, value);
  749. } else {
  750. switch (field->options().ctype()) {
  751. default: // TODO(kenton): Support other string reps.
  752. case FieldOptions::STRING:
  753. *MutableRepeatedField<string>(message, field, index) = value;
  754. break;
  755. }
  756. }
  757. }
  758. void GeneratedMessageReflection::AddString(
  759. Message* message, const FieldDescriptor* field,
  760. const string& value) const {
  761. USAGE_CHECK_ALL(AddString, REPEATED, STRING);
  762. if (field->is_extension()) {
  763. MutableExtensionSet(message)->AddString(field->number(),
  764. field->type(), value, field);
  765. } else {
  766. switch (field->options().ctype()) {
  767. default: // TODO(kenton): Support other string reps.
  768. case FieldOptions::STRING:
  769. *AddField<string>(message, field) = value;
  770. break;
  771. }
  772. }
  773. }
  774. // -------------------------------------------------------------------
  775. const EnumValueDescriptor* GeneratedMessageReflection::GetEnum(
  776. const Message& message, const FieldDescriptor* field) const {
  777. USAGE_CHECK_ALL(GetEnum, SINGULAR, ENUM);
  778. int value;
  779. if (field->is_extension()) {
  780. value = GetExtensionSet(message).GetEnum(
  781. field->number(), field->default_value_enum()->number());
  782. } else {
  783. value = GetField<int>(message, field);
  784. }
  785. const EnumValueDescriptor* result =
  786. field->enum_type()->FindValueByNumber(value);
  787. GOOGLE_CHECK(result != NULL);
  788. return result;
  789. }
  790. void GeneratedMessageReflection::SetEnum(
  791. Message* message, const FieldDescriptor* field,
  792. const EnumValueDescriptor* value) const {
  793. USAGE_CHECK_ALL(SetEnum, SINGULAR, ENUM);
  794. USAGE_CHECK_ENUM_VALUE(SetEnum);
  795. if (field->is_extension()) {
  796. MutableExtensionSet(message)->SetEnum(field->number(), field->type(),
  797. value->number(), field);
  798. } else {
  799. SetField<int>(message, field, value->number());
  800. }
  801. }
  802. const EnumValueDescriptor* GeneratedMessageReflection::GetRepeatedEnum(
  803. const Message& message, const FieldDescriptor* field, int index) const {
  804. USAGE_CHECK_ALL(GetRepeatedEnum, REPEATED, ENUM);
  805. int value;
  806. if (field->is_extension()) {
  807. value = GetExtensionSet(message).GetRepeatedEnum(field->number(), index);
  808. } else {
  809. value = GetRepeatedField<int>(message, field, index);
  810. }
  811. const EnumValueDescriptor* result =
  812. field->enum_type()->FindValueByNumber(value);
  813. GOOGLE_CHECK(result != NULL);
  814. return result;
  815. }
  816. void GeneratedMessageReflection::SetRepeatedEnum(
  817. Message* message,
  818. const FieldDescriptor* field, int index,
  819. const EnumValueDescriptor* value) const {
  820. USAGE_CHECK_ALL(SetRepeatedEnum, REPEATED, ENUM);
  821. USAGE_CHECK_ENUM_VALUE(SetRepeatedEnum);
  822. if (field->is_extension()) {
  823. MutableExtensionSet(message)->SetRepeatedEnum(
  824. field->number(), index, value->number());
  825. } else {
  826. SetRepeatedField<int>(message, field, index, value->number());
  827. }
  828. }
  829. void GeneratedMessageReflection::AddEnum(
  830. Message* message, const FieldDescriptor* field,
  831. const EnumValueDescriptor* value) const {
  832. USAGE_CHECK_ALL(AddEnum, REPEATED, ENUM);
  833. USAGE_CHECK_ENUM_VALUE(AddEnum);
  834. if (field->is_extension()) {
  835. MutableExtensionSet(message)->AddEnum(field->number(), field->type(),
  836. field->options().packed(),
  837. value->number(), field);
  838. } else {
  839. AddField<int>(message, field, value->number());
  840. }
  841. }
  842. // -------------------------------------------------------------------
  843. const Message& GeneratedMessageReflection::GetMessage(
  844. const Message& message, const FieldDescriptor* field,
  845. MessageFactory* factory) const {
  846. USAGE_CHECK_ALL(GetMessage, SINGULAR, MESSAGE);
  847. if (field->is_extension()) {
  848. return static_cast<const Message&>(
  849. GetExtensionSet(message).GetMessage(
  850. field->number(), field->message_type(),
  851. factory == NULL ? message_factory_ : factory));
  852. } else {
  853. const Message* result = GetRaw<const Message*>(message, field);
  854. if (result == NULL) {
  855. result = DefaultRaw<const Message*>(field);
  856. }
  857. return *result;
  858. }
  859. }
  860. Message* GeneratedMessageReflection::MutableMessage(
  861. Message* message, const FieldDescriptor* field,
  862. MessageFactory* factory) const {
  863. USAGE_CHECK_ALL(MutableMessage, SINGULAR, MESSAGE);
  864. if (field->is_extension()) {
  865. return static_cast<Message*>(
  866. MutableExtensionSet(message)->MutableMessage(field,
  867. factory == NULL ? message_factory_ : factory));
  868. } else {
  869. Message** result = MutableField<Message*>(message, field);
  870. if (*result == NULL) {
  871. const Message* default_message = DefaultRaw<const Message*>(field);
  872. *result = default_message->New();
  873. }
  874. return *result;
  875. }
  876. }
  877. const Message& GeneratedMessageReflection::GetRepeatedMessage(
  878. const Message& message, const FieldDescriptor* field, int index) const {
  879. USAGE_CHECK_ALL(GetRepeatedMessage, REPEATED, MESSAGE);
  880. if (field->is_extension()) {
  881. return static_cast<const Message&>(
  882. GetExtensionSet(message).GetRepeatedMessage(field->number(), index));
  883. } else {
  884. return GetRaw<RepeatedPtrFieldBase>(message, field)
  885. .Get<GenericTypeHandler<Message> >(index);
  886. }
  887. }
  888. Message* GeneratedMessageReflection::MutableRepeatedMessage(
  889. Message* message, const FieldDescriptor* field, int index) const {
  890. USAGE_CHECK_ALL(MutableRepeatedMessage, REPEATED, MESSAGE);
  891. if (field->is_extension()) {
  892. return static_cast<Message*>(
  893. MutableExtensionSet(message)->MutableRepeatedMessage(
  894. field->number(), index));
  895. } else {
  896. return MutableRaw<RepeatedPtrFieldBase>(message, field)
  897. ->Mutable<GenericTypeHandler<Message> >(index);
  898. }
  899. }
  900. Message* GeneratedMessageReflection::AddMessage(
  901. Message* message, const FieldDescriptor* field,
  902. MessageFactory* factory) const {
  903. USAGE_CHECK_ALL(AddMessage, REPEATED, MESSAGE);
  904. if (factory == NULL) factory = message_factory_;
  905. if (field->is_extension()) {
  906. return static_cast<Message*>(
  907. MutableExtensionSet(message)->AddMessage(field, factory));
  908. } else {
  909. // We can't use AddField<Message>() because RepeatedPtrFieldBase doesn't
  910. // know how to allocate one.
  911. RepeatedPtrFieldBase* repeated =
  912. MutableRaw<RepeatedPtrFieldBase>(message, field);
  913. Message* result = repeated->AddFromCleared<GenericTypeHandler<Message> >();
  914. if (result == NULL) {
  915. // We must allocate a new object.
  916. const Message* prototype;
  917. if (repeated->size() == 0) {
  918. prototype = factory->GetPrototype(field->message_type());
  919. } else {
  920. prototype = &repeated->Get<GenericTypeHandler<Message> >(0);
  921. }
  922. result = prototype->New();
  923. repeated->AddAllocated<GenericTypeHandler<Message> >(result);
  924. }
  925. return result;
  926. }
  927. }
  928. // -------------------------------------------------------------------
  929. const FieldDescriptor* GeneratedMessageReflection::FindKnownExtensionByName(
  930. const string& name) const {
  931. if (extensions_offset_ == -1) return NULL;
  932. const FieldDescriptor* result = descriptor_pool_->FindExtensionByName(name);
  933. if (result != NULL && result->containing_type() == descriptor_) {
  934. return result;
  935. }
  936. if (descriptor_->options().message_set_wire_format()) {
  937. // MessageSet extensions may be identified by type name.
  938. const Descriptor* type = descriptor_pool_->FindMessageTypeByName(name);
  939. if (type != NULL) {
  940. // Look for a matching extension in the foreign type's scope.
  941. for (int i = 0; i < type->extension_count(); i++) {
  942. const FieldDescriptor* extension = type->extension(i);
  943. if (extension->containing_type() == descriptor_ &&
  944. extension->type() == FieldDescriptor::TYPE_MESSAGE &&
  945. extension->is_optional() &&
  946. extension->message_type() == type) {
  947. // Found it.
  948. return extension;
  949. }
  950. }
  951. }
  952. }
  953. return NULL;
  954. }
  955. const FieldDescriptor* GeneratedMessageReflection::FindKnownExtensionByNumber(
  956. int number) const {
  957. if (extensions_offset_ == -1) return NULL;
  958. return descriptor_pool_->FindExtensionByNumber(descriptor_, number);
  959. }
  960. // ===================================================================
  961. // Some private helpers.
  962. // These simple template accessors obtain pointers (or references) to
  963. // the given field.
  964. template <typename Type>
  965. inline const Type& GeneratedMessageReflection::GetRaw(
  966. const Message& message, const FieldDescriptor* field) const {
  967. const void* ptr = reinterpret_cast<const uint8*>(&message) +
  968. offsets_[field->index()];
  969. return *reinterpret_cast<const Type*>(ptr);
  970. }
  971. template <typename Type>
  972. inline Type* GeneratedMessageReflection::MutableRaw(
  973. Message* message, const FieldDescriptor* field) const {
  974. void* ptr = reinterpret_cast<uint8*>(message) + offsets_[field->index()];
  975. return reinterpret_cast<Type*>(ptr);
  976. }
  977. template <typename Type>
  978. inline const Type& GeneratedMessageReflection::DefaultRaw(
  979. const FieldDescriptor* field) const {
  980. const void* ptr = reinterpret_cast<const uint8*>(default_instance_) +
  981. offsets_[field->index()];
  982. return *reinterpret_cast<const Type*>(ptr);
  983. }
  984. inline const uint32* GeneratedMessageReflection::GetHasBits(
  985. const Message& message) const {
  986. const void* ptr = reinterpret_cast<const uint8*>(&message) + has_bits_offset_;
  987. return reinterpret_cast<const uint32*>(ptr);
  988. }
  989. inline uint32* GeneratedMessageReflection::MutableHasBits(
  990. Message* message) const {
  991. void* ptr = reinterpret_cast<uint8*>(message) + has_bits_offset_;
  992. return reinterpret_cast<uint32*>(ptr);
  993. }
  994. inline const ExtensionSet& GeneratedMessageReflection::GetExtensionSet(
  995. const Message& message) const {
  996. GOOGLE_DCHECK_NE(extensions_offset_, -1);
  997. const void* ptr = reinterpret_cast<const uint8*>(&message) +
  998. extensions_offset_;
  999. return *reinterpret_cast<const ExtensionSet*>(ptr);
  1000. }
  1001. inline ExtensionSet* GeneratedMessageReflection::MutableExtensionSet(
  1002. Message* message) const {
  1003. GOOGLE_DCHECK_NE(extensions_offset_, -1);
  1004. void* ptr = reinterpret_cast<uint8*>(message) + extensions_offset_;
  1005. return reinterpret_cast<ExtensionSet*>(ptr);
  1006. }
  1007. // Simple accessors for manipulating has_bits_.
  1008. inline bool GeneratedMessageReflection::HasBit(
  1009. const Message& message, const FieldDescriptor* field) const {
  1010. return GetHasBits(message)[field->index() / 32] &
  1011. (1 << (field->index() % 32));
  1012. }
  1013. inline void GeneratedMessageReflection::SetBit(
  1014. Message* message, const FieldDescriptor* field) const {
  1015. MutableHasBits(message)[field->index() / 32] |= (1 << (field->index() % 32));
  1016. }
  1017. inline void GeneratedMessageReflection::ClearBit(
  1018. Message* message, const FieldDescriptor* field) const {
  1019. MutableHasBits(message)[field->index() / 32] &= ~(1 << (field->index() % 32));
  1020. }
  1021. // Template implementations of basic accessors. Inline because each
  1022. // template instance is only called from one location. These are
  1023. // used for all types except messages.
  1024. template <typename Type>
  1025. inline const Type& GeneratedMessageReflection::GetField(
  1026. const Message& message, const FieldDescriptor* field) const {
  1027. return GetRaw<Type>(message, field);
  1028. }
  1029. template <typename Type>
  1030. inline void GeneratedMessageReflection::SetField(
  1031. Message* message, const FieldDescriptor* field, const Type& value) const {
  1032. *MutableRaw<Type>(message, field) = value;
  1033. SetBit(message, field);
  1034. }
  1035. template <typename Type>
  1036. inline Type* GeneratedMessageReflection::MutableField(
  1037. Message* message, const FieldDescriptor* field) const {
  1038. SetBit(message, field);
  1039. return MutableRaw<Type>(message, field);
  1040. }
  1041. template <typename Type>
  1042. inline const Type& GeneratedMessageReflection::GetRepeatedField(
  1043. const Message& message, const FieldDescriptor* field, int index) const {
  1044. return GetRaw<RepeatedField<Type> >(message, field).Get(index);
  1045. }
  1046. template <typename Type>
  1047. inline const Type& GeneratedMessageReflection::GetRepeatedPtrField(
  1048. const Message& message, const FieldDescriptor* field, int index) const {
  1049. return GetRaw<RepeatedPtrField<Type> >(message, field).Get(index);
  1050. }
  1051. template <typename Type>
  1052. inline void GeneratedMessageReflection::SetRepeatedField(
  1053. Message* message, const FieldDescriptor* field,
  1054. int index, Type value) const {
  1055. MutableRaw<RepeatedField<Type> >(message, field)->Set(index, value);
  1056. }
  1057. template <typename Type>
  1058. inline Type* GeneratedMessageReflection::MutableRepeatedField(
  1059. Message* message, const FieldDescriptor* field, int index) const {
  1060. RepeatedPtrField<Type>* repeated =
  1061. MutableRaw<RepeatedPtrField<Type> >(message, field);
  1062. return repeated->Mutable(index);
  1063. }
  1064. template <typename Type>
  1065. inline void GeneratedMessageReflection::AddField(
  1066. Message* message, const FieldDescriptor* field, const Type& value) const {
  1067. MutableRaw<RepeatedField<Type> >(message, field)->Add(value);
  1068. }
  1069. template <typename Type>
  1070. inline Type* GeneratedMessageReflection::AddField(
  1071. Message* message, const FieldDescriptor* field) const {
  1072. RepeatedPtrField<Type>* repeated =
  1073. MutableRaw<RepeatedPtrField<Type> >(message, field);
  1074. return repeated->Add();
  1075. }
  1076. } // namespace internal
  1077. } // namespace protobuf
  1078. } // namespace google