protobuf 1.4.2 → 2.0.0.rc1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (198) hide show
  1. data/.gitignore +4 -0
  2. data/Rakefile +7 -7
  3. data/bin/rpc_server +2 -188
  4. data/bin/rprotoc +44 -38
  5. data/examples/addressbook.pb.rb +2 -2
  6. data/ext/Makefile +11 -0
  7. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/code_generator.h +142 -0
  8. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/command_line_interface.h +318 -0
  9. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/cpp/cpp_enum.h +99 -0
  10. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/cpp/cpp_enum_field.h +103 -0
  11. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/cpp/cpp_extension.h +85 -0
  12. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/cpp/cpp_field.h +167 -0
  13. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/cpp/cpp_file.h +98 -0
  14. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/cpp/cpp_generator.h +72 -0
  15. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/cpp/cpp_helpers.h +159 -0
  16. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/cpp/cpp_message.h +170 -0
  17. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/cpp/cpp_message_field.h +102 -0
  18. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/cpp/cpp_primitive_field.h +103 -0
  19. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/cpp/cpp_service.h +118 -0
  20. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/cpp/cpp_string_field.h +104 -0
  21. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/cpp/cpp_test_bad_identifiers.pb.h +2721 -0
  22. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/importer.h +303 -0
  23. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/java/java_enum.h +84 -0
  24. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/java/java_enum_field.h +121 -0
  25. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/java/java_extension.h +77 -0
  26. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/java/java_field.h +108 -0
  27. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/java/java_file.h +101 -0
  28. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/java/java_generator.h +72 -0
  29. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/java/java_helpers.h +213 -0
  30. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/java/java_message.h +109 -0
  31. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/java/java_message_field.h +134 -0
  32. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/java/java_primitive_field.h +121 -0
  33. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/java/java_service.h +113 -0
  34. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/java/java_string_field.h +120 -0
  35. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/mock_code_generator.h +113 -0
  36. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/package_info.h +64 -0
  37. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/parser.h +434 -0
  38. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/plugin.h +73 -0
  39. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/plugin.pb.h +790 -0
  40. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/python/python_generator.h +156 -0
  41. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/subprocess.h +108 -0
  42. data/ext/protobuf-2.4.1/src/google/protobuf/compiler/zip_writer.h +93 -0
  43. data/ext/protobuf-2.4.1/src/google/protobuf/descriptor.h +1367 -0
  44. data/ext/protobuf-2.4.1/src/google/protobuf/descriptor.pb.h +5223 -0
  45. data/ext/protobuf-2.4.1/src/google/protobuf/descriptor_database.h +366 -0
  46. data/ext/protobuf-2.4.1/src/google/protobuf/dynamic_message.h +136 -0
  47. data/ext/protobuf-2.4.1/src/google/protobuf/extension_set.h +904 -0
  48. data/ext/protobuf-2.4.1/src/google/protobuf/generated_message_reflection.h +424 -0
  49. data/ext/protobuf-2.4.1/src/google/protobuf/generated_message_util.h +82 -0
  50. data/ext/protobuf-2.4.1/src/google/protobuf/io/coded_stream.h +1102 -0
  51. data/ext/protobuf-2.4.1/src/google/protobuf/io/coded_stream_inl.h +64 -0
  52. data/ext/protobuf-2.4.1/src/google/protobuf/io/gzip_stream.h +207 -0
  53. data/ext/protobuf-2.4.1/src/google/protobuf/io/package_info.h +54 -0
  54. data/ext/protobuf-2.4.1/src/google/protobuf/io/printer.h +136 -0
  55. data/ext/protobuf-2.4.1/src/google/protobuf/io/tokenizer.h +313 -0
  56. data/ext/protobuf-2.4.1/src/google/protobuf/io/zero_copy_stream.h +238 -0
  57. data/ext/protobuf-2.4.1/src/google/protobuf/io/zero_copy_stream_impl.h +357 -0
  58. data/ext/protobuf-2.4.1/src/google/protobuf/io/zero_copy_stream_impl_lite.h +340 -0
  59. data/ext/protobuf-2.4.1/src/google/protobuf/message.h +692 -0
  60. data/ext/protobuf-2.4.1/src/google/protobuf/message_lite.h +239 -0
  61. data/ext/protobuf-2.4.1/src/google/protobuf/package_info.h +64 -0
  62. data/ext/protobuf-2.4.1/src/google/protobuf/reflection_ops.h +80 -0
  63. data/ext/protobuf-2.4.1/src/google/protobuf/repeated_field.h +1295 -0
  64. data/ext/protobuf-2.4.1/src/google/protobuf/service.h +291 -0
  65. data/ext/protobuf-2.4.1/src/google/protobuf/stubs/common.h +1211 -0
  66. data/ext/protobuf-2.4.1/src/google/protobuf/stubs/hash.h +220 -0
  67. data/ext/protobuf-2.4.1/src/google/protobuf/stubs/map-util.h +119 -0
  68. data/ext/protobuf-2.4.1/src/google/protobuf/stubs/once.h +123 -0
  69. data/ext/protobuf-2.4.1/src/google/protobuf/stubs/stl_util-inl.h +121 -0
  70. data/ext/protobuf-2.4.1/src/google/protobuf/stubs/strutil.h +457 -0
  71. data/ext/protobuf-2.4.1/src/google/protobuf/stubs/substitute.h +170 -0
  72. data/ext/protobuf-2.4.1/src/google/protobuf/test_util.h +174 -0
  73. data/ext/protobuf-2.4.1/src/google/protobuf/test_util_lite.h +101 -0
  74. data/ext/protobuf-2.4.1/src/google/protobuf/testing/file.h +83 -0
  75. data/ext/protobuf-2.4.1/src/google/protobuf/testing/googletest.h +98 -0
  76. data/ext/protobuf-2.4.1/src/google/protobuf/text_format.h +285 -0
  77. data/ext/protobuf-2.4.1/src/google/protobuf/unittest.pb.h +11915 -0
  78. data/ext/protobuf-2.4.1/src/google/protobuf/unittest_custom_options.pb.h +2895 -0
  79. data/ext/protobuf-2.4.1/src/google/protobuf/unittest_embed_optimize_for.pb.h +211 -0
  80. data/ext/protobuf-2.4.1/src/google/protobuf/unittest_empty.pb.h +56 -0
  81. data/ext/protobuf-2.4.1/src/google/protobuf/unittest_import.pb.h +188 -0
  82. data/ext/protobuf-2.4.1/src/google/protobuf/unittest_import_lite.pb.h +151 -0
  83. data/ext/protobuf-2.4.1/src/google/protobuf/unittest_lite.pb.h +4752 -0
  84. data/ext/protobuf-2.4.1/src/google/protobuf/unittest_lite_imports_nonlite.pb.h +150 -0
  85. data/ext/protobuf-2.4.1/src/google/protobuf/unittest_mset.pb.h +816 -0
  86. data/ext/protobuf-2.4.1/src/google/protobuf/unittest_no_generic_services.pb.h +197 -0
  87. data/ext/protobuf-2.4.1/src/google/protobuf/unittest_optimize_for.pb.h +403 -0
  88. data/ext/protobuf-2.4.1/src/google/protobuf/unknown_field_set.h +268 -0
  89. data/ext/protobuf-2.4.1/src/google/protobuf/wire_format.h +304 -0
  90. data/ext/protobuf-2.4.1/src/google/protobuf/wire_format_lite.h +620 -0
  91. data/ext/protobuf-2.4.1/src/google/protobuf/wire_format_lite_inl.h +774 -0
  92. data/ext/ruby_generator/RubyGenerator.cpp +435 -0
  93. data/ext/ruby_generator/RubyGenerator.h +180 -0
  94. data/ext/ruby_generator/extconf.rb +24 -0
  95. data/lib/protobuf.rb +55 -33
  96. data/lib/protobuf/cli.rb +176 -0
  97. data/lib/protobuf/common/logger.rb +11 -11
  98. data/lib/protobuf/{message/enum.rb → enum.rb} +0 -10
  99. data/lib/protobuf/evented.rb +22 -0
  100. data/lib/protobuf/field.rb +57 -0
  101. data/lib/protobuf/field/base_field.rb +210 -0
  102. data/lib/protobuf/field/bool_field.rb +24 -0
  103. data/lib/protobuf/field/bytes_field.rb +38 -0
  104. data/lib/protobuf/field/double_field.rb +19 -0
  105. data/lib/protobuf/field/enum_field.rb +58 -0
  106. data/lib/protobuf/field/extension_fields.rb +24 -0
  107. data/lib/protobuf/field/field_array.rb +55 -0
  108. data/lib/protobuf/field/fixed32_field.rb +19 -0
  109. data/lib/protobuf/field/fixed64_field.rb +22 -0
  110. data/lib/protobuf/field/float_field.rb +29 -0
  111. data/lib/protobuf/field/int32_field.rb +10 -0
  112. data/lib/protobuf/field/int64_field.rb +10 -0
  113. data/lib/protobuf/field/integer_field.rb +19 -0
  114. data/lib/protobuf/field/message_field.rb +51 -0
  115. data/lib/protobuf/field/sfixed32_field.rb +21 -0
  116. data/lib/protobuf/field/sfixed64_field.rb +24 -0
  117. data/lib/protobuf/field/signed_integer_field.rb +23 -0
  118. data/lib/protobuf/field/sint32_field.rb +10 -0
  119. data/lib/protobuf/field/sint64_field.rb +10 -0
  120. data/lib/protobuf/field/string_field.rb +14 -0
  121. data/lib/protobuf/field/uint32_field.rb +10 -0
  122. data/lib/protobuf/field/uint64_field.rb +10 -0
  123. data/lib/protobuf/field/varint_field.rb +63 -0
  124. data/lib/protobuf/message.rb +376 -0
  125. data/lib/protobuf/message/message.rb +1 -475
  126. data/lib/protobuf/rpc/buffer.rb +1 -1
  127. data/lib/protobuf/rpc/client.rb +26 -26
  128. data/lib/protobuf/rpc/connector.rb +15 -14
  129. data/lib/protobuf/rpc/connectors/eventmachine.rb +13 -13
  130. data/lib/protobuf/rpc/rpc.pb.rb +39 -28
  131. data/lib/protobuf/rpc/server.rb +7 -28
  132. data/lib/protobuf/rpc/servers/evented_runner.rb +15 -15
  133. data/lib/protobuf/rpc/servers/socket/server.rb +2 -1
  134. data/lib/protobuf/rpc/servers/socket_runner.rb +5 -6
  135. data/lib/protobuf/rpc/servers/zmq_runner.rb +4 -5
  136. data/lib/protobuf/socket.rb +22 -0
  137. data/lib/protobuf/version.rb +2 -1
  138. data/lib/protobuf/zmq.rb +21 -0
  139. data/proto/rpc.pb.rb +48 -0
  140. data/protobuf.gemspec +14 -6
  141. data/spec/benchmark/tasks.rb +42 -23
  142. data/spec/functional/evented_server_spec.rb +2 -0
  143. data/spec/functional/socket_server_spec.rb +22 -26
  144. data/spec/functional/zmq_server_spec.rb +22 -26
  145. data/spec/lib/protobuf/cli_spec.rb +182 -0
  146. data/spec/{unit → lib/protobuf}/common/logger_spec.rb +0 -0
  147. data/spec/{unit → lib/protobuf/message}/enum_spec.rb +0 -0
  148. data/spec/{unit → lib/protobuf/message}/message_spec.rb +0 -0
  149. data/spec/{unit → lib/protobuf}/rpc/client_spec.rb +6 -4
  150. data/spec/lib/protobuf/rpc/connector_spec.rb +41 -0
  151. data/spec/{unit → lib/protobuf}/rpc/connectors/base_spec.rb +18 -18
  152. data/spec/{unit → lib/protobuf}/rpc/connectors/common_spec.rb +20 -20
  153. data/spec/{unit → lib/protobuf}/rpc/connectors/socket_spec.rb +9 -8
  154. data/spec/{unit → lib/protobuf}/rpc/connectors/zmq_spec.rb +1 -1
  155. data/spec/{unit → lib/protobuf}/rpc/servers/evented_server_spec.rb +4 -4
  156. data/spec/{unit → lib/protobuf}/rpc/servers/socket_server_spec.rb +11 -23
  157. data/spec/{unit → lib/protobuf}/rpc/servers/zmq/broker_spec.rb +5 -0
  158. data/spec/{unit → lib/protobuf}/rpc/servers/zmq/server_spec.rb +5 -0
  159. data/spec/{unit → lib/protobuf}/rpc/servers/zmq/util_spec.rb +5 -0
  160. data/spec/{unit → lib/protobuf}/rpc/servers/zmq/worker_spec.rb +5 -0
  161. data/spec/{unit → lib/protobuf}/rpc/service_spec.rb +0 -0
  162. data/spec/proto/test.pb.rb +48 -25
  163. data/spec/spec_helper.rb +9 -15
  164. data/spec/support/all.rb +7 -0
  165. data/spec/{helper → support}/server.rb +5 -7
  166. data/spec/{helper → support}/silent_constants.rb +4 -0
  167. data/spec/support/test_app_file.rb +2 -0
  168. data/spec/{helper → support}/tolerance_matcher.rb +0 -0
  169. data/test/proto/types.pb.rb +1 -1
  170. data/test/test_addressbook.rb +1 -1
  171. data/test/test_enum_value.rb +1 -1
  172. data/test/test_standard_message.rb +1 -1
  173. metadata +243 -107
  174. data/lib/protobuf/common/util.rb +0 -59
  175. data/lib/protobuf/compiler/compiler.rb +0 -52
  176. data/lib/protobuf/compiler/nodes.rb +0 -323
  177. data/lib/protobuf/compiler/proto.y +0 -216
  178. data/lib/protobuf/compiler/proto2.ebnf +0 -79
  179. data/lib/protobuf/compiler/proto_parser.rb +0 -1425
  180. data/lib/protobuf/compiler/template/rpc_service_implementation.erb +0 -42
  181. data/lib/protobuf/compiler/visitors.rb +0 -282
  182. data/lib/protobuf/descriptor/descriptor.proto +0 -286
  183. data/lib/protobuf/descriptor/descriptor.rb +0 -55
  184. data/lib/protobuf/descriptor/descriptor_builder.rb +0 -143
  185. data/lib/protobuf/descriptor/descriptor_proto.rb +0 -138
  186. data/lib/protobuf/descriptor/enum_descriptor.rb +0 -33
  187. data/lib/protobuf/descriptor/field_descriptor.rb +0 -49
  188. data/lib/protobuf/descriptor/file_descriptor.rb +0 -37
  189. data/lib/protobuf/message/field.rb +0 -684
  190. data/lib/protobuf/message/protoable.rb +0 -38
  191. data/spec/helper/all.rb +0 -7
  192. data/spec/unit/common/util_spec.rb +0 -17
  193. data/spec/unit/rpc/connector_spec.rb +0 -31
  194. data/spec/unit/rpc/connectors/eventmachine_client_spec.rb +0 -32
  195. data/spec/unit/rpc/connectors/eventmachine_spec.rb +0 -0
  196. data/test/check_unbuild.rb +0 -30
  197. data/test/test_compiler.rb +0 -325
  198. data/test/test_descriptor.rb +0 -122
@@ -0,0 +1,104 @@
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
+ #ifndef GOOGLE_PROTOBUF_COMPILER_CPP_STRING_FIELD_H__
36
+ #define GOOGLE_PROTOBUF_COMPILER_CPP_STRING_FIELD_H__
37
+
38
+ #include <map>
39
+ #include <string>
40
+ #include <google/protobuf/compiler/cpp/cpp_field.h>
41
+
42
+ namespace google {
43
+ namespace protobuf {
44
+ namespace compiler {
45
+ namespace cpp {
46
+
47
+ class StringFieldGenerator : public FieldGenerator {
48
+ public:
49
+ explicit StringFieldGenerator(const FieldDescriptor* descriptor);
50
+ ~StringFieldGenerator();
51
+
52
+ // implements FieldGenerator ---------------------------------------
53
+ void GeneratePrivateMembers(io::Printer* printer) const;
54
+ void GenerateAccessorDeclarations(io::Printer* printer) const;
55
+ void GenerateInlineAccessorDefinitions(io::Printer* printer) const;
56
+ void GenerateNonInlineAccessorDefinitions(io::Printer* printer) const;
57
+ void GenerateClearingCode(io::Printer* printer) const;
58
+ void GenerateMergingCode(io::Printer* printer) const;
59
+ void GenerateSwappingCode(io::Printer* printer) const;
60
+ void GenerateConstructorCode(io::Printer* printer) const;
61
+ void GenerateDestructorCode(io::Printer* printer) const;
62
+ void GenerateMergeFromCodedStream(io::Printer* printer) const;
63
+ void GenerateSerializeWithCachedSizes(io::Printer* printer) const;
64
+ void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
65
+ void GenerateByteSize(io::Printer* printer) const;
66
+
67
+ private:
68
+ const FieldDescriptor* descriptor_;
69
+ map<string, string> variables_;
70
+
71
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StringFieldGenerator);
72
+ };
73
+
74
+ class RepeatedStringFieldGenerator : public FieldGenerator {
75
+ public:
76
+ explicit RepeatedStringFieldGenerator(const FieldDescriptor* descriptor);
77
+ ~RepeatedStringFieldGenerator();
78
+
79
+ // implements FieldGenerator ---------------------------------------
80
+ void GeneratePrivateMembers(io::Printer* printer) const;
81
+ void GenerateAccessorDeclarations(io::Printer* printer) const;
82
+ void GenerateInlineAccessorDefinitions(io::Printer* printer) const;
83
+ void GenerateClearingCode(io::Printer* printer) const;
84
+ void GenerateMergingCode(io::Printer* printer) const;
85
+ void GenerateSwappingCode(io::Printer* printer) const;
86
+ void GenerateConstructorCode(io::Printer* printer) const;
87
+ void GenerateMergeFromCodedStream(io::Printer* printer) const;
88
+ void GenerateSerializeWithCachedSizes(io::Printer* printer) const;
89
+ void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
90
+ void GenerateByteSize(io::Printer* printer) const;
91
+
92
+ private:
93
+ const FieldDescriptor* descriptor_;
94
+ map<string, string> variables_;
95
+
96
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RepeatedStringFieldGenerator);
97
+ };
98
+
99
+ } // namespace cpp
100
+ } // namespace compiler
101
+ } // namespace protobuf
102
+
103
+ } // namespace google
104
+ #endif // GOOGLE_PROTOBUF_COMPILER_CPP_STRING_FIELD_H__
@@ -0,0 +1,2721 @@
1
+ // Generated by the protocol buffer compiler. DO NOT EDIT!
2
+ // source: google/protobuf/compiler/cpp/cpp_test_bad_identifiers.proto
3
+
4
+ #ifndef PROTOBUF_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto__INCLUDED
5
+ #define PROTOBUF_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto__INCLUDED
6
+
7
+ #include <string>
8
+
9
+ #include <google/protobuf/stubs/common.h>
10
+
11
+ #if GOOGLE_PROTOBUF_VERSION < 2004000
12
+ #error This file was generated by a newer version of protoc which is
13
+ #error incompatible with your Protocol Buffer headers. Please update
14
+ #error your headers.
15
+ #endif
16
+ #if 2004001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
17
+ #error This file was generated by an older version of protoc which is
18
+ #error incompatible with your Protocol Buffer headers. Please
19
+ #error regenerate this file with a newer version of protoc.
20
+ #endif
21
+
22
+ #include <google/protobuf/generated_message_util.h>
23
+ #include <google/protobuf/repeated_field.h>
24
+ #include <google/protobuf/extension_set.h>
25
+ #include <google/protobuf/generated_message_reflection.h>
26
+ #include <google/protobuf/service.h>
27
+ // @@protoc_insertion_point(includes)
28
+
29
+ namespace protobuf_unittest {
30
+
31
+ // Internal implementation detail -- do not call these.
32
+ void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
33
+ void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
34
+ void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
35
+
36
+ class TestConflictingSymbolNames;
37
+ class TestConflictingSymbolNames_BuildDescriptors;
38
+ class TestConflictingSymbolNames_TypeTraits;
39
+ class TestConflictingSymbolNames_Data1;
40
+ class TestConflictingSymbolNames_Data2;
41
+ class TestConflictingSymbolNames_Data3;
42
+ class TestConflictingSymbolNames_Data4;
43
+ class TestConflictingSymbolNames_Data5;
44
+ class TestConflictingSymbolNames_Data6;
45
+ class TestConflictingSymbolNames_Cord;
46
+ class TestConflictingSymbolNames_StringPiece;
47
+ class TestConflictingSymbolNames_DO;
48
+ class DummyMessage;
49
+
50
+ enum TestConflictingSymbolNames_TestEnum {
51
+ TestConflictingSymbolNames_TestEnum_FOO = 1
52
+ };
53
+ bool TestConflictingSymbolNames_TestEnum_IsValid(int value);
54
+ const TestConflictingSymbolNames_TestEnum TestConflictingSymbolNames_TestEnum_TestEnum_MIN = TestConflictingSymbolNames_TestEnum_FOO;
55
+ const TestConflictingSymbolNames_TestEnum TestConflictingSymbolNames_TestEnum_TestEnum_MAX = TestConflictingSymbolNames_TestEnum_FOO;
56
+ const int TestConflictingSymbolNames_TestEnum_TestEnum_ARRAYSIZE = TestConflictingSymbolNames_TestEnum_TestEnum_MAX + 1;
57
+
58
+ const ::google::protobuf::EnumDescriptor* TestConflictingSymbolNames_TestEnum_descriptor();
59
+ inline const ::std::string& TestConflictingSymbolNames_TestEnum_Name(TestConflictingSymbolNames_TestEnum value) {
60
+ return ::google::protobuf::internal::NameOfEnum(
61
+ TestConflictingSymbolNames_TestEnum_descriptor(), value);
62
+ }
63
+ inline bool TestConflictingSymbolNames_TestEnum_Parse(
64
+ const ::std::string& name, TestConflictingSymbolNames_TestEnum* value) {
65
+ return ::google::protobuf::internal::ParseNamedEnum<TestConflictingSymbolNames_TestEnum>(
66
+ TestConflictingSymbolNames_TestEnum_descriptor(), name, value);
67
+ }
68
+ // ===================================================================
69
+
70
+ class TestConflictingSymbolNames_BuildDescriptors : public ::google::protobuf::Message {
71
+ public:
72
+ TestConflictingSymbolNames_BuildDescriptors();
73
+ virtual ~TestConflictingSymbolNames_BuildDescriptors();
74
+
75
+ TestConflictingSymbolNames_BuildDescriptors(const TestConflictingSymbolNames_BuildDescriptors& from);
76
+
77
+ inline TestConflictingSymbolNames_BuildDescriptors& operator=(const TestConflictingSymbolNames_BuildDescriptors& from) {
78
+ CopyFrom(from);
79
+ return *this;
80
+ }
81
+
82
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
83
+ return _unknown_fields_;
84
+ }
85
+
86
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
87
+ return &_unknown_fields_;
88
+ }
89
+
90
+ static const ::google::protobuf::Descriptor* descriptor();
91
+ static const TestConflictingSymbolNames_BuildDescriptors& default_instance();
92
+
93
+ void Swap(TestConflictingSymbolNames_BuildDescriptors* other);
94
+
95
+ // implements Message ----------------------------------------------
96
+
97
+ TestConflictingSymbolNames_BuildDescriptors* New() const;
98
+ void CopyFrom(const ::google::protobuf::Message& from);
99
+ void MergeFrom(const ::google::protobuf::Message& from);
100
+ void CopyFrom(const TestConflictingSymbolNames_BuildDescriptors& from);
101
+ void MergeFrom(const TestConflictingSymbolNames_BuildDescriptors& from);
102
+ void Clear();
103
+ bool IsInitialized() const;
104
+
105
+ int ByteSize() const;
106
+ bool MergePartialFromCodedStream(
107
+ ::google::protobuf::io::CodedInputStream* input);
108
+ void SerializeWithCachedSizes(
109
+ ::google::protobuf::io::CodedOutputStream* output) const;
110
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
111
+ int GetCachedSize() const { return _cached_size_; }
112
+ private:
113
+ void SharedCtor();
114
+ void SharedDtor();
115
+ void SetCachedSize(int size) const;
116
+ public:
117
+
118
+ ::google::protobuf::Metadata GetMetadata() const;
119
+
120
+ // nested types ----------------------------------------------------
121
+
122
+ // accessors -------------------------------------------------------
123
+
124
+ // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
125
+ private:
126
+
127
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
128
+
129
+
130
+ mutable int _cached_size_;
131
+ ::google::protobuf::uint32 _has_bits_[1];
132
+
133
+ friend void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
134
+ friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
135
+ friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
136
+
137
+ void InitAsDefaultInstance();
138
+ static TestConflictingSymbolNames_BuildDescriptors* default_instance_;
139
+ };
140
+ // -------------------------------------------------------------------
141
+
142
+ class TestConflictingSymbolNames_TypeTraits : public ::google::protobuf::Message {
143
+ public:
144
+ TestConflictingSymbolNames_TypeTraits();
145
+ virtual ~TestConflictingSymbolNames_TypeTraits();
146
+
147
+ TestConflictingSymbolNames_TypeTraits(const TestConflictingSymbolNames_TypeTraits& from);
148
+
149
+ inline TestConflictingSymbolNames_TypeTraits& operator=(const TestConflictingSymbolNames_TypeTraits& from) {
150
+ CopyFrom(from);
151
+ return *this;
152
+ }
153
+
154
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
155
+ return _unknown_fields_;
156
+ }
157
+
158
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
159
+ return &_unknown_fields_;
160
+ }
161
+
162
+ static const ::google::protobuf::Descriptor* descriptor();
163
+ static const TestConflictingSymbolNames_TypeTraits& default_instance();
164
+
165
+ void Swap(TestConflictingSymbolNames_TypeTraits* other);
166
+
167
+ // implements Message ----------------------------------------------
168
+
169
+ TestConflictingSymbolNames_TypeTraits* New() const;
170
+ void CopyFrom(const ::google::protobuf::Message& from);
171
+ void MergeFrom(const ::google::protobuf::Message& from);
172
+ void CopyFrom(const TestConflictingSymbolNames_TypeTraits& from);
173
+ void MergeFrom(const TestConflictingSymbolNames_TypeTraits& from);
174
+ void Clear();
175
+ bool IsInitialized() const;
176
+
177
+ int ByteSize() const;
178
+ bool MergePartialFromCodedStream(
179
+ ::google::protobuf::io::CodedInputStream* input);
180
+ void SerializeWithCachedSizes(
181
+ ::google::protobuf::io::CodedOutputStream* output) const;
182
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
183
+ int GetCachedSize() const { return _cached_size_; }
184
+ private:
185
+ void SharedCtor();
186
+ void SharedDtor();
187
+ void SetCachedSize(int size) const;
188
+ public:
189
+
190
+ ::google::protobuf::Metadata GetMetadata() const;
191
+
192
+ // nested types ----------------------------------------------------
193
+
194
+ // accessors -------------------------------------------------------
195
+
196
+ // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
197
+ private:
198
+
199
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
200
+
201
+
202
+ mutable int _cached_size_;
203
+ ::google::protobuf::uint32 _has_bits_[1];
204
+
205
+ friend void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
206
+ friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
207
+ friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
208
+
209
+ void InitAsDefaultInstance();
210
+ static TestConflictingSymbolNames_TypeTraits* default_instance_;
211
+ };
212
+ // -------------------------------------------------------------------
213
+
214
+ class TestConflictingSymbolNames_Data1 : public ::google::protobuf::Message {
215
+ public:
216
+ TestConflictingSymbolNames_Data1();
217
+ virtual ~TestConflictingSymbolNames_Data1();
218
+
219
+ TestConflictingSymbolNames_Data1(const TestConflictingSymbolNames_Data1& from);
220
+
221
+ inline TestConflictingSymbolNames_Data1& operator=(const TestConflictingSymbolNames_Data1& from) {
222
+ CopyFrom(from);
223
+ return *this;
224
+ }
225
+
226
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
227
+ return _unknown_fields_;
228
+ }
229
+
230
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
231
+ return &_unknown_fields_;
232
+ }
233
+
234
+ static const ::google::protobuf::Descriptor* descriptor();
235
+ static const TestConflictingSymbolNames_Data1& default_instance();
236
+
237
+ void Swap(TestConflictingSymbolNames_Data1* other);
238
+
239
+ // implements Message ----------------------------------------------
240
+
241
+ TestConflictingSymbolNames_Data1* New() const;
242
+ void CopyFrom(const ::google::protobuf::Message& from);
243
+ void MergeFrom(const ::google::protobuf::Message& from);
244
+ void CopyFrom(const TestConflictingSymbolNames_Data1& from);
245
+ void MergeFrom(const TestConflictingSymbolNames_Data1& from);
246
+ void Clear();
247
+ bool IsInitialized() const;
248
+
249
+ int ByteSize() const;
250
+ bool MergePartialFromCodedStream(
251
+ ::google::protobuf::io::CodedInputStream* input);
252
+ void SerializeWithCachedSizes(
253
+ ::google::protobuf::io::CodedOutputStream* output) const;
254
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
255
+ int GetCachedSize() const { return _cached_size_; }
256
+ private:
257
+ void SharedCtor();
258
+ void SharedDtor();
259
+ void SetCachedSize(int size) const;
260
+ public:
261
+
262
+ ::google::protobuf::Metadata GetMetadata() const;
263
+
264
+ // nested types ----------------------------------------------------
265
+
266
+ // accessors -------------------------------------------------------
267
+
268
+ // repeated int32 data = 1;
269
+ inline int data_size() const;
270
+ inline void clear_data();
271
+ static const int kDataFieldNumber = 1;
272
+ inline ::google::protobuf::int32 data(int index) const;
273
+ inline void set_data(int index, ::google::protobuf::int32 value);
274
+ inline void add_data(::google::protobuf::int32 value);
275
+ inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
276
+ data() const;
277
+ inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
278
+ mutable_data();
279
+
280
+ // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Data1)
281
+ private:
282
+
283
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
284
+
285
+ ::google::protobuf::RepeatedField< ::google::protobuf::int32 > data_;
286
+
287
+ mutable int _cached_size_;
288
+ ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
289
+
290
+ friend void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
291
+ friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
292
+ friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
293
+
294
+ void InitAsDefaultInstance();
295
+ static TestConflictingSymbolNames_Data1* default_instance_;
296
+ };
297
+ // -------------------------------------------------------------------
298
+
299
+ class TestConflictingSymbolNames_Data2 : public ::google::protobuf::Message {
300
+ public:
301
+ TestConflictingSymbolNames_Data2();
302
+ virtual ~TestConflictingSymbolNames_Data2();
303
+
304
+ TestConflictingSymbolNames_Data2(const TestConflictingSymbolNames_Data2& from);
305
+
306
+ inline TestConflictingSymbolNames_Data2& operator=(const TestConflictingSymbolNames_Data2& from) {
307
+ CopyFrom(from);
308
+ return *this;
309
+ }
310
+
311
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
312
+ return _unknown_fields_;
313
+ }
314
+
315
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
316
+ return &_unknown_fields_;
317
+ }
318
+
319
+ static const ::google::protobuf::Descriptor* descriptor();
320
+ static const TestConflictingSymbolNames_Data2& default_instance();
321
+
322
+ void Swap(TestConflictingSymbolNames_Data2* other);
323
+
324
+ // implements Message ----------------------------------------------
325
+
326
+ TestConflictingSymbolNames_Data2* New() const;
327
+ void CopyFrom(const ::google::protobuf::Message& from);
328
+ void MergeFrom(const ::google::protobuf::Message& from);
329
+ void CopyFrom(const TestConflictingSymbolNames_Data2& from);
330
+ void MergeFrom(const TestConflictingSymbolNames_Data2& from);
331
+ void Clear();
332
+ bool IsInitialized() const;
333
+
334
+ int ByteSize() const;
335
+ bool MergePartialFromCodedStream(
336
+ ::google::protobuf::io::CodedInputStream* input);
337
+ void SerializeWithCachedSizes(
338
+ ::google::protobuf::io::CodedOutputStream* output) const;
339
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
340
+ int GetCachedSize() const { return _cached_size_; }
341
+ private:
342
+ void SharedCtor();
343
+ void SharedDtor();
344
+ void SetCachedSize(int size) const;
345
+ public:
346
+
347
+ ::google::protobuf::Metadata GetMetadata() const;
348
+
349
+ // nested types ----------------------------------------------------
350
+
351
+ // accessors -------------------------------------------------------
352
+
353
+ // repeated .protobuf_unittest.TestConflictingSymbolNames.TestEnum data = 1;
354
+ inline int data_size() const;
355
+ inline void clear_data();
356
+ static const int kDataFieldNumber = 1;
357
+ inline ::protobuf_unittest::TestConflictingSymbolNames_TestEnum data(int index) const;
358
+ inline void set_data(int index, ::protobuf_unittest::TestConflictingSymbolNames_TestEnum value);
359
+ inline void add_data(::protobuf_unittest::TestConflictingSymbolNames_TestEnum value);
360
+ inline const ::google::protobuf::RepeatedField<int>& data() const;
361
+ inline ::google::protobuf::RepeatedField<int>* mutable_data();
362
+
363
+ // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Data2)
364
+ private:
365
+
366
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
367
+
368
+ ::google::protobuf::RepeatedField<int> data_;
369
+
370
+ mutable int _cached_size_;
371
+ ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
372
+
373
+ friend void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
374
+ friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
375
+ friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
376
+
377
+ void InitAsDefaultInstance();
378
+ static TestConflictingSymbolNames_Data2* default_instance_;
379
+ };
380
+ // -------------------------------------------------------------------
381
+
382
+ class TestConflictingSymbolNames_Data3 : public ::google::protobuf::Message {
383
+ public:
384
+ TestConflictingSymbolNames_Data3();
385
+ virtual ~TestConflictingSymbolNames_Data3();
386
+
387
+ TestConflictingSymbolNames_Data3(const TestConflictingSymbolNames_Data3& from);
388
+
389
+ inline TestConflictingSymbolNames_Data3& operator=(const TestConflictingSymbolNames_Data3& from) {
390
+ CopyFrom(from);
391
+ return *this;
392
+ }
393
+
394
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
395
+ return _unknown_fields_;
396
+ }
397
+
398
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
399
+ return &_unknown_fields_;
400
+ }
401
+
402
+ static const ::google::protobuf::Descriptor* descriptor();
403
+ static const TestConflictingSymbolNames_Data3& default_instance();
404
+
405
+ void Swap(TestConflictingSymbolNames_Data3* other);
406
+
407
+ // implements Message ----------------------------------------------
408
+
409
+ TestConflictingSymbolNames_Data3* New() const;
410
+ void CopyFrom(const ::google::protobuf::Message& from);
411
+ void MergeFrom(const ::google::protobuf::Message& from);
412
+ void CopyFrom(const TestConflictingSymbolNames_Data3& from);
413
+ void MergeFrom(const TestConflictingSymbolNames_Data3& from);
414
+ void Clear();
415
+ bool IsInitialized() const;
416
+
417
+ int ByteSize() const;
418
+ bool MergePartialFromCodedStream(
419
+ ::google::protobuf::io::CodedInputStream* input);
420
+ void SerializeWithCachedSizes(
421
+ ::google::protobuf::io::CodedOutputStream* output) const;
422
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
423
+ int GetCachedSize() const { return _cached_size_; }
424
+ private:
425
+ void SharedCtor();
426
+ void SharedDtor();
427
+ void SetCachedSize(int size) const;
428
+ public:
429
+
430
+ ::google::protobuf::Metadata GetMetadata() const;
431
+
432
+ // nested types ----------------------------------------------------
433
+
434
+ // accessors -------------------------------------------------------
435
+
436
+ // repeated string data = 1;
437
+ inline int data_size() const;
438
+ inline void clear_data();
439
+ static const int kDataFieldNumber = 1;
440
+ inline const ::std::string& data(int index) const;
441
+ inline ::std::string* mutable_data(int index);
442
+ inline void set_data(int index, const ::std::string& value);
443
+ inline void set_data(int index, const char* value);
444
+ inline void set_data(int index, const char* value, size_t size);
445
+ inline ::std::string* add_data();
446
+ inline void add_data(const ::std::string& value);
447
+ inline void add_data(const char* value);
448
+ inline void add_data(const char* value, size_t size);
449
+ inline const ::google::protobuf::RepeatedPtrField< ::std::string>& data() const;
450
+ inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_data();
451
+
452
+ // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Data3)
453
+ private:
454
+
455
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
456
+
457
+ ::google::protobuf::RepeatedPtrField< ::std::string> data_;
458
+
459
+ mutable int _cached_size_;
460
+ ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
461
+
462
+ friend void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
463
+ friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
464
+ friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
465
+
466
+ void InitAsDefaultInstance();
467
+ static TestConflictingSymbolNames_Data3* default_instance_;
468
+ };
469
+ // -------------------------------------------------------------------
470
+
471
+ class TestConflictingSymbolNames_Data4 : public ::google::protobuf::Message {
472
+ public:
473
+ TestConflictingSymbolNames_Data4();
474
+ virtual ~TestConflictingSymbolNames_Data4();
475
+
476
+ TestConflictingSymbolNames_Data4(const TestConflictingSymbolNames_Data4& from);
477
+
478
+ inline TestConflictingSymbolNames_Data4& operator=(const TestConflictingSymbolNames_Data4& from) {
479
+ CopyFrom(from);
480
+ return *this;
481
+ }
482
+
483
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
484
+ return _unknown_fields_;
485
+ }
486
+
487
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
488
+ return &_unknown_fields_;
489
+ }
490
+
491
+ static const ::google::protobuf::Descriptor* descriptor();
492
+ static const TestConflictingSymbolNames_Data4& default_instance();
493
+
494
+ void Swap(TestConflictingSymbolNames_Data4* other);
495
+
496
+ // implements Message ----------------------------------------------
497
+
498
+ TestConflictingSymbolNames_Data4* New() const;
499
+ void CopyFrom(const ::google::protobuf::Message& from);
500
+ void MergeFrom(const ::google::protobuf::Message& from);
501
+ void CopyFrom(const TestConflictingSymbolNames_Data4& from);
502
+ void MergeFrom(const TestConflictingSymbolNames_Data4& from);
503
+ void Clear();
504
+ bool IsInitialized() const;
505
+
506
+ int ByteSize() const;
507
+ bool MergePartialFromCodedStream(
508
+ ::google::protobuf::io::CodedInputStream* input);
509
+ void SerializeWithCachedSizes(
510
+ ::google::protobuf::io::CodedOutputStream* output) const;
511
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
512
+ int GetCachedSize() const { return _cached_size_; }
513
+ private:
514
+ void SharedCtor();
515
+ void SharedDtor();
516
+ void SetCachedSize(int size) const;
517
+ public:
518
+
519
+ ::google::protobuf::Metadata GetMetadata() const;
520
+
521
+ // nested types ----------------------------------------------------
522
+
523
+ // accessors -------------------------------------------------------
524
+
525
+ // repeated .protobuf_unittest.TestConflictingSymbolNames.Data4 data = 1;
526
+ inline int data_size() const;
527
+ inline void clear_data();
528
+ static const int kDataFieldNumber = 1;
529
+ inline const ::protobuf_unittest::TestConflictingSymbolNames_Data4& data(int index) const;
530
+ inline ::protobuf_unittest::TestConflictingSymbolNames_Data4* mutable_data(int index);
531
+ inline ::protobuf_unittest::TestConflictingSymbolNames_Data4* add_data();
532
+ inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestConflictingSymbolNames_Data4 >&
533
+ data() const;
534
+ inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestConflictingSymbolNames_Data4 >*
535
+ mutable_data();
536
+
537
+ // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Data4)
538
+ private:
539
+
540
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
541
+
542
+ ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestConflictingSymbolNames_Data4 > data_;
543
+
544
+ mutable int _cached_size_;
545
+ ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
546
+
547
+ friend void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
548
+ friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
549
+ friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
550
+
551
+ void InitAsDefaultInstance();
552
+ static TestConflictingSymbolNames_Data4* default_instance_;
553
+ };
554
+ // -------------------------------------------------------------------
555
+
556
+ class TestConflictingSymbolNames_Data5 : public ::google::protobuf::Message {
557
+ public:
558
+ TestConflictingSymbolNames_Data5();
559
+ virtual ~TestConflictingSymbolNames_Data5();
560
+
561
+ TestConflictingSymbolNames_Data5(const TestConflictingSymbolNames_Data5& from);
562
+
563
+ inline TestConflictingSymbolNames_Data5& operator=(const TestConflictingSymbolNames_Data5& from) {
564
+ CopyFrom(from);
565
+ return *this;
566
+ }
567
+
568
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
569
+ return _unknown_fields_;
570
+ }
571
+
572
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
573
+ return &_unknown_fields_;
574
+ }
575
+
576
+ static const ::google::protobuf::Descriptor* descriptor();
577
+ static const TestConflictingSymbolNames_Data5& default_instance();
578
+
579
+ void Swap(TestConflictingSymbolNames_Data5* other);
580
+
581
+ // implements Message ----------------------------------------------
582
+
583
+ TestConflictingSymbolNames_Data5* New() const;
584
+ void CopyFrom(const ::google::protobuf::Message& from);
585
+ void MergeFrom(const ::google::protobuf::Message& from);
586
+ void CopyFrom(const TestConflictingSymbolNames_Data5& from);
587
+ void MergeFrom(const TestConflictingSymbolNames_Data5& from);
588
+ void Clear();
589
+ bool IsInitialized() const;
590
+
591
+ int ByteSize() const;
592
+ bool MergePartialFromCodedStream(
593
+ ::google::protobuf::io::CodedInputStream* input);
594
+ void SerializeWithCachedSizes(
595
+ ::google::protobuf::io::CodedOutputStream* output) const;
596
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
597
+ int GetCachedSize() const { return _cached_size_; }
598
+ private:
599
+ void SharedCtor();
600
+ void SharedDtor();
601
+ void SetCachedSize(int size) const;
602
+ public:
603
+
604
+ ::google::protobuf::Metadata GetMetadata() const;
605
+
606
+ // nested types ----------------------------------------------------
607
+
608
+ // accessors -------------------------------------------------------
609
+
610
+ // repeated string data = 1 [ctype = STRING_PIECE];
611
+ inline int data_size() const;
612
+ inline void clear_data();
613
+ static const int kDataFieldNumber = 1;
614
+ private:
615
+ // Hidden due to unknown ctype option.
616
+ inline const ::std::string& data(int index) const;
617
+ inline ::std::string* mutable_data(int index);
618
+ inline void set_data(int index, const ::std::string& value);
619
+ inline void set_data(int index, const char* value);
620
+ inline void set_data(int index, const char* value, size_t size);
621
+ inline ::std::string* add_data();
622
+ inline void add_data(const ::std::string& value);
623
+ inline void add_data(const char* value);
624
+ inline void add_data(const char* value, size_t size);
625
+ inline const ::google::protobuf::RepeatedPtrField< ::std::string>& data() const;
626
+ inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_data();
627
+ public:
628
+
629
+ // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Data5)
630
+ private:
631
+
632
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
633
+
634
+ ::google::protobuf::RepeatedPtrField< ::std::string> data_;
635
+
636
+ mutable int _cached_size_;
637
+ ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
638
+
639
+ friend void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
640
+ friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
641
+ friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
642
+
643
+ void InitAsDefaultInstance();
644
+ static TestConflictingSymbolNames_Data5* default_instance_;
645
+ };
646
+ // -------------------------------------------------------------------
647
+
648
+ class TestConflictingSymbolNames_Data6 : public ::google::protobuf::Message {
649
+ public:
650
+ TestConflictingSymbolNames_Data6();
651
+ virtual ~TestConflictingSymbolNames_Data6();
652
+
653
+ TestConflictingSymbolNames_Data6(const TestConflictingSymbolNames_Data6& from);
654
+
655
+ inline TestConflictingSymbolNames_Data6& operator=(const TestConflictingSymbolNames_Data6& from) {
656
+ CopyFrom(from);
657
+ return *this;
658
+ }
659
+
660
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
661
+ return _unknown_fields_;
662
+ }
663
+
664
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
665
+ return &_unknown_fields_;
666
+ }
667
+
668
+ static const ::google::protobuf::Descriptor* descriptor();
669
+ static const TestConflictingSymbolNames_Data6& default_instance();
670
+
671
+ void Swap(TestConflictingSymbolNames_Data6* other);
672
+
673
+ // implements Message ----------------------------------------------
674
+
675
+ TestConflictingSymbolNames_Data6* New() const;
676
+ void CopyFrom(const ::google::protobuf::Message& from);
677
+ void MergeFrom(const ::google::protobuf::Message& from);
678
+ void CopyFrom(const TestConflictingSymbolNames_Data6& from);
679
+ void MergeFrom(const TestConflictingSymbolNames_Data6& from);
680
+ void Clear();
681
+ bool IsInitialized() const;
682
+
683
+ int ByteSize() const;
684
+ bool MergePartialFromCodedStream(
685
+ ::google::protobuf::io::CodedInputStream* input);
686
+ void SerializeWithCachedSizes(
687
+ ::google::protobuf::io::CodedOutputStream* output) const;
688
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
689
+ int GetCachedSize() const { return _cached_size_; }
690
+ private:
691
+ void SharedCtor();
692
+ void SharedDtor();
693
+ void SetCachedSize(int size) const;
694
+ public:
695
+
696
+ ::google::protobuf::Metadata GetMetadata() const;
697
+
698
+ // nested types ----------------------------------------------------
699
+
700
+ // accessors -------------------------------------------------------
701
+
702
+ // repeated string data = 1 [ctype = CORD];
703
+ inline int data_size() const;
704
+ inline void clear_data();
705
+ static const int kDataFieldNumber = 1;
706
+ private:
707
+ // Hidden due to unknown ctype option.
708
+ inline const ::std::string& data(int index) const;
709
+ inline ::std::string* mutable_data(int index);
710
+ inline void set_data(int index, const ::std::string& value);
711
+ inline void set_data(int index, const char* value);
712
+ inline void set_data(int index, const char* value, size_t size);
713
+ inline ::std::string* add_data();
714
+ inline void add_data(const ::std::string& value);
715
+ inline void add_data(const char* value);
716
+ inline void add_data(const char* value, size_t size);
717
+ inline const ::google::protobuf::RepeatedPtrField< ::std::string>& data() const;
718
+ inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_data();
719
+ public:
720
+
721
+ // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Data6)
722
+ private:
723
+
724
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
725
+
726
+ ::google::protobuf::RepeatedPtrField< ::std::string> data_;
727
+
728
+ mutable int _cached_size_;
729
+ ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
730
+
731
+ friend void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
732
+ friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
733
+ friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
734
+
735
+ void InitAsDefaultInstance();
736
+ static TestConflictingSymbolNames_Data6* default_instance_;
737
+ };
738
+ // -------------------------------------------------------------------
739
+
740
+ class TestConflictingSymbolNames_Cord : public ::google::protobuf::Message {
741
+ public:
742
+ TestConflictingSymbolNames_Cord();
743
+ virtual ~TestConflictingSymbolNames_Cord();
744
+
745
+ TestConflictingSymbolNames_Cord(const TestConflictingSymbolNames_Cord& from);
746
+
747
+ inline TestConflictingSymbolNames_Cord& operator=(const TestConflictingSymbolNames_Cord& from) {
748
+ CopyFrom(from);
749
+ return *this;
750
+ }
751
+
752
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
753
+ return _unknown_fields_;
754
+ }
755
+
756
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
757
+ return &_unknown_fields_;
758
+ }
759
+
760
+ static const ::google::protobuf::Descriptor* descriptor();
761
+ static const TestConflictingSymbolNames_Cord& default_instance();
762
+
763
+ void Swap(TestConflictingSymbolNames_Cord* other);
764
+
765
+ // implements Message ----------------------------------------------
766
+
767
+ TestConflictingSymbolNames_Cord* New() const;
768
+ void CopyFrom(const ::google::protobuf::Message& from);
769
+ void MergeFrom(const ::google::protobuf::Message& from);
770
+ void CopyFrom(const TestConflictingSymbolNames_Cord& from);
771
+ void MergeFrom(const TestConflictingSymbolNames_Cord& from);
772
+ void Clear();
773
+ bool IsInitialized() const;
774
+
775
+ int ByteSize() const;
776
+ bool MergePartialFromCodedStream(
777
+ ::google::protobuf::io::CodedInputStream* input);
778
+ void SerializeWithCachedSizes(
779
+ ::google::protobuf::io::CodedOutputStream* output) const;
780
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
781
+ int GetCachedSize() const { return _cached_size_; }
782
+ private:
783
+ void SharedCtor();
784
+ void SharedDtor();
785
+ void SetCachedSize(int size) const;
786
+ public:
787
+
788
+ ::google::protobuf::Metadata GetMetadata() const;
789
+
790
+ // nested types ----------------------------------------------------
791
+
792
+ // accessors -------------------------------------------------------
793
+
794
+ // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Cord)
795
+ private:
796
+
797
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
798
+
799
+
800
+ mutable int _cached_size_;
801
+ ::google::protobuf::uint32 _has_bits_[1];
802
+
803
+ friend void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
804
+ friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
805
+ friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
806
+
807
+ void InitAsDefaultInstance();
808
+ static TestConflictingSymbolNames_Cord* default_instance_;
809
+ };
810
+ // -------------------------------------------------------------------
811
+
812
+ class TestConflictingSymbolNames_StringPiece : public ::google::protobuf::Message {
813
+ public:
814
+ TestConflictingSymbolNames_StringPiece();
815
+ virtual ~TestConflictingSymbolNames_StringPiece();
816
+
817
+ TestConflictingSymbolNames_StringPiece(const TestConflictingSymbolNames_StringPiece& from);
818
+
819
+ inline TestConflictingSymbolNames_StringPiece& operator=(const TestConflictingSymbolNames_StringPiece& from) {
820
+ CopyFrom(from);
821
+ return *this;
822
+ }
823
+
824
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
825
+ return _unknown_fields_;
826
+ }
827
+
828
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
829
+ return &_unknown_fields_;
830
+ }
831
+
832
+ static const ::google::protobuf::Descriptor* descriptor();
833
+ static const TestConflictingSymbolNames_StringPiece& default_instance();
834
+
835
+ void Swap(TestConflictingSymbolNames_StringPiece* other);
836
+
837
+ // implements Message ----------------------------------------------
838
+
839
+ TestConflictingSymbolNames_StringPiece* New() const;
840
+ void CopyFrom(const ::google::protobuf::Message& from);
841
+ void MergeFrom(const ::google::protobuf::Message& from);
842
+ void CopyFrom(const TestConflictingSymbolNames_StringPiece& from);
843
+ void MergeFrom(const TestConflictingSymbolNames_StringPiece& from);
844
+ void Clear();
845
+ bool IsInitialized() const;
846
+
847
+ int ByteSize() const;
848
+ bool MergePartialFromCodedStream(
849
+ ::google::protobuf::io::CodedInputStream* input);
850
+ void SerializeWithCachedSizes(
851
+ ::google::protobuf::io::CodedOutputStream* output) const;
852
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
853
+ int GetCachedSize() const { return _cached_size_; }
854
+ private:
855
+ void SharedCtor();
856
+ void SharedDtor();
857
+ void SetCachedSize(int size) const;
858
+ public:
859
+
860
+ ::google::protobuf::Metadata GetMetadata() const;
861
+
862
+ // nested types ----------------------------------------------------
863
+
864
+ // accessors -------------------------------------------------------
865
+
866
+ // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
867
+ private:
868
+
869
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
870
+
871
+
872
+ mutable int _cached_size_;
873
+ ::google::protobuf::uint32 _has_bits_[1];
874
+
875
+ friend void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
876
+ friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
877
+ friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
878
+
879
+ void InitAsDefaultInstance();
880
+ static TestConflictingSymbolNames_StringPiece* default_instance_;
881
+ };
882
+ // -------------------------------------------------------------------
883
+
884
+ class TestConflictingSymbolNames_DO : public ::google::protobuf::Message {
885
+ public:
886
+ TestConflictingSymbolNames_DO();
887
+ virtual ~TestConflictingSymbolNames_DO();
888
+
889
+ TestConflictingSymbolNames_DO(const TestConflictingSymbolNames_DO& from);
890
+
891
+ inline TestConflictingSymbolNames_DO& operator=(const TestConflictingSymbolNames_DO& from) {
892
+ CopyFrom(from);
893
+ return *this;
894
+ }
895
+
896
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
897
+ return _unknown_fields_;
898
+ }
899
+
900
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
901
+ return &_unknown_fields_;
902
+ }
903
+
904
+ static const ::google::protobuf::Descriptor* descriptor();
905
+ static const TestConflictingSymbolNames_DO& default_instance();
906
+
907
+ void Swap(TestConflictingSymbolNames_DO* other);
908
+
909
+ // implements Message ----------------------------------------------
910
+
911
+ TestConflictingSymbolNames_DO* New() const;
912
+ void CopyFrom(const ::google::protobuf::Message& from);
913
+ void MergeFrom(const ::google::protobuf::Message& from);
914
+ void CopyFrom(const TestConflictingSymbolNames_DO& from);
915
+ void MergeFrom(const TestConflictingSymbolNames_DO& from);
916
+ void Clear();
917
+ bool IsInitialized() const;
918
+
919
+ int ByteSize() const;
920
+ bool MergePartialFromCodedStream(
921
+ ::google::protobuf::io::CodedInputStream* input);
922
+ void SerializeWithCachedSizes(
923
+ ::google::protobuf::io::CodedOutputStream* output) const;
924
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
925
+ int GetCachedSize() const { return _cached_size_; }
926
+ private:
927
+ void SharedCtor();
928
+ void SharedDtor();
929
+ void SetCachedSize(int size) const;
930
+ public:
931
+
932
+ ::google::protobuf::Metadata GetMetadata() const;
933
+
934
+ // nested types ----------------------------------------------------
935
+
936
+ // accessors -------------------------------------------------------
937
+
938
+ // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.DO)
939
+ private:
940
+
941
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
942
+
943
+
944
+ mutable int _cached_size_;
945
+ ::google::protobuf::uint32 _has_bits_[1];
946
+
947
+ friend void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
948
+ friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
949
+ friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
950
+
951
+ void InitAsDefaultInstance();
952
+ static TestConflictingSymbolNames_DO* default_instance_;
953
+ };
954
+ // -------------------------------------------------------------------
955
+
956
+ class TestConflictingSymbolNames : public ::google::protobuf::Message {
957
+ public:
958
+ TestConflictingSymbolNames();
959
+ virtual ~TestConflictingSymbolNames();
960
+
961
+ TestConflictingSymbolNames(const TestConflictingSymbolNames& from);
962
+
963
+ inline TestConflictingSymbolNames& operator=(const TestConflictingSymbolNames& from) {
964
+ CopyFrom(from);
965
+ return *this;
966
+ }
967
+
968
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
969
+ return _unknown_fields_;
970
+ }
971
+
972
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
973
+ return &_unknown_fields_;
974
+ }
975
+
976
+ static const ::google::protobuf::Descriptor* descriptor();
977
+ static const TestConflictingSymbolNames& default_instance();
978
+
979
+ void Swap(TestConflictingSymbolNames* other);
980
+
981
+ // implements Message ----------------------------------------------
982
+
983
+ TestConflictingSymbolNames* New() const;
984
+ void CopyFrom(const ::google::protobuf::Message& from);
985
+ void MergeFrom(const ::google::protobuf::Message& from);
986
+ void CopyFrom(const TestConflictingSymbolNames& from);
987
+ void MergeFrom(const TestConflictingSymbolNames& from);
988
+ void Clear();
989
+ bool IsInitialized() const;
990
+
991
+ int ByteSize() const;
992
+ bool MergePartialFromCodedStream(
993
+ ::google::protobuf::io::CodedInputStream* input);
994
+ void SerializeWithCachedSizes(
995
+ ::google::protobuf::io::CodedOutputStream* output) const;
996
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
997
+ int GetCachedSize() const { return _cached_size_; }
998
+ private:
999
+ void SharedCtor();
1000
+ void SharedDtor();
1001
+ void SetCachedSize(int size) const;
1002
+ public:
1003
+
1004
+ ::google::protobuf::Metadata GetMetadata() const;
1005
+
1006
+ // nested types ----------------------------------------------------
1007
+
1008
+ typedef TestConflictingSymbolNames_BuildDescriptors BuildDescriptors;
1009
+ typedef TestConflictingSymbolNames_TypeTraits TypeTraits;
1010
+ typedef TestConflictingSymbolNames_Data1 Data1;
1011
+ typedef TestConflictingSymbolNames_Data2 Data2;
1012
+ typedef TestConflictingSymbolNames_Data3 Data3;
1013
+ typedef TestConflictingSymbolNames_Data4 Data4;
1014
+ typedef TestConflictingSymbolNames_Data5 Data5;
1015
+ typedef TestConflictingSymbolNames_Data6 Data6;
1016
+ typedef TestConflictingSymbolNames_Cord Cord;
1017
+ typedef TestConflictingSymbolNames_StringPiece StringPiece;
1018
+ typedef TestConflictingSymbolNames_DO DO;
1019
+
1020
+ typedef TestConflictingSymbolNames_TestEnum TestEnum;
1021
+ static const TestEnum FOO = TestConflictingSymbolNames_TestEnum_FOO;
1022
+ static inline bool TestEnum_IsValid(int value) {
1023
+ return TestConflictingSymbolNames_TestEnum_IsValid(value);
1024
+ }
1025
+ static const TestEnum TestEnum_MIN =
1026
+ TestConflictingSymbolNames_TestEnum_TestEnum_MIN;
1027
+ static const TestEnum TestEnum_MAX =
1028
+ TestConflictingSymbolNames_TestEnum_TestEnum_MAX;
1029
+ static const int TestEnum_ARRAYSIZE =
1030
+ TestConflictingSymbolNames_TestEnum_TestEnum_ARRAYSIZE;
1031
+ static inline const ::google::protobuf::EnumDescriptor*
1032
+ TestEnum_descriptor() {
1033
+ return TestConflictingSymbolNames_TestEnum_descriptor();
1034
+ }
1035
+ static inline const ::std::string& TestEnum_Name(TestEnum value) {
1036
+ return TestConflictingSymbolNames_TestEnum_Name(value);
1037
+ }
1038
+ static inline bool TestEnum_Parse(const ::std::string& name,
1039
+ TestEnum* value) {
1040
+ return TestConflictingSymbolNames_TestEnum_Parse(name, value);
1041
+ }
1042
+
1043
+ // accessors -------------------------------------------------------
1044
+
1045
+ // optional int32 input = 1;
1046
+ inline bool has_input() const;
1047
+ inline void clear_input();
1048
+ static const int kInputFieldNumber = 1;
1049
+ inline ::google::protobuf::int32 input() const;
1050
+ inline void set_input(::google::protobuf::int32 value);
1051
+
1052
+ // optional int32 output = 2;
1053
+ inline bool has_output() const;
1054
+ inline void clear_output();
1055
+ static const int kOutputFieldNumber = 2;
1056
+ inline ::google::protobuf::int32 output() const;
1057
+ inline void set_output(::google::protobuf::int32 value);
1058
+
1059
+ // optional string length = 3;
1060
+ inline bool has_length() const;
1061
+ inline void clear_length();
1062
+ static const int kLengthFieldNumber = 3;
1063
+ inline const ::std::string& length() const;
1064
+ inline void set_length(const ::std::string& value);
1065
+ inline void set_length(const char* value);
1066
+ inline void set_length(const char* value, size_t size);
1067
+ inline ::std::string* mutable_length();
1068
+ inline ::std::string* release_length();
1069
+
1070
+ // repeated int32 i = 4;
1071
+ inline int i_size() const;
1072
+ inline void clear_i();
1073
+ static const int kIFieldNumber = 4;
1074
+ inline ::google::protobuf::int32 i(int index) const;
1075
+ inline void set_i(int index, ::google::protobuf::int32 value);
1076
+ inline void add_i(::google::protobuf::int32 value);
1077
+ inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
1078
+ i() const;
1079
+ inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
1080
+ mutable_i();
1081
+
1082
+ // repeated string new_element = 5 [ctype = STRING_PIECE];
1083
+ inline int new_element_size() const;
1084
+ inline void clear_new_element();
1085
+ static const int kNewElementFieldNumber = 5;
1086
+ private:
1087
+ // Hidden due to unknown ctype option.
1088
+ inline const ::std::string& new_element(int index) const;
1089
+ inline ::std::string* mutable_new_element(int index);
1090
+ inline void set_new_element(int index, const ::std::string& value);
1091
+ inline void set_new_element(int index, const char* value);
1092
+ inline void set_new_element(int index, const char* value, size_t size);
1093
+ inline ::std::string* add_new_element();
1094
+ inline void add_new_element(const ::std::string& value);
1095
+ inline void add_new_element(const char* value);
1096
+ inline void add_new_element(const char* value, size_t size);
1097
+ inline const ::google::protobuf::RepeatedPtrField< ::std::string>& new_element() const;
1098
+ inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_new_element();
1099
+ public:
1100
+
1101
+ // optional int32 total_size = 6;
1102
+ inline bool has_total_size() const;
1103
+ inline void clear_total_size();
1104
+ static const int kTotalSizeFieldNumber = 6;
1105
+ inline ::google::protobuf::int32 total_size() const;
1106
+ inline void set_total_size(::google::protobuf::int32 value);
1107
+
1108
+ // optional int32 tag = 7;
1109
+ inline bool has_tag() const;
1110
+ inline void clear_tag();
1111
+ static const int kTagFieldNumber = 7;
1112
+ inline ::google::protobuf::int32 tag() const;
1113
+ inline void set_tag(::google::protobuf::int32 value);
1114
+
1115
+ // optional int32 source = 8;
1116
+ inline bool has_source() const;
1117
+ inline void clear_source();
1118
+ static const int kSourceFieldNumber = 8;
1119
+ inline ::google::protobuf::int32 source() const;
1120
+ inline void set_source(::google::protobuf::int32 value);
1121
+
1122
+ // optional int32 value = 9;
1123
+ inline bool has_value() const;
1124
+ inline void clear_value();
1125
+ static const int kValueFieldNumber = 9;
1126
+ inline ::google::protobuf::int32 value() const;
1127
+ inline void set_value(::google::protobuf::int32 value);
1128
+
1129
+ // optional int32 file = 10;
1130
+ inline bool has_file() const;
1131
+ inline void clear_file();
1132
+ static const int kFileFieldNumber = 10;
1133
+ inline ::google::protobuf::int32 file() const;
1134
+ inline void set_file(::google::protobuf::int32 value);
1135
+
1136
+ // optional int32 from = 11;
1137
+ inline bool has_from() const;
1138
+ inline void clear_from();
1139
+ static const int kFromFieldNumber = 11;
1140
+ inline ::google::protobuf::int32 from() const;
1141
+ inline void set_from(::google::protobuf::int32 value);
1142
+
1143
+ // optional int32 handle_uninterpreted = 12;
1144
+ inline bool has_handle_uninterpreted() const;
1145
+ inline void clear_handle_uninterpreted();
1146
+ static const int kHandleUninterpretedFieldNumber = 12;
1147
+ inline ::google::protobuf::int32 handle_uninterpreted() const;
1148
+ inline void set_handle_uninterpreted(::google::protobuf::int32 value);
1149
+
1150
+ // repeated int32 index = 13;
1151
+ inline int index_size() const;
1152
+ inline void clear_index();
1153
+ static const int kIndexFieldNumber = 13;
1154
+ inline ::google::protobuf::int32 index(int index) const;
1155
+ inline void set_index(int index, ::google::protobuf::int32 value);
1156
+ inline void add_index(::google::protobuf::int32 value);
1157
+ inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
1158
+ index() const;
1159
+ inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
1160
+ mutable_index();
1161
+
1162
+ // optional int32 controller = 14;
1163
+ inline bool has_controller() const;
1164
+ inline void clear_controller();
1165
+ static const int kControllerFieldNumber = 14;
1166
+ inline ::google::protobuf::int32 controller() const;
1167
+ inline void set_controller(::google::protobuf::int32 value);
1168
+
1169
+ // optional int32 already_here = 15;
1170
+ inline bool has_already_here() const;
1171
+ inline void clear_already_here();
1172
+ static const int kAlreadyHereFieldNumber = 15;
1173
+ inline ::google::protobuf::int32 already_here() const;
1174
+ inline void set_already_here(::google::protobuf::int32 value);
1175
+
1176
+ // optional uint32 uint32 = 16;
1177
+ inline bool has_uint32() const;
1178
+ inline void clear_uint32();
1179
+ static const int kUint32FieldNumber = 16;
1180
+ inline ::google::protobuf::uint32 uint32() const;
1181
+ inline void set_uint32(::google::protobuf::uint32 value);
1182
+
1183
+ // optional uint64 uint64 = 17;
1184
+ inline bool has_uint64() const;
1185
+ inline void clear_uint64();
1186
+ static const int kUint64FieldNumber = 17;
1187
+ inline ::google::protobuf::uint64 uint64() const;
1188
+ inline void set_uint64(::google::protobuf::uint64 value);
1189
+
1190
+ // optional string string = 18;
1191
+ inline bool has_string() const;
1192
+ inline void clear_string();
1193
+ static const int kStringFieldNumber = 18;
1194
+ inline const ::std::string& string() const;
1195
+ inline void set_string(const ::std::string& value);
1196
+ inline void set_string(const char* value);
1197
+ inline void set_string(const char* value, size_t size);
1198
+ inline ::std::string* mutable_string();
1199
+ inline ::std::string* release_string();
1200
+
1201
+ // optional int32 memset = 19;
1202
+ inline bool has_memset() const;
1203
+ inline void clear_memset();
1204
+ static const int kMemsetFieldNumber = 19;
1205
+ inline ::google::protobuf::int32 memset() const;
1206
+ inline void set_memset(::google::protobuf::int32 value);
1207
+
1208
+ // optional int32 int32 = 20;
1209
+ inline bool has_int32() const;
1210
+ inline void clear_int32();
1211
+ static const int kInt32FieldNumber = 20;
1212
+ inline ::google::protobuf::int32 int32() const;
1213
+ inline void set_int32(::google::protobuf::int32 value);
1214
+
1215
+ // optional int64 int64 = 21;
1216
+ inline bool has_int64() const;
1217
+ inline void clear_int64();
1218
+ static const int kInt64FieldNumber = 21;
1219
+ inline ::google::protobuf::int64 int64() const;
1220
+ inline void set_int64(::google::protobuf::int64 value);
1221
+
1222
+ // optional uint32 cached_size = 22;
1223
+ inline bool has_cached_size() const;
1224
+ inline void clear_cached_size();
1225
+ static const int kCachedSizeFieldNumber = 22;
1226
+ inline ::google::protobuf::uint32 cached_size() const;
1227
+ inline void set_cached_size(::google::protobuf::uint32 value);
1228
+
1229
+ // optional uint32 extensions = 23;
1230
+ inline bool has_extensions() const;
1231
+ inline void clear_extensions();
1232
+ static const int kExtensionsFieldNumber = 23;
1233
+ inline ::google::protobuf::uint32 extensions() const;
1234
+ inline void set_extensions(::google::protobuf::uint32 value);
1235
+
1236
+ // optional uint32 bit = 24;
1237
+ inline bool has_bit() const;
1238
+ inline void clear_bit();
1239
+ static const int kBitFieldNumber = 24;
1240
+ inline ::google::protobuf::uint32 bit() const;
1241
+ inline void set_bit(::google::protobuf::uint32 value);
1242
+
1243
+ // optional uint32 bits = 25;
1244
+ inline bool has_bits() const;
1245
+ inline void clear_bits();
1246
+ static const int kBitsFieldNumber = 25;
1247
+ inline ::google::protobuf::uint32 bits() const;
1248
+ inline void set_bits(::google::protobuf::uint32 value);
1249
+
1250
+ // optional uint32 offsets = 26;
1251
+ inline bool has_offsets() const;
1252
+ inline void clear_offsets();
1253
+ static const int kOffsetsFieldNumber = 26;
1254
+ inline ::google::protobuf::uint32 offsets() const;
1255
+ inline void set_offsets(::google::protobuf::uint32 value);
1256
+
1257
+ // optional uint32 reflection = 27;
1258
+ inline bool has_reflection() const;
1259
+ inline void clear_reflection();
1260
+ static const int kReflectionFieldNumber = 27;
1261
+ inline ::google::protobuf::uint32 reflection() const;
1262
+ inline void set_reflection(::google::protobuf::uint32 value);
1263
+
1264
+ // optional string some_cord = 28 [ctype = CORD];
1265
+ inline bool has_some_cord() const;
1266
+ inline void clear_some_cord();
1267
+ static const int kSomeCordFieldNumber = 28;
1268
+ private:
1269
+ // Hidden due to unknown ctype option.
1270
+ inline const ::std::string& some_cord() const;
1271
+ inline void set_some_cord(const ::std::string& value);
1272
+ inline void set_some_cord(const char* value);
1273
+ inline void set_some_cord(const char* value, size_t size);
1274
+ inline ::std::string* mutable_some_cord();
1275
+ inline ::std::string* release_some_cord();
1276
+ public:
1277
+
1278
+ // optional string some_string_piece = 29 [ctype = STRING_PIECE];
1279
+ inline bool has_some_string_piece() const;
1280
+ inline void clear_some_string_piece();
1281
+ static const int kSomeStringPieceFieldNumber = 29;
1282
+ private:
1283
+ // Hidden due to unknown ctype option.
1284
+ inline const ::std::string& some_string_piece() const;
1285
+ inline void set_some_string_piece(const ::std::string& value);
1286
+ inline void set_some_string_piece(const char* value);
1287
+ inline void set_some_string_piece(const char* value, size_t size);
1288
+ inline ::std::string* mutable_some_string_piece();
1289
+ inline ::std::string* release_some_string_piece();
1290
+ public:
1291
+
1292
+ // optional uint32 int = 30;
1293
+ inline bool has_int_() const;
1294
+ inline void clear_int_();
1295
+ static const int kIntFieldNumber = 30;
1296
+ inline ::google::protobuf::uint32 int_() const;
1297
+ inline void set_int_(::google::protobuf::uint32 value);
1298
+
1299
+ // optional uint32 friend = 31;
1300
+ inline bool has_friend_() const;
1301
+ inline void clear_friend_();
1302
+ static const int kFriendFieldNumber = 31;
1303
+ inline ::google::protobuf::uint32 friend_() const;
1304
+ inline void set_friend_(::google::protobuf::uint32 value);
1305
+
1306
+ // optional .protobuf_unittest.TestConflictingSymbolNames.DO do = 32;
1307
+ inline bool has_do_() const;
1308
+ inline void clear_do_();
1309
+ static const int kDoFieldNumber = 32;
1310
+ inline const ::protobuf_unittest::TestConflictingSymbolNames_DO& do_() const;
1311
+ inline ::protobuf_unittest::TestConflictingSymbolNames_DO* mutable_do_();
1312
+ inline ::protobuf_unittest::TestConflictingSymbolNames_DO* release_do_();
1313
+
1314
+ GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(TestConflictingSymbolNames)
1315
+ // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames)
1316
+ private:
1317
+ inline void set_has_input();
1318
+ inline void clear_has_input();
1319
+ inline void set_has_output();
1320
+ inline void clear_has_output();
1321
+ inline void set_has_length();
1322
+ inline void clear_has_length();
1323
+ inline void set_has_total_size();
1324
+ inline void clear_has_total_size();
1325
+ inline void set_has_tag();
1326
+ inline void clear_has_tag();
1327
+ inline void set_has_source();
1328
+ inline void clear_has_source();
1329
+ inline void set_has_value();
1330
+ inline void clear_has_value();
1331
+ inline void set_has_file();
1332
+ inline void clear_has_file();
1333
+ inline void set_has_from();
1334
+ inline void clear_has_from();
1335
+ inline void set_has_handle_uninterpreted();
1336
+ inline void clear_has_handle_uninterpreted();
1337
+ inline void set_has_controller();
1338
+ inline void clear_has_controller();
1339
+ inline void set_has_already_here();
1340
+ inline void clear_has_already_here();
1341
+ inline void set_has_uint32();
1342
+ inline void clear_has_uint32();
1343
+ inline void set_has_uint64();
1344
+ inline void clear_has_uint64();
1345
+ inline void set_has_string();
1346
+ inline void clear_has_string();
1347
+ inline void set_has_memset();
1348
+ inline void clear_has_memset();
1349
+ inline void set_has_int32();
1350
+ inline void clear_has_int32();
1351
+ inline void set_has_int64();
1352
+ inline void clear_has_int64();
1353
+ inline void set_has_cached_size();
1354
+ inline void clear_has_cached_size();
1355
+ inline void set_has_extensions();
1356
+ inline void clear_has_extensions();
1357
+ inline void set_has_bit();
1358
+ inline void clear_has_bit();
1359
+ inline void set_has_bits();
1360
+ inline void clear_has_bits();
1361
+ inline void set_has_offsets();
1362
+ inline void clear_has_offsets();
1363
+ inline void set_has_reflection();
1364
+ inline void clear_has_reflection();
1365
+ inline void set_has_some_cord();
1366
+ inline void clear_has_some_cord();
1367
+ inline void set_has_some_string_piece();
1368
+ inline void clear_has_some_string_piece();
1369
+ inline void set_has_int_();
1370
+ inline void clear_has_int_();
1371
+ inline void set_has_friend_();
1372
+ inline void clear_has_friend_();
1373
+ inline void set_has_do_();
1374
+ inline void clear_has_do_();
1375
+
1376
+ ::google::protobuf::internal::ExtensionSet _extensions_;
1377
+
1378
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
1379
+
1380
+ ::google::protobuf::int32 input_;
1381
+ ::google::protobuf::int32 output_;
1382
+ ::std::string* length_;
1383
+ ::google::protobuf::RepeatedField< ::google::protobuf::int32 > i_;
1384
+ ::google::protobuf::RepeatedPtrField< ::std::string> new_element_;
1385
+ ::google::protobuf::int32 total_size_;
1386
+ ::google::protobuf::int32 tag_;
1387
+ ::google::protobuf::int32 source_;
1388
+ ::google::protobuf::int32 value_;
1389
+ ::google::protobuf::int32 file_;
1390
+ ::google::protobuf::int32 from_;
1391
+ ::google::protobuf::RepeatedField< ::google::protobuf::int32 > index_;
1392
+ ::google::protobuf::int32 handle_uninterpreted_;
1393
+ ::google::protobuf::int32 controller_;
1394
+ ::google::protobuf::int32 already_here_;
1395
+ ::google::protobuf::uint32 uint32_;
1396
+ ::google::protobuf::uint64 uint64_;
1397
+ ::std::string* string_;
1398
+ ::google::protobuf::int32 memset_;
1399
+ ::google::protobuf::int32 int32_;
1400
+ ::google::protobuf::int64 int64_;
1401
+ ::google::protobuf::uint32 cached_size_;
1402
+ ::google::protobuf::uint32 extensions_;
1403
+ ::google::protobuf::uint32 bit_;
1404
+ ::google::protobuf::uint32 bits_;
1405
+ ::google::protobuf::uint32 offsets_;
1406
+ ::google::protobuf::uint32 reflection_;
1407
+ ::std::string* some_cord_;
1408
+ ::std::string* some_string_piece_;
1409
+ ::google::protobuf::uint32 int__;
1410
+ ::google::protobuf::uint32 friend__;
1411
+ ::protobuf_unittest::TestConflictingSymbolNames_DO* do__;
1412
+
1413
+ mutable int _cached_size_;
1414
+ ::google::protobuf::uint32 _has_bits_[(32 + 31) / 32];
1415
+
1416
+ friend void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
1417
+ friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
1418
+ friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
1419
+
1420
+ void InitAsDefaultInstance();
1421
+ static TestConflictingSymbolNames* default_instance_;
1422
+ };
1423
+ // -------------------------------------------------------------------
1424
+
1425
+ class DummyMessage : public ::google::protobuf::Message {
1426
+ public:
1427
+ DummyMessage();
1428
+ virtual ~DummyMessage();
1429
+
1430
+ DummyMessage(const DummyMessage& from);
1431
+
1432
+ inline DummyMessage& operator=(const DummyMessage& from) {
1433
+ CopyFrom(from);
1434
+ return *this;
1435
+ }
1436
+
1437
+ inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1438
+ return _unknown_fields_;
1439
+ }
1440
+
1441
+ inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1442
+ return &_unknown_fields_;
1443
+ }
1444
+
1445
+ static const ::google::protobuf::Descriptor* descriptor();
1446
+ static const DummyMessage& default_instance();
1447
+
1448
+ void Swap(DummyMessage* other);
1449
+
1450
+ // implements Message ----------------------------------------------
1451
+
1452
+ DummyMessage* New() const;
1453
+ void CopyFrom(const ::google::protobuf::Message& from);
1454
+ void MergeFrom(const ::google::protobuf::Message& from);
1455
+ void CopyFrom(const DummyMessage& from);
1456
+ void MergeFrom(const DummyMessage& from);
1457
+ void Clear();
1458
+ bool IsInitialized() const;
1459
+
1460
+ int ByteSize() const;
1461
+ bool MergePartialFromCodedStream(
1462
+ ::google::protobuf::io::CodedInputStream* input);
1463
+ void SerializeWithCachedSizes(
1464
+ ::google::protobuf::io::CodedOutputStream* output) const;
1465
+ ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1466
+ int GetCachedSize() const { return _cached_size_; }
1467
+ private:
1468
+ void SharedCtor();
1469
+ void SharedDtor();
1470
+ void SetCachedSize(int size) const;
1471
+ public:
1472
+
1473
+ ::google::protobuf::Metadata GetMetadata() const;
1474
+
1475
+ // nested types ----------------------------------------------------
1476
+
1477
+ // accessors -------------------------------------------------------
1478
+
1479
+ // @@protoc_insertion_point(class_scope:protobuf_unittest.DummyMessage)
1480
+ private:
1481
+
1482
+ ::google::protobuf::UnknownFieldSet _unknown_fields_;
1483
+
1484
+
1485
+ mutable int _cached_size_;
1486
+ ::google::protobuf::uint32 _has_bits_[1];
1487
+
1488
+ friend void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
1489
+ friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
1490
+ friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
1491
+
1492
+ void InitAsDefaultInstance();
1493
+ static DummyMessage* default_instance_;
1494
+ };
1495
+ // ===================================================================
1496
+
1497
+ class TestConflictingMethodNames_Stub;
1498
+
1499
+ class TestConflictingMethodNames : public ::google::protobuf::Service {
1500
+ protected:
1501
+ // This class should be treated as an abstract interface.
1502
+ inline TestConflictingMethodNames() {};
1503
+ public:
1504
+ virtual ~TestConflictingMethodNames();
1505
+
1506
+ typedef TestConflictingMethodNames_Stub Stub;
1507
+
1508
+ static const ::google::protobuf::ServiceDescriptor* descriptor();
1509
+
1510
+ virtual void Closure(::google::protobuf::RpcController* controller,
1511
+ const ::protobuf_unittest::DummyMessage* request,
1512
+ ::protobuf_unittest::DummyMessage* response,
1513
+ ::google::protobuf::Closure* done);
1514
+
1515
+ // implements Service ----------------------------------------------
1516
+
1517
+ const ::google::protobuf::ServiceDescriptor* GetDescriptor();
1518
+ void CallMethod(const ::google::protobuf::MethodDescriptor* method,
1519
+ ::google::protobuf::RpcController* controller,
1520
+ const ::google::protobuf::Message* request,
1521
+ ::google::protobuf::Message* response,
1522
+ ::google::protobuf::Closure* done);
1523
+ const ::google::protobuf::Message& GetRequestPrototype(
1524
+ const ::google::protobuf::MethodDescriptor* method) const;
1525
+ const ::google::protobuf::Message& GetResponsePrototype(
1526
+ const ::google::protobuf::MethodDescriptor* method) const;
1527
+
1528
+ private:
1529
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TestConflictingMethodNames);
1530
+ };
1531
+
1532
+ class TestConflictingMethodNames_Stub : public TestConflictingMethodNames {
1533
+ public:
1534
+ TestConflictingMethodNames_Stub(::google::protobuf::RpcChannel* channel);
1535
+ TestConflictingMethodNames_Stub(::google::protobuf::RpcChannel* channel,
1536
+ ::google::protobuf::Service::ChannelOwnership ownership);
1537
+ ~TestConflictingMethodNames_Stub();
1538
+
1539
+ inline ::google::protobuf::RpcChannel* channel() { return channel_; }
1540
+
1541
+ // implements TestConflictingMethodNames ------------------------------------------
1542
+
1543
+ void Closure(::google::protobuf::RpcController* controller,
1544
+ const ::protobuf_unittest::DummyMessage* request,
1545
+ ::protobuf_unittest::DummyMessage* response,
1546
+ ::google::protobuf::Closure* done);
1547
+ private:
1548
+ ::google::protobuf::RpcChannel* channel_;
1549
+ bool owns_channel_;
1550
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TestConflictingMethodNames_Stub);
1551
+ };
1552
+
1553
+
1554
+ // ===================================================================
1555
+
1556
+
1557
+ // ===================================================================
1558
+
1559
+ // TestConflictingSymbolNames_BuildDescriptors
1560
+
1561
+ // -------------------------------------------------------------------
1562
+
1563
+ // TestConflictingSymbolNames_TypeTraits
1564
+
1565
+ // -------------------------------------------------------------------
1566
+
1567
+ // TestConflictingSymbolNames_Data1
1568
+
1569
+ // repeated int32 data = 1;
1570
+ inline int TestConflictingSymbolNames_Data1::data_size() const {
1571
+ return data_.size();
1572
+ }
1573
+ inline void TestConflictingSymbolNames_Data1::clear_data() {
1574
+ data_.Clear();
1575
+ }
1576
+ inline ::google::protobuf::int32 TestConflictingSymbolNames_Data1::data(int index) const {
1577
+ return data_.Get(index);
1578
+ }
1579
+ inline void TestConflictingSymbolNames_Data1::set_data(int index, ::google::protobuf::int32 value) {
1580
+ data_.Set(index, value);
1581
+ }
1582
+ inline void TestConflictingSymbolNames_Data1::add_data(::google::protobuf::int32 value) {
1583
+ data_.Add(value);
1584
+ }
1585
+ inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
1586
+ TestConflictingSymbolNames_Data1::data() const {
1587
+ return data_;
1588
+ }
1589
+ inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
1590
+ TestConflictingSymbolNames_Data1::mutable_data() {
1591
+ return &data_;
1592
+ }
1593
+
1594
+ // -------------------------------------------------------------------
1595
+
1596
+ // TestConflictingSymbolNames_Data2
1597
+
1598
+ // repeated .protobuf_unittest.TestConflictingSymbolNames.TestEnum data = 1;
1599
+ inline int TestConflictingSymbolNames_Data2::data_size() const {
1600
+ return data_.size();
1601
+ }
1602
+ inline void TestConflictingSymbolNames_Data2::clear_data() {
1603
+ data_.Clear();
1604
+ }
1605
+ inline ::protobuf_unittest::TestConflictingSymbolNames_TestEnum TestConflictingSymbolNames_Data2::data(int index) const {
1606
+ return static_cast< ::protobuf_unittest::TestConflictingSymbolNames_TestEnum >(data_.Get(index));
1607
+ }
1608
+ inline void TestConflictingSymbolNames_Data2::set_data(int index, ::protobuf_unittest::TestConflictingSymbolNames_TestEnum value) {
1609
+ GOOGLE_DCHECK(::protobuf_unittest::TestConflictingSymbolNames_TestEnum_IsValid(value));
1610
+ data_.Set(index, value);
1611
+ }
1612
+ inline void TestConflictingSymbolNames_Data2::add_data(::protobuf_unittest::TestConflictingSymbolNames_TestEnum value) {
1613
+ GOOGLE_DCHECK(::protobuf_unittest::TestConflictingSymbolNames_TestEnum_IsValid(value));
1614
+ data_.Add(value);
1615
+ }
1616
+ inline const ::google::protobuf::RepeatedField<int>&
1617
+ TestConflictingSymbolNames_Data2::data() const {
1618
+ return data_;
1619
+ }
1620
+ inline ::google::protobuf::RepeatedField<int>*
1621
+ TestConflictingSymbolNames_Data2::mutable_data() {
1622
+ return &data_;
1623
+ }
1624
+
1625
+ // -------------------------------------------------------------------
1626
+
1627
+ // TestConflictingSymbolNames_Data3
1628
+
1629
+ // repeated string data = 1;
1630
+ inline int TestConflictingSymbolNames_Data3::data_size() const {
1631
+ return data_.size();
1632
+ }
1633
+ inline void TestConflictingSymbolNames_Data3::clear_data() {
1634
+ data_.Clear();
1635
+ }
1636
+ inline const ::std::string& TestConflictingSymbolNames_Data3::data(int index) const {
1637
+ return data_.Get(index);
1638
+ }
1639
+ inline ::std::string* TestConflictingSymbolNames_Data3::mutable_data(int index) {
1640
+ return data_.Mutable(index);
1641
+ }
1642
+ inline void TestConflictingSymbolNames_Data3::set_data(int index, const ::std::string& value) {
1643
+ data_.Mutable(index)->assign(value);
1644
+ }
1645
+ inline void TestConflictingSymbolNames_Data3::set_data(int index, const char* value) {
1646
+ data_.Mutable(index)->assign(value);
1647
+ }
1648
+ inline void TestConflictingSymbolNames_Data3::set_data(int index, const char* value, size_t size) {
1649
+ data_.Mutable(index)->assign(
1650
+ reinterpret_cast<const char*>(value), size);
1651
+ }
1652
+ inline ::std::string* TestConflictingSymbolNames_Data3::add_data() {
1653
+ return data_.Add();
1654
+ }
1655
+ inline void TestConflictingSymbolNames_Data3::add_data(const ::std::string& value) {
1656
+ data_.Add()->assign(value);
1657
+ }
1658
+ inline void TestConflictingSymbolNames_Data3::add_data(const char* value) {
1659
+ data_.Add()->assign(value);
1660
+ }
1661
+ inline void TestConflictingSymbolNames_Data3::add_data(const char* value, size_t size) {
1662
+ data_.Add()->assign(reinterpret_cast<const char*>(value), size);
1663
+ }
1664
+ inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
1665
+ TestConflictingSymbolNames_Data3::data() const {
1666
+ return data_;
1667
+ }
1668
+ inline ::google::protobuf::RepeatedPtrField< ::std::string>*
1669
+ TestConflictingSymbolNames_Data3::mutable_data() {
1670
+ return &data_;
1671
+ }
1672
+
1673
+ // -------------------------------------------------------------------
1674
+
1675
+ // TestConflictingSymbolNames_Data4
1676
+
1677
+ // repeated .protobuf_unittest.TestConflictingSymbolNames.Data4 data = 1;
1678
+ inline int TestConflictingSymbolNames_Data4::data_size() const {
1679
+ return data_.size();
1680
+ }
1681
+ inline void TestConflictingSymbolNames_Data4::clear_data() {
1682
+ data_.Clear();
1683
+ }
1684
+ inline const ::protobuf_unittest::TestConflictingSymbolNames_Data4& TestConflictingSymbolNames_Data4::data(int index) const {
1685
+ return data_.Get(index);
1686
+ }
1687
+ inline ::protobuf_unittest::TestConflictingSymbolNames_Data4* TestConflictingSymbolNames_Data4::mutable_data(int index) {
1688
+ return data_.Mutable(index);
1689
+ }
1690
+ inline ::protobuf_unittest::TestConflictingSymbolNames_Data4* TestConflictingSymbolNames_Data4::add_data() {
1691
+ return data_.Add();
1692
+ }
1693
+ inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestConflictingSymbolNames_Data4 >&
1694
+ TestConflictingSymbolNames_Data4::data() const {
1695
+ return data_;
1696
+ }
1697
+ inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestConflictingSymbolNames_Data4 >*
1698
+ TestConflictingSymbolNames_Data4::mutable_data() {
1699
+ return &data_;
1700
+ }
1701
+
1702
+ // -------------------------------------------------------------------
1703
+
1704
+ // TestConflictingSymbolNames_Data5
1705
+
1706
+ // repeated string data = 1 [ctype = STRING_PIECE];
1707
+ inline int TestConflictingSymbolNames_Data5::data_size() const {
1708
+ return data_.size();
1709
+ }
1710
+ inline void TestConflictingSymbolNames_Data5::clear_data() {
1711
+ data_.Clear();
1712
+ }
1713
+ inline const ::std::string& TestConflictingSymbolNames_Data5::data(int index) const {
1714
+ return data_.Get(index);
1715
+ }
1716
+ inline ::std::string* TestConflictingSymbolNames_Data5::mutable_data(int index) {
1717
+ return data_.Mutable(index);
1718
+ }
1719
+ inline void TestConflictingSymbolNames_Data5::set_data(int index, const ::std::string& value) {
1720
+ data_.Mutable(index)->assign(value);
1721
+ }
1722
+ inline void TestConflictingSymbolNames_Data5::set_data(int index, const char* value) {
1723
+ data_.Mutable(index)->assign(value);
1724
+ }
1725
+ inline void TestConflictingSymbolNames_Data5::set_data(int index, const char* value, size_t size) {
1726
+ data_.Mutable(index)->assign(
1727
+ reinterpret_cast<const char*>(value), size);
1728
+ }
1729
+ inline ::std::string* TestConflictingSymbolNames_Data5::add_data() {
1730
+ return data_.Add();
1731
+ }
1732
+ inline void TestConflictingSymbolNames_Data5::add_data(const ::std::string& value) {
1733
+ data_.Add()->assign(value);
1734
+ }
1735
+ inline void TestConflictingSymbolNames_Data5::add_data(const char* value) {
1736
+ data_.Add()->assign(value);
1737
+ }
1738
+ inline void TestConflictingSymbolNames_Data5::add_data(const char* value, size_t size) {
1739
+ data_.Add()->assign(reinterpret_cast<const char*>(value), size);
1740
+ }
1741
+ inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
1742
+ TestConflictingSymbolNames_Data5::data() const {
1743
+ return data_;
1744
+ }
1745
+ inline ::google::protobuf::RepeatedPtrField< ::std::string>*
1746
+ TestConflictingSymbolNames_Data5::mutable_data() {
1747
+ return &data_;
1748
+ }
1749
+
1750
+ // -------------------------------------------------------------------
1751
+
1752
+ // TestConflictingSymbolNames_Data6
1753
+
1754
+ // repeated string data = 1 [ctype = CORD];
1755
+ inline int TestConflictingSymbolNames_Data6::data_size() const {
1756
+ return data_.size();
1757
+ }
1758
+ inline void TestConflictingSymbolNames_Data6::clear_data() {
1759
+ data_.Clear();
1760
+ }
1761
+ inline const ::std::string& TestConflictingSymbolNames_Data6::data(int index) const {
1762
+ return data_.Get(index);
1763
+ }
1764
+ inline ::std::string* TestConflictingSymbolNames_Data6::mutable_data(int index) {
1765
+ return data_.Mutable(index);
1766
+ }
1767
+ inline void TestConflictingSymbolNames_Data6::set_data(int index, const ::std::string& value) {
1768
+ data_.Mutable(index)->assign(value);
1769
+ }
1770
+ inline void TestConflictingSymbolNames_Data6::set_data(int index, const char* value) {
1771
+ data_.Mutable(index)->assign(value);
1772
+ }
1773
+ inline void TestConflictingSymbolNames_Data6::set_data(int index, const char* value, size_t size) {
1774
+ data_.Mutable(index)->assign(
1775
+ reinterpret_cast<const char*>(value), size);
1776
+ }
1777
+ inline ::std::string* TestConflictingSymbolNames_Data6::add_data() {
1778
+ return data_.Add();
1779
+ }
1780
+ inline void TestConflictingSymbolNames_Data6::add_data(const ::std::string& value) {
1781
+ data_.Add()->assign(value);
1782
+ }
1783
+ inline void TestConflictingSymbolNames_Data6::add_data(const char* value) {
1784
+ data_.Add()->assign(value);
1785
+ }
1786
+ inline void TestConflictingSymbolNames_Data6::add_data(const char* value, size_t size) {
1787
+ data_.Add()->assign(reinterpret_cast<const char*>(value), size);
1788
+ }
1789
+ inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
1790
+ TestConflictingSymbolNames_Data6::data() const {
1791
+ return data_;
1792
+ }
1793
+ inline ::google::protobuf::RepeatedPtrField< ::std::string>*
1794
+ TestConflictingSymbolNames_Data6::mutable_data() {
1795
+ return &data_;
1796
+ }
1797
+
1798
+ // -------------------------------------------------------------------
1799
+
1800
+ // TestConflictingSymbolNames_Cord
1801
+
1802
+ // -------------------------------------------------------------------
1803
+
1804
+ // TestConflictingSymbolNames_StringPiece
1805
+
1806
+ // -------------------------------------------------------------------
1807
+
1808
+ // TestConflictingSymbolNames_DO
1809
+
1810
+ // -------------------------------------------------------------------
1811
+
1812
+ // TestConflictingSymbolNames
1813
+
1814
+ // optional int32 input = 1;
1815
+ inline bool TestConflictingSymbolNames::has_input() const {
1816
+ return (_has_bits_[0] & 0x00000001u) != 0;
1817
+ }
1818
+ inline void TestConflictingSymbolNames::set_has_input() {
1819
+ _has_bits_[0] |= 0x00000001u;
1820
+ }
1821
+ inline void TestConflictingSymbolNames::clear_has_input() {
1822
+ _has_bits_[0] &= ~0x00000001u;
1823
+ }
1824
+ inline void TestConflictingSymbolNames::clear_input() {
1825
+ input_ = 0;
1826
+ clear_has_input();
1827
+ }
1828
+ inline ::google::protobuf::int32 TestConflictingSymbolNames::input() const {
1829
+ return input_;
1830
+ }
1831
+ inline void TestConflictingSymbolNames::set_input(::google::protobuf::int32 value) {
1832
+ set_has_input();
1833
+ input_ = value;
1834
+ }
1835
+
1836
+ // optional int32 output = 2;
1837
+ inline bool TestConflictingSymbolNames::has_output() const {
1838
+ return (_has_bits_[0] & 0x00000002u) != 0;
1839
+ }
1840
+ inline void TestConflictingSymbolNames::set_has_output() {
1841
+ _has_bits_[0] |= 0x00000002u;
1842
+ }
1843
+ inline void TestConflictingSymbolNames::clear_has_output() {
1844
+ _has_bits_[0] &= ~0x00000002u;
1845
+ }
1846
+ inline void TestConflictingSymbolNames::clear_output() {
1847
+ output_ = 0;
1848
+ clear_has_output();
1849
+ }
1850
+ inline ::google::protobuf::int32 TestConflictingSymbolNames::output() const {
1851
+ return output_;
1852
+ }
1853
+ inline void TestConflictingSymbolNames::set_output(::google::protobuf::int32 value) {
1854
+ set_has_output();
1855
+ output_ = value;
1856
+ }
1857
+
1858
+ // optional string length = 3;
1859
+ inline bool TestConflictingSymbolNames::has_length() const {
1860
+ return (_has_bits_[0] & 0x00000004u) != 0;
1861
+ }
1862
+ inline void TestConflictingSymbolNames::set_has_length() {
1863
+ _has_bits_[0] |= 0x00000004u;
1864
+ }
1865
+ inline void TestConflictingSymbolNames::clear_has_length() {
1866
+ _has_bits_[0] &= ~0x00000004u;
1867
+ }
1868
+ inline void TestConflictingSymbolNames::clear_length() {
1869
+ if (length_ != &::google::protobuf::internal::kEmptyString) {
1870
+ length_->clear();
1871
+ }
1872
+ clear_has_length();
1873
+ }
1874
+ inline const ::std::string& TestConflictingSymbolNames::length() const {
1875
+ return *length_;
1876
+ }
1877
+ inline void TestConflictingSymbolNames::set_length(const ::std::string& value) {
1878
+ set_has_length();
1879
+ if (length_ == &::google::protobuf::internal::kEmptyString) {
1880
+ length_ = new ::std::string;
1881
+ }
1882
+ length_->assign(value);
1883
+ }
1884
+ inline void TestConflictingSymbolNames::set_length(const char* value) {
1885
+ set_has_length();
1886
+ if (length_ == &::google::protobuf::internal::kEmptyString) {
1887
+ length_ = new ::std::string;
1888
+ }
1889
+ length_->assign(value);
1890
+ }
1891
+ inline void TestConflictingSymbolNames::set_length(const char* value, size_t size) {
1892
+ set_has_length();
1893
+ if (length_ == &::google::protobuf::internal::kEmptyString) {
1894
+ length_ = new ::std::string;
1895
+ }
1896
+ length_->assign(reinterpret_cast<const char*>(value), size);
1897
+ }
1898
+ inline ::std::string* TestConflictingSymbolNames::mutable_length() {
1899
+ set_has_length();
1900
+ if (length_ == &::google::protobuf::internal::kEmptyString) {
1901
+ length_ = new ::std::string;
1902
+ }
1903
+ return length_;
1904
+ }
1905
+ inline ::std::string* TestConflictingSymbolNames::release_length() {
1906
+ clear_has_length();
1907
+ if (length_ == &::google::protobuf::internal::kEmptyString) {
1908
+ return NULL;
1909
+ } else {
1910
+ ::std::string* temp = length_;
1911
+ length_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
1912
+ return temp;
1913
+ }
1914
+ }
1915
+
1916
+ // repeated int32 i = 4;
1917
+ inline int TestConflictingSymbolNames::i_size() const {
1918
+ return i_.size();
1919
+ }
1920
+ inline void TestConflictingSymbolNames::clear_i() {
1921
+ i_.Clear();
1922
+ }
1923
+ inline ::google::protobuf::int32 TestConflictingSymbolNames::i(int index) const {
1924
+ return i_.Get(index);
1925
+ }
1926
+ inline void TestConflictingSymbolNames::set_i(int index, ::google::protobuf::int32 value) {
1927
+ i_.Set(index, value);
1928
+ }
1929
+ inline void TestConflictingSymbolNames::add_i(::google::protobuf::int32 value) {
1930
+ i_.Add(value);
1931
+ }
1932
+ inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
1933
+ TestConflictingSymbolNames::i() const {
1934
+ return i_;
1935
+ }
1936
+ inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
1937
+ TestConflictingSymbolNames::mutable_i() {
1938
+ return &i_;
1939
+ }
1940
+
1941
+ // repeated string new_element = 5 [ctype = STRING_PIECE];
1942
+ inline int TestConflictingSymbolNames::new_element_size() const {
1943
+ return new_element_.size();
1944
+ }
1945
+ inline void TestConflictingSymbolNames::clear_new_element() {
1946
+ new_element_.Clear();
1947
+ }
1948
+ inline const ::std::string& TestConflictingSymbolNames::new_element(int index) const {
1949
+ return new_element_.Get(index);
1950
+ }
1951
+ inline ::std::string* TestConflictingSymbolNames::mutable_new_element(int index) {
1952
+ return new_element_.Mutable(index);
1953
+ }
1954
+ inline void TestConflictingSymbolNames::set_new_element(int index, const ::std::string& value) {
1955
+ new_element_.Mutable(index)->assign(value);
1956
+ }
1957
+ inline void TestConflictingSymbolNames::set_new_element(int index, const char* value) {
1958
+ new_element_.Mutable(index)->assign(value);
1959
+ }
1960
+ inline void TestConflictingSymbolNames::set_new_element(int index, const char* value, size_t size) {
1961
+ new_element_.Mutable(index)->assign(
1962
+ reinterpret_cast<const char*>(value), size);
1963
+ }
1964
+ inline ::std::string* TestConflictingSymbolNames::add_new_element() {
1965
+ return new_element_.Add();
1966
+ }
1967
+ inline void TestConflictingSymbolNames::add_new_element(const ::std::string& value) {
1968
+ new_element_.Add()->assign(value);
1969
+ }
1970
+ inline void TestConflictingSymbolNames::add_new_element(const char* value) {
1971
+ new_element_.Add()->assign(value);
1972
+ }
1973
+ inline void TestConflictingSymbolNames::add_new_element(const char* value, size_t size) {
1974
+ new_element_.Add()->assign(reinterpret_cast<const char*>(value), size);
1975
+ }
1976
+ inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
1977
+ TestConflictingSymbolNames::new_element() const {
1978
+ return new_element_;
1979
+ }
1980
+ inline ::google::protobuf::RepeatedPtrField< ::std::string>*
1981
+ TestConflictingSymbolNames::mutable_new_element() {
1982
+ return &new_element_;
1983
+ }
1984
+
1985
+ // optional int32 total_size = 6;
1986
+ inline bool TestConflictingSymbolNames::has_total_size() const {
1987
+ return (_has_bits_[0] & 0x00000020u) != 0;
1988
+ }
1989
+ inline void TestConflictingSymbolNames::set_has_total_size() {
1990
+ _has_bits_[0] |= 0x00000020u;
1991
+ }
1992
+ inline void TestConflictingSymbolNames::clear_has_total_size() {
1993
+ _has_bits_[0] &= ~0x00000020u;
1994
+ }
1995
+ inline void TestConflictingSymbolNames::clear_total_size() {
1996
+ total_size_ = 0;
1997
+ clear_has_total_size();
1998
+ }
1999
+ inline ::google::protobuf::int32 TestConflictingSymbolNames::total_size() const {
2000
+ return total_size_;
2001
+ }
2002
+ inline void TestConflictingSymbolNames::set_total_size(::google::protobuf::int32 value) {
2003
+ set_has_total_size();
2004
+ total_size_ = value;
2005
+ }
2006
+
2007
+ // optional int32 tag = 7;
2008
+ inline bool TestConflictingSymbolNames::has_tag() const {
2009
+ return (_has_bits_[0] & 0x00000040u) != 0;
2010
+ }
2011
+ inline void TestConflictingSymbolNames::set_has_tag() {
2012
+ _has_bits_[0] |= 0x00000040u;
2013
+ }
2014
+ inline void TestConflictingSymbolNames::clear_has_tag() {
2015
+ _has_bits_[0] &= ~0x00000040u;
2016
+ }
2017
+ inline void TestConflictingSymbolNames::clear_tag() {
2018
+ tag_ = 0;
2019
+ clear_has_tag();
2020
+ }
2021
+ inline ::google::protobuf::int32 TestConflictingSymbolNames::tag() const {
2022
+ return tag_;
2023
+ }
2024
+ inline void TestConflictingSymbolNames::set_tag(::google::protobuf::int32 value) {
2025
+ set_has_tag();
2026
+ tag_ = value;
2027
+ }
2028
+
2029
+ // optional int32 source = 8;
2030
+ inline bool TestConflictingSymbolNames::has_source() const {
2031
+ return (_has_bits_[0] & 0x00000080u) != 0;
2032
+ }
2033
+ inline void TestConflictingSymbolNames::set_has_source() {
2034
+ _has_bits_[0] |= 0x00000080u;
2035
+ }
2036
+ inline void TestConflictingSymbolNames::clear_has_source() {
2037
+ _has_bits_[0] &= ~0x00000080u;
2038
+ }
2039
+ inline void TestConflictingSymbolNames::clear_source() {
2040
+ source_ = 0;
2041
+ clear_has_source();
2042
+ }
2043
+ inline ::google::protobuf::int32 TestConflictingSymbolNames::source() const {
2044
+ return source_;
2045
+ }
2046
+ inline void TestConflictingSymbolNames::set_source(::google::protobuf::int32 value) {
2047
+ set_has_source();
2048
+ source_ = value;
2049
+ }
2050
+
2051
+ // optional int32 value = 9;
2052
+ inline bool TestConflictingSymbolNames::has_value() const {
2053
+ return (_has_bits_[0] & 0x00000100u) != 0;
2054
+ }
2055
+ inline void TestConflictingSymbolNames::set_has_value() {
2056
+ _has_bits_[0] |= 0x00000100u;
2057
+ }
2058
+ inline void TestConflictingSymbolNames::clear_has_value() {
2059
+ _has_bits_[0] &= ~0x00000100u;
2060
+ }
2061
+ inline void TestConflictingSymbolNames::clear_value() {
2062
+ value_ = 0;
2063
+ clear_has_value();
2064
+ }
2065
+ inline ::google::protobuf::int32 TestConflictingSymbolNames::value() const {
2066
+ return value_;
2067
+ }
2068
+ inline void TestConflictingSymbolNames::set_value(::google::protobuf::int32 value) {
2069
+ set_has_value();
2070
+ value_ = value;
2071
+ }
2072
+
2073
+ // optional int32 file = 10;
2074
+ inline bool TestConflictingSymbolNames::has_file() const {
2075
+ return (_has_bits_[0] & 0x00000200u) != 0;
2076
+ }
2077
+ inline void TestConflictingSymbolNames::set_has_file() {
2078
+ _has_bits_[0] |= 0x00000200u;
2079
+ }
2080
+ inline void TestConflictingSymbolNames::clear_has_file() {
2081
+ _has_bits_[0] &= ~0x00000200u;
2082
+ }
2083
+ inline void TestConflictingSymbolNames::clear_file() {
2084
+ file_ = 0;
2085
+ clear_has_file();
2086
+ }
2087
+ inline ::google::protobuf::int32 TestConflictingSymbolNames::file() const {
2088
+ return file_;
2089
+ }
2090
+ inline void TestConflictingSymbolNames::set_file(::google::protobuf::int32 value) {
2091
+ set_has_file();
2092
+ file_ = value;
2093
+ }
2094
+
2095
+ // optional int32 from = 11;
2096
+ inline bool TestConflictingSymbolNames::has_from() const {
2097
+ return (_has_bits_[0] & 0x00000400u) != 0;
2098
+ }
2099
+ inline void TestConflictingSymbolNames::set_has_from() {
2100
+ _has_bits_[0] |= 0x00000400u;
2101
+ }
2102
+ inline void TestConflictingSymbolNames::clear_has_from() {
2103
+ _has_bits_[0] &= ~0x00000400u;
2104
+ }
2105
+ inline void TestConflictingSymbolNames::clear_from() {
2106
+ from_ = 0;
2107
+ clear_has_from();
2108
+ }
2109
+ inline ::google::protobuf::int32 TestConflictingSymbolNames::from() const {
2110
+ return from_;
2111
+ }
2112
+ inline void TestConflictingSymbolNames::set_from(::google::protobuf::int32 value) {
2113
+ set_has_from();
2114
+ from_ = value;
2115
+ }
2116
+
2117
+ // optional int32 handle_uninterpreted = 12;
2118
+ inline bool TestConflictingSymbolNames::has_handle_uninterpreted() const {
2119
+ return (_has_bits_[0] & 0x00000800u) != 0;
2120
+ }
2121
+ inline void TestConflictingSymbolNames::set_has_handle_uninterpreted() {
2122
+ _has_bits_[0] |= 0x00000800u;
2123
+ }
2124
+ inline void TestConflictingSymbolNames::clear_has_handle_uninterpreted() {
2125
+ _has_bits_[0] &= ~0x00000800u;
2126
+ }
2127
+ inline void TestConflictingSymbolNames::clear_handle_uninterpreted() {
2128
+ handle_uninterpreted_ = 0;
2129
+ clear_has_handle_uninterpreted();
2130
+ }
2131
+ inline ::google::protobuf::int32 TestConflictingSymbolNames::handle_uninterpreted() const {
2132
+ return handle_uninterpreted_;
2133
+ }
2134
+ inline void TestConflictingSymbolNames::set_handle_uninterpreted(::google::protobuf::int32 value) {
2135
+ set_has_handle_uninterpreted();
2136
+ handle_uninterpreted_ = value;
2137
+ }
2138
+
2139
+ // repeated int32 index = 13;
2140
+ inline int TestConflictingSymbolNames::index_size() const {
2141
+ return index_.size();
2142
+ }
2143
+ inline void TestConflictingSymbolNames::clear_index() {
2144
+ index_.Clear();
2145
+ }
2146
+ inline ::google::protobuf::int32 TestConflictingSymbolNames::index(int index) const {
2147
+ return index_.Get(index);
2148
+ }
2149
+ inline void TestConflictingSymbolNames::set_index(int index, ::google::protobuf::int32 value) {
2150
+ index_.Set(index, value);
2151
+ }
2152
+ inline void TestConflictingSymbolNames::add_index(::google::protobuf::int32 value) {
2153
+ index_.Add(value);
2154
+ }
2155
+ inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
2156
+ TestConflictingSymbolNames::index() const {
2157
+ return index_;
2158
+ }
2159
+ inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
2160
+ TestConflictingSymbolNames::mutable_index() {
2161
+ return &index_;
2162
+ }
2163
+
2164
+ // optional int32 controller = 14;
2165
+ inline bool TestConflictingSymbolNames::has_controller() const {
2166
+ return (_has_bits_[0] & 0x00002000u) != 0;
2167
+ }
2168
+ inline void TestConflictingSymbolNames::set_has_controller() {
2169
+ _has_bits_[0] |= 0x00002000u;
2170
+ }
2171
+ inline void TestConflictingSymbolNames::clear_has_controller() {
2172
+ _has_bits_[0] &= ~0x00002000u;
2173
+ }
2174
+ inline void TestConflictingSymbolNames::clear_controller() {
2175
+ controller_ = 0;
2176
+ clear_has_controller();
2177
+ }
2178
+ inline ::google::protobuf::int32 TestConflictingSymbolNames::controller() const {
2179
+ return controller_;
2180
+ }
2181
+ inline void TestConflictingSymbolNames::set_controller(::google::protobuf::int32 value) {
2182
+ set_has_controller();
2183
+ controller_ = value;
2184
+ }
2185
+
2186
+ // optional int32 already_here = 15;
2187
+ inline bool TestConflictingSymbolNames::has_already_here() const {
2188
+ return (_has_bits_[0] & 0x00004000u) != 0;
2189
+ }
2190
+ inline void TestConflictingSymbolNames::set_has_already_here() {
2191
+ _has_bits_[0] |= 0x00004000u;
2192
+ }
2193
+ inline void TestConflictingSymbolNames::clear_has_already_here() {
2194
+ _has_bits_[0] &= ~0x00004000u;
2195
+ }
2196
+ inline void TestConflictingSymbolNames::clear_already_here() {
2197
+ already_here_ = 0;
2198
+ clear_has_already_here();
2199
+ }
2200
+ inline ::google::protobuf::int32 TestConflictingSymbolNames::already_here() const {
2201
+ return already_here_;
2202
+ }
2203
+ inline void TestConflictingSymbolNames::set_already_here(::google::protobuf::int32 value) {
2204
+ set_has_already_here();
2205
+ already_here_ = value;
2206
+ }
2207
+
2208
+ // optional uint32 uint32 = 16;
2209
+ inline bool TestConflictingSymbolNames::has_uint32() const {
2210
+ return (_has_bits_[0] & 0x00008000u) != 0;
2211
+ }
2212
+ inline void TestConflictingSymbolNames::set_has_uint32() {
2213
+ _has_bits_[0] |= 0x00008000u;
2214
+ }
2215
+ inline void TestConflictingSymbolNames::clear_has_uint32() {
2216
+ _has_bits_[0] &= ~0x00008000u;
2217
+ }
2218
+ inline void TestConflictingSymbolNames::clear_uint32() {
2219
+ uint32_ = 0u;
2220
+ clear_has_uint32();
2221
+ }
2222
+ inline ::google::protobuf::uint32 TestConflictingSymbolNames::uint32() const {
2223
+ return uint32_;
2224
+ }
2225
+ inline void TestConflictingSymbolNames::set_uint32(::google::protobuf::uint32 value) {
2226
+ set_has_uint32();
2227
+ uint32_ = value;
2228
+ }
2229
+
2230
+ // optional uint64 uint64 = 17;
2231
+ inline bool TestConflictingSymbolNames::has_uint64() const {
2232
+ return (_has_bits_[0] & 0x00010000u) != 0;
2233
+ }
2234
+ inline void TestConflictingSymbolNames::set_has_uint64() {
2235
+ _has_bits_[0] |= 0x00010000u;
2236
+ }
2237
+ inline void TestConflictingSymbolNames::clear_has_uint64() {
2238
+ _has_bits_[0] &= ~0x00010000u;
2239
+ }
2240
+ inline void TestConflictingSymbolNames::clear_uint64() {
2241
+ uint64_ = GOOGLE_ULONGLONG(0);
2242
+ clear_has_uint64();
2243
+ }
2244
+ inline ::google::protobuf::uint64 TestConflictingSymbolNames::uint64() const {
2245
+ return uint64_;
2246
+ }
2247
+ inline void TestConflictingSymbolNames::set_uint64(::google::protobuf::uint64 value) {
2248
+ set_has_uint64();
2249
+ uint64_ = value;
2250
+ }
2251
+
2252
+ // optional string string = 18;
2253
+ inline bool TestConflictingSymbolNames::has_string() const {
2254
+ return (_has_bits_[0] & 0x00020000u) != 0;
2255
+ }
2256
+ inline void TestConflictingSymbolNames::set_has_string() {
2257
+ _has_bits_[0] |= 0x00020000u;
2258
+ }
2259
+ inline void TestConflictingSymbolNames::clear_has_string() {
2260
+ _has_bits_[0] &= ~0x00020000u;
2261
+ }
2262
+ inline void TestConflictingSymbolNames::clear_string() {
2263
+ if (string_ != &::google::protobuf::internal::kEmptyString) {
2264
+ string_->clear();
2265
+ }
2266
+ clear_has_string();
2267
+ }
2268
+ inline const ::std::string& TestConflictingSymbolNames::string() const {
2269
+ return *string_;
2270
+ }
2271
+ inline void TestConflictingSymbolNames::set_string(const ::std::string& value) {
2272
+ set_has_string();
2273
+ if (string_ == &::google::protobuf::internal::kEmptyString) {
2274
+ string_ = new ::std::string;
2275
+ }
2276
+ string_->assign(value);
2277
+ }
2278
+ inline void TestConflictingSymbolNames::set_string(const char* value) {
2279
+ set_has_string();
2280
+ if (string_ == &::google::protobuf::internal::kEmptyString) {
2281
+ string_ = new ::std::string;
2282
+ }
2283
+ string_->assign(value);
2284
+ }
2285
+ inline void TestConflictingSymbolNames::set_string(const char* value, size_t size) {
2286
+ set_has_string();
2287
+ if (string_ == &::google::protobuf::internal::kEmptyString) {
2288
+ string_ = new ::std::string;
2289
+ }
2290
+ string_->assign(reinterpret_cast<const char*>(value), size);
2291
+ }
2292
+ inline ::std::string* TestConflictingSymbolNames::mutable_string() {
2293
+ set_has_string();
2294
+ if (string_ == &::google::protobuf::internal::kEmptyString) {
2295
+ string_ = new ::std::string;
2296
+ }
2297
+ return string_;
2298
+ }
2299
+ inline ::std::string* TestConflictingSymbolNames::release_string() {
2300
+ clear_has_string();
2301
+ if (string_ == &::google::protobuf::internal::kEmptyString) {
2302
+ return NULL;
2303
+ } else {
2304
+ ::std::string* temp = string_;
2305
+ string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
2306
+ return temp;
2307
+ }
2308
+ }
2309
+
2310
+ // optional int32 memset = 19;
2311
+ inline bool TestConflictingSymbolNames::has_memset() const {
2312
+ return (_has_bits_[0] & 0x00040000u) != 0;
2313
+ }
2314
+ inline void TestConflictingSymbolNames::set_has_memset() {
2315
+ _has_bits_[0] |= 0x00040000u;
2316
+ }
2317
+ inline void TestConflictingSymbolNames::clear_has_memset() {
2318
+ _has_bits_[0] &= ~0x00040000u;
2319
+ }
2320
+ inline void TestConflictingSymbolNames::clear_memset() {
2321
+ memset_ = 0;
2322
+ clear_has_memset();
2323
+ }
2324
+ inline ::google::protobuf::int32 TestConflictingSymbolNames::memset() const {
2325
+ return memset_;
2326
+ }
2327
+ inline void TestConflictingSymbolNames::set_memset(::google::protobuf::int32 value) {
2328
+ set_has_memset();
2329
+ memset_ = value;
2330
+ }
2331
+
2332
+ // optional int32 int32 = 20;
2333
+ inline bool TestConflictingSymbolNames::has_int32() const {
2334
+ return (_has_bits_[0] & 0x00080000u) != 0;
2335
+ }
2336
+ inline void TestConflictingSymbolNames::set_has_int32() {
2337
+ _has_bits_[0] |= 0x00080000u;
2338
+ }
2339
+ inline void TestConflictingSymbolNames::clear_has_int32() {
2340
+ _has_bits_[0] &= ~0x00080000u;
2341
+ }
2342
+ inline void TestConflictingSymbolNames::clear_int32() {
2343
+ int32_ = 0;
2344
+ clear_has_int32();
2345
+ }
2346
+ inline ::google::protobuf::int32 TestConflictingSymbolNames::int32() const {
2347
+ return int32_;
2348
+ }
2349
+ inline void TestConflictingSymbolNames::set_int32(::google::protobuf::int32 value) {
2350
+ set_has_int32();
2351
+ int32_ = value;
2352
+ }
2353
+
2354
+ // optional int64 int64 = 21;
2355
+ inline bool TestConflictingSymbolNames::has_int64() const {
2356
+ return (_has_bits_[0] & 0x00100000u) != 0;
2357
+ }
2358
+ inline void TestConflictingSymbolNames::set_has_int64() {
2359
+ _has_bits_[0] |= 0x00100000u;
2360
+ }
2361
+ inline void TestConflictingSymbolNames::clear_has_int64() {
2362
+ _has_bits_[0] &= ~0x00100000u;
2363
+ }
2364
+ inline void TestConflictingSymbolNames::clear_int64() {
2365
+ int64_ = GOOGLE_LONGLONG(0);
2366
+ clear_has_int64();
2367
+ }
2368
+ inline ::google::protobuf::int64 TestConflictingSymbolNames::int64() const {
2369
+ return int64_;
2370
+ }
2371
+ inline void TestConflictingSymbolNames::set_int64(::google::protobuf::int64 value) {
2372
+ set_has_int64();
2373
+ int64_ = value;
2374
+ }
2375
+
2376
+ // optional uint32 cached_size = 22;
2377
+ inline bool TestConflictingSymbolNames::has_cached_size() const {
2378
+ return (_has_bits_[0] & 0x00200000u) != 0;
2379
+ }
2380
+ inline void TestConflictingSymbolNames::set_has_cached_size() {
2381
+ _has_bits_[0] |= 0x00200000u;
2382
+ }
2383
+ inline void TestConflictingSymbolNames::clear_has_cached_size() {
2384
+ _has_bits_[0] &= ~0x00200000u;
2385
+ }
2386
+ inline void TestConflictingSymbolNames::clear_cached_size() {
2387
+ cached_size_ = 0u;
2388
+ clear_has_cached_size();
2389
+ }
2390
+ inline ::google::protobuf::uint32 TestConflictingSymbolNames::cached_size() const {
2391
+ return cached_size_;
2392
+ }
2393
+ inline void TestConflictingSymbolNames::set_cached_size(::google::protobuf::uint32 value) {
2394
+ set_has_cached_size();
2395
+ cached_size_ = value;
2396
+ }
2397
+
2398
+ // optional uint32 extensions = 23;
2399
+ inline bool TestConflictingSymbolNames::has_extensions() const {
2400
+ return (_has_bits_[0] & 0x00400000u) != 0;
2401
+ }
2402
+ inline void TestConflictingSymbolNames::set_has_extensions() {
2403
+ _has_bits_[0] |= 0x00400000u;
2404
+ }
2405
+ inline void TestConflictingSymbolNames::clear_has_extensions() {
2406
+ _has_bits_[0] &= ~0x00400000u;
2407
+ }
2408
+ inline void TestConflictingSymbolNames::clear_extensions() {
2409
+ extensions_ = 0u;
2410
+ clear_has_extensions();
2411
+ }
2412
+ inline ::google::protobuf::uint32 TestConflictingSymbolNames::extensions() const {
2413
+ return extensions_;
2414
+ }
2415
+ inline void TestConflictingSymbolNames::set_extensions(::google::protobuf::uint32 value) {
2416
+ set_has_extensions();
2417
+ extensions_ = value;
2418
+ }
2419
+
2420
+ // optional uint32 bit = 24;
2421
+ inline bool TestConflictingSymbolNames::has_bit() const {
2422
+ return (_has_bits_[0] & 0x00800000u) != 0;
2423
+ }
2424
+ inline void TestConflictingSymbolNames::set_has_bit() {
2425
+ _has_bits_[0] |= 0x00800000u;
2426
+ }
2427
+ inline void TestConflictingSymbolNames::clear_has_bit() {
2428
+ _has_bits_[0] &= ~0x00800000u;
2429
+ }
2430
+ inline void TestConflictingSymbolNames::clear_bit() {
2431
+ bit_ = 0u;
2432
+ clear_has_bit();
2433
+ }
2434
+ inline ::google::protobuf::uint32 TestConflictingSymbolNames::bit() const {
2435
+ return bit_;
2436
+ }
2437
+ inline void TestConflictingSymbolNames::set_bit(::google::protobuf::uint32 value) {
2438
+ set_has_bit();
2439
+ bit_ = value;
2440
+ }
2441
+
2442
+ // optional uint32 bits = 25;
2443
+ inline bool TestConflictingSymbolNames::has_bits() const {
2444
+ return (_has_bits_[0] & 0x01000000u) != 0;
2445
+ }
2446
+ inline void TestConflictingSymbolNames::set_has_bits() {
2447
+ _has_bits_[0] |= 0x01000000u;
2448
+ }
2449
+ inline void TestConflictingSymbolNames::clear_has_bits() {
2450
+ _has_bits_[0] &= ~0x01000000u;
2451
+ }
2452
+ inline void TestConflictingSymbolNames::clear_bits() {
2453
+ bits_ = 0u;
2454
+ clear_has_bits();
2455
+ }
2456
+ inline ::google::protobuf::uint32 TestConflictingSymbolNames::bits() const {
2457
+ return bits_;
2458
+ }
2459
+ inline void TestConflictingSymbolNames::set_bits(::google::protobuf::uint32 value) {
2460
+ set_has_bits();
2461
+ bits_ = value;
2462
+ }
2463
+
2464
+ // optional uint32 offsets = 26;
2465
+ inline bool TestConflictingSymbolNames::has_offsets() const {
2466
+ return (_has_bits_[0] & 0x02000000u) != 0;
2467
+ }
2468
+ inline void TestConflictingSymbolNames::set_has_offsets() {
2469
+ _has_bits_[0] |= 0x02000000u;
2470
+ }
2471
+ inline void TestConflictingSymbolNames::clear_has_offsets() {
2472
+ _has_bits_[0] &= ~0x02000000u;
2473
+ }
2474
+ inline void TestConflictingSymbolNames::clear_offsets() {
2475
+ offsets_ = 0u;
2476
+ clear_has_offsets();
2477
+ }
2478
+ inline ::google::protobuf::uint32 TestConflictingSymbolNames::offsets() const {
2479
+ return offsets_;
2480
+ }
2481
+ inline void TestConflictingSymbolNames::set_offsets(::google::protobuf::uint32 value) {
2482
+ set_has_offsets();
2483
+ offsets_ = value;
2484
+ }
2485
+
2486
+ // optional uint32 reflection = 27;
2487
+ inline bool TestConflictingSymbolNames::has_reflection() const {
2488
+ return (_has_bits_[0] & 0x04000000u) != 0;
2489
+ }
2490
+ inline void TestConflictingSymbolNames::set_has_reflection() {
2491
+ _has_bits_[0] |= 0x04000000u;
2492
+ }
2493
+ inline void TestConflictingSymbolNames::clear_has_reflection() {
2494
+ _has_bits_[0] &= ~0x04000000u;
2495
+ }
2496
+ inline void TestConflictingSymbolNames::clear_reflection() {
2497
+ reflection_ = 0u;
2498
+ clear_has_reflection();
2499
+ }
2500
+ inline ::google::protobuf::uint32 TestConflictingSymbolNames::reflection() const {
2501
+ return reflection_;
2502
+ }
2503
+ inline void TestConflictingSymbolNames::set_reflection(::google::protobuf::uint32 value) {
2504
+ set_has_reflection();
2505
+ reflection_ = value;
2506
+ }
2507
+
2508
+ // optional string some_cord = 28 [ctype = CORD];
2509
+ inline bool TestConflictingSymbolNames::has_some_cord() const {
2510
+ return (_has_bits_[0] & 0x08000000u) != 0;
2511
+ }
2512
+ inline void TestConflictingSymbolNames::set_has_some_cord() {
2513
+ _has_bits_[0] |= 0x08000000u;
2514
+ }
2515
+ inline void TestConflictingSymbolNames::clear_has_some_cord() {
2516
+ _has_bits_[0] &= ~0x08000000u;
2517
+ }
2518
+ inline void TestConflictingSymbolNames::clear_some_cord() {
2519
+ if (some_cord_ != &::google::protobuf::internal::kEmptyString) {
2520
+ some_cord_->clear();
2521
+ }
2522
+ clear_has_some_cord();
2523
+ }
2524
+ inline const ::std::string& TestConflictingSymbolNames::some_cord() const {
2525
+ return *some_cord_;
2526
+ }
2527
+ inline void TestConflictingSymbolNames::set_some_cord(const ::std::string& value) {
2528
+ set_has_some_cord();
2529
+ if (some_cord_ == &::google::protobuf::internal::kEmptyString) {
2530
+ some_cord_ = new ::std::string;
2531
+ }
2532
+ some_cord_->assign(value);
2533
+ }
2534
+ inline void TestConflictingSymbolNames::set_some_cord(const char* value) {
2535
+ set_has_some_cord();
2536
+ if (some_cord_ == &::google::protobuf::internal::kEmptyString) {
2537
+ some_cord_ = new ::std::string;
2538
+ }
2539
+ some_cord_->assign(value);
2540
+ }
2541
+ inline void TestConflictingSymbolNames::set_some_cord(const char* value, size_t size) {
2542
+ set_has_some_cord();
2543
+ if (some_cord_ == &::google::protobuf::internal::kEmptyString) {
2544
+ some_cord_ = new ::std::string;
2545
+ }
2546
+ some_cord_->assign(reinterpret_cast<const char*>(value), size);
2547
+ }
2548
+ inline ::std::string* TestConflictingSymbolNames::mutable_some_cord() {
2549
+ set_has_some_cord();
2550
+ if (some_cord_ == &::google::protobuf::internal::kEmptyString) {
2551
+ some_cord_ = new ::std::string;
2552
+ }
2553
+ return some_cord_;
2554
+ }
2555
+ inline ::std::string* TestConflictingSymbolNames::release_some_cord() {
2556
+ clear_has_some_cord();
2557
+ if (some_cord_ == &::google::protobuf::internal::kEmptyString) {
2558
+ return NULL;
2559
+ } else {
2560
+ ::std::string* temp = some_cord_;
2561
+ some_cord_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
2562
+ return temp;
2563
+ }
2564
+ }
2565
+
2566
+ // optional string some_string_piece = 29 [ctype = STRING_PIECE];
2567
+ inline bool TestConflictingSymbolNames::has_some_string_piece() const {
2568
+ return (_has_bits_[0] & 0x10000000u) != 0;
2569
+ }
2570
+ inline void TestConflictingSymbolNames::set_has_some_string_piece() {
2571
+ _has_bits_[0] |= 0x10000000u;
2572
+ }
2573
+ inline void TestConflictingSymbolNames::clear_has_some_string_piece() {
2574
+ _has_bits_[0] &= ~0x10000000u;
2575
+ }
2576
+ inline void TestConflictingSymbolNames::clear_some_string_piece() {
2577
+ if (some_string_piece_ != &::google::protobuf::internal::kEmptyString) {
2578
+ some_string_piece_->clear();
2579
+ }
2580
+ clear_has_some_string_piece();
2581
+ }
2582
+ inline const ::std::string& TestConflictingSymbolNames::some_string_piece() const {
2583
+ return *some_string_piece_;
2584
+ }
2585
+ inline void TestConflictingSymbolNames::set_some_string_piece(const ::std::string& value) {
2586
+ set_has_some_string_piece();
2587
+ if (some_string_piece_ == &::google::protobuf::internal::kEmptyString) {
2588
+ some_string_piece_ = new ::std::string;
2589
+ }
2590
+ some_string_piece_->assign(value);
2591
+ }
2592
+ inline void TestConflictingSymbolNames::set_some_string_piece(const char* value) {
2593
+ set_has_some_string_piece();
2594
+ if (some_string_piece_ == &::google::protobuf::internal::kEmptyString) {
2595
+ some_string_piece_ = new ::std::string;
2596
+ }
2597
+ some_string_piece_->assign(value);
2598
+ }
2599
+ inline void TestConflictingSymbolNames::set_some_string_piece(const char* value, size_t size) {
2600
+ set_has_some_string_piece();
2601
+ if (some_string_piece_ == &::google::protobuf::internal::kEmptyString) {
2602
+ some_string_piece_ = new ::std::string;
2603
+ }
2604
+ some_string_piece_->assign(reinterpret_cast<const char*>(value), size);
2605
+ }
2606
+ inline ::std::string* TestConflictingSymbolNames::mutable_some_string_piece() {
2607
+ set_has_some_string_piece();
2608
+ if (some_string_piece_ == &::google::protobuf::internal::kEmptyString) {
2609
+ some_string_piece_ = new ::std::string;
2610
+ }
2611
+ return some_string_piece_;
2612
+ }
2613
+ inline ::std::string* TestConflictingSymbolNames::release_some_string_piece() {
2614
+ clear_has_some_string_piece();
2615
+ if (some_string_piece_ == &::google::protobuf::internal::kEmptyString) {
2616
+ return NULL;
2617
+ } else {
2618
+ ::std::string* temp = some_string_piece_;
2619
+ some_string_piece_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
2620
+ return temp;
2621
+ }
2622
+ }
2623
+
2624
+ // optional uint32 int = 30;
2625
+ inline bool TestConflictingSymbolNames::has_int_() const {
2626
+ return (_has_bits_[0] & 0x20000000u) != 0;
2627
+ }
2628
+ inline void TestConflictingSymbolNames::set_has_int_() {
2629
+ _has_bits_[0] |= 0x20000000u;
2630
+ }
2631
+ inline void TestConflictingSymbolNames::clear_has_int_() {
2632
+ _has_bits_[0] &= ~0x20000000u;
2633
+ }
2634
+ inline void TestConflictingSymbolNames::clear_int_() {
2635
+ int__ = 0u;
2636
+ clear_has_int_();
2637
+ }
2638
+ inline ::google::protobuf::uint32 TestConflictingSymbolNames::int_() const {
2639
+ return int__;
2640
+ }
2641
+ inline void TestConflictingSymbolNames::set_int_(::google::protobuf::uint32 value) {
2642
+ set_has_int_();
2643
+ int__ = value;
2644
+ }
2645
+
2646
+ // optional uint32 friend = 31;
2647
+ inline bool TestConflictingSymbolNames::has_friend_() const {
2648
+ return (_has_bits_[0] & 0x40000000u) != 0;
2649
+ }
2650
+ inline void TestConflictingSymbolNames::set_has_friend_() {
2651
+ _has_bits_[0] |= 0x40000000u;
2652
+ }
2653
+ inline void TestConflictingSymbolNames::clear_has_friend_() {
2654
+ _has_bits_[0] &= ~0x40000000u;
2655
+ }
2656
+ inline void TestConflictingSymbolNames::clear_friend_() {
2657
+ friend__ = 0u;
2658
+ clear_has_friend_();
2659
+ }
2660
+ inline ::google::protobuf::uint32 TestConflictingSymbolNames::friend_() const {
2661
+ return friend__;
2662
+ }
2663
+ inline void TestConflictingSymbolNames::set_friend_(::google::protobuf::uint32 value) {
2664
+ set_has_friend_();
2665
+ friend__ = value;
2666
+ }
2667
+
2668
+ // optional .protobuf_unittest.TestConflictingSymbolNames.DO do = 32;
2669
+ inline bool TestConflictingSymbolNames::has_do_() const {
2670
+ return (_has_bits_[0] & 0x80000000u) != 0;
2671
+ }
2672
+ inline void TestConflictingSymbolNames::set_has_do_() {
2673
+ _has_bits_[0] |= 0x80000000u;
2674
+ }
2675
+ inline void TestConflictingSymbolNames::clear_has_do_() {
2676
+ _has_bits_[0] &= ~0x80000000u;
2677
+ }
2678
+ inline void TestConflictingSymbolNames::clear_do_() {
2679
+ if (do__ != NULL) do__->::protobuf_unittest::TestConflictingSymbolNames_DO::Clear();
2680
+ clear_has_do_();
2681
+ }
2682
+ inline const ::protobuf_unittest::TestConflictingSymbolNames_DO& TestConflictingSymbolNames::do_() const {
2683
+ return do__ != NULL ? *do__ : *default_instance_->do__;
2684
+ }
2685
+ inline ::protobuf_unittest::TestConflictingSymbolNames_DO* TestConflictingSymbolNames::mutable_do_() {
2686
+ set_has_do_();
2687
+ if (do__ == NULL) do__ = new ::protobuf_unittest::TestConflictingSymbolNames_DO;
2688
+ return do__;
2689
+ }
2690
+ inline ::protobuf_unittest::TestConflictingSymbolNames_DO* TestConflictingSymbolNames::release_do_() {
2691
+ clear_has_do_();
2692
+ ::protobuf_unittest::TestConflictingSymbolNames_DO* temp = do__;
2693
+ do__ = NULL;
2694
+ return temp;
2695
+ }
2696
+
2697
+ // -------------------------------------------------------------------
2698
+
2699
+ // DummyMessage
2700
+
2701
+
2702
+ // @@protoc_insertion_point(namespace_scope)
2703
+
2704
+ } // namespace protobuf_unittest
2705
+
2706
+ #ifndef SWIG
2707
+ namespace google {
2708
+ namespace protobuf {
2709
+
2710
+ template <>
2711
+ inline const EnumDescriptor* GetEnumDescriptor< ::protobuf_unittest::TestConflictingSymbolNames_TestEnum>() {
2712
+ return ::protobuf_unittest::TestConflictingSymbolNames_TestEnum_descriptor();
2713
+ }
2714
+
2715
+ } // namespace google
2716
+ } // namespace protobuf
2717
+ #endif // SWIG
2718
+
2719
+ // @@protoc_insertion_point(global_scope)
2720
+
2721
+ #endif // PROTOBUF_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto__INCLUDED