src/third_party/protobuf/src/google/protobuf/descriptor.pb.cc

   1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
   2 // source: google/protobuf/descriptor.proto
   3
   4 #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
   5 #include "google/protobuf/descriptor.pb.h"
   6
   7 #include <algorithm>
   8
   9 #include <google/protobuf/stubs/common.h>
  10 #include <google/protobuf/stubs/once.h>
  11 #include <google/protobuf/io/coded_stream.h>
  12 #include <google/protobuf/wire_format_lite_inl.h>
  13 #include <google/protobuf/descriptor.h>
  14 #include <google/protobuf/generated_message_reflection.h>
  15 #include <google/protobuf/reflection_ops.h>
  16 #include <google/protobuf/wire_format.h>
  17 // @@protoc_insertion_point(includes)
  18
  19 namespace google {
  20 namespace protobuf {
  21
  22 namespace {
  23
  24 const ::google::protobuf::Descriptor* FileDescriptorSet_descriptor_ = NULL;
  25 const ::google::protobuf::internal::GeneratedMessageReflection*
  26   FileDescriptorSet_reflection_ = NULL;
  27 const ::google::protobuf::Descriptor* FileDescriptorProto_descriptor_ = NULL;
  28 const ::google::protobuf::internal::GeneratedMessageReflection*
  29   FileDescriptorProto_reflection_ = NULL;
  30 const ::google::protobuf::Descriptor* DescriptorProto_descriptor_ = NULL;
  31 const ::google::protobuf::internal::GeneratedMessageReflection*
  32   DescriptorProto_reflection_ = NULL;
  33 const ::google::protobuf::Descriptor* DescriptorProto_ExtensionRange_descriptor_ = NULL;
  34 const ::google::protobuf::internal::GeneratedMessageReflection*
  35   DescriptorProto_ExtensionRange_reflection_ = NULL;
  36 const ::google::protobuf::Descriptor* FieldDescriptorProto_descriptor_ = NULL;
  37 const ::google::protobuf::internal::GeneratedMessageReflection*
  38   FieldDescriptorProto_reflection_ = NULL;
  39 const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Type_descriptor_ = NULL;
  40 const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Label_descriptor_ = NULL;
  41 const ::google::protobuf::Descriptor* EnumDescriptorProto_descriptor_ = NULL;
  42 const ::google::protobuf::internal::GeneratedMessageReflection*
  43   EnumDescriptorProto_reflection_ = NULL;
  44 const ::google::protobuf::Descriptor* EnumValueDescriptorProto_descriptor_ = NULL;
  45 const ::google::protobuf::internal::GeneratedMessageReflection*
  46   EnumValueDescriptorProto_reflection_ = NULL;
  47 const ::google::protobuf::Descriptor* ServiceDescriptorProto_descriptor_ = NULL;
  48 const ::google::protobuf::internal::GeneratedMessageReflection*
  49   ServiceDescriptorProto_reflection_ = NULL;
  50 const ::google::protobuf::Descriptor* MethodDescriptorProto_descriptor_ = NULL;
  51 const ::google::protobuf::internal::GeneratedMessageReflection*
  52   MethodDescriptorProto_reflection_ = NULL;
  53 const ::google::protobuf::Descriptor* FileOptions_descriptor_ = NULL;
  54 const ::google::protobuf::internal::GeneratedMessageReflection*
  55   FileOptions_reflection_ = NULL;
  56 const ::google::protobuf::EnumDescriptor* FileOptions_OptimizeMode_descriptor_ = NULL;
  57 const ::google::protobuf::Descriptor* MessageOptions_descriptor_ = NULL;
  58 const ::google::protobuf::internal::GeneratedMessageReflection*
  59   MessageOptions_reflection_ = NULL;
  60 const ::google::protobuf::Descriptor* FieldOptions_descriptor_ = NULL;
  61 const ::google::protobuf::internal::GeneratedMessageReflection*
  62   FieldOptions_reflection_ = NULL;
  63 const ::google::protobuf::EnumDescriptor* FieldOptions_CType_descriptor_ = NULL;
  64 const ::google::protobuf::Descriptor* EnumOptions_descriptor_ = NULL;
  65 const ::google::protobuf::internal::GeneratedMessageReflection*
  66   EnumOptions_reflection_ = NULL;
  67 const ::google::protobuf::Descriptor* EnumValueOptions_descriptor_ = NULL;
  68 const ::google::protobuf::internal::GeneratedMessageReflection*
  69   EnumValueOptions_reflection_ = NULL;
  70 const ::google::protobuf::Descriptor* ServiceOptions_descriptor_ = NULL;
  71 const ::google::protobuf::internal::GeneratedMessageReflection*
  72   ServiceOptions_reflection_ = NULL;
  73 const ::google::protobuf::Descriptor* MethodOptions_descriptor_ = NULL;
  74 const ::google::protobuf::internal::GeneratedMessageReflection*
  75   MethodOptions_reflection_ = NULL;
  76 const ::google::protobuf::Descriptor* UninterpretedOption_descriptor_ = NULL;
  77 const ::google::protobuf::internal::GeneratedMessageReflection*
  78   UninterpretedOption_reflection_ = NULL;
  79 const ::google::protobuf::Descriptor* UninterpretedOption_NamePart_descriptor_ = NULL;
  80 const ::google::protobuf::internal::GeneratedMessageReflection*
  81   UninterpretedOption_NamePart_reflection_ = NULL;
  82 const ::google::protobuf::Descriptor* SourceCodeInfo_descriptor_ = NULL;
  83 const ::google::protobuf::internal::GeneratedMessageReflection*
  84   SourceCodeInfo_reflection_ = NULL;
  85 const ::google::protobuf::Descriptor* SourceCodeInfo_Location_descriptor_ = NULL;
  86 const ::google::protobuf::internal::GeneratedMessageReflection*
  87   SourceCodeInfo_Location_reflection_ = NULL;
  88
  89 }  // namespace
  90
  91
  92 void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto() {
  93   protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
  94   const ::google::protobuf::FileDescriptor* file =
  95     ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
  96       "google/protobuf/descriptor.proto");
  97   GOOGLE_CHECK(file != NULL);
  98   FileDescriptorSet_descriptor_ = file->message_type(0);
  99   static const int FileDescriptorSet_offsets_[1] = {
 100     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorSet, file_),
 101   };
 102   FileDescriptorSet_reflection_ =
 103     new ::google::protobuf::internal::GeneratedMessageReflection(
 104       FileDescriptorSet_descriptor_,
 105       FileDescriptorSet::default_instance_,
 106       FileDescriptorSet_offsets_,
 107       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorSet, _has_bits_[0]),
 108       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorSet, _unknown_fields_),
 109       -1,
 110       ::google::protobuf::DescriptorPool::generated_pool(),
 111       ::google::protobuf::MessageFactory::generated_factory(),
 112       sizeof(FileDescriptorSet));
 113   FileDescriptorProto_descriptor_ = file->message_type(1);
 114   static const int FileDescriptorProto_offsets_[11] = {
 115     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, name_),
 116     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, package_),
 117     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, dependency_),
 118     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, public_dependency_),
 119     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, weak_dependency_),
 120     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, message_type_),
 121     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, enum_type_),
 122     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, service_),
 123     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, extension_),
 124     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, options_),
 125     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, source_code_info_),
 126   };
 127   FileDescriptorProto_reflection_ =
 128     new ::google::protobuf::internal::GeneratedMessageReflection(
 129       FileDescriptorProto_descriptor_,
 130       FileDescriptorProto::default_instance_,
 131       FileDescriptorProto_offsets_,
 132       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, _has_bits_[0]),
 133       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, _unknown_fields_),
 134       -1,
 135       ::google::protobuf::DescriptorPool::generated_pool(),
 136       ::google::protobuf::MessageFactory::generated_factory(),
 137       sizeof(FileDescriptorProto));
 138   DescriptorProto_descriptor_ = file->message_type(2);
 139   static const int DescriptorProto_offsets_[7] = {
 140     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, name_),
 141     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, field_),
 142     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, extension_),
 143     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, nested_type_),
 144     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, enum_type_),
 145     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, extension_range_),
 146     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, options_),
 147   };
 148   DescriptorProto_reflection_ =
 149     new ::google::protobuf::internal::GeneratedMessageReflection(
 150       DescriptorProto_descriptor_,
 151       DescriptorProto::default_instance_,
 152       DescriptorProto_offsets_,
 153       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, _has_bits_[0]),
 154       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, _unknown_fields_),
 155       -1,
 156       ::google::protobuf::DescriptorPool::generated_pool(),
 157       ::google::protobuf::MessageFactory::generated_factory(),
 158       sizeof(DescriptorProto));
 159   DescriptorProto_ExtensionRange_descriptor_ = DescriptorProto_descriptor_->nested_type(0);
 160   static const int DescriptorProto_ExtensionRange_offsets_[2] = {
 161     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto_ExtensionRange, start_),
 162     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto_ExtensionRange, end_),
 163   };
 164   DescriptorProto_ExtensionRange_reflection_ =
 165     new ::google::protobuf::internal::GeneratedMessageReflection(
 166       DescriptorProto_ExtensionRange_descriptor_,
 167       DescriptorProto_ExtensionRange::default_instance_,
 168       DescriptorProto_ExtensionRange_offsets_,
 169       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto_ExtensionRange, _has_bits_[0]),
 170       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto_ExtensionRange, _unknown_fields_),
 171       -1,
 172       ::google::protobuf::DescriptorPool::generated_pool(),
 173       ::google::protobuf::MessageFactory::generated_factory(),
 174       sizeof(DescriptorProto_ExtensionRange));
 175   FieldDescriptorProto_descriptor_ = file->message_type(3);
 176   static const int FieldDescriptorProto_offsets_[8] = {
 177     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, name_),
 178     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, number_),
 179     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, label_),
 180     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, type_),
 181     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, type_name_),
 182     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, extendee_),
 183     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, default_value_),
 184     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, options_),
 185   };
 186   FieldDescriptorProto_reflection_ =
 187     new ::google::protobuf::internal::GeneratedMessageReflection(
 188       FieldDescriptorProto_descriptor_,
 189       FieldDescriptorProto::default_instance_,
 190       FieldDescriptorProto_offsets_,
 191       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, _has_bits_[0]),
 192       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, _unknown_fields_),
 193       -1,
 194       ::google::protobuf::DescriptorPool::generated_pool(),
 195       ::google::protobuf::MessageFactory::generated_factory(),
 196       sizeof(FieldDescriptorProto));
 197   FieldDescriptorProto_Type_descriptor_ = FieldDescriptorProto_descriptor_->enum_type(0);
 198   FieldDescriptorProto_Label_descriptor_ = FieldDescriptorProto_descriptor_->enum_type(1);
 199   EnumDescriptorProto_descriptor_ = file->message_type(4);
 200   static const int EnumDescriptorProto_offsets_[3] = {
 201     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumDescriptorProto, name_),
 202     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumDescriptorProto, value_),
 203     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumDescriptorProto, options_),
 204   };
 205   EnumDescriptorProto_reflection_ =
 206     new ::google::protobuf::internal::GeneratedMessageReflection(
 207       EnumDescriptorProto_descriptor_,
 208       EnumDescriptorProto::default_instance_,
 209       EnumDescriptorProto_offsets_,
 210       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumDescriptorProto, _has_bits_[0]),
 211       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumDescriptorProto, _unknown_fields_),
 212       -1,
 213       ::google::protobuf::DescriptorPool::generated_pool(),
 214       ::google::protobuf::MessageFactory::generated_factory(),
 215       sizeof(EnumDescriptorProto));
 216   EnumValueDescriptorProto_descriptor_ = file->message_type(5);
 217   static const int EnumValueDescriptorProto_offsets_[3] = {
 218     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueDescriptorProto, name_),
 219     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueDescriptorProto, number_),
 220     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueDescriptorProto, options_),
 221   };
 222   EnumValueDescriptorProto_reflection_ =
 223     new ::google::protobuf::internal::GeneratedMessageReflection(
 224       EnumValueDescriptorProto_descriptor_,
 225       EnumValueDescriptorProto::default_instance_,
 226       EnumValueDescriptorProto_offsets_,
 227       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueDescriptorProto, _has_bits_[0]),
 228       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueDescriptorProto, _unknown_fields_),
 229       -1,
 230       ::google::protobuf::DescriptorPool::generated_pool(),
 231       ::google::protobuf::MessageFactory::generated_factory(),
 232       sizeof(EnumValueDescriptorProto));
 233   ServiceDescriptorProto_descriptor_ = file->message_type(6);
 234   static const int ServiceDescriptorProto_offsets_[3] = {
 235     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDescriptorProto, name_),
 236     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDescriptorProto, method_),
 237     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDescriptorProto, options_),
 238   };
 239   ServiceDescriptorProto_reflection_ =
 240     new ::google::protobuf::internal::GeneratedMessageReflection(
 241       ServiceDescriptorProto_descriptor_,
 242       ServiceDescriptorProto::default_instance_,
 243       ServiceDescriptorProto_offsets_,
 244       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDescriptorProto, _has_bits_[0]),
 245       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDescriptorProto, _unknown_fields_),
 246       -1,
 247       ::google::protobuf::DescriptorPool::generated_pool(),
 248       ::google::protobuf::MessageFactory::generated_factory(),
 249       sizeof(ServiceDescriptorProto));
 250   MethodDescriptorProto_descriptor_ = file->message_type(7);
 251   static const int MethodDescriptorProto_offsets_[4] = {
 252     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodDescriptorProto, name_),
 253     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodDescriptorProto, input_type_),
 254     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodDescriptorProto, output_type_),
 255     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodDescriptorProto, options_),
 256   };
 257   MethodDescriptorProto_reflection_ =
 258     new ::google::protobuf::internal::GeneratedMessageReflection(
 259       MethodDescriptorProto_descriptor_,
 260       MethodDescriptorProto::default_instance_,
 261       MethodDescriptorProto_offsets_,
 262       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodDescriptorProto, _has_bits_[0]),
 263       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodDescriptorProto, _unknown_fields_),
 264       -1,
 265       ::google::protobuf::DescriptorPool::generated_pool(),
 266       ::google::protobuf::MessageFactory::generated_factory(),
 267       sizeof(MethodDescriptorProto));
 268   FileOptions_descriptor_ = file->message_type(8);
 269   static const int FileOptions_offsets_[11] = {
 270     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, java_package_),
 271     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, java_outer_classname_),
 272     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, java_multiple_files_),
 273     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, retain_unknown_fields_),
 274     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, java_generate_equals_and_hash_),
 275     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, optimize_for_),
 276     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, go_package_),
 277     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, cc_generic_services_),
 278     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, java_generic_services_),
 279     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, py_generic_services_),
 280     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, uninterpreted_option_),
 281   };
 282   FileOptions_reflection_ =
 283     new ::google::protobuf::internal::GeneratedMessageReflection(
 284       FileOptions_descriptor_,
 285       FileOptions::default_instance_,
 286       FileOptions_offsets_,
 287       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, _has_bits_[0]),
 288       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, _unknown_fields_),
 289       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, _extensions_),
 290       ::google::protobuf::DescriptorPool::generated_pool(),
 291       ::google::protobuf::MessageFactory::generated_factory(),
 292       sizeof(FileOptions));
 293   FileOptions_OptimizeMode_descriptor_ = FileOptions_descriptor_->enum_type(0);
 294   MessageOptions_descriptor_ = file->message_type(9);
 295   static const int MessageOptions_offsets_[3] = {
 296     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageOptions, message_set_wire_format_),
 297     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageOptions, no_standard_descriptor_accessor_),
 298     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageOptions, uninterpreted_option_),
 299   };
 300   MessageOptions_reflection_ =
 301     new ::google::protobuf::internal::GeneratedMessageReflection(
 302       MessageOptions_descriptor_,
 303       MessageOptions::default_instance_,
 304       MessageOptions_offsets_,
 305       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageOptions, _has_bits_[0]),
 306       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageOptions, _unknown_fields_),
 307       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageOptions, _extensions_),
 308       ::google::protobuf::DescriptorPool::generated_pool(),
 309       ::google::protobuf::MessageFactory::generated_factory(),
 310       sizeof(MessageOptions));
 311   FieldOptions_descriptor_ = file->message_type(10);
 312   static const int FieldOptions_offsets_[7] = {
 313     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, ctype_),
 314     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, packed_),
 315     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, lazy_),
 316     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, deprecated_),
 317     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, experimental_map_key_),
 318     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, weak_),
 319     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, uninterpreted_option_),
 320   };
 321   FieldOptions_reflection_ =
 322     new ::google::protobuf::internal::GeneratedMessageReflection(
 323       FieldOptions_descriptor_,
 324       FieldOptions::default_instance_,
 325       FieldOptions_offsets_,
 326       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, _has_bits_[0]),
 327       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, _unknown_fields_),
 328       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, _extensions_),
 329       ::google::protobuf::DescriptorPool::generated_pool(),
 330       ::google::protobuf::MessageFactory::generated_factory(),
 331       sizeof(FieldOptions));
 332   FieldOptions_CType_descriptor_ = FieldOptions_descriptor_->enum_type(0);
 333   EnumOptions_descriptor_ = file->message_type(11);
 334   static const int EnumOptions_offsets_[2] = {
 335     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumOptions, allow_alias_),
 336     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumOptions, uninterpreted_option_),
 337   };
 338   EnumOptions_reflection_ =
 339     new ::google::protobuf::internal::GeneratedMessageReflection(
 340       EnumOptions_descriptor_,
 341       EnumOptions::default_instance_,
 342       EnumOptions_offsets_,
 343       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumOptions, _has_bits_[0]),
 344       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumOptions, _unknown_fields_),
 345       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumOptions, _extensions_),
 346       ::google::protobuf::DescriptorPool::generated_pool(),
 347       ::google::protobuf::MessageFactory::generated_factory(),
 348       sizeof(EnumOptions));
 349   EnumValueOptions_descriptor_ = file->message_type(12);
 350   static const int EnumValueOptions_offsets_[1] = {
 351     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueOptions, uninterpreted_option_),
 352   };
 353   EnumValueOptions_reflection_ =
 354     new ::google::protobuf::internal::GeneratedMessageReflection(
 355       EnumValueOptions_descriptor_,
 356       EnumValueOptions::default_instance_,
 357       EnumValueOptions_offsets_,
 358       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueOptions, _has_bits_[0]),
 359       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueOptions, _unknown_fields_),
 360       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueOptions, _extensions_),
 361       ::google::protobuf::DescriptorPool::generated_pool(),
 362       ::google::protobuf::MessageFactory::generated_factory(),
 363       sizeof(EnumValueOptions));
 364   ServiceOptions_descriptor_ = file->message_type(13);
 365   static const int ServiceOptions_offsets_[1] = {
 366     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceOptions, uninterpreted_option_),
 367   };
 368   ServiceOptions_reflection_ =
 369     new ::google::protobuf::internal::GeneratedMessageReflection(
 370       ServiceOptions_descriptor_,
 371       ServiceOptions::default_instance_,
 372       ServiceOptions_offsets_,
 373       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceOptions, _has_bits_[0]),
 374       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceOptions, _unknown_fields_),
 375       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceOptions, _extensions_),
 376       ::google::protobuf::DescriptorPool::generated_pool(),
 377       ::google::protobuf::MessageFactory::generated_factory(),
 378       sizeof(ServiceOptions));
 379   MethodOptions_descriptor_ = file->message_type(14);
 380   static const int MethodOptions_offsets_[1] = {
 381     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodOptions, uninterpreted_option_),
 382   };
 383   MethodOptions_reflection_ =
 384     new ::google::protobuf::internal::GeneratedMessageReflection(
 385       MethodOptions_descriptor_,
 386       MethodOptions::default_instance_,
 387       MethodOptions_offsets_,
 388       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodOptions, _has_bits_[0]),
 389       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodOptions, _unknown_fields_),
 390       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodOptions, _extensions_),
 391       ::google::protobuf::DescriptorPool::generated_pool(),
 392       ::google::protobuf::MessageFactory::generated_factory(),
 393       sizeof(MethodOptions));
 394   UninterpretedOption_descriptor_ = file->message_type(15);
 395   static const int UninterpretedOption_offsets_[7] = {
 396     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption, name_),
 397     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption, identifier_value_),
 398     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption, positive_int_value_),
 399     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption, negative_int_value_),
 400     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption, double_value_),
 401     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption, string_value_),
 402     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption, aggregate_value_),
 403   };
 404   UninterpretedOption_reflection_ =
 405     new ::google::protobuf::internal::GeneratedMessageReflection(
 406       UninterpretedOption_descriptor_,
 407       UninterpretedOption::default_instance_,
 408       UninterpretedOption_offsets_,
 409       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption, _has_bits_[0]),
 410       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption, _unknown_fields_),
 411       -1,
 412       ::google::protobuf::DescriptorPool::generated_pool(),
 413       ::google::protobuf::MessageFactory::generated_factory(),
 414       sizeof(UninterpretedOption));
 415   UninterpretedOption_NamePart_descriptor_ = UninterpretedOption_descriptor_->nested_type(0);
 416   static const int UninterpretedOption_NamePart_offsets_[2] = {
 417     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption_NamePart, name_part_),
 418     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption_NamePart, is_extension_),
 419   };
 420   UninterpretedOption_NamePart_reflection_ =
 421     new ::google::protobuf::internal::GeneratedMessageReflection(
 422       UninterpretedOption_NamePart_descriptor_,
 423       UninterpretedOption_NamePart::default_instance_,
 424       UninterpretedOption_NamePart_offsets_,
 425       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption_NamePart, _has_bits_[0]),
 426       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption_NamePart, _unknown_fields_),
 427       -1,
 428       ::google::protobuf::DescriptorPool::generated_pool(),
 429       ::google::protobuf::MessageFactory::generated_factory(),
 430       sizeof(UninterpretedOption_NamePart));
 431   SourceCodeInfo_descriptor_ = file->message_type(16);
 432   static const int SourceCodeInfo_offsets_[1] = {
 433     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SourceCodeInfo, location_),
 434   };
 435   SourceCodeInfo_reflection_ =
 436     new ::google::protobuf::internal::GeneratedMessageReflection(
 437       SourceCodeInfo_descriptor_,
 438       SourceCodeInfo::default_instance_,
 439       SourceCodeInfo_offsets_,
 440       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SourceCodeInfo, _has_bits_[0]),
 441       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SourceCodeInfo, _unknown_fields_),
 442       -1,
 443       ::google::protobuf::DescriptorPool::generated_pool(),
 444       ::google::protobuf::MessageFactory::generated_factory(),
 445       sizeof(SourceCodeInfo));
 446   SourceCodeInfo_Location_descriptor_ = SourceCodeInfo_descriptor_->nested_type(0);
 447   static const int SourceCodeInfo_Location_offsets_[4] = {
 448     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SourceCodeInfo_Location, path_),
 449     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SourceCodeInfo_Location, span_),
 450     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SourceCodeInfo_Location, leading_comments_),
 451     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SourceCodeInfo_Location, trailing_comments_),
 452   };
 453   SourceCodeInfo_Location_reflection_ =
 454     new ::google::protobuf::internal::GeneratedMessageReflection(
 455       SourceCodeInfo_Location_descriptor_,
 456       SourceCodeInfo_Location::default_instance_,
 457       SourceCodeInfo_Location_offsets_,
 458       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SourceCodeInfo_Location, _has_bits_[0]),
 459       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SourceCodeInfo_Location, _unknown_fields_),
 460       -1,
 461       ::google::protobuf::DescriptorPool::generated_pool(),
 462       ::google::protobuf::MessageFactory::generated_factory(),
 463       sizeof(SourceCodeInfo_Location));
 464 }
 465
 466 namespace {
 467
 468 GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
 469 inline void protobuf_AssignDescriptorsOnce() {
 470   ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
 471                  &protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto);
 472 }
 473
 474 void protobuf_RegisterTypes(const ::std::string&) {
 475   protobuf_AssignDescriptorsOnce();
 476   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 477     FileDescriptorSet_descriptor_, &FileDescriptorSet::default_instance());
 478   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 479     FileDescriptorProto_descriptor_, &FileDescriptorProto::default_instance());
 480   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 481     DescriptorProto_descriptor_, &DescriptorProto::default_instance());
 482   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 483     DescriptorProto_ExtensionRange_descriptor_, &DescriptorProto_ExtensionRange::default_instance());
 484   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 485     FieldDescriptorProto_descriptor_, &FieldDescriptorProto::default_instance());
 486   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 487     EnumDescriptorProto_descriptor_, &EnumDescriptorProto::default_instance());
 488   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 489     EnumValueDescriptorProto_descriptor_, &EnumValueDescriptorProto::default_instance());
 490   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 491     ServiceDescriptorProto_descriptor_, &ServiceDescriptorProto::default_instance());
 492   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 493     MethodDescriptorProto_descriptor_, &MethodDescriptorProto::default_instance());
 494   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 495     FileOptions_descriptor_, &FileOptions::default_instance());
 496   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 497     MessageOptions_descriptor_, &MessageOptions::default_instance());
 498   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 499     FieldOptions_descriptor_, &FieldOptions::default_instance());
 500   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 501     EnumOptions_descriptor_, &EnumOptions::default_instance());
 502   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 503     EnumValueOptions_descriptor_, &EnumValueOptions::default_instance());
 504   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 505     ServiceOptions_descriptor_, &ServiceOptions::default_instance());
 506   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 507     MethodOptions_descriptor_, &MethodOptions::default_instance());
 508   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 509     UninterpretedOption_descriptor_, &UninterpretedOption::default_instance());
 510   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 511     UninterpretedOption_NamePart_descriptor_, &UninterpretedOption_NamePart::default_instance());
 512   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 513     SourceCodeInfo_descriptor_, &SourceCodeInfo::default_instance());
 514   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 515     SourceCodeInfo_Location_descriptor_, &SourceCodeInfo_Location::default_instance());
 516 }
 517
 518 }  // namespace
 519
 520 void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto() {
 521   delete FileDescriptorSet::default_instance_;
 522   delete FileDescriptorSet_reflection_;
 523   delete FileDescriptorProto::default_instance_;
 524   delete FileDescriptorProto_reflection_;
 525   delete DescriptorProto::default_instance_;
 526   delete DescriptorProto_reflection_;
 527   delete DescriptorProto_ExtensionRange::default_instance_;
 528   delete DescriptorProto_ExtensionRange_reflection_;
 529   delete FieldDescriptorProto::default_instance_;
 530   delete FieldDescriptorProto_reflection_;
 531   delete EnumDescriptorProto::default_instance_;
 532   delete EnumDescriptorProto_reflection_;
 533   delete EnumValueDescriptorProto::default_instance_;
 534   delete EnumValueDescriptorProto_reflection_;
 535   delete ServiceDescriptorProto::default_instance_;
 536   delete ServiceDescriptorProto_reflection_;
 537   delete MethodDescriptorProto::default_instance_;
 538   delete MethodDescriptorProto_reflection_;
 539   delete FileOptions::default_instance_;
 540   delete FileOptions_reflection_;
 541   delete MessageOptions::default_instance_;
 542   delete MessageOptions_reflection_;
 543   delete FieldOptions::default_instance_;
 544   delete FieldOptions_reflection_;
 545   delete EnumOptions::default_instance_;
 546   delete EnumOptions_reflection_;
 547   delete EnumValueOptions::default_instance_;
 548   delete EnumValueOptions_reflection_;
 549   delete ServiceOptions::default_instance_;
 550   delete ServiceOptions_reflection_;
 551   delete MethodOptions::default_instance_;
 552   delete MethodOptions_reflection_;
 553   delete UninterpretedOption::default_instance_;
 554   delete UninterpretedOption_reflection_;
 555   delete UninterpretedOption_NamePart::default_instance_;
 556   delete UninterpretedOption_NamePart_reflection_;
 557   delete SourceCodeInfo::default_instance_;
 558   delete SourceCodeInfo_reflection_;
 559   delete SourceCodeInfo_Location::default_instance_;
 560   delete SourceCodeInfo_Location_reflection_;
 561 }
 562
 563 void protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto() {
 564   static bool already_here = false;
 565   if (already_here) return;
 566   already_here = true;
 567   GOOGLE_PROTOBUF_VERIFY_VERSION;
 568
 569   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
 570     "\n google/protobuf/descriptor.proto\022\017goog"
 571     "le.protobuf\"G\n\021FileDescriptorSet\0222\n\004file"
 572     "\030\001 \003(\0132$.google.protobuf.FileDescriptorP"
 573     "roto\"\313\003\n\023FileDescriptorProto\022\014\n\004name\030\001 \001"
 574     "(\t\022\017\n\007package\030\002 \001(\t\022\022\n\ndependency\030\003 \003(\t\022"
 575     "\031\n\021public_dependency\030\n \003(\005\022\027\n\017weak_depen"
 576     "dency\030\013 \003(\005\0226\n\014message_type\030\004 \003(\0132 .goog"
 577     "le.protobuf.DescriptorProto\0227\n\tenum_type"
 578     "\030\005 \003(\0132$.google.protobuf.EnumDescriptorP"
 579     "roto\0228\n\007service\030\006 \003(\0132\'.google.protobuf."
 580     "ServiceDescriptorProto\0228\n\textension\030\007 \003("
 581     "\0132%.google.protobuf.FieldDescriptorProto"
 582     "\022-\n\007options\030\010 \001(\0132\034.google.protobuf.File"
 583     "Options\0229\n\020source_code_info\030\t \001(\0132\037.goog"
 584     "le.protobuf.SourceCodeInfo\"\251\003\n\017Descripto"
 585     "rProto\022\014\n\004name\030\001 \001(\t\0224\n\005field\030\002 \003(\0132%.go"
 586     "ogle.protobuf.FieldDescriptorProto\0228\n\tex"
 587     "tension\030\006 \003(\0132%.google.protobuf.FieldDes"
 588     "criptorProto\0225\n\013nested_type\030\003 \003(\0132 .goog"
 589     "le.protobuf.DescriptorProto\0227\n\tenum_type"
 590     "\030\004 \003(\0132$.google.protobuf.EnumDescriptorP"
 591     "roto\022H\n\017extension_range\030\005 \003(\0132/.google.p"
 592     "rotobuf.DescriptorProto.ExtensionRange\0220"
 593     "\n\007options\030\007 \001(\0132\037.google.protobuf.Messag"
 594     "eOptions\032,\n\016ExtensionRange\022\r\n\005start\030\001 \001("
 595     "\005\022\013\n\003end\030\002 \001(\005\"\224\005\n\024FieldDescriptorProto\022"
 596     "\014\n\004name\030\001 \001(\t\022\016\n\006number\030\003 \001(\005\022:\n\005label\030\004"
 597     " \001(\0162+.google.protobuf.FieldDescriptorPr"
 598     "oto.Label\0228\n\004type\030\005 \001(\0162*.google.protobu"
 599     "f.FieldDescriptorProto.Type\022\021\n\ttype_name"
 600     "\030\006 \001(\t\022\020\n\010extendee\030\002 \001(\t\022\025\n\rdefault_valu"
 601     "e\030\007 \001(\t\022.\n\007options\030\010 \001(\0132\035.google.protob"
 602     "uf.FieldOptions\"\266\002\n\004Type\022\017\n\013TYPE_DOUBLE\020"
 603     "\001\022\016\n\nTYPE_FLOAT\020\002\022\016\n\nTYPE_INT64\020\003\022\017\n\013TYP"
 604     "E_UINT64\020\004\022\016\n\nTYPE_INT32\020\005\022\020\n\014TYPE_FIXED"
 605     "64\020\006\022\020\n\014TYPE_FIXED32\020\007\022\r\n\tTYPE_BOOL\020\010\022\017\n"
 606     "\013TYPE_STRING\020\t\022\016\n\nTYPE_GROUP\020\n\022\020\n\014TYPE_M"
 607     "ESSAGE\020\013\022\016\n\nTYPE_BYTES\020\014\022\017\n\013TYPE_UINT32\020"
 608     "\r\022\r\n\tTYPE_ENUM\020\016\022\021\n\rTYPE_SFIXED32\020\017\022\021\n\rT"
 609     "YPE_SFIXED64\020\020\022\017\n\013TYPE_SINT32\020\021\022\017\n\013TYPE_"
 610     "SINT64\020\022\"C\n\005Label\022\022\n\016LABEL_OPTIONAL\020\001\022\022\n"
 611     "\016LABEL_REQUIRED\020\002\022\022\n\016LABEL_REPEATED\020\003\"\214\001"
 612     "\n\023EnumDescriptorProto\022\014\n\004name\030\001 \001(\t\0228\n\005v"
 613     "alue\030\002 \003(\0132).google.protobuf.EnumValueDe"
 614     "scriptorProto\022-\n\007options\030\003 \001(\0132\034.google."
 615     "protobuf.EnumOptions\"l\n\030EnumValueDescrip"
 616     "torProto\022\014\n\004name\030\001 \001(\t\022\016\n\006number\030\002 \001(\005\0222"
 617     "\n\007options\030\003 \001(\0132!.google.protobuf.EnumVa"
 618     "lueOptions\"\220\001\n\026ServiceDescriptorProto\022\014\n"
 619     "\004name\030\001 \001(\t\0226\n\006method\030\002 \003(\0132&.google.pro"
 620     "tobuf.MethodDescriptorProto\0220\n\007options\030\003"
 621     " \001(\0132\037.google.protobuf.ServiceOptions\"\177\n"
 622     "\025MethodDescriptorProto\022\014\n\004name\030\001 \001(\t\022\022\n\n"
 623     "input_type\030\002 \001(\t\022\023\n\013output_type\030\003 \001(\t\022/\n"
 624     "\007options\030\004 \001(\0132\036.google.protobuf.MethodO"
 625     "ptions\"\217\004\n\013FileOptions\022\024\n\014java_package\030\001"
 626     " \001(\t\022\034\n\024java_outer_classname\030\010 \001(\t\022\"\n\023ja"
 627     "va_multiple_files\030\n \001(\010:\005false\022$\n\025retain"
 628     "_unknown_fields\030\014 \001(\010:\005false\022,\n\035java_gen"
 629     "erate_equals_and_hash\030\024 \001(\010:\005false\022F\n\014op"
 630     "timize_for\030\t \001(\0162).google.protobuf.FileO"
 631     "ptions.OptimizeMode:\005SPEED\022\022\n\ngo_package"
 632     "\030\013 \001(\t\022\"\n\023cc_generic_services\030\020 \001(\010:\005fal"
 633     "se\022$\n\025java_generic_services\030\021 \001(\010:\005false"
 634     "\022\"\n\023py_generic_services\030\022 \001(\010:\005false\022C\n\024"
 635     "uninterpreted_option\030\347\007 \003(\0132$.google.pro"
 636     "tobuf.UninterpretedOption\":\n\014OptimizeMod"
 637     "e\022\t\n\005SPEED\020\001\022\r\n\tCODE_SIZE\020\002\022\020\n\014LITE_RUNT"
 638     "IME\020\003*\t\010\350\007\020\200\200\200\200\002\"\270\001\n\016MessageOptions\022&\n\027m"
 639     "essage_set_wire_format\030\001 \001(\010:\005false\022.\n\037n"
 640     "o_standard_descriptor_accessor\030\002 \001(\010:\005fa"
 641     "lse\022C\n\024uninterpreted_option\030\347\007 \003(\0132$.goo"
 642     "gle.protobuf.UninterpretedOption*\t\010\350\007\020\200\200"
 643     "\200\200\002\"\276\002\n\014FieldOptions\022:\n\005ctype\030\001 \001(\0162#.go"
 644     "ogle.protobuf.FieldOptions.CType:\006STRING"
 645     "\022\016\n\006packed\030\002 \001(\010\022\023\n\004lazy\030\005 \001(\010:\005false\022\031\n"
 646     "\ndeprecated\030\003 \001(\010:\005false\022\034\n\024experimental"
 647     "_map_key\030\t \001(\t\022\023\n\004weak\030\n \001(\010:\005false\022C\n\024u"
 648     "ninterpreted_option\030\347\007 \003(\0132$.google.prot"
 649     "obuf.UninterpretedOption\"/\n\005CType\022\n\n\006STR"
 650     "ING\020\000\022\010\n\004CORD\020\001\022\020\n\014STRING_PIECE\020\002*\t\010\350\007\020\200"
 651     "\200\200\200\002\"x\n\013EnumOptions\022\031\n\013allow_alias\030\002 \001(\010"
 652     ":\004true\022C\n\024uninterpreted_option\030\347\007 \003(\0132$."
 653     "google.protobuf.UninterpretedOption*\t\010\350\007"
 654     "\020\200\200\200\200\002\"b\n\020EnumValueOptions\022C\n\024uninterpre"
 655     "ted_option\030\347\007 \003(\0132$.google.protobuf.Unin"
 656     "terpretedOption*\t\010\350\007\020\200\200\200\200\002\"`\n\016ServiceOpt"
 657     "ions\022C\n\024uninterpreted_option\030\347\007 \003(\0132$.go"
 658     "ogle.protobuf.UninterpretedOption*\t\010\350\007\020\200"
 659     "\200\200\200\002\"_\n\rMethodOptions\022C\n\024uninterpreted_o"
 660     "ption\030\347\007 \003(\0132$.google.protobuf.Uninterpr"
 661     "etedOption*\t\010\350\007\020\200\200\200\200\002\"\236\002\n\023UninterpretedO"
 662     "ption\022;\n\004name\030\002 \003(\0132-.google.protobuf.Un"
 663     "interpretedOption.NamePart\022\030\n\020identifier"
 664     "_value\030\003 \001(\t\022\032\n\022positive_int_value\030\004 \001(\004"
 665     "\022\032\n\022negative_int_value\030\005 \001(\003\022\024\n\014double_v"
 666     "alue\030\006 \001(\001\022\024\n\014string_value\030\007 \001(\014\022\027\n\017aggr"
 667     "egate_value\030\010 \001(\t\0323\n\010NamePart\022\021\n\tname_pa"
 668     "rt\030\001 \002(\t\022\024\n\014is_extension\030\002 \002(\010\"\261\001\n\016Sourc"
 669     "eCodeInfo\022:\n\010location\030\001 \003(\0132(.google.pro"
 670     "tobuf.SourceCodeInfo.Location\032c\n\010Locatio"
 671     "n\022\020\n\004path\030\001 \003(\005B\002\020\001\022\020\n\004span\030\002 \003(\005B\002\020\001\022\030\n"
 672     "\020leading_comments\030\003 \001(\t\022\031\n\021trailing_comm"
 673     "ents\030\004 \001(\tB)\n\023com.google.protobufB\020Descr"
 674     "iptorProtosH\001", 4173);
 675   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
 676     "google/protobuf/descriptor.proto", &protobuf_RegisterTypes);
 677   FileDescriptorSet::default_instance_ = new FileDescriptorSet();
 678   FileDescriptorProto::default_instance_ = new FileDescriptorProto();
 679   DescriptorProto::default_instance_ = new DescriptorProto();
 680   DescriptorProto_ExtensionRange::default_instance_ = new DescriptorProto_ExtensionRange();
 681   FieldDescriptorProto::default_instance_ = new FieldDescriptorProto();
 682   EnumDescriptorProto::default_instance_ = new EnumDescriptorProto();
 683   EnumValueDescriptorProto::default_instance_ = new EnumValueDescriptorProto();
 684   ServiceDescriptorProto::default_instance_ = new ServiceDescriptorProto();
 685   MethodDescriptorProto::default_instance_ = new MethodDescriptorProto();
 686   FileOptions::default_instance_ = new FileOptions();
 687   MessageOptions::default_instance_ = new MessageOptions();
 688   FieldOptions::default_instance_ = new FieldOptions();
 689   EnumOptions::default_instance_ = new EnumOptions();
 690   EnumValueOptions::default_instance_ = new EnumValueOptions();
 691   ServiceOptions::default_instance_ = new ServiceOptions();
 692   MethodOptions::default_instance_ = new MethodOptions();
 693   UninterpretedOption::default_instance_ = new UninterpretedOption();
 694   UninterpretedOption_NamePart::default_instance_ = new UninterpretedOption_NamePart();
 695   SourceCodeInfo::default_instance_ = new SourceCodeInfo();
 696   SourceCodeInfo_Location::default_instance_ = new SourceCodeInfo_Location();
 697   FileDescriptorSet::default_instance_->InitAsDefaultInstance();
 698   FileDescriptorProto::default_instance_->InitAsDefaultInstance();
 699   DescriptorProto::default_instance_->InitAsDefaultInstance();
 700   DescriptorProto_ExtensionRange::default_instance_->InitAsDefaultInstance();
 701   FieldDescriptorProto::default_instance_->InitAsDefaultInstance();
 702   EnumDescriptorProto::default_instance_->InitAsDefaultInstance();
 703   EnumValueDescriptorProto::default_instance_->InitAsDefaultInstance();
 704   ServiceDescriptorProto::default_instance_->InitAsDefaultInstance();
 705   MethodDescriptorProto::default_instance_->InitAsDefaultInstance();
 706   FileOptions::default_instance_->InitAsDefaultInstance();
 707   MessageOptions::default_instance_->InitAsDefaultInstance();
 708   FieldOptions::default_instance_->InitAsDefaultInstance();
 709   EnumOptions::default_instance_->InitAsDefaultInstance();
 710   EnumValueOptions::default_instance_->InitAsDefaultInstance();
 711   ServiceOptions::default_instance_->InitAsDefaultInstance();
 712   MethodOptions::default_instance_->InitAsDefaultInstance();
 713   UninterpretedOption::default_instance_->InitAsDefaultInstance();
 714   UninterpretedOption_NamePart::default_instance_->InitAsDefaultInstance();
 715   SourceCodeInfo::default_instance_->InitAsDefaultInstance();
 716   SourceCodeInfo_Location::default_instance_->InitAsDefaultInstance();
 717   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto);
 718 }
 719
 720 // Force AddDescriptors() to be called at static initialization time.
 721 struct StaticDescriptorInitializer_google_2fprotobuf_2fdescriptor_2eproto {
 722   StaticDescriptorInitializer_google_2fprotobuf_2fdescriptor_2eproto() {
 723     protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 724   }
 725 } static_descriptor_initializer_google_2fprotobuf_2fdescriptor_2eproto_;
 726
 727 // ===================================================================
 728
 729 #ifndef _MSC_VER
 730 const int FileDescriptorSet::kFileFieldNumber;
 731 #endif  // !_MSC_VER
 732
 733 FileDescriptorSet::FileDescriptorSet()
 734   : ::google::protobuf::Message() {
 735   SharedCtor();
 736 }
 737
 738 void FileDescriptorSet::InitAsDefaultInstance() {
 739 }
 740
 741 FileDescriptorSet::FileDescriptorSet(const FileDescriptorSet& from)
 742   : ::google::protobuf::Message() {
 743   SharedCtor();
 744   MergeFrom(from);
 745 }
 746
 747 void FileDescriptorSet::SharedCtor() {
 748   _cached_size_ = 0;
 749   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 750 }
 751
 752 FileDescriptorSet::~FileDescriptorSet() {
 753   SharedDtor();
 754 }
 755
 756 void FileDescriptorSet::SharedDtor() {
 757   if (this != default_instance_) {
 758   }
 759 }
 760
 761 void FileDescriptorSet::SetCachedSize(int size) const {
 762   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
 763   _cached_size_ = size;
 764   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 765 }
 766 const ::google::protobuf::Descriptor* FileDescriptorSet::descriptor() {
 767   protobuf_AssignDescriptorsOnce();
 768   return FileDescriptorSet_descriptor_;
 769 }
 770
 771 const FileDescriptorSet& FileDescriptorSet::default_instance() {
 772   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
 773   return *default_instance_;
 774 }
 775
 776 FileDescriptorSet* FileDescriptorSet::default_instance_ = NULL;
 777
 778 FileDescriptorSet* FileDescriptorSet::New() const {
 779   return new FileDescriptorSet;
 780 }
 781
 782 void FileDescriptorSet::Clear() {
 783   file_.Clear();
 784   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 785   mutable_unknown_fields()->Clear();
 786 }
 787
 788 bool FileDescriptorSet::MergePartialFromCodedStream(
 789     ::google::protobuf::io::CodedInputStream* input) {
 790 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
 791   ::google::protobuf::uint32 tag;
 792   while ((tag = input->ReadTag()) != 0) {
 793     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
 794       // repeated .google.protobuf.FileDescriptorProto file = 1;
 795       case 1: {
 796         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 797             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 798          parse_file:
 799           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
 800                 input, add_file()));
 801         } else {
 802           goto handle_uninterpreted;
 803         }
 804         if (input->ExpectTag(10)) goto parse_file;
 805         if (input->ExpectAtEnd()) return true;
 806         break;
 807       }
 808
 809       default: {
 810       handle_uninterpreted:
 811         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 812             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
 813           return true;
 814         }
 815         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
 816               input, tag, mutable_unknown_fields()));
 817         break;
 818       }
 819     }
 820   }
 821   return true;
 822 #undef DO_
 823 }
 824
 825 void FileDescriptorSet::SerializeWithCachedSizes(
 826     ::google::protobuf::io::CodedOutputStream* output) const {
 827   // repeated .google.protobuf.FileDescriptorProto file = 1;
 828   for (int i = 0; i < this->file_size(); i++) {
 829     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
 830       1, this->file(i), output);
 831   }
 832
 833   if (!unknown_fields().empty()) {
 834     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
 835         unknown_fields(), output);
 836   }
 837 }
 838
 839 ::google::protobuf::uint8* FileDescriptorSet::SerializeWithCachedSizesToArray(
 840     ::google::protobuf::uint8* target) const {
 841   // repeated .google.protobuf.FileDescriptorProto file = 1;
 842   for (int i = 0; i < this->file_size(); i++) {
 843     target = ::google::protobuf::internal::WireFormatLite::
 844       WriteMessageNoVirtualToArray(
 845         1, this->file(i), target);
 846   }
 847
 848   if (!unknown_fields().empty()) {
 849     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
 850         unknown_fields(), target);
 851   }
 852   return target;
 853 }
 854
 855 int FileDescriptorSet::ByteSize() const {
 856   int total_size = 0;
 857
 858   // repeated .google.protobuf.FileDescriptorProto file = 1;
 859   total_size += 1 * this->file_size();
 860   for (int i = 0; i < this->file_size(); i++) {
 861     total_size +=
 862       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
 863         this->file(i));
 864   }
 865
 866   if (!unknown_fields().empty()) {
 867     total_size +=
 868       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
 869         unknown_fields());
 870   }
 871   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
 872   _cached_size_ = total_size;
 873   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 874   return total_size;
 875 }
 876
 877 void FileDescriptorSet::MergeFrom(const ::google::protobuf::Message& from) {
 878   GOOGLE_CHECK_NE(&from, this);
 879   const FileDescriptorSet* source =
 880     ::google::protobuf::internal::dynamic_cast_if_available<const FileDescriptorSet*>(
 881       &from);
 882   if (source == NULL) {
 883     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
 884   } else {
 885     MergeFrom(*source);
 886   }
 887 }
 888
 889 void FileDescriptorSet::MergeFrom(const FileDescriptorSet& from) {
 890   GOOGLE_CHECK_NE(&from, this);
 891   file_.MergeFrom(from.file_);
 892   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 893 }
 894
 895 void FileDescriptorSet::CopyFrom(const ::google::protobuf::Message& from) {
 896   if (&from == this) return;
 897   Clear();
 898   MergeFrom(from);
 899 }
 900
 901 void FileDescriptorSet::CopyFrom(const FileDescriptorSet& from) {
 902   if (&from == this) return;
 903   Clear();
 904   MergeFrom(from);
 905 }
 906
 907 bool FileDescriptorSet::IsInitialized() const {
 908
 909   for (int i = 0; i < file_size(); i++) {
 910     if (!this->file(i).IsInitialized()) return false;
 911   }
 912   return true;
 913 }
 914
 915 void FileDescriptorSet::Swap(FileDescriptorSet* other) {
 916   if (other != this) {
 917     file_.Swap(&other->file_);
 918     std::swap(_has_bits_[0], other->_has_bits_[0]);
 919     _unknown_fields_.Swap(&other->_unknown_fields_);
 920     std::swap(_cached_size_, other->_cached_size_);
 921   }
 922 }
 923
 924 ::google::protobuf::Metadata FileDescriptorSet::GetMetadata() const {
 925   protobuf_AssignDescriptorsOnce();
 926   ::google::protobuf::Metadata metadata;
 927   metadata.descriptor = FileDescriptorSet_descriptor_;
 928   metadata.reflection = FileDescriptorSet_reflection_;
 929   return metadata;
 930 }
 931
 932
 933 // ===================================================================
 934
 935 #ifndef _MSC_VER
 936 const int FileDescriptorProto::kNameFieldNumber;
 937 const int FileDescriptorProto::kPackageFieldNumber;
 938 const int FileDescriptorProto::kDependencyFieldNumber;
 939 const int FileDescriptorProto::kPublicDependencyFieldNumber;
 940 const int FileDescriptorProto::kWeakDependencyFieldNumber;
 941 const int FileDescriptorProto::kMessageTypeFieldNumber;
 942 const int FileDescriptorProto::kEnumTypeFieldNumber;
 943 const int FileDescriptorProto::kServiceFieldNumber;
 944 const int FileDescriptorProto::kExtensionFieldNumber;
 945 const int FileDescriptorProto::kOptionsFieldNumber;
 946 const int FileDescriptorProto::kSourceCodeInfoFieldNumber;
 947 #endif  // !_MSC_VER
 948
 949 FileDescriptorProto::FileDescriptorProto()
 950   : ::google::protobuf::Message() {
 951   SharedCtor();
 952 }
 953
 954 void FileDescriptorProto::InitAsDefaultInstance() {
 955   options_ = const_cast< ::google::protobuf::FileOptions*>(&::google::protobuf::FileOptions::default_instance());
 956   source_code_info_ = const_cast< ::google::protobuf::SourceCodeInfo*>(&::google::protobuf::SourceCodeInfo::default_instance());
 957 }
 958
 959 FileDescriptorProto::FileDescriptorProto(const FileDescriptorProto& from)
 960   : ::google::protobuf::Message() {
 961   SharedCtor();
 962   MergeFrom(from);
 963 }
 964
 965 void FileDescriptorProto::SharedCtor() {
 966   _cached_size_ = 0;
 967   name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 968   package_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
 969   options_ = NULL;
 970   source_code_info_ = NULL;
 971   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 972 }
 973
 974 FileDescriptorProto::~FileDescriptorProto() {
 975   SharedDtor();
 976 }
 977
 978 void FileDescriptorProto::SharedDtor() {
 979   if (name_ != &::google::protobuf::internal::GetEmptyString()) {
 980     delete name_;
 981   }
 982   if (package_ != &::google::protobuf::internal::GetEmptyString()) {
 983     delete package_;
 984   }
 985   if (this != default_instance_) {
 986     delete options_;
 987     delete source_code_info_;
 988   }
 989 }
 990
 991 void FileDescriptorProto::SetCachedSize(int size) const {
 992   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
 993   _cached_size_ = size;
 994   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 995 }
 996 const ::google::protobuf::Descriptor* FileDescriptorProto::descriptor() {
 997   protobuf_AssignDescriptorsOnce();
 998   return FileDescriptorProto_descriptor_;
 999 }
1000
1001 const FileDescriptorProto& FileDescriptorProto::default_instance() {
1002   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
1003   return *default_instance_;
1004 }
1005
1006 FileDescriptorProto* FileDescriptorProto::default_instance_ = NULL;
1007
1008 FileDescriptorProto* FileDescriptorProto::New() const {
1009   return new FileDescriptorProto;
1010 }
1011
1012 void FileDescriptorProto::Clear() {
1013   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1014     if (has_name()) {
1015       if (name_ != &::google::protobuf::internal::GetEmptyString()) {
1016         name_->clear();
1017       }
1018     }
1019     if (has_package()) {
1020       if (package_ != &::google::protobuf::internal::GetEmptyString()) {
1021         package_->clear();
1022       }
1023     }
1024   }
1025   if (_has_bits_[9 / 32] & (0xffu << (9 % 32))) {
1026     if (has_options()) {
1027       if (options_ != NULL) options_->::google::protobuf::FileOptions::Clear();
1028     }
1029     if (has_source_code_info()) {
1030       if (source_code_info_ != NULL) source_code_info_->::google::protobuf::SourceCodeInfo::Clear();
1031     }
1032   }
1033   dependency_.Clear();
1034   public_dependency_.Clear();
1035   weak_dependency_.Clear();
1036   message_type_.Clear();
1037   enum_type_.Clear();
1038   service_.Clear();
1039   extension_.Clear();
1040   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1041   mutable_unknown_fields()->Clear();
1042 }
1043
1044 bool FileDescriptorProto::MergePartialFromCodedStream(
1045     ::google::protobuf::io::CodedInputStream* input) {
1046 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
1047   ::google::protobuf::uint32 tag;
1048   while ((tag = input->ReadTag()) != 0) {
1049     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1050       // optional string name = 1;
1051       case 1: {
1052         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1053             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1054           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1055                 input, this->mutable_name()));
1056           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1057             this->name().data(), this->name().length(),
1058             ::google::protobuf::internal::WireFormat::PARSE);
1059         } else {
1060           goto handle_uninterpreted;
1061         }
1062         if (input->ExpectTag(18)) goto parse_package;
1063         break;
1064       }
1065
1066       // optional string package = 2;
1067       case 2: {
1068         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1069             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1070          parse_package:
1071           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1072                 input, this->mutable_package()));
1073           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1074             this->package().data(), this->package().length(),
1075             ::google::protobuf::internal::WireFormat::PARSE);
1076         } else {
1077           goto handle_uninterpreted;
1078         }
1079         if (input->ExpectTag(26)) goto parse_dependency;
1080         break;
1081       }
1082
1083       // repeated string dependency = 3;
1084       case 3: {
1085         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1086             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1087          parse_dependency:
1088           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1089                 input, this->add_dependency()));
1090           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1091             this->dependency(this->dependency_size() - 1).data(),
1092             this->dependency(this->dependency_size() - 1).length(),
1093             ::google::protobuf::internal::WireFormat::PARSE);
1094         } else {
1095           goto handle_uninterpreted;
1096         }
1097         if (input->ExpectTag(26)) goto parse_dependency;
1098         if (input->ExpectTag(34)) goto parse_message_type;
1099         break;
1100       }
1101
1102       // repeated .google.protobuf.DescriptorProto message_type = 4;
1103       case 4: {
1104         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1105             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1106          parse_message_type:
1107           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1108                 input, add_message_type()));
1109         } else {
1110           goto handle_uninterpreted;
1111         }
1112         if (input->ExpectTag(34)) goto parse_message_type;
1113         if (input->ExpectTag(42)) goto parse_enum_type;
1114         break;
1115       }
1116
1117       // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
1118       case 5: {
1119         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1120             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1121          parse_enum_type:
1122           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1123                 input, add_enum_type()));
1124         } else {
1125           goto handle_uninterpreted;
1126         }
1127         if (input->ExpectTag(42)) goto parse_enum_type;
1128         if (input->ExpectTag(50)) goto parse_service;
1129         break;
1130       }
1131
1132       // repeated .google.protobuf.ServiceDescriptorProto service = 6;
1133       case 6: {
1134         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1135             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1136          parse_service:
1137           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1138                 input, add_service()));
1139         } else {
1140           goto handle_uninterpreted;
1141         }
1142         if (input->ExpectTag(50)) goto parse_service;
1143         if (input->ExpectTag(58)) goto parse_extension;
1144         break;
1145       }
1146
1147       // repeated .google.protobuf.FieldDescriptorProto extension = 7;
1148       case 7: {
1149         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1150             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1151          parse_extension:
1152           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1153                 input, add_extension()));
1154         } else {
1155           goto handle_uninterpreted;
1156         }
1157         if (input->ExpectTag(58)) goto parse_extension;
1158         if (input->ExpectTag(66)) goto parse_options;
1159         break;
1160       }
1161
1162       // optional .google.protobuf.FileOptions options = 8;
1163       case 8: {
1164         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1165             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1166          parse_options:
1167           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1168                input, mutable_options()));
1169         } else {
1170           goto handle_uninterpreted;
1171         }
1172         if (input->ExpectTag(74)) goto parse_source_code_info;
1173         break;
1174       }
1175
1176       // optional .google.protobuf.SourceCodeInfo source_code_info = 9;
1177       case 9: {
1178         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1179             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1180          parse_source_code_info:
1181           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1182                input, mutable_source_code_info()));
1183         } else {
1184           goto handle_uninterpreted;
1185         }
1186         if (input->ExpectTag(80)) goto parse_public_dependency;
1187         break;
1188       }
1189
1190       // repeated int32 public_dependency = 10;
1191       case 10: {
1192         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1193             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1194          parse_public_dependency:
1195           DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
1196                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
1197                  1, 80, input, this->mutable_public_dependency())));
1198         } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
1199                    == ::google::protobuf::internal::WireFormatLite::
1200                       WIRETYPE_LENGTH_DELIMITED) {
1201           DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
1202                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
1203                  input, this->mutable_public_dependency())));
1204         } else {
1205           goto handle_uninterpreted;
1206         }
1207         if (input->ExpectTag(80)) goto parse_public_dependency;
1208         if (input->ExpectTag(88)) goto parse_weak_dependency;
1209         break;
1210       }
1211
1212       // repeated int32 weak_dependency = 11;
1213       case 11: {
1214         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1215             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1216          parse_weak_dependency:
1217           DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
1218                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
1219                  1, 88, input, this->mutable_weak_dependency())));
1220         } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
1221                    == ::google::protobuf::internal::WireFormatLite::
1222                       WIRETYPE_LENGTH_DELIMITED) {
1223           DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
1224                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
1225                  input, this->mutable_weak_dependency())));
1226         } else {
1227           goto handle_uninterpreted;
1228         }
1229         if (input->ExpectTag(88)) goto parse_weak_dependency;
1230         if (input->ExpectAtEnd()) return true;
1231         break;
1232       }
1233
1234       default: {
1235       handle_uninterpreted:
1236         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1237             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
1238           return true;
1239         }
1240         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
1241               input, tag, mutable_unknown_fields()));
1242         break;
1243       }
1244     }
1245   }
1246   return true;
1247 #undef DO_
1248 }
1249
1250 void FileDescriptorProto::SerializeWithCachedSizes(
1251     ::google::protobuf::io::CodedOutputStream* output) const {
1252   // optional string name = 1;
1253   if (has_name()) {
1254     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1255       this->name().data(), this->name().length(),
1256       ::google::protobuf::internal::WireFormat::SERIALIZE);
1257     ::google::protobuf::internal::WireFormatLite::WriteString(
1258       1, this->name(), output);
1259   }
1260
1261   // optional string package = 2;
1262   if (has_package()) {
1263     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1264       this->package().data(), this->package().length(),
1265       ::google::protobuf::internal::WireFormat::SERIALIZE);
1266     ::google::protobuf::internal::WireFormatLite::WriteString(
1267       2, this->package(), output);
1268   }
1269
1270   // repeated string dependency = 3;
1271   for (int i = 0; i < this->dependency_size(); i++) {
1272   ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1273     this->dependency(i).data(), this->dependency(i).length(),
1274     ::google::protobuf::internal::WireFormat::SERIALIZE);
1275     ::google::protobuf::internal::WireFormatLite::WriteString(
1276       3, this->dependency(i), output);
1277   }
1278
1279   // repeated .google.protobuf.DescriptorProto message_type = 4;
1280   for (int i = 0; i < this->message_type_size(); i++) {
1281     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1282       4, this->message_type(i), output);
1283   }
1284
1285   // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
1286   for (int i = 0; i < this->enum_type_size(); i++) {
1287     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1288       5, this->enum_type(i), output);
1289   }
1290
1291   // repeated .google.protobuf.ServiceDescriptorProto service = 6;
1292   for (int i = 0; i < this->service_size(); i++) {
1293     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1294       6, this->service(i), output);
1295   }
1296
1297   // repeated .google.protobuf.FieldDescriptorProto extension = 7;
1298   for (int i = 0; i < this->extension_size(); i++) {
1299     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1300       7, this->extension(i), output);
1301   }
1302
1303   // optional .google.protobuf.FileOptions options = 8;
1304   if (has_options()) {
1305     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1306       8, this->options(), output);
1307   }
1308
1309   // optional .google.protobuf.SourceCodeInfo source_code_info = 9;
1310   if (has_source_code_info()) {
1311     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1312       9, this->source_code_info(), output);
1313   }
1314
1315   // repeated int32 public_dependency = 10;
1316   for (int i = 0; i < this->public_dependency_size(); i++) {
1317     ::google::protobuf::internal::WireFormatLite::WriteInt32(
1318       10, this->public_dependency(i), output);
1319   }
1320
1321   // repeated int32 weak_dependency = 11;
1322   for (int i = 0; i < this->weak_dependency_size(); i++) {
1323     ::google::protobuf::internal::WireFormatLite::WriteInt32(
1324       11, this->weak_dependency(i), output);
1325   }
1326
1327   if (!unknown_fields().empty()) {
1328     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
1329         unknown_fields(), output);
1330   }
1331 }
1332
1333 ::google::protobuf::uint8* FileDescriptorProto::SerializeWithCachedSizesToArray(
1334     ::google::protobuf::uint8* target) const {
1335   // optional string name = 1;
1336   if (has_name()) {
1337     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1338       this->name().data(), this->name().length(),
1339       ::google::protobuf::internal::WireFormat::SERIALIZE);
1340     target =
1341       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1342         1, this->name(), target);
1343   }
1344
1345   // optional string package = 2;
1346   if (has_package()) {
1347     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1348       this->package().data(), this->package().length(),
1349       ::google::protobuf::internal::WireFormat::SERIALIZE);
1350     target =
1351       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1352         2, this->package(), target);
1353   }
1354
1355   // repeated string dependency = 3;
1356   for (int i = 0; i < this->dependency_size(); i++) {
1357     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1358       this->dependency(i).data(), this->dependency(i).length(),
1359       ::google::protobuf::internal::WireFormat::SERIALIZE);
1360     target = ::google::protobuf::internal::WireFormatLite::
1361       WriteStringToArray(3, this->dependency(i), target);
1362   }
1363
1364   // repeated .google.protobuf.DescriptorProto message_type = 4;
1365   for (int i = 0; i < this->message_type_size(); i++) {
1366     target = ::google::protobuf::internal::WireFormatLite::
1367       WriteMessageNoVirtualToArray(
1368         4, this->message_type(i), target);
1369   }
1370
1371   // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
1372   for (int i = 0; i < this->enum_type_size(); i++) {
1373     target = ::google::protobuf::internal::WireFormatLite::
1374       WriteMessageNoVirtualToArray(
1375         5, this->enum_type(i), target);
1376   }
1377
1378   // repeated .google.protobuf.ServiceDescriptorProto service = 6;
1379   for (int i = 0; i < this->service_size(); i++) {
1380     target = ::google::protobuf::internal::WireFormatLite::
1381       WriteMessageNoVirtualToArray(
1382         6, this->service(i), target);
1383   }
1384
1385   // repeated .google.protobuf.FieldDescriptorProto extension = 7;
1386   for (int i = 0; i < this->extension_size(); i++) {
1387     target = ::google::protobuf::internal::WireFormatLite::
1388       WriteMessageNoVirtualToArray(
1389         7, this->extension(i), target);
1390   }
1391
1392   // optional .google.protobuf.FileOptions options = 8;
1393   if (has_options()) {
1394     target = ::google::protobuf::internal::WireFormatLite::
1395       WriteMessageNoVirtualToArray(
1396         8, this->options(), target);
1397   }
1398
1399   // optional .google.protobuf.SourceCodeInfo source_code_info = 9;
1400   if (has_source_code_info()) {
1401     target = ::google::protobuf::internal::WireFormatLite::
1402       WriteMessageNoVirtualToArray(
1403         9, this->source_code_info(), target);
1404   }
1405
1406   // repeated int32 public_dependency = 10;
1407   for (int i = 0; i < this->public_dependency_size(); i++) {
1408     target = ::google::protobuf::internal::WireFormatLite::
1409       WriteInt32ToArray(10, this->public_dependency(i), target);
1410   }
1411
1412   // repeated int32 weak_dependency = 11;
1413   for (int i = 0; i < this->weak_dependency_size(); i++) {
1414     target = ::google::protobuf::internal::WireFormatLite::
1415       WriteInt32ToArray(11, this->weak_dependency(i), target);
1416   }
1417
1418   if (!unknown_fields().empty()) {
1419     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
1420         unknown_fields(), target);
1421   }
1422   return target;
1423 }
1424
1425 int FileDescriptorProto::ByteSize() const {
1426   int total_size = 0;
1427
1428   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1429     // optional string name = 1;
1430     if (has_name()) {
1431       total_size += 1 +
1432         ::google::protobuf::internal::WireFormatLite::StringSize(
1433           this->name());
1434     }
1435
1436     // optional string package = 2;
1437     if (has_package()) {
1438       total_size += 1 +
1439         ::google::protobuf::internal::WireFormatLite::StringSize(
1440           this->package());
1441     }
1442
1443   }
1444   if (_has_bits_[9 / 32] & (0xffu << (9 % 32))) {
1445     // optional .google.protobuf.FileOptions options = 8;
1446     if (has_options()) {
1447       total_size += 1 +
1448         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1449           this->options());
1450     }
1451
1452     // optional .google.protobuf.SourceCodeInfo source_code_info = 9;
1453     if (has_source_code_info()) {
1454       total_size += 1 +
1455         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1456           this->source_code_info());
1457     }
1458
1459   }
1460   // repeated string dependency = 3;
1461   total_size += 1 * this->dependency_size();
1462   for (int i = 0; i < this->dependency_size(); i++) {
1463     total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
1464       this->dependency(i));
1465   }
1466
1467   // repeated int32 public_dependency = 10;
1468   {
1469     int data_size = 0;
1470     for (int i = 0; i < this->public_dependency_size(); i++) {
1471       data_size += ::google::protobuf::internal::WireFormatLite::
1472         Int32Size(this->public_dependency(i));
1473     }
1474     total_size += 1 * this->public_dependency_size() + data_size;
1475   }
1476
1477   // repeated int32 weak_dependency = 11;
1478   {
1479     int data_size = 0;
1480     for (int i = 0; i < this->weak_dependency_size(); i++) {
1481       data_size += ::google::protobuf::internal::WireFormatLite::
1482         Int32Size(this->weak_dependency(i));
1483     }
1484     total_size += 1 * this->weak_dependency_size() + data_size;
1485   }
1486
1487   // repeated .google.protobuf.DescriptorProto message_type = 4;
1488   total_size += 1 * this->message_type_size();
1489   for (int i = 0; i < this->message_type_size(); i++) {
1490     total_size +=
1491       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1492         this->message_type(i));
1493   }
1494
1495   // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
1496   total_size += 1 * this->enum_type_size();
1497   for (int i = 0; i < this->enum_type_size(); i++) {
1498     total_size +=
1499       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1500         this->enum_type(i));
1501   }
1502
1503   // repeated .google.protobuf.ServiceDescriptorProto service = 6;
1504   total_size += 1 * this->service_size();
1505   for (int i = 0; i < this->service_size(); i++) {
1506     total_size +=
1507       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1508         this->service(i));
1509   }
1510
1511   // repeated .google.protobuf.FieldDescriptorProto extension = 7;
1512   total_size += 1 * this->extension_size();
1513   for (int i = 0; i < this->extension_size(); i++) {
1514     total_size +=
1515       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1516         this->extension(i));
1517   }
1518
1519   if (!unknown_fields().empty()) {
1520     total_size +=
1521       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
1522         unknown_fields());
1523   }
1524   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1525   _cached_size_ = total_size;
1526   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1527   return total_size;
1528 }
1529
1530 void FileDescriptorProto::MergeFrom(const ::google::protobuf::Message& from) {
1531   GOOGLE_CHECK_NE(&from, this);
1532   const FileDescriptorProto* source =
1533     ::google::protobuf::internal::dynamic_cast_if_available<const FileDescriptorProto*>(
1534       &from);
1535   if (source == NULL) {
1536     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1537   } else {
1538     MergeFrom(*source);
1539   }
1540 }
1541
1542 void FileDescriptorProto::MergeFrom(const FileDescriptorProto& from) {
1543   GOOGLE_CHECK_NE(&from, this);
1544   dependency_.MergeFrom(from.dependency_);
1545   public_dependency_.MergeFrom(from.public_dependency_);
1546   weak_dependency_.MergeFrom(from.weak_dependency_);
1547   message_type_.MergeFrom(from.message_type_);
1548   enum_type_.MergeFrom(from.enum_type_);
1549   service_.MergeFrom(from.service_);
1550   extension_.MergeFrom(from.extension_);
1551   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1552     if (from.has_name()) {
1553       set_name(from.name());
1554     }
1555     if (from.has_package()) {
1556       set_package(from.package());
1557     }
1558   }
1559   if (from._has_bits_[9 / 32] & (0xffu << (9 % 32))) {
1560     if (from.has_options()) {
1561       mutable_options()->::google::protobuf::FileOptions::MergeFrom(from.options());
1562     }
1563     if (from.has_source_code_info()) {
1564       mutable_source_code_info()->::google::protobuf::SourceCodeInfo::MergeFrom(from.source_code_info());
1565     }
1566   }
1567   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
1568 }
1569
1570 void FileDescriptorProto::CopyFrom(const ::google::protobuf::Message& from) {
1571   if (&from == this) return;
1572   Clear();
1573   MergeFrom(from);
1574 }
1575
1576 void FileDescriptorProto::CopyFrom(const FileDescriptorProto& from) {
1577   if (&from == this) return;
1578   Clear();
1579   MergeFrom(from);
1580 }
1581
1582 bool FileDescriptorProto::IsInitialized() const {
1583
1584   for (int i = 0; i < message_type_size(); i++) {
1585     if (!this->message_type(i).IsInitialized()) return false;
1586   }
1587   for (int i = 0; i < enum_type_size(); i++) {
1588     if (!this->enum_type(i).IsInitialized()) return false;
1589   }
1590   for (int i = 0; i < service_size(); i++) {
1591     if (!this->service(i).IsInitialized()) return false;
1592   }
1593   for (int i = 0; i < extension_size(); i++) {
1594     if (!this->extension(i).IsInitialized()) return false;
1595   }
1596   if (has_options()) {
1597     if (!this->options().IsInitialized()) return false;
1598   }
1599   return true;
1600 }
1601
1602 void FileDescriptorProto::Swap(FileDescriptorProto* other) {
1603   if (other != this) {
1604     std::swap(name_, other->name_);
1605     std::swap(package_, other->package_);
1606     dependency_.Swap(&other->dependency_);
1607     public_dependency_.Swap(&other->public_dependency_);
1608     weak_dependency_.Swap(&other->weak_dependency_);
1609     message_type_.Swap(&other->message_type_);
1610     enum_type_.Swap(&other->enum_type_);
1611     service_.Swap(&other->service_);
1612     extension_.Swap(&other->extension_);
1613     std::swap(options_, other->options_);
1614     std::swap(source_code_info_, other->source_code_info_);
1615     std::swap(_has_bits_[0], other->_has_bits_[0]);
1616     _unknown_fields_.Swap(&other->_unknown_fields_);
1617     std::swap(_cached_size_, other->_cached_size_);
1618   }
1619 }
1620
1621 ::google::protobuf::Metadata FileDescriptorProto::GetMetadata() const {
1622   protobuf_AssignDescriptorsOnce();
1623   ::google::protobuf::Metadata metadata;
1624   metadata.descriptor = FileDescriptorProto_descriptor_;
1625   metadata.reflection = FileDescriptorProto_reflection_;
1626   return metadata;
1627 }
1628
1629
1630 // ===================================================================
1631
1632 #ifndef _MSC_VER
1633 const int DescriptorProto_ExtensionRange::kStartFieldNumber;
1634 const int DescriptorProto_ExtensionRange::kEndFieldNumber;
1635 #endif  // !_MSC_VER
1636
1637 DescriptorProto_ExtensionRange::DescriptorProto_ExtensionRange()
1638   : ::google::protobuf::Message() {
1639   SharedCtor();
1640 }
1641
1642 void DescriptorProto_ExtensionRange::InitAsDefaultInstance() {
1643 }
1644
1645 DescriptorProto_ExtensionRange::DescriptorProto_ExtensionRange(const DescriptorProto_ExtensionRange& from)
1646   : ::google::protobuf::Message() {
1647   SharedCtor();
1648   MergeFrom(from);
1649 }
1650
1651 void DescriptorProto_ExtensionRange::SharedCtor() {
1652   _cached_size_ = 0;
1653   start_ = 0;
1654   end_ = 0;
1655   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1656 }
1657
1658 DescriptorProto_ExtensionRange::~DescriptorProto_ExtensionRange() {
1659   SharedDtor();
1660 }
1661
1662 void DescriptorProto_ExtensionRange::SharedDtor() {
1663   if (this != default_instance_) {
1664   }
1665 }
1666
1667 void DescriptorProto_ExtensionRange::SetCachedSize(int size) const {
1668   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1669   _cached_size_ = size;
1670   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1671 }
1672 const ::google::protobuf::Descriptor* DescriptorProto_ExtensionRange::descriptor() {
1673   protobuf_AssignDescriptorsOnce();
1674   return DescriptorProto_ExtensionRange_descriptor_;
1675 }
1676
1677 const DescriptorProto_ExtensionRange& DescriptorProto_ExtensionRange::default_instance() {
1678   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
1679   return *default_instance_;
1680 }
1681
1682 DescriptorProto_ExtensionRange* DescriptorProto_ExtensionRange::default_instance_ = NULL;
1683
1684 DescriptorProto_ExtensionRange* DescriptorProto_ExtensionRange::New() const {
1685   return new DescriptorProto_ExtensionRange;
1686 }
1687
1688 void DescriptorProto_ExtensionRange::Clear() {
1689   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1690     start_ = 0;
1691     end_ = 0;
1692   }
1693   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1694   mutable_unknown_fields()->Clear();
1695 }
1696
1697 bool DescriptorProto_ExtensionRange::MergePartialFromCodedStream(
1698     ::google::protobuf::io::CodedInputStream* input) {
1699 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
1700   ::google::protobuf::uint32 tag;
1701   while ((tag = input->ReadTag()) != 0) {
1702     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1703       // optional int32 start = 1;
1704       case 1: {
1705         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1706             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1707           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1708                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
1709                  input, &start_)));
1710           set_has_start();
1711         } else {
1712           goto handle_uninterpreted;
1713         }
1714         if (input->ExpectTag(16)) goto parse_end;
1715         break;
1716       }
1717
1718       // optional int32 end = 2;
1719       case 2: {
1720         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1721             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1722          parse_end:
1723           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1724                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
1725                  input, &end_)));
1726           set_has_end();
1727         } else {
1728           goto handle_uninterpreted;
1729         }
1730         if (input->ExpectAtEnd()) return true;
1731         break;
1732       }
1733
1734       default: {
1735       handle_uninterpreted:
1736         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1737             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
1738           return true;
1739         }
1740         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
1741               input, tag, mutable_unknown_fields()));
1742         break;
1743       }
1744     }
1745   }
1746   return true;
1747 #undef DO_
1748 }
1749
1750 void DescriptorProto_ExtensionRange::SerializeWithCachedSizes(
1751     ::google::protobuf::io::CodedOutputStream* output) const {
1752   // optional int32 start = 1;
1753   if (has_start()) {
1754     ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->start(), output);
1755   }
1756
1757   // optional int32 end = 2;
1758   if (has_end()) {
1759     ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->end(), output);
1760   }
1761
1762   if (!unknown_fields().empty()) {
1763     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
1764         unknown_fields(), output);
1765   }
1766 }
1767
1768 ::google::protobuf::uint8* DescriptorProto_ExtensionRange::SerializeWithCachedSizesToArray(
1769     ::google::protobuf::uint8* target) const {
1770   // optional int32 start = 1;
1771   if (has_start()) {
1772     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->start(), target);
1773   }
1774
1775   // optional int32 end = 2;
1776   if (has_end()) {
1777     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->end(), target);
1778   }
1779
1780   if (!unknown_fields().empty()) {
1781     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
1782         unknown_fields(), target);
1783   }
1784   return target;
1785 }
1786
1787 int DescriptorProto_ExtensionRange::ByteSize() const {
1788   int total_size = 0;
1789
1790   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1791     // optional int32 start = 1;
1792     if (has_start()) {
1793       total_size += 1 +
1794         ::google::protobuf::internal::WireFormatLite::Int32Size(
1795           this->start());
1796     }
1797
1798     // optional int32 end = 2;
1799     if (has_end()) {
1800       total_size += 1 +
1801         ::google::protobuf::internal::WireFormatLite::Int32Size(
1802           this->end());
1803     }
1804
1805   }
1806   if (!unknown_fields().empty()) {
1807     total_size +=
1808       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
1809         unknown_fields());
1810   }
1811   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1812   _cached_size_ = total_size;
1813   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1814   return total_size;
1815 }
1816
1817 void DescriptorProto_ExtensionRange::MergeFrom(const ::google::protobuf::Message& from) {
1818   GOOGLE_CHECK_NE(&from, this);
1819   const DescriptorProto_ExtensionRange* source =
1820     ::google::protobuf::internal::dynamic_cast_if_available<const DescriptorProto_ExtensionRange*>(
1821       &from);
1822   if (source == NULL) {
1823     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1824   } else {
1825     MergeFrom(*source);
1826   }
1827 }
1828
1829 void DescriptorProto_ExtensionRange::MergeFrom(const DescriptorProto_ExtensionRange& from) {
1830   GOOGLE_CHECK_NE(&from, this);
1831   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1832     if (from.has_start()) {
1833       set_start(from.start());
1834     }
1835     if (from.has_end()) {
1836       set_end(from.end());
1837     }
1838   }
1839   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
1840 }
1841
1842 void DescriptorProto_ExtensionRange::CopyFrom(const ::google::protobuf::Message& from) {
1843   if (&from == this) return;
1844   Clear();
1845   MergeFrom(from);
1846 }
1847
1848 void DescriptorProto_ExtensionRange::CopyFrom(const DescriptorProto_ExtensionRange& from) {
1849   if (&from == this) return;
1850   Clear();
1851   MergeFrom(from);
1852 }
1853
1854 bool DescriptorProto_ExtensionRange::IsInitialized() const {
1855
1856   return true;
1857 }
1858
1859 void DescriptorProto_ExtensionRange::Swap(DescriptorProto_ExtensionRange* other) {
1860   if (other != this) {
1861     std::swap(start_, other->start_);
1862     std::swap(end_, other->end_);
1863     std::swap(_has_bits_[0], other->_has_bits_[0]);
1864     _unknown_fields_.Swap(&other->_unknown_fields_);
1865     std::swap(_cached_size_, other->_cached_size_);
1866   }
1867 }
1868
1869 ::google::protobuf::Metadata DescriptorProto_ExtensionRange::GetMetadata() const {
1870   protobuf_AssignDescriptorsOnce();
1871   ::google::protobuf::Metadata metadata;
1872   metadata.descriptor = DescriptorProto_ExtensionRange_descriptor_;
1873   metadata.reflection = DescriptorProto_ExtensionRange_reflection_;
1874   return metadata;
1875 }
1876
1877
1878 // -------------------------------------------------------------------
1879
1880 #ifndef _MSC_VER
1881 const int DescriptorProto::kNameFieldNumber;
1882 const int DescriptorProto::kFieldFieldNumber;
1883 const int DescriptorProto::kExtensionFieldNumber;
1884 const int DescriptorProto::kNestedTypeFieldNumber;
1885 const int DescriptorProto::kEnumTypeFieldNumber;
1886 const int DescriptorProto::kExtensionRangeFieldNumber;
1887 const int DescriptorProto::kOptionsFieldNumber;
1888 #endif  // !_MSC_VER
1889
1890 DescriptorProto::DescriptorProto()
1891   : ::google::protobuf::Message() {
1892   SharedCtor();
1893 }
1894
1895 void DescriptorProto::InitAsDefaultInstance() {
1896   options_ = const_cast< ::google::protobuf::MessageOptions*>(&::google::protobuf::MessageOptions::default_instance());
1897 }
1898
1899 DescriptorProto::DescriptorProto(const DescriptorProto& from)
1900   : ::google::protobuf::Message() {
1901   SharedCtor();
1902   MergeFrom(from);
1903 }
1904
1905 void DescriptorProto::SharedCtor() {
1906   _cached_size_ = 0;
1907   name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1908   options_ = NULL;
1909   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1910 }
1911
1912 DescriptorProto::~DescriptorProto() {
1913   SharedDtor();
1914 }
1915
1916 void DescriptorProto::SharedDtor() {
1917   if (name_ != &::google::protobuf::internal::GetEmptyString()) {
1918     delete name_;
1919   }
1920   if (this != default_instance_) {
1921     delete options_;
1922   }
1923 }
1924
1925 void DescriptorProto::SetCachedSize(int size) const {
1926   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1927   _cached_size_ = size;
1928   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1929 }
1930 const ::google::protobuf::Descriptor* DescriptorProto::descriptor() {
1931   protobuf_AssignDescriptorsOnce();
1932   return DescriptorProto_descriptor_;
1933 }
1934
1935 const DescriptorProto& DescriptorProto::default_instance() {
1936   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
1937   return *default_instance_;
1938 }
1939
1940 DescriptorProto* DescriptorProto::default_instance_ = NULL;
1941
1942 DescriptorProto* DescriptorProto::New() const {
1943   return new DescriptorProto;
1944 }
1945
1946 void DescriptorProto::Clear() {
1947   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1948     if (has_name()) {
1949       if (name_ != &::google::protobuf::internal::GetEmptyString()) {
1950         name_->clear();
1951       }
1952     }
1953     if (has_options()) {
1954       if (options_ != NULL) options_->::google::protobuf::MessageOptions::Clear();
1955     }
1956   }
1957   field_.Clear();
1958   extension_.Clear();
1959   nested_type_.Clear();
1960   enum_type_.Clear();
1961   extension_range_.Clear();
1962   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1963   mutable_unknown_fields()->Clear();
1964 }
1965
1966 bool DescriptorProto::MergePartialFromCodedStream(
1967     ::google::protobuf::io::CodedInputStream* input) {
1968 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
1969   ::google::protobuf::uint32 tag;
1970   while ((tag = input->ReadTag()) != 0) {
1971     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1972       // optional string name = 1;
1973       case 1: {
1974         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1975             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1976           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1977                 input, this->mutable_name()));
1978           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1979             this->name().data(), this->name().length(),
1980             ::google::protobuf::internal::WireFormat::PARSE);
1981         } else {
1982           goto handle_uninterpreted;
1983         }
1984         if (input->ExpectTag(18)) goto parse_field;
1985         break;
1986       }
1987
1988       // repeated .google.protobuf.FieldDescriptorProto field = 2;
1989       case 2: {
1990         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1991             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1992          parse_field:
1993           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1994                 input, add_field()));
1995         } else {
1996           goto handle_uninterpreted;
1997         }
1998         if (input->ExpectTag(18)) goto parse_field;
1999         if (input->ExpectTag(26)) goto parse_nested_type;
2000         break;
2001       }
2002
2003       // repeated .google.protobuf.DescriptorProto nested_type = 3;
2004       case 3: {
2005         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2006             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2007          parse_nested_type:
2008           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
2009                 input, add_nested_type()));
2010         } else {
2011           goto handle_uninterpreted;
2012         }
2013         if (input->ExpectTag(26)) goto parse_nested_type;
2014         if (input->ExpectTag(34)) goto parse_enum_type;
2015         break;
2016       }
2017
2018       // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
2019       case 4: {
2020         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2021             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2022          parse_enum_type:
2023           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
2024                 input, add_enum_type()));
2025         } else {
2026           goto handle_uninterpreted;
2027         }
2028         if (input->ExpectTag(34)) goto parse_enum_type;
2029         if (input->ExpectTag(42)) goto parse_extension_range;
2030         break;
2031       }
2032
2033       // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
2034       case 5: {
2035         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2036             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2037          parse_extension_range:
2038           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
2039                 input, add_extension_range()));
2040         } else {
2041           goto handle_uninterpreted;
2042         }
2043         if (input->ExpectTag(42)) goto parse_extension_range;
2044         if (input->ExpectTag(50)) goto parse_extension;
2045         break;
2046       }
2047
2048       // repeated .google.protobuf.FieldDescriptorProto extension = 6;
2049       case 6: {
2050         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2051             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2052          parse_extension:
2053           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
2054                 input, add_extension()));
2055         } else {
2056           goto handle_uninterpreted;
2057         }
2058         if (input->ExpectTag(50)) goto parse_extension;
2059         if (input->ExpectTag(58)) goto parse_options;
2060         break;
2061       }
2062
2063       // optional .google.protobuf.MessageOptions options = 7;
2064       case 7: {
2065         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2066             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2067          parse_options:
2068           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
2069                input, mutable_options()));
2070         } else {
2071           goto handle_uninterpreted;
2072         }
2073         if (input->ExpectAtEnd()) return true;
2074         break;
2075       }
2076
2077       default: {
2078       handle_uninterpreted:
2079         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2080             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
2081           return true;
2082         }
2083         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
2084               input, tag, mutable_unknown_fields()));
2085         break;
2086       }
2087     }
2088   }
2089   return true;
2090 #undef DO_
2091 }
2092
2093 void DescriptorProto::SerializeWithCachedSizes(
2094     ::google::protobuf::io::CodedOutputStream* output) const {
2095   // optional string name = 1;
2096   if (has_name()) {
2097     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2098       this->name().data(), this->name().length(),
2099       ::google::protobuf::internal::WireFormat::SERIALIZE);
2100     ::google::protobuf::internal::WireFormatLite::WriteString(
2101       1, this->name(), output);
2102   }
2103
2104   // repeated .google.protobuf.FieldDescriptorProto field = 2;
2105   for (int i = 0; i < this->field_size(); i++) {
2106     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2107       2, this->field(i), output);
2108   }
2109
2110   // repeated .google.protobuf.DescriptorProto nested_type = 3;
2111   for (int i = 0; i < this->nested_type_size(); i++) {
2112     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2113       3, this->nested_type(i), output);
2114   }
2115
2116   // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
2117   for (int i = 0; i < this->enum_type_size(); i++) {
2118     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2119       4, this->enum_type(i), output);
2120   }
2121
2122   // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
2123   for (int i = 0; i < this->extension_range_size(); i++) {
2124     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2125       5, this->extension_range(i), output);
2126   }
2127
2128   // repeated .google.protobuf.FieldDescriptorProto extension = 6;
2129   for (int i = 0; i < this->extension_size(); i++) {
2130     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2131       6, this->extension(i), output);
2132   }
2133
2134   // optional .google.protobuf.MessageOptions options = 7;
2135   if (has_options()) {
2136     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2137       7, this->options(), output);
2138   }
2139
2140   if (!unknown_fields().empty()) {
2141     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
2142         unknown_fields(), output);
2143   }
2144 }
2145
2146 ::google::protobuf::uint8* DescriptorProto::SerializeWithCachedSizesToArray(
2147     ::google::protobuf::uint8* target) const {
2148   // optional string name = 1;
2149   if (has_name()) {
2150     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2151       this->name().data(), this->name().length(),
2152       ::google::protobuf::internal::WireFormat::SERIALIZE);
2153     target =
2154       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2155         1, this->name(), target);
2156   }
2157
2158   // repeated .google.protobuf.FieldDescriptorProto field = 2;
2159   for (int i = 0; i < this->field_size(); i++) {
2160     target = ::google::protobuf::internal::WireFormatLite::
2161       WriteMessageNoVirtualToArray(
2162         2, this->field(i), target);
2163   }
2164
2165   // repeated .google.protobuf.DescriptorProto nested_type = 3;
2166   for (int i = 0; i < this->nested_type_size(); i++) {
2167     target = ::google::protobuf::internal::WireFormatLite::
2168       WriteMessageNoVirtualToArray(
2169         3, this->nested_type(i), target);
2170   }
2171
2172   // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
2173   for (int i = 0; i < this->enum_type_size(); i++) {
2174     target = ::google::protobuf::internal::WireFormatLite::
2175       WriteMessageNoVirtualToArray(
2176         4, this->enum_type(i), target);
2177   }
2178
2179   // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
2180   for (int i = 0; i < this->extension_range_size(); i++) {
2181     target = ::google::protobuf::internal::WireFormatLite::
2182       WriteMessageNoVirtualToArray(
2183         5, this->extension_range(i), target);
2184   }
2185
2186   // repeated .google.protobuf.FieldDescriptorProto extension = 6;
2187   for (int i = 0; i < this->extension_size(); i++) {
2188     target = ::google::protobuf::internal::WireFormatLite::
2189       WriteMessageNoVirtualToArray(
2190         6, this->extension(i), target);
2191   }
2192
2193   // optional .google.protobuf.MessageOptions options = 7;
2194   if (has_options()) {
2195     target = ::google::protobuf::internal::WireFormatLite::
2196       WriteMessageNoVirtualToArray(
2197         7, this->options(), target);
2198   }
2199
2200   if (!unknown_fields().empty()) {
2201     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
2202         unknown_fields(), target);
2203   }
2204   return target;
2205 }
2206
2207 int DescriptorProto::ByteSize() const {
2208   int total_size = 0;
2209
2210   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2211     // optional string name = 1;
2212     if (has_name()) {
2213       total_size += 1 +
2214         ::google::protobuf::internal::WireFormatLite::StringSize(
2215           this->name());
2216     }
2217
2218     // optional .google.protobuf.MessageOptions options = 7;
2219     if (has_options()) {
2220       total_size += 1 +
2221         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
2222           this->options());
2223     }
2224
2225   }
2226   // repeated .google.protobuf.FieldDescriptorProto field = 2;
2227   total_size += 1 * this->field_size();
2228   for (int i = 0; i < this->field_size(); i++) {
2229     total_size +=
2230       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
2231         this->field(i));
2232   }
2233
2234   // repeated .google.protobuf.FieldDescriptorProto extension = 6;
2235   total_size += 1 * this->extension_size();
2236   for (int i = 0; i < this->extension_size(); i++) {
2237     total_size +=
2238       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
2239         this->extension(i));
2240   }
2241
2242   // repeated .google.protobuf.DescriptorProto nested_type = 3;
2243   total_size += 1 * this->nested_type_size();
2244   for (int i = 0; i < this->nested_type_size(); i++) {
2245     total_size +=
2246       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
2247         this->nested_type(i));
2248   }
2249
2250   // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
2251   total_size += 1 * this->enum_type_size();
2252   for (int i = 0; i < this->enum_type_size(); i++) {
2253     total_size +=
2254       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
2255         this->enum_type(i));
2256   }
2257
2258   // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
2259   total_size += 1 * this->extension_range_size();
2260   for (int i = 0; i < this->extension_range_size(); i++) {
2261     total_size +=
2262       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
2263         this->extension_range(i));
2264   }
2265
2266   if (!unknown_fields().empty()) {
2267     total_size +=
2268       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
2269         unknown_fields());
2270   }
2271   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2272   _cached_size_ = total_size;
2273   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2274   return total_size;
2275 }
2276
2277 void DescriptorProto::MergeFrom(const ::google::protobuf::Message& from) {
2278   GOOGLE_CHECK_NE(&from, this);
2279   const DescriptorProto* source =
2280     ::google::protobuf::internal::dynamic_cast_if_available<const DescriptorProto*>(
2281       &from);
2282   if (source == NULL) {
2283     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2284   } else {
2285     MergeFrom(*source);
2286   }
2287 }
2288
2289 void DescriptorProto::MergeFrom(const DescriptorProto& from) {
2290   GOOGLE_CHECK_NE(&from, this);
2291   field_.MergeFrom(from.field_);
2292   extension_.MergeFrom(from.extension_);
2293   nested_type_.MergeFrom(from.nested_type_);
2294   enum_type_.MergeFrom(from.enum_type_);
2295   extension_range_.MergeFrom(from.extension_range_);
2296   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2297     if (from.has_name()) {
2298       set_name(from.name());
2299     }
2300     if (from.has_options()) {
2301       mutable_options()->::google::protobuf::MessageOptions::MergeFrom(from.options());
2302     }
2303   }
2304   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
2305 }
2306
2307 void DescriptorProto::CopyFrom(const ::google::protobuf::Message& from) {
2308   if (&from == this) return;
2309   Clear();
2310   MergeFrom(from);
2311 }
2312
2313 void DescriptorProto::CopyFrom(const DescriptorProto& from) {
2314   if (&from == this) return;
2315   Clear();
2316   MergeFrom(from);
2317 }
2318
2319 bool DescriptorProto::IsInitialized() const {
2320
2321   for (int i = 0; i < field_size(); i++) {
2322     if (!this->field(i).IsInitialized()) return false;
2323   }
2324   for (int i = 0; i < extension_size(); i++) {
2325     if (!this->extension(i).IsInitialized()) return false;
2326   }
2327   for (int i = 0; i < nested_type_size(); i++) {
2328     if (!this->nested_type(i).IsInitialized()) return false;
2329   }
2330   for (int i = 0; i < enum_type_size(); i++) {
2331     if (!this->enum_type(i).IsInitialized()) return false;
2332   }
2333   if (has_options()) {
2334     if (!this->options().IsInitialized()) return false;
2335   }
2336   return true;
2337 }
2338
2339 void DescriptorProto::Swap(DescriptorProto* other) {
2340   if (other != this) {
2341     std::swap(name_, other->name_);
2342     field_.Swap(&other->field_);
2343     extension_.Swap(&other->extension_);
2344     nested_type_.Swap(&other->nested_type_);
2345     enum_type_.Swap(&other->enum_type_);
2346     extension_range_.Swap(&other->extension_range_);
2347     std::swap(options_, other->options_);
2348     std::swap(_has_bits_[0], other->_has_bits_[0]);
2349     _unknown_fields_.Swap(&other->_unknown_fields_);
2350     std::swap(_cached_size_, other->_cached_size_);
2351   }
2352 }
2353
2354 ::google::protobuf::Metadata DescriptorProto::GetMetadata() const {
2355   protobuf_AssignDescriptorsOnce();
2356   ::google::protobuf::Metadata metadata;
2357   metadata.descriptor = DescriptorProto_descriptor_;
2358   metadata.reflection = DescriptorProto_reflection_;
2359   return metadata;
2360 }
2361
2362
2363 // ===================================================================
2364
2365 const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Type_descriptor() {
2366   protobuf_AssignDescriptorsOnce();
2367   return FieldDescriptorProto_Type_descriptor_;
2368 }
2369 bool FieldDescriptorProto_Type_IsValid(int value) {
2370   switch(value) {
2371     case 1:
2372     case 2:
2373     case 3:
2374     case 4:
2375     case 5:
2376     case 6:
2377     case 7:
2378     case 8:
2379     case 9:
2380     case 10:
2381     case 11:
2382     case 12:
2383     case 13:
2384     case 14:
2385     case 15:
2386     case 16:
2387     case 17:
2388     case 18:
2389       return true;
2390     default:
2391       return false;
2392   }
2393 }
2394
2395 #ifndef _MSC_VER
2396 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_DOUBLE;
2397 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_FLOAT;
2398 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_INT64;
2399 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_UINT64;
2400 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_INT32;
2401 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_FIXED64;
2402 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_FIXED32;
2403 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_BOOL;
2404 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_STRING;
2405 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_GROUP;
2406 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_MESSAGE;
2407 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_BYTES;
2408 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_UINT32;
2409 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_ENUM;
2410 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_SFIXED32;
2411 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_SFIXED64;
2412 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_SINT32;
2413 const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_SINT64;
2414 const FieldDescriptorProto_Type FieldDescriptorProto::Type_MIN;
2415 const FieldDescriptorProto_Type FieldDescriptorProto::Type_MAX;
2416 const int FieldDescriptorProto::Type_ARRAYSIZE;
2417 #endif  // _MSC_VER
2418 const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Label_descriptor() {
2419   protobuf_AssignDescriptorsOnce();
2420   return FieldDescriptorProto_Label_descriptor_;
2421 }
2422 bool FieldDescriptorProto_Label_IsValid(int value) {
2423   switch(value) {
2424     case 1:
2425     case 2:
2426     case 3:
2427       return true;
2428     default:
2429       return false;
2430   }
2431 }
2432
2433 #ifndef _MSC_VER
2434 const FieldDescriptorProto_Label FieldDescriptorProto::LABEL_OPTIONAL;
2435 const FieldDescriptorProto_Label FieldDescriptorProto::LABEL_REQUIRED;
2436 const FieldDescriptorProto_Label FieldDescriptorProto::LABEL_REPEATED;
2437 const FieldDescriptorProto_Label FieldDescriptorProto::Label_MIN;
2438 const FieldDescriptorProto_Label FieldDescriptorProto::Label_MAX;
2439 const int FieldDescriptorProto::Label_ARRAYSIZE;
2440 #endif  // _MSC_VER
2441 #ifndef _MSC_VER
2442 const int FieldDescriptorProto::kNameFieldNumber;
2443 const int FieldDescriptorProto::kNumberFieldNumber;
2444 const int FieldDescriptorProto::kLabelFieldNumber;
2445 const int FieldDescriptorProto::kTypeFieldNumber;
2446 const int FieldDescriptorProto::kTypeNameFieldNumber;
2447 const int FieldDescriptorProto::kExtendeeFieldNumber;
2448 const int FieldDescriptorProto::kDefaultValueFieldNumber;
2449 const int FieldDescriptorProto::kOptionsFieldNumber;
2450 #endif  // !_MSC_VER
2451
2452 FieldDescriptorProto::FieldDescriptorProto()
2453   : ::google::protobuf::Message() {
2454   SharedCtor();
2455 }
2456
2457 void FieldDescriptorProto::InitAsDefaultInstance() {
2458   options_ = const_cast< ::google::protobuf::FieldOptions*>(&::google::protobuf::FieldOptions::default_instance());
2459 }
2460
2461 FieldDescriptorProto::FieldDescriptorProto(const FieldDescriptorProto& from)
2462   : ::google::protobuf::Message() {
2463   SharedCtor();
2464   MergeFrom(from);
2465 }
2466
2467 void FieldDescriptorProto::SharedCtor() {
2468   _cached_size_ = 0;
2469   name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
2470   number_ = 0;
2471   label_ = 1;
2472   type_ = 1;
2473   type_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
2474   extendee_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
2475   default_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
2476   options_ = NULL;
2477   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2478 }
2479
2480 FieldDescriptorProto::~FieldDescriptorProto() {
2481   SharedDtor();
2482 }
2483
2484 void FieldDescriptorProto::SharedDtor() {
2485   if (name_ != &::google::protobuf::internal::GetEmptyString()) {
2486     delete name_;
2487   }
2488   if (type_name_ != &::google::protobuf::internal::GetEmptyString()) {
2489     delete type_name_;
2490   }
2491   if (extendee_ != &::google::protobuf::internal::GetEmptyString()) {
2492     delete extendee_;
2493   }
2494   if (default_value_ != &::google::protobuf::internal::GetEmptyString()) {
2495     delete default_value_;
2496   }
2497   if (this != default_instance_) {
2498     delete options_;
2499   }
2500 }
2501
2502 void FieldDescriptorProto::SetCachedSize(int size) const {
2503   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2504   _cached_size_ = size;
2505   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2506 }
2507 const ::google::protobuf::Descriptor* FieldDescriptorProto::descriptor() {
2508   protobuf_AssignDescriptorsOnce();
2509   return FieldDescriptorProto_descriptor_;
2510 }
2511
2512 const FieldDescriptorProto& FieldDescriptorProto::default_instance() {
2513   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
2514   return *default_instance_;
2515 }
2516
2517 FieldDescriptorProto* FieldDescriptorProto::default_instance_ = NULL;
2518
2519 FieldDescriptorProto* FieldDescriptorProto::New() const {
2520   return new FieldDescriptorProto;
2521 }
2522
2523 void FieldDescriptorProto::Clear() {
2524   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2525     if (has_name()) {
2526       if (name_ != &::google::protobuf::internal::GetEmptyString()) {
2527         name_->clear();
2528       }
2529     }
2530     number_ = 0;
2531     label_ = 1;
2532     type_ = 1;
2533     if (has_type_name()) {
2534       if (type_name_ != &::google::protobuf::internal::GetEmptyString()) {
2535         type_name_->clear();
2536       }
2537     }
2538     if (has_extendee()) {
2539       if (extendee_ != &::google::protobuf::internal::GetEmptyString()) {
2540         extendee_->clear();
2541       }
2542     }
2543     if (has_default_value()) {
2544       if (default_value_ != &::google::protobuf::internal::GetEmptyString()) {
2545         default_value_->clear();
2546       }
2547     }
2548     if (has_options()) {
2549       if (options_ != NULL) options_->::google::protobuf::FieldOptions::Clear();
2550     }
2551   }
2552   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2553   mutable_unknown_fields()->Clear();
2554 }
2555
2556 bool FieldDescriptorProto::MergePartialFromCodedStream(
2557     ::google::protobuf::io::CodedInputStream* input) {
2558 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
2559   ::google::protobuf::uint32 tag;
2560   while ((tag = input->ReadTag()) != 0) {
2561     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
2562       // optional string name = 1;
2563       case 1: {
2564         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2565             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2566           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
2567                 input, this->mutable_name()));
2568           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2569             this->name().data(), this->name().length(),
2570             ::google::protobuf::internal::WireFormat::PARSE);
2571         } else {
2572           goto handle_uninterpreted;
2573         }
2574         if (input->ExpectTag(18)) goto parse_extendee;
2575         break;
2576       }
2577
2578       // optional string extendee = 2;
2579       case 2: {
2580         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2581             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2582          parse_extendee:
2583           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
2584                 input, this->mutable_extendee()));
2585           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2586             this->extendee().data(), this->extendee().length(),
2587             ::google::protobuf::internal::WireFormat::PARSE);
2588         } else {
2589           goto handle_uninterpreted;
2590         }
2591         if (input->ExpectTag(24)) goto parse_number;
2592         break;
2593       }
2594
2595       // optional int32 number = 3;
2596       case 3: {
2597         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2598             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2599          parse_number:
2600           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2601                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
2602                  input, &number_)));
2603           set_has_number();
2604         } else {
2605           goto handle_uninterpreted;
2606         }
2607         if (input->ExpectTag(32)) goto parse_label;
2608         break;
2609       }
2610
2611       // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
2612       case 4: {
2613         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2614             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2615          parse_label:
2616           int value;
2617           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2618                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
2619                  input, &value)));
2620           if (::google::protobuf::FieldDescriptorProto_Label_IsValid(value)) {
2621             set_label(static_cast< ::google::protobuf::FieldDescriptorProto_Label >(value));
2622           } else {
2623             mutable_unknown_fields()->AddVarint(4, value);
2624           }
2625         } else {
2626           goto handle_uninterpreted;
2627         }
2628         if (input->ExpectTag(40)) goto parse_type;
2629         break;
2630       }
2631
2632       // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
2633       case 5: {
2634         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2635             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2636          parse_type:
2637           int value;
2638           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2639                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
2640                  input, &value)));
2641           if (::google::protobuf::FieldDescriptorProto_Type_IsValid(value)) {
2642             set_type(static_cast< ::google::protobuf::FieldDescriptorProto_Type >(value));
2643           } else {
2644             mutable_unknown_fields()->AddVarint(5, value);
2645           }
2646         } else {
2647           goto handle_uninterpreted;
2648         }
2649         if (input->ExpectTag(50)) goto parse_type_name;
2650         break;
2651       }
2652
2653       // optional string type_name = 6;
2654       case 6: {
2655         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2656             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2657          parse_type_name:
2658           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
2659                 input, this->mutable_type_name()));
2660           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2661             this->type_name().data(), this->type_name().length(),
2662             ::google::protobuf::internal::WireFormat::PARSE);
2663         } else {
2664           goto handle_uninterpreted;
2665         }
2666         if (input->ExpectTag(58)) goto parse_default_value;
2667         break;
2668       }
2669
2670       // optional string default_value = 7;
2671       case 7: {
2672         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2673             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2674          parse_default_value:
2675           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
2676                 input, this->mutable_default_value()));
2677           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2678             this->default_value().data(), this->default_value().length(),
2679             ::google::protobuf::internal::WireFormat::PARSE);
2680         } else {
2681           goto handle_uninterpreted;
2682         }
2683         if (input->ExpectTag(66)) goto parse_options;
2684         break;
2685       }
2686
2687       // optional .google.protobuf.FieldOptions options = 8;
2688       case 8: {
2689         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2690             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2691          parse_options:
2692           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
2693                input, mutable_options()));
2694         } else {
2695           goto handle_uninterpreted;
2696         }
2697         if (input->ExpectAtEnd()) return true;
2698         break;
2699       }
2700
2701       default: {
2702       handle_uninterpreted:
2703         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2704             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
2705           return true;
2706         }
2707         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
2708               input, tag, mutable_unknown_fields()));
2709         break;
2710       }
2711     }
2712   }
2713   return true;
2714 #undef DO_
2715 }
2716
2717 void FieldDescriptorProto::SerializeWithCachedSizes(
2718     ::google::protobuf::io::CodedOutputStream* output) const {
2719   // optional string name = 1;
2720   if (has_name()) {
2721     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2722       this->name().data(), this->name().length(),
2723       ::google::protobuf::internal::WireFormat::SERIALIZE);
2724     ::google::protobuf::internal::WireFormatLite::WriteString(
2725       1, this->name(), output);
2726   }
2727
2728   // optional string extendee = 2;
2729   if (has_extendee()) {
2730     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2731       this->extendee().data(), this->extendee().length(),
2732       ::google::protobuf::internal::WireFormat::SERIALIZE);
2733     ::google::protobuf::internal::WireFormatLite::WriteString(
2734       2, this->extendee(), output);
2735   }
2736
2737   // optional int32 number = 3;
2738   if (has_number()) {
2739     ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->number(), output);
2740   }
2741
2742   // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
2743   if (has_label()) {
2744     ::google::protobuf::internal::WireFormatLite::WriteEnum(
2745       4, this->label(), output);
2746   }
2747
2748   // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
2749   if (has_type()) {
2750     ::google::protobuf::internal::WireFormatLite::WriteEnum(
2751       5, this->type(), output);
2752   }
2753
2754   // optional string type_name = 6;
2755   if (has_type_name()) {
2756     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2757       this->type_name().data(), this->type_name().length(),
2758       ::google::protobuf::internal::WireFormat::SERIALIZE);
2759     ::google::protobuf::internal::WireFormatLite::WriteString(
2760       6, this->type_name(), output);
2761   }
2762
2763   // optional string default_value = 7;
2764   if (has_default_value()) {
2765     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2766       this->default_value().data(), this->default_value().length(),
2767       ::google::protobuf::internal::WireFormat::SERIALIZE);
2768     ::google::protobuf::internal::WireFormatLite::WriteString(
2769       7, this->default_value(), output);
2770   }
2771
2772   // optional .google.protobuf.FieldOptions options = 8;
2773   if (has_options()) {
2774     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
2775       8, this->options(), output);
2776   }
2777
2778   if (!unknown_fields().empty()) {
2779     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
2780         unknown_fields(), output);
2781   }
2782 }
2783
2784 ::google::protobuf::uint8* FieldDescriptorProto::SerializeWithCachedSizesToArray(
2785     ::google::protobuf::uint8* target) const {
2786   // optional string name = 1;
2787   if (has_name()) {
2788     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2789       this->name().data(), this->name().length(),
2790       ::google::protobuf::internal::WireFormat::SERIALIZE);
2791     target =
2792       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2793         1, this->name(), target);
2794   }
2795
2796   // optional string extendee = 2;
2797   if (has_extendee()) {
2798     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2799       this->extendee().data(), this->extendee().length(),
2800       ::google::protobuf::internal::WireFormat::SERIALIZE);
2801     target =
2802       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2803         2, this->extendee(), target);
2804   }
2805
2806   // optional int32 number = 3;
2807   if (has_number()) {
2808     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->number(), target);
2809   }
2810
2811   // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
2812   if (has_label()) {
2813     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
2814       4, this->label(), target);
2815   }
2816
2817   // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
2818   if (has_type()) {
2819     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
2820       5, this->type(), target);
2821   }
2822
2823   // optional string type_name = 6;
2824   if (has_type_name()) {
2825     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2826       this->type_name().data(), this->type_name().length(),
2827       ::google::protobuf::internal::WireFormat::SERIALIZE);
2828     target =
2829       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2830         6, this->type_name(), target);
2831   }
2832
2833   // optional string default_value = 7;
2834   if (has_default_value()) {
2835     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
2836       this->default_value().data(), this->default_value().length(),
2837       ::google::protobuf::internal::WireFormat::SERIALIZE);
2838     target =
2839       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
2840         7, this->default_value(), target);
2841   }
2842
2843   // optional .google.protobuf.FieldOptions options = 8;
2844   if (has_options()) {
2845     target = ::google::protobuf::internal::WireFormatLite::
2846       WriteMessageNoVirtualToArray(
2847         8, this->options(), target);
2848   }
2849
2850   if (!unknown_fields().empty()) {
2851     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
2852         unknown_fields(), target);
2853   }
2854   return target;
2855 }
2856
2857 int FieldDescriptorProto::ByteSize() const {
2858   int total_size = 0;
2859
2860   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2861     // optional string name = 1;
2862     if (has_name()) {
2863       total_size += 1 +
2864         ::google::protobuf::internal::WireFormatLite::StringSize(
2865           this->name());
2866     }
2867
2868     // optional int32 number = 3;
2869     if (has_number()) {
2870       total_size += 1 +
2871         ::google::protobuf::internal::WireFormatLite::Int32Size(
2872           this->number());
2873     }
2874
2875     // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
2876     if (has_label()) {
2877       total_size += 1 +
2878         ::google::protobuf::internal::WireFormatLite::EnumSize(this->label());
2879     }
2880
2881     // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
2882     if (has_type()) {
2883       total_size += 1 +
2884         ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
2885     }
2886
2887     // optional string type_name = 6;
2888     if (has_type_name()) {
2889       total_size += 1 +
2890         ::google::protobuf::internal::WireFormatLite::StringSize(
2891           this->type_name());
2892     }
2893
2894     // optional string extendee = 2;
2895     if (has_extendee()) {
2896       total_size += 1 +
2897         ::google::protobuf::internal::WireFormatLite::StringSize(
2898           this->extendee());
2899     }
2900
2901     // optional string default_value = 7;
2902     if (has_default_value()) {
2903       total_size += 1 +
2904         ::google::protobuf::internal::WireFormatLite::StringSize(
2905           this->default_value());
2906     }
2907
2908     // optional .google.protobuf.FieldOptions options = 8;
2909     if (has_options()) {
2910       total_size += 1 +
2911         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
2912           this->options());
2913     }
2914
2915   }
2916   if (!unknown_fields().empty()) {
2917     total_size +=
2918       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
2919         unknown_fields());
2920   }
2921   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2922   _cached_size_ = total_size;
2923   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2924   return total_size;
2925 }
2926
2927 void FieldDescriptorProto::MergeFrom(const ::google::protobuf::Message& from) {
2928   GOOGLE_CHECK_NE(&from, this);
2929   const FieldDescriptorProto* source =
2930     ::google::protobuf::internal::dynamic_cast_if_available<const FieldDescriptorProto*>(
2931       &from);
2932   if (source == NULL) {
2933     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2934   } else {
2935     MergeFrom(*source);
2936   }
2937 }
2938
2939 void FieldDescriptorProto::MergeFrom(const FieldDescriptorProto& from) {
2940   GOOGLE_CHECK_NE(&from, this);
2941   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2942     if (from.has_name()) {
2943       set_name(from.name());
2944     }
2945     if (from.has_number()) {
2946       set_number(from.number());
2947     }
2948     if (from.has_label()) {
2949       set_label(from.label());
2950     }
2951     if (from.has_type()) {
2952       set_type(from.type());
2953     }
2954     if (from.has_type_name()) {
2955       set_type_name(from.type_name());
2956     }
2957     if (from.has_extendee()) {
2958       set_extendee(from.extendee());
2959     }
2960     if (from.has_default_value()) {
2961       set_default_value(from.default_value());
2962     }
2963     if (from.has_options()) {
2964       mutable_options()->::google::protobuf::FieldOptions::MergeFrom(from.options());
2965     }
2966   }
2967   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
2968 }
2969
2970 void FieldDescriptorProto::CopyFrom(const ::google::protobuf::Message& from) {
2971   if (&from == this) return;
2972   Clear();
2973   MergeFrom(from);
2974 }
2975
2976 void FieldDescriptorProto::CopyFrom(const FieldDescriptorProto& from) {
2977   if (&from == this) return;
2978   Clear();
2979   MergeFrom(from);
2980 }
2981
2982 bool FieldDescriptorProto::IsInitialized() const {
2983
2984   if (has_options()) {
2985     if (!this->options().IsInitialized()) return false;
2986   }
2987   return true;
2988 }
2989
2990 void FieldDescriptorProto::Swap(FieldDescriptorProto* other) {
2991   if (other != this) {
2992     std::swap(name_, other->name_);
2993     std::swap(number_, other->number_);
2994     std::swap(label_, other->label_);
2995     std::swap(type_, other->type_);
2996     std::swap(type_name_, other->type_name_);
2997     std::swap(extendee_, other->extendee_);
2998     std::swap(default_value_, other->default_value_);
2999     std::swap(options_, other->options_);
3000     std::swap(_has_bits_[0], other->_has_bits_[0]);
3001     _unknown_fields_.Swap(&other->_unknown_fields_);
3002     std::swap(_cached_size_, other->_cached_size_);
3003   }
3004 }
3005
3006 ::google::protobuf::Metadata FieldDescriptorProto::GetMetadata() const {
3007   protobuf_AssignDescriptorsOnce();
3008   ::google::protobuf::Metadata metadata;
3009   metadata.descriptor = FieldDescriptorProto_descriptor_;
3010   metadata.reflection = FieldDescriptorProto_reflection_;
3011   return metadata;
3012 }
3013
3014
3015 // ===================================================================
3016
3017 #ifndef _MSC_VER
3018 const int EnumDescriptorProto::kNameFieldNumber;
3019 const int EnumDescriptorProto::kValueFieldNumber;
3020 const int EnumDescriptorProto::kOptionsFieldNumber;
3021 #endif  // !_MSC_VER
3022
3023 EnumDescriptorProto::EnumDescriptorProto()
3024   : ::google::protobuf::Message() {
3025   SharedCtor();
3026 }
3027
3028 void EnumDescriptorProto::InitAsDefaultInstance() {
3029   options_ = const_cast< ::google::protobuf::EnumOptions*>(&::google::protobuf::EnumOptions::default_instance());
3030 }
3031
3032 EnumDescriptorProto::EnumDescriptorProto(const EnumDescriptorProto& from)
3033   : ::google::protobuf::Message() {
3034   SharedCtor();
3035   MergeFrom(from);
3036 }
3037
3038 void EnumDescriptorProto::SharedCtor() {
3039   _cached_size_ = 0;
3040   name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
3041   options_ = NULL;
3042   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3043 }
3044
3045 EnumDescriptorProto::~EnumDescriptorProto() {
3046   SharedDtor();
3047 }
3048
3049 void EnumDescriptorProto::SharedDtor() {
3050   if (name_ != &::google::protobuf::internal::GetEmptyString()) {
3051     delete name_;
3052   }
3053   if (this != default_instance_) {
3054     delete options_;
3055   }
3056 }
3057
3058 void EnumDescriptorProto::SetCachedSize(int size) const {
3059   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3060   _cached_size_ = size;
3061   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3062 }
3063 const ::google::protobuf::Descriptor* EnumDescriptorProto::descriptor() {
3064   protobuf_AssignDescriptorsOnce();
3065   return EnumDescriptorProto_descriptor_;
3066 }
3067
3068 const EnumDescriptorProto& EnumDescriptorProto::default_instance() {
3069   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
3070   return *default_instance_;
3071 }
3072
3073 EnumDescriptorProto* EnumDescriptorProto::default_instance_ = NULL;
3074
3075 EnumDescriptorProto* EnumDescriptorProto::New() const {
3076   return new EnumDescriptorProto;
3077 }
3078
3079 void EnumDescriptorProto::Clear() {
3080   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3081     if (has_name()) {
3082       if (name_ != &::google::protobuf::internal::GetEmptyString()) {
3083         name_->clear();
3084       }
3085     }
3086     if (has_options()) {
3087       if (options_ != NULL) options_->::google::protobuf::EnumOptions::Clear();
3088     }
3089   }
3090   value_.Clear();
3091   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3092   mutable_unknown_fields()->Clear();
3093 }
3094
3095 bool EnumDescriptorProto::MergePartialFromCodedStream(
3096     ::google::protobuf::io::CodedInputStream* input) {
3097 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
3098   ::google::protobuf::uint32 tag;
3099   while ((tag = input->ReadTag()) != 0) {
3100     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
3101       // optional string name = 1;
3102       case 1: {
3103         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3104             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
3105           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
3106                 input, this->mutable_name()));
3107           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3108             this->name().data(), this->name().length(),
3109             ::google::protobuf::internal::WireFormat::PARSE);
3110         } else {
3111           goto handle_uninterpreted;
3112         }
3113         if (input->ExpectTag(18)) goto parse_value;
3114         break;
3115       }
3116
3117       // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
3118       case 2: {
3119         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3120             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
3121          parse_value:
3122           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
3123                 input, add_value()));
3124         } else {
3125           goto handle_uninterpreted;
3126         }
3127         if (input->ExpectTag(18)) goto parse_value;
3128         if (input->ExpectTag(26)) goto parse_options;
3129         break;
3130       }
3131
3132       // optional .google.protobuf.EnumOptions options = 3;
3133       case 3: {
3134         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3135             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
3136          parse_options:
3137           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
3138                input, mutable_options()));
3139         } else {
3140           goto handle_uninterpreted;
3141         }
3142         if (input->ExpectAtEnd()) return true;
3143         break;
3144       }
3145
3146       default: {
3147       handle_uninterpreted:
3148         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3149             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
3150           return true;
3151         }
3152         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
3153               input, tag, mutable_unknown_fields()));
3154         break;
3155       }
3156     }
3157   }
3158   return true;
3159 #undef DO_
3160 }
3161
3162 void EnumDescriptorProto::SerializeWithCachedSizes(
3163     ::google::protobuf::io::CodedOutputStream* output) const {
3164   // optional string name = 1;
3165   if (has_name()) {
3166     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3167       this->name().data(), this->name().length(),
3168       ::google::protobuf::internal::WireFormat::SERIALIZE);
3169     ::google::protobuf::internal::WireFormatLite::WriteString(
3170       1, this->name(), output);
3171   }
3172
3173   // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
3174   for (int i = 0; i < this->value_size(); i++) {
3175     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
3176       2, this->value(i), output);
3177   }
3178
3179   // optional .google.protobuf.EnumOptions options = 3;
3180   if (has_options()) {
3181     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
3182       3, this->options(), output);
3183   }
3184
3185   if (!unknown_fields().empty()) {
3186     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
3187         unknown_fields(), output);
3188   }
3189 }
3190
3191 ::google::protobuf::uint8* EnumDescriptorProto::SerializeWithCachedSizesToArray(
3192     ::google::protobuf::uint8* target) const {
3193   // optional string name = 1;
3194   if (has_name()) {
3195     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3196       this->name().data(), this->name().length(),
3197       ::google::protobuf::internal::WireFormat::SERIALIZE);
3198     target =
3199       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3200         1, this->name(), target);
3201   }
3202
3203   // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
3204   for (int i = 0; i < this->value_size(); i++) {
3205     target = ::google::protobuf::internal::WireFormatLite::
3206       WriteMessageNoVirtualToArray(
3207         2, this->value(i), target);
3208   }
3209
3210   // optional .google.protobuf.EnumOptions options = 3;
3211   if (has_options()) {
3212     target = ::google::protobuf::internal::WireFormatLite::
3213       WriteMessageNoVirtualToArray(
3214         3, this->options(), target);
3215   }
3216
3217   if (!unknown_fields().empty()) {
3218     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
3219         unknown_fields(), target);
3220   }
3221   return target;
3222 }
3223
3224 int EnumDescriptorProto::ByteSize() const {
3225   int total_size = 0;
3226
3227   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3228     // optional string name = 1;
3229     if (has_name()) {
3230       total_size += 1 +
3231         ::google::protobuf::internal::WireFormatLite::StringSize(
3232           this->name());
3233     }
3234
3235     // optional .google.protobuf.EnumOptions options = 3;
3236     if (has_options()) {
3237       total_size += 1 +
3238         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
3239           this->options());
3240     }
3241
3242   }
3243   // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
3244   total_size += 1 * this->value_size();
3245   for (int i = 0; i < this->value_size(); i++) {
3246     total_size +=
3247       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
3248         this->value(i));
3249   }
3250
3251   if (!unknown_fields().empty()) {
3252     total_size +=
3253       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
3254         unknown_fields());
3255   }
3256   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3257   _cached_size_ = total_size;
3258   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3259   return total_size;
3260 }
3261
3262 void EnumDescriptorProto::MergeFrom(const ::google::protobuf::Message& from) {
3263   GOOGLE_CHECK_NE(&from, this);
3264   const EnumDescriptorProto* source =
3265     ::google::protobuf::internal::dynamic_cast_if_available<const EnumDescriptorProto*>(
3266       &from);
3267   if (source == NULL) {
3268     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
3269   } else {
3270     MergeFrom(*source);
3271   }
3272 }
3273
3274 void EnumDescriptorProto::MergeFrom(const EnumDescriptorProto& from) {
3275   GOOGLE_CHECK_NE(&from, this);
3276   value_.MergeFrom(from.value_);
3277   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3278     if (from.has_name()) {
3279       set_name(from.name());
3280     }
3281     if (from.has_options()) {
3282       mutable_options()->::google::protobuf::EnumOptions::MergeFrom(from.options());
3283     }
3284   }
3285   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
3286 }
3287
3288 void EnumDescriptorProto::CopyFrom(const ::google::protobuf::Message& from) {
3289   if (&from == this) return;
3290   Clear();
3291   MergeFrom(from);
3292 }
3293
3294 void EnumDescriptorProto::CopyFrom(const EnumDescriptorProto& from) {
3295   if (&from == this) return;
3296   Clear();
3297   MergeFrom(from);
3298 }
3299
3300 bool EnumDescriptorProto::IsInitialized() const {
3301
3302   for (int i = 0; i < value_size(); i++) {
3303     if (!this->value(i).IsInitialized()) return false;
3304   }
3305   if (has_options()) {
3306     if (!this->options().IsInitialized()) return false;
3307   }
3308   return true;
3309 }
3310
3311 void EnumDescriptorProto::Swap(EnumDescriptorProto* other) {
3312   if (other != this) {
3313     std::swap(name_, other->name_);
3314     value_.Swap(&other->value_);
3315     std::swap(options_, other->options_);
3316     std::swap(_has_bits_[0], other->_has_bits_[0]);
3317     _unknown_fields_.Swap(&other->_unknown_fields_);
3318     std::swap(_cached_size_, other->_cached_size_);
3319   }
3320 }
3321
3322 ::google::protobuf::Metadata EnumDescriptorProto::GetMetadata() const {
3323   protobuf_AssignDescriptorsOnce();
3324   ::google::protobuf::Metadata metadata;
3325   metadata.descriptor = EnumDescriptorProto_descriptor_;
3326   metadata.reflection = EnumDescriptorProto_reflection_;
3327   return metadata;
3328 }
3329
3330
3331 // ===================================================================
3332
3333 #ifndef _MSC_VER
3334 const int EnumValueDescriptorProto::kNameFieldNumber;
3335 const int EnumValueDescriptorProto::kNumberFieldNumber;
3336 const int EnumValueDescriptorProto::kOptionsFieldNumber;
3337 #endif  // !_MSC_VER
3338
3339 EnumValueDescriptorProto::EnumValueDescriptorProto()
3340   : ::google::protobuf::Message() {
3341   SharedCtor();
3342 }
3343
3344 void EnumValueDescriptorProto::InitAsDefaultInstance() {
3345   options_ = const_cast< ::google::protobuf::EnumValueOptions*>(&::google::protobuf::EnumValueOptions::default_instance());
3346 }
3347
3348 EnumValueDescriptorProto::EnumValueDescriptorProto(const EnumValueDescriptorProto& from)
3349   : ::google::protobuf::Message() {
3350   SharedCtor();
3351   MergeFrom(from);
3352 }
3353
3354 void EnumValueDescriptorProto::SharedCtor() {
3355   _cached_size_ = 0;
3356   name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
3357   number_ = 0;
3358   options_ = NULL;
3359   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3360 }
3361
3362 EnumValueDescriptorProto::~EnumValueDescriptorProto() {
3363   SharedDtor();
3364 }
3365
3366 void EnumValueDescriptorProto::SharedDtor() {
3367   if (name_ != &::google::protobuf::internal::GetEmptyString()) {
3368     delete name_;
3369   }
3370   if (this != default_instance_) {
3371     delete options_;
3372   }
3373 }
3374
3375 void EnumValueDescriptorProto::SetCachedSize(int size) const {
3376   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3377   _cached_size_ = size;
3378   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3379 }
3380 const ::google::protobuf::Descriptor* EnumValueDescriptorProto::descriptor() {
3381   protobuf_AssignDescriptorsOnce();
3382   return EnumValueDescriptorProto_descriptor_;
3383 }
3384
3385 const EnumValueDescriptorProto& EnumValueDescriptorProto::default_instance() {
3386   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
3387   return *default_instance_;
3388 }
3389
3390 EnumValueDescriptorProto* EnumValueDescriptorProto::default_instance_ = NULL;
3391
3392 EnumValueDescriptorProto* EnumValueDescriptorProto::New() const {
3393   return new EnumValueDescriptorProto;
3394 }
3395
3396 void EnumValueDescriptorProto::Clear() {
3397   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3398     if (has_name()) {
3399       if (name_ != &::google::protobuf::internal::GetEmptyString()) {
3400         name_->clear();
3401       }
3402     }
3403     number_ = 0;
3404     if (has_options()) {
3405       if (options_ != NULL) options_->::google::protobuf::EnumValueOptions::Clear();
3406     }
3407   }
3408   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3409   mutable_unknown_fields()->Clear();
3410 }
3411
3412 bool EnumValueDescriptorProto::MergePartialFromCodedStream(
3413     ::google::protobuf::io::CodedInputStream* input) {
3414 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
3415   ::google::protobuf::uint32 tag;
3416   while ((tag = input->ReadTag()) != 0) {
3417     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
3418       // optional string name = 1;
3419       case 1: {
3420         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3421             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
3422           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
3423                 input, this->mutable_name()));
3424           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3425             this->name().data(), this->name().length(),
3426             ::google::protobuf::internal::WireFormat::PARSE);
3427         } else {
3428           goto handle_uninterpreted;
3429         }
3430         if (input->ExpectTag(16)) goto parse_number;
3431         break;
3432       }
3433
3434       // optional int32 number = 2;
3435       case 2: {
3436         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3437             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
3438          parse_number:
3439           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
3440                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
3441                  input, &number_)));
3442           set_has_number();
3443         } else {
3444           goto handle_uninterpreted;
3445         }
3446         if (input->ExpectTag(26)) goto parse_options;
3447         break;
3448       }
3449
3450       // optional .google.protobuf.EnumValueOptions options = 3;
3451       case 3: {
3452         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3453             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
3454          parse_options:
3455           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
3456                input, mutable_options()));
3457         } else {
3458           goto handle_uninterpreted;
3459         }
3460         if (input->ExpectAtEnd()) return true;
3461         break;
3462       }
3463
3464       default: {
3465       handle_uninterpreted:
3466         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3467             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
3468           return true;
3469         }
3470         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
3471               input, tag, mutable_unknown_fields()));
3472         break;
3473       }
3474     }
3475   }
3476   return true;
3477 #undef DO_
3478 }
3479
3480 void EnumValueDescriptorProto::SerializeWithCachedSizes(
3481     ::google::protobuf::io::CodedOutputStream* output) const {
3482   // optional string name = 1;
3483   if (has_name()) {
3484     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3485       this->name().data(), this->name().length(),
3486       ::google::protobuf::internal::WireFormat::SERIALIZE);
3487     ::google::protobuf::internal::WireFormatLite::WriteString(
3488       1, this->name(), output);
3489   }
3490
3491   // optional int32 number = 2;
3492   if (has_number()) {
3493     ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->number(), output);
3494   }
3495
3496   // optional .google.protobuf.EnumValueOptions options = 3;
3497   if (has_options()) {
3498     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
3499       3, this->options(), output);
3500   }
3501
3502   if (!unknown_fields().empty()) {
3503     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
3504         unknown_fields(), output);
3505   }
3506 }
3507
3508 ::google::protobuf::uint8* EnumValueDescriptorProto::SerializeWithCachedSizesToArray(
3509     ::google::protobuf::uint8* target) const {
3510   // optional string name = 1;
3511   if (has_name()) {
3512     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3513       this->name().data(), this->name().length(),
3514       ::google::protobuf::internal::WireFormat::SERIALIZE);
3515     target =
3516       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3517         1, this->name(), target);
3518   }
3519
3520   // optional int32 number = 2;
3521   if (has_number()) {
3522     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->number(), target);
3523   }
3524
3525   // optional .google.protobuf.EnumValueOptions options = 3;
3526   if (has_options()) {
3527     target = ::google::protobuf::internal::WireFormatLite::
3528       WriteMessageNoVirtualToArray(
3529         3, this->options(), target);
3530   }
3531
3532   if (!unknown_fields().empty()) {
3533     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
3534         unknown_fields(), target);
3535   }
3536   return target;
3537 }
3538
3539 int EnumValueDescriptorProto::ByteSize() const {
3540   int total_size = 0;
3541
3542   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3543     // optional string name = 1;
3544     if (has_name()) {
3545       total_size += 1 +
3546         ::google::protobuf::internal::WireFormatLite::StringSize(
3547           this->name());
3548     }
3549
3550     // optional int32 number = 2;
3551     if (has_number()) {
3552       total_size += 1 +
3553         ::google::protobuf::internal::WireFormatLite::Int32Size(
3554           this->number());
3555     }
3556
3557     // optional .google.protobuf.EnumValueOptions options = 3;
3558     if (has_options()) {
3559       total_size += 1 +
3560         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
3561           this->options());
3562     }
3563
3564   }
3565   if (!unknown_fields().empty()) {
3566     total_size +=
3567       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
3568         unknown_fields());
3569   }
3570   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3571   _cached_size_ = total_size;
3572   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3573   return total_size;
3574 }
3575
3576 void EnumValueDescriptorProto::MergeFrom(const ::google::protobuf::Message& from) {
3577   GOOGLE_CHECK_NE(&from, this);
3578   const EnumValueDescriptorProto* source =
3579     ::google::protobuf::internal::dynamic_cast_if_available<const EnumValueDescriptorProto*>(
3580       &from);
3581   if (source == NULL) {
3582     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
3583   } else {
3584     MergeFrom(*source);
3585   }
3586 }
3587
3588 void EnumValueDescriptorProto::MergeFrom(const EnumValueDescriptorProto& from) {
3589   GOOGLE_CHECK_NE(&from, this);
3590   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3591     if (from.has_name()) {
3592       set_name(from.name());
3593     }
3594     if (from.has_number()) {
3595       set_number(from.number());
3596     }
3597     if (from.has_options()) {
3598       mutable_options()->::google::protobuf::EnumValueOptions::MergeFrom(from.options());
3599     }
3600   }
3601   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
3602 }
3603
3604 void EnumValueDescriptorProto::CopyFrom(const ::google::protobuf::Message& from) {
3605   if (&from == this) return;
3606   Clear();
3607   MergeFrom(from);
3608 }
3609
3610 void EnumValueDescriptorProto::CopyFrom(const EnumValueDescriptorProto& from) {
3611   if (&from == this) return;
3612   Clear();
3613   MergeFrom(from);
3614 }
3615
3616 bool EnumValueDescriptorProto::IsInitialized() const {
3617
3618   if (has_options()) {
3619     if (!this->options().IsInitialized()) return false;
3620   }
3621   return true;
3622 }
3623
3624 void EnumValueDescriptorProto::Swap(EnumValueDescriptorProto* other) {
3625   if (other != this) {
3626     std::swap(name_, other->name_);
3627     std::swap(number_, other->number_);
3628     std::swap(options_, other->options_);
3629     std::swap(_has_bits_[0], other->_has_bits_[0]);
3630     _unknown_fields_.Swap(&other->_unknown_fields_);
3631     std::swap(_cached_size_, other->_cached_size_);
3632   }
3633 }
3634
3635 ::google::protobuf::Metadata EnumValueDescriptorProto::GetMetadata() const {
3636   protobuf_AssignDescriptorsOnce();
3637   ::google::protobuf::Metadata metadata;
3638   metadata.descriptor = EnumValueDescriptorProto_descriptor_;
3639   metadata.reflection = EnumValueDescriptorProto_reflection_;
3640   return metadata;
3641 }
3642
3643
3644 // ===================================================================
3645
3646 #ifndef _MSC_VER
3647 const int ServiceDescriptorProto::kNameFieldNumber;
3648 const int ServiceDescriptorProto::kMethodFieldNumber;
3649 const int ServiceDescriptorProto::kOptionsFieldNumber;
3650 #endif  // !_MSC_VER
3651
3652 ServiceDescriptorProto::ServiceDescriptorProto()
3653   : ::google::protobuf::Message() {
3654   SharedCtor();
3655 }
3656
3657 void ServiceDescriptorProto::InitAsDefaultInstance() {
3658   options_ = const_cast< ::google::protobuf::ServiceOptions*>(&::google::protobuf::ServiceOptions::default_instance());
3659 }
3660
3661 ServiceDescriptorProto::ServiceDescriptorProto(const ServiceDescriptorProto& from)
3662   : ::google::protobuf::Message() {
3663   SharedCtor();
3664   MergeFrom(from);
3665 }
3666
3667 void ServiceDescriptorProto::SharedCtor() {
3668   _cached_size_ = 0;
3669   name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
3670   options_ = NULL;
3671   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3672 }
3673
3674 ServiceDescriptorProto::~ServiceDescriptorProto() {
3675   SharedDtor();
3676 }
3677
3678 void ServiceDescriptorProto::SharedDtor() {
3679   if (name_ != &::google::protobuf::internal::GetEmptyString()) {
3680     delete name_;
3681   }
3682   if (this != default_instance_) {
3683     delete options_;
3684   }
3685 }
3686
3687 void ServiceDescriptorProto::SetCachedSize(int size) const {
3688   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3689   _cached_size_ = size;
3690   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3691 }
3692 const ::google::protobuf::Descriptor* ServiceDescriptorProto::descriptor() {
3693   protobuf_AssignDescriptorsOnce();
3694   return ServiceDescriptorProto_descriptor_;
3695 }
3696
3697 const ServiceDescriptorProto& ServiceDescriptorProto::default_instance() {
3698   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
3699   return *default_instance_;
3700 }
3701
3702 ServiceDescriptorProto* ServiceDescriptorProto::default_instance_ = NULL;
3703
3704 ServiceDescriptorProto* ServiceDescriptorProto::New() const {
3705   return new ServiceDescriptorProto;
3706 }
3707
3708 void ServiceDescriptorProto::Clear() {
3709   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3710     if (has_name()) {
3711       if (name_ != &::google::protobuf::internal::GetEmptyString()) {
3712         name_->clear();
3713       }
3714     }
3715     if (has_options()) {
3716       if (options_ != NULL) options_->::google::protobuf::ServiceOptions::Clear();
3717     }
3718   }
3719   method_.Clear();
3720   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3721   mutable_unknown_fields()->Clear();
3722 }
3723
3724 bool ServiceDescriptorProto::MergePartialFromCodedStream(
3725     ::google::protobuf::io::CodedInputStream* input) {
3726 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
3727   ::google::protobuf::uint32 tag;
3728   while ((tag = input->ReadTag()) != 0) {
3729     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
3730       // optional string name = 1;
3731       case 1: {
3732         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3733             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
3734           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
3735                 input, this->mutable_name()));
3736           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3737             this->name().data(), this->name().length(),
3738             ::google::protobuf::internal::WireFormat::PARSE);
3739         } else {
3740           goto handle_uninterpreted;
3741         }
3742         if (input->ExpectTag(18)) goto parse_method;
3743         break;
3744       }
3745
3746       // repeated .google.protobuf.MethodDescriptorProto method = 2;
3747       case 2: {
3748         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3749             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
3750          parse_method:
3751           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
3752                 input, add_method()));
3753         } else {
3754           goto handle_uninterpreted;
3755         }
3756         if (input->ExpectTag(18)) goto parse_method;
3757         if (input->ExpectTag(26)) goto parse_options;
3758         break;
3759       }
3760
3761       // optional .google.protobuf.ServiceOptions options = 3;
3762       case 3: {
3763         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3764             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
3765          parse_options:
3766           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
3767                input, mutable_options()));
3768         } else {
3769           goto handle_uninterpreted;
3770         }
3771         if (input->ExpectAtEnd()) return true;
3772         break;
3773       }
3774
3775       default: {
3776       handle_uninterpreted:
3777         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3778             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
3779           return true;
3780         }
3781         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
3782               input, tag, mutable_unknown_fields()));
3783         break;
3784       }
3785     }
3786   }
3787   return true;
3788 #undef DO_
3789 }
3790
3791 void ServiceDescriptorProto::SerializeWithCachedSizes(
3792     ::google::protobuf::io::CodedOutputStream* output) const {
3793   // optional string name = 1;
3794   if (has_name()) {
3795     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3796       this->name().data(), this->name().length(),
3797       ::google::protobuf::internal::WireFormat::SERIALIZE);
3798     ::google::protobuf::internal::WireFormatLite::WriteString(
3799       1, this->name(), output);
3800   }
3801
3802   // repeated .google.protobuf.MethodDescriptorProto method = 2;
3803   for (int i = 0; i < this->method_size(); i++) {
3804     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
3805       2, this->method(i), output);
3806   }
3807
3808   // optional .google.protobuf.ServiceOptions options = 3;
3809   if (has_options()) {
3810     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
3811       3, this->options(), output);
3812   }
3813
3814   if (!unknown_fields().empty()) {
3815     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
3816         unknown_fields(), output);
3817   }
3818 }
3819
3820 ::google::protobuf::uint8* ServiceDescriptorProto::SerializeWithCachedSizesToArray(
3821     ::google::protobuf::uint8* target) const {
3822   // optional string name = 1;
3823   if (has_name()) {
3824     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
3825       this->name().data(), this->name().length(),
3826       ::google::protobuf::internal::WireFormat::SERIALIZE);
3827     target =
3828       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
3829         1, this->name(), target);
3830   }
3831
3832   // repeated .google.protobuf.MethodDescriptorProto method = 2;
3833   for (int i = 0; i < this->method_size(); i++) {
3834     target = ::google::protobuf::internal::WireFormatLite::
3835       WriteMessageNoVirtualToArray(
3836         2, this->method(i), target);
3837   }
3838
3839   // optional .google.protobuf.ServiceOptions options = 3;
3840   if (has_options()) {
3841     target = ::google::protobuf::internal::WireFormatLite::
3842       WriteMessageNoVirtualToArray(
3843         3, this->options(), target);
3844   }
3845
3846   if (!unknown_fields().empty()) {
3847     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
3848         unknown_fields(), target);
3849   }
3850   return target;
3851 }
3852
3853 int ServiceDescriptorProto::ByteSize() const {
3854   int total_size = 0;
3855
3856   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3857     // optional string name = 1;
3858     if (has_name()) {
3859       total_size += 1 +
3860         ::google::protobuf::internal::WireFormatLite::StringSize(
3861           this->name());
3862     }
3863
3864     // optional .google.protobuf.ServiceOptions options = 3;
3865     if (has_options()) {
3866       total_size += 1 +
3867         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
3868           this->options());
3869     }
3870
3871   }
3872   // repeated .google.protobuf.MethodDescriptorProto method = 2;
3873   total_size += 1 * this->method_size();
3874   for (int i = 0; i < this->method_size(); i++) {
3875     total_size +=
3876       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
3877         this->method(i));
3878   }
3879
3880   if (!unknown_fields().empty()) {
3881     total_size +=
3882       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
3883         unknown_fields());
3884   }
3885   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
3886   _cached_size_ = total_size;
3887   GOOGLE_SAFE_CONCURRENT_WRITES_END();
3888   return total_size;
3889 }
3890
3891 void ServiceDescriptorProto::MergeFrom(const ::google::protobuf::Message& from) {
3892   GOOGLE_CHECK_NE(&from, this);
3893   const ServiceDescriptorProto* source =
3894     ::google::protobuf::internal::dynamic_cast_if_available<const ServiceDescriptorProto*>(
3895       &from);
3896   if (source == NULL) {
3897     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
3898   } else {
3899     MergeFrom(*source);
3900   }
3901 }
3902
3903 void ServiceDescriptorProto::MergeFrom(const ServiceDescriptorProto& from) {
3904   GOOGLE_CHECK_NE(&from, this);
3905   method_.MergeFrom(from.method_);
3906   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3907     if (from.has_name()) {
3908       set_name(from.name());
3909     }
3910     if (from.has_options()) {
3911       mutable_options()->::google::protobuf::ServiceOptions::MergeFrom(from.options());
3912     }
3913   }
3914   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
3915 }
3916
3917 void ServiceDescriptorProto::CopyFrom(const ::google::protobuf::Message& from) {
3918   if (&from == this) return;
3919   Clear();
3920   MergeFrom(from);
3921 }
3922
3923 void ServiceDescriptorProto::CopyFrom(const ServiceDescriptorProto& from) {
3924   if (&from == this) return;
3925   Clear();
3926   MergeFrom(from);
3927 }
3928
3929 bool ServiceDescriptorProto::IsInitialized() const {
3930
3931   for (int i = 0; i < method_size(); i++) {
3932     if (!this->method(i).IsInitialized()) return false;
3933   }
3934   if (has_options()) {
3935     if (!this->options().IsInitialized()) return false;
3936   }
3937   return true;
3938 }
3939
3940 void ServiceDescriptorProto::Swap(ServiceDescriptorProto* other) {
3941   if (other != this) {
3942     std::swap(name_, other->name_);
3943     method_.Swap(&other->method_);
3944     std::swap(options_, other->options_);
3945     std::swap(_has_bits_[0], other->_has_bits_[0]);
3946     _unknown_fields_.Swap(&other->_unknown_fields_);
3947     std::swap(_cached_size_, other->_cached_size_);
3948   }
3949 }
3950
3951 ::google::protobuf::Metadata ServiceDescriptorProto::GetMetadata() const {
3952   protobuf_AssignDescriptorsOnce();
3953   ::google::protobuf::Metadata metadata;
3954   metadata.descriptor = ServiceDescriptorProto_descriptor_;
3955   metadata.reflection = ServiceDescriptorProto_reflection_;
3956   return metadata;
3957 }
3958
3959
3960 // ===================================================================
3961
3962 #ifndef _MSC_VER
3963 const int MethodDescriptorProto::kNameFieldNumber;
3964 const int MethodDescriptorProto::kInputTypeFieldNumber;
3965 const int MethodDescriptorProto::kOutputTypeFieldNumber;
3966 const int MethodDescriptorProto::kOptionsFieldNumber;
3967 #endif  // !_MSC_VER
3968
3969 MethodDescriptorProto::MethodDescriptorProto()
3970   : ::google::protobuf::Message() {
3971   SharedCtor();
3972 }
3973
3974 void MethodDescriptorProto::InitAsDefaultInstance() {
3975   options_ = const_cast< ::google::protobuf::MethodOptions*>(&::google::protobuf::MethodOptions::default_instance());
3976 }
3977
3978 MethodDescriptorProto::MethodDescriptorProto(const MethodDescriptorProto& from)
3979   : ::google::protobuf::Message() {
3980   SharedCtor();
3981   MergeFrom(from);
3982 }
3983
3984 void MethodDescriptorProto::SharedCtor() {
3985   _cached_size_ = 0;
3986   name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
3987   input_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
3988   output_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
3989   options_ = NULL;
3990   ::memset(_has_bits_, 0, sizeof(_has_bits_));
3991 }
3992
3993 MethodDescriptorProto::~MethodDescriptorProto() {
3994   SharedDtor();
3995 }
3996
3997 void MethodDescriptorProto::SharedDtor() {
3998   if (name_ != &::google::protobuf::internal::GetEmptyString()) {
3999     delete name_;
4000   }
4001   if (input_type_ != &::google::protobuf::internal::GetEmptyString()) {
4002     delete input_type_;
4003   }
4004   if (output_type_ != &::google::protobuf::internal::GetEmptyString()) {
4005     delete output_type_;
4006   }
4007   if (this != default_instance_) {
4008     delete options_;
4009   }
4010 }
4011
4012 void MethodDescriptorProto::SetCachedSize(int size) const {
4013   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
4014   _cached_size_ = size;
4015   GOOGLE_SAFE_CONCURRENT_WRITES_END();
4016 }
4017 const ::google::protobuf::Descriptor* MethodDescriptorProto::descriptor() {
4018   protobuf_AssignDescriptorsOnce();
4019   return MethodDescriptorProto_descriptor_;
4020 }
4021
4022 const MethodDescriptorProto& MethodDescriptorProto::default_instance() {
4023   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
4024   return *default_instance_;
4025 }
4026
4027 MethodDescriptorProto* MethodDescriptorProto::default_instance_ = NULL;
4028
4029 MethodDescriptorProto* MethodDescriptorProto::New() const {
4030   return new MethodDescriptorProto;
4031 }
4032
4033 void MethodDescriptorProto::Clear() {
4034   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4035     if (has_name()) {
4036       if (name_ != &::google::protobuf::internal::GetEmptyString()) {
4037         name_->clear();
4038       }
4039     }
4040     if (has_input_type()) {
4041       if (input_type_ != &::google::protobuf::internal::GetEmptyString()) {
4042         input_type_->clear();
4043       }
4044     }
4045     if (has_output_type()) {
4046       if (output_type_ != &::google::protobuf::internal::GetEmptyString()) {
4047         output_type_->clear();
4048       }
4049     }
4050     if (has_options()) {
4051       if (options_ != NULL) options_->::google::protobuf::MethodOptions::Clear();
4052     }
4053   }
4054   ::memset(_has_bits_, 0, sizeof(_has_bits_));
4055   mutable_unknown_fields()->Clear();
4056 }
4057
4058 bool MethodDescriptorProto::MergePartialFromCodedStream(
4059     ::google::protobuf::io::CodedInputStream* input) {
4060 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
4061   ::google::protobuf::uint32 tag;
4062   while ((tag = input->ReadTag()) != 0) {
4063     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
4064       // optional string name = 1;
4065       case 1: {
4066         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4067             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
4068           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
4069                 input, this->mutable_name()));
4070           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4071             this->name().data(), this->name().length(),
4072             ::google::protobuf::internal::WireFormat::PARSE);
4073         } else {
4074           goto handle_uninterpreted;
4075         }
4076         if (input->ExpectTag(18)) goto parse_input_type;
4077         break;
4078       }
4079
4080       // optional string input_type = 2;
4081       case 2: {
4082         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4083             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
4084          parse_input_type:
4085           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
4086                 input, this->mutable_input_type()));
4087           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4088             this->input_type().data(), this->input_type().length(),
4089             ::google::protobuf::internal::WireFormat::PARSE);
4090         } else {
4091           goto handle_uninterpreted;
4092         }
4093         if (input->ExpectTag(26)) goto parse_output_type;
4094         break;
4095       }
4096
4097       // optional string output_type = 3;
4098       case 3: {
4099         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4100             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
4101          parse_output_type:
4102           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
4103                 input, this->mutable_output_type()));
4104           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4105             this->output_type().data(), this->output_type().length(),
4106             ::google::protobuf::internal::WireFormat::PARSE);
4107         } else {
4108           goto handle_uninterpreted;
4109         }
4110         if (input->ExpectTag(34)) goto parse_options;
4111         break;
4112       }
4113
4114       // optional .google.protobuf.MethodOptions options = 4;
4115       case 4: {
4116         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4117             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
4118          parse_options:
4119           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
4120                input, mutable_options()));
4121         } else {
4122           goto handle_uninterpreted;
4123         }
4124         if (input->ExpectAtEnd()) return true;
4125         break;
4126       }
4127
4128       default: {
4129       handle_uninterpreted:
4130         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4131             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
4132           return true;
4133         }
4134         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
4135               input, tag, mutable_unknown_fields()));
4136         break;
4137       }
4138     }
4139   }
4140   return true;
4141 #undef DO_
4142 }
4143
4144 void MethodDescriptorProto::SerializeWithCachedSizes(
4145     ::google::protobuf::io::CodedOutputStream* output) const {
4146   // optional string name = 1;
4147   if (has_name()) {
4148     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4149       this->name().data(), this->name().length(),
4150       ::google::protobuf::internal::WireFormat::SERIALIZE);
4151     ::google::protobuf::internal::WireFormatLite::WriteString(
4152       1, this->name(), output);
4153   }
4154
4155   // optional string input_type = 2;
4156   if (has_input_type()) {
4157     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4158       this->input_type().data(), this->input_type().length(),
4159       ::google::protobuf::internal::WireFormat::SERIALIZE);
4160     ::google::protobuf::internal::WireFormatLite::WriteString(
4161       2, this->input_type(), output);
4162   }
4163
4164   // optional string output_type = 3;
4165   if (has_output_type()) {
4166     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4167       this->output_type().data(), this->output_type().length(),
4168       ::google::protobuf::internal::WireFormat::SERIALIZE);
4169     ::google::protobuf::internal::WireFormatLite::WriteString(
4170       3, this->output_type(), output);
4171   }
4172
4173   // optional .google.protobuf.MethodOptions options = 4;
4174   if (has_options()) {
4175     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
4176       4, this->options(), output);
4177   }
4178
4179   if (!unknown_fields().empty()) {
4180     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
4181         unknown_fields(), output);
4182   }
4183 }
4184
4185 ::google::protobuf::uint8* MethodDescriptorProto::SerializeWithCachedSizesToArray(
4186     ::google::protobuf::uint8* target) const {
4187   // optional string name = 1;
4188   if (has_name()) {
4189     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4190       this->name().data(), this->name().length(),
4191       ::google::protobuf::internal::WireFormat::SERIALIZE);
4192     target =
4193       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4194         1, this->name(), target);
4195   }
4196
4197   // optional string input_type = 2;
4198   if (has_input_type()) {
4199     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4200       this->input_type().data(), this->input_type().length(),
4201       ::google::protobuf::internal::WireFormat::SERIALIZE);
4202     target =
4203       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4204         2, this->input_type(), target);
4205   }
4206
4207   // optional string output_type = 3;
4208   if (has_output_type()) {
4209     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4210       this->output_type().data(), this->output_type().length(),
4211       ::google::protobuf::internal::WireFormat::SERIALIZE);
4212     target =
4213       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4214         3, this->output_type(), target);
4215   }
4216
4217   // optional .google.protobuf.MethodOptions options = 4;
4218   if (has_options()) {
4219     target = ::google::protobuf::internal::WireFormatLite::
4220       WriteMessageNoVirtualToArray(
4221         4, this->options(), target);
4222   }
4223
4224   if (!unknown_fields().empty()) {
4225     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
4226         unknown_fields(), target);
4227   }
4228   return target;
4229 }
4230
4231 int MethodDescriptorProto::ByteSize() const {
4232   int total_size = 0;
4233
4234   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4235     // optional string name = 1;
4236     if (has_name()) {
4237       total_size += 1 +
4238         ::google::protobuf::internal::WireFormatLite::StringSize(
4239           this->name());
4240     }
4241
4242     // optional string input_type = 2;
4243     if (has_input_type()) {
4244       total_size += 1 +
4245         ::google::protobuf::internal::WireFormatLite::StringSize(
4246           this->input_type());
4247     }
4248
4249     // optional string output_type = 3;
4250     if (has_output_type()) {
4251       total_size += 1 +
4252         ::google::protobuf::internal::WireFormatLite::StringSize(
4253           this->output_type());
4254     }
4255
4256     // optional .google.protobuf.MethodOptions options = 4;
4257     if (has_options()) {
4258       total_size += 1 +
4259         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
4260           this->options());
4261     }
4262
4263   }
4264   if (!unknown_fields().empty()) {
4265     total_size +=
4266       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
4267         unknown_fields());
4268   }
4269   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
4270   _cached_size_ = total_size;
4271   GOOGLE_SAFE_CONCURRENT_WRITES_END();
4272   return total_size;
4273 }
4274
4275 void MethodDescriptorProto::MergeFrom(const ::google::protobuf::Message& from) {
4276   GOOGLE_CHECK_NE(&from, this);
4277   const MethodDescriptorProto* source =
4278     ::google::protobuf::internal::dynamic_cast_if_available<const MethodDescriptorProto*>(
4279       &from);
4280   if (source == NULL) {
4281     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
4282   } else {
4283     MergeFrom(*source);
4284   }
4285 }
4286
4287 void MethodDescriptorProto::MergeFrom(const MethodDescriptorProto& from) {
4288   GOOGLE_CHECK_NE(&from, this);
4289   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4290     if (from.has_name()) {
4291       set_name(from.name());
4292     }
4293     if (from.has_input_type()) {
4294       set_input_type(from.input_type());
4295     }
4296     if (from.has_output_type()) {
4297       set_output_type(from.output_type());
4298     }
4299     if (from.has_options()) {
4300       mutable_options()->::google::protobuf::MethodOptions::MergeFrom(from.options());
4301     }
4302   }
4303   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
4304 }
4305
4306 void MethodDescriptorProto::CopyFrom(const ::google::protobuf::Message& from) {
4307   if (&from == this) return;
4308   Clear();
4309   MergeFrom(from);
4310 }
4311
4312 void MethodDescriptorProto::CopyFrom(const MethodDescriptorProto& from) {
4313   if (&from == this) return;
4314   Clear();
4315   MergeFrom(from);
4316 }
4317
4318 bool MethodDescriptorProto::IsInitialized() const {
4319
4320   if (has_options()) {
4321     if (!this->options().IsInitialized()) return false;
4322   }
4323   return true;
4324 }
4325
4326 void MethodDescriptorProto::Swap(MethodDescriptorProto* other) {
4327   if (other != this) {
4328     std::swap(name_, other->name_);
4329     std::swap(input_type_, other->input_type_);
4330     std::swap(output_type_, other->output_type_);
4331     std::swap(options_, other->options_);
4332     std::swap(_has_bits_[0], other->_has_bits_[0]);
4333     _unknown_fields_.Swap(&other->_unknown_fields_);
4334     std::swap(_cached_size_, other->_cached_size_);
4335   }
4336 }
4337
4338 ::google::protobuf::Metadata MethodDescriptorProto::GetMetadata() const {
4339   protobuf_AssignDescriptorsOnce();
4340   ::google::protobuf::Metadata metadata;
4341   metadata.descriptor = MethodDescriptorProto_descriptor_;
4342   metadata.reflection = MethodDescriptorProto_reflection_;
4343   return metadata;
4344 }
4345
4346
4347 // ===================================================================
4348
4349 const ::google::protobuf::EnumDescriptor* FileOptions_OptimizeMode_descriptor() {
4350   protobuf_AssignDescriptorsOnce();
4351   return FileOptions_OptimizeMode_descriptor_;
4352 }
4353 bool FileOptions_OptimizeMode_IsValid(int value) {
4354   switch(value) {
4355     case 1:
4356     case 2:
4357     case 3:
4358       return true;
4359     default:
4360       return false;
4361   }
4362 }
4363
4364 #ifndef _MSC_VER
4365 const FileOptions_OptimizeMode FileOptions::SPEED;
4366 const FileOptions_OptimizeMode FileOptions::CODE_SIZE;
4367 const FileOptions_OptimizeMode FileOptions::LITE_RUNTIME;
4368 const FileOptions_OptimizeMode FileOptions::OptimizeMode_MIN;
4369 const FileOptions_OptimizeMode FileOptions::OptimizeMode_MAX;
4370 const int FileOptions::OptimizeMode_ARRAYSIZE;
4371 #endif  // _MSC_VER
4372 #ifndef _MSC_VER
4373 const int FileOptions::kJavaPackageFieldNumber;
4374 const int FileOptions::kJavaOuterClassnameFieldNumber;
4375 const int FileOptions::kJavaMultipleFilesFieldNumber;
4376 const int FileOptions::kRetainUnknownFieldsFieldNumber;
4377 const int FileOptions::kJavaGenerateEqualsAndHashFieldNumber;
4378 const int FileOptions::kOptimizeForFieldNumber;
4379 const int FileOptions::kGoPackageFieldNumber;
4380 const int FileOptions::kCcGenericServicesFieldNumber;
4381 const int FileOptions::kJavaGenericServicesFieldNumber;
4382 const int FileOptions::kPyGenericServicesFieldNumber;
4383 const int FileOptions::kUninterpretedOptionFieldNumber;
4384 #endif  // !_MSC_VER
4385
4386 FileOptions::FileOptions()
4387   : ::google::protobuf::Message() {
4388   SharedCtor();
4389 }
4390
4391 void FileOptions::InitAsDefaultInstance() {
4392 }
4393
4394 FileOptions::FileOptions(const FileOptions& from)
4395   : ::google::protobuf::Message() {
4396   SharedCtor();
4397   MergeFrom(from);
4398 }
4399
4400 void FileOptions::SharedCtor() {
4401   _cached_size_ = 0;
4402   java_package_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
4403   java_outer_classname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
4404   java_multiple_files_ = false;
4405   retain_unknown_fields_ = false;
4406   java_generate_equals_and_hash_ = false;
4407   optimize_for_ = 1;
4408   go_package_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
4409   cc_generic_services_ = false;
4410   java_generic_services_ = false;
4411   py_generic_services_ = false;
4412   ::memset(_has_bits_, 0, sizeof(_has_bits_));
4413 }
4414
4415 FileOptions::~FileOptions() {
4416   SharedDtor();
4417 }
4418
4419 void FileOptions::SharedDtor() {
4420   if (java_package_ != &::google::protobuf::internal::GetEmptyString()) {
4421     delete java_package_;
4422   }
4423   if (java_outer_classname_ != &::google::protobuf::internal::GetEmptyString()) {
4424     delete java_outer_classname_;
4425   }
4426   if (go_package_ != &::google::protobuf::internal::GetEmptyString()) {
4427     delete go_package_;
4428   }
4429   if (this != default_instance_) {
4430   }
4431 }
4432
4433 void FileOptions::SetCachedSize(int size) const {
4434   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
4435   _cached_size_ = size;
4436   GOOGLE_SAFE_CONCURRENT_WRITES_END();
4437 }
4438 const ::google::protobuf::Descriptor* FileOptions::descriptor() {
4439   protobuf_AssignDescriptorsOnce();
4440   return FileOptions_descriptor_;
4441 }
4442
4443 const FileOptions& FileOptions::default_instance() {
4444   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
4445   return *default_instance_;
4446 }
4447
4448 FileOptions* FileOptions::default_instance_ = NULL;
4449
4450 FileOptions* FileOptions::New() const {
4451   return new FileOptions;
4452 }
4453
4454 void FileOptions::Clear() {
4455   _extensions_.Clear();
4456   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4457     if (has_java_package()) {
4458       if (java_package_ != &::google::protobuf::internal::GetEmptyString()) {
4459         java_package_->clear();
4460       }
4461     }
4462     if (has_java_outer_classname()) {
4463       if (java_outer_classname_ != &::google::protobuf::internal::GetEmptyString()) {
4464         java_outer_classname_->clear();
4465       }
4466     }
4467     java_multiple_files_ = false;
4468     retain_unknown_fields_ = false;
4469     java_generate_equals_and_hash_ = false;
4470     optimize_for_ = 1;
4471     if (has_go_package()) {
4472       if (go_package_ != &::google::protobuf::internal::GetEmptyString()) {
4473         go_package_->clear();
4474       }
4475     }
4476     cc_generic_services_ = false;
4477   }
4478   if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
4479     java_generic_services_ = false;
4480     py_generic_services_ = false;
4481   }
4482   uninterpreted_option_.Clear();
4483   ::memset(_has_bits_, 0, sizeof(_has_bits_));
4484   mutable_unknown_fields()->Clear();
4485 }
4486
4487 bool FileOptions::MergePartialFromCodedStream(
4488     ::google::protobuf::io::CodedInputStream* input) {
4489 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
4490   ::google::protobuf::uint32 tag;
4491   while ((tag = input->ReadTag()) != 0) {
4492     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
4493       // optional string java_package = 1;
4494       case 1: {
4495         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4496             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
4497           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
4498                 input, this->mutable_java_package()));
4499           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4500             this->java_package().data(), this->java_package().length(),
4501             ::google::protobuf::internal::WireFormat::PARSE);
4502         } else {
4503           goto handle_uninterpreted;
4504         }
4505         if (input->ExpectTag(66)) goto parse_java_outer_classname;
4506         break;
4507       }
4508
4509       // optional string java_outer_classname = 8;
4510       case 8: {
4511         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4512             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
4513          parse_java_outer_classname:
4514           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
4515                 input, this->mutable_java_outer_classname()));
4516           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4517             this->java_outer_classname().data(), this->java_outer_classname().length(),
4518             ::google::protobuf::internal::WireFormat::PARSE);
4519         } else {
4520           goto handle_uninterpreted;
4521         }
4522         if (input->ExpectTag(72)) goto parse_optimize_for;
4523         break;
4524       }
4525
4526       // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
4527       case 9: {
4528         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4529             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
4530          parse_optimize_for:
4531           int value;
4532           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
4533                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
4534                  input, &value)));
4535           if (::google::protobuf::FileOptions_OptimizeMode_IsValid(value)) {
4536             set_optimize_for(static_cast< ::google::protobuf::FileOptions_OptimizeMode >(value));
4537           } else {
4538             mutable_unknown_fields()->AddVarint(9, value);
4539           }
4540         } else {
4541           goto handle_uninterpreted;
4542         }
4543         if (input->ExpectTag(80)) goto parse_java_multiple_files;
4544         break;
4545       }
4546
4547       // optional bool java_multiple_files = 10 [default = false];
4548       case 10: {
4549         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4550             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
4551          parse_java_multiple_files:
4552           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
4553                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
4554                  input, &java_multiple_files_)));
4555           set_has_java_multiple_files();
4556         } else {
4557           goto handle_uninterpreted;
4558         }
4559         if (input->ExpectTag(90)) goto parse_go_package;
4560         break;
4561       }
4562
4563       // optional string go_package = 11;
4564       case 11: {
4565         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4566             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
4567          parse_go_package:
4568           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
4569                 input, this->mutable_go_package()));
4570           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4571             this->go_package().data(), this->go_package().length(),
4572             ::google::protobuf::internal::WireFormat::PARSE);
4573         } else {
4574           goto handle_uninterpreted;
4575         }
4576         if (input->ExpectTag(96)) goto parse_retain_unknown_fields;
4577         break;
4578       }
4579
4580       // optional bool retain_unknown_fields = 12 [default = false];
4581       case 12: {
4582         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4583             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
4584          parse_retain_unknown_fields:
4585           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
4586                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
4587                  input, &retain_unknown_fields_)));
4588           set_has_retain_unknown_fields();
4589         } else {
4590           goto handle_uninterpreted;
4591         }
4592         if (input->ExpectTag(128)) goto parse_cc_generic_services;
4593         break;
4594       }
4595
4596       // optional bool cc_generic_services = 16 [default = false];
4597       case 16: {
4598         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4599             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
4600          parse_cc_generic_services:
4601           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
4602                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
4603                  input, &cc_generic_services_)));
4604           set_has_cc_generic_services();
4605         } else {
4606           goto handle_uninterpreted;
4607         }
4608         if (input->ExpectTag(136)) goto parse_java_generic_services;
4609         break;
4610       }
4611
4612       // optional bool java_generic_services = 17 [default = false];
4613       case 17: {
4614         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4615             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
4616          parse_java_generic_services:
4617           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
4618                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
4619                  input, &java_generic_services_)));
4620           set_has_java_generic_services();
4621         } else {
4622           goto handle_uninterpreted;
4623         }
4624         if (input->ExpectTag(144)) goto parse_py_generic_services;
4625         break;
4626       }
4627
4628       // optional bool py_generic_services = 18 [default = false];
4629       case 18: {
4630         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4631             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
4632          parse_py_generic_services:
4633           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
4634                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
4635                  input, &py_generic_services_)));
4636           set_has_py_generic_services();
4637         } else {
4638           goto handle_uninterpreted;
4639         }
4640         if (input->ExpectTag(160)) goto parse_java_generate_equals_and_hash;
4641         break;
4642       }
4643
4644       // optional bool java_generate_equals_and_hash = 20 [default = false];
4645       case 20: {
4646         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4647             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
4648          parse_java_generate_equals_and_hash:
4649           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
4650                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
4651                  input, &java_generate_equals_and_hash_)));
4652           set_has_java_generate_equals_and_hash();
4653         } else {
4654           goto handle_uninterpreted;
4655         }
4656         if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
4657         break;
4658       }
4659
4660       // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
4661       case 999: {
4662         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4663             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
4664          parse_uninterpreted_option:
4665           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
4666                 input, add_uninterpreted_option()));
4667         } else {
4668           goto handle_uninterpreted;
4669         }
4670         if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
4671         if (input->ExpectAtEnd()) return true;
4672         break;
4673       }
4674
4675       default: {
4676       handle_uninterpreted:
4677         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4678             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
4679           return true;
4680         }
4681         if ((8000u <= tag)) {
4682           DO_(_extensions_.ParseField(tag, input, default_instance_,
4683                                       mutable_unknown_fields()));
4684           continue;
4685         }
4686         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
4687               input, tag, mutable_unknown_fields()));
4688         break;
4689       }
4690     }
4691   }
4692   return true;
4693 #undef DO_
4694 }
4695
4696 void FileOptions::SerializeWithCachedSizes(
4697     ::google::protobuf::io::CodedOutputStream* output) const {
4698   // optional string java_package = 1;
4699   if (has_java_package()) {
4700     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4701       this->java_package().data(), this->java_package().length(),
4702       ::google::protobuf::internal::WireFormat::SERIALIZE);
4703     ::google::protobuf::internal::WireFormatLite::WriteString(
4704       1, this->java_package(), output);
4705   }
4706
4707   // optional string java_outer_classname = 8;
4708   if (has_java_outer_classname()) {
4709     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4710       this->java_outer_classname().data(), this->java_outer_classname().length(),
4711       ::google::protobuf::internal::WireFormat::SERIALIZE);
4712     ::google::protobuf::internal::WireFormatLite::WriteString(
4713       8, this->java_outer_classname(), output);
4714   }
4715
4716   // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
4717   if (has_optimize_for()) {
4718     ::google::protobuf::internal::WireFormatLite::WriteEnum(
4719       9, this->optimize_for(), output);
4720   }
4721
4722   // optional bool java_multiple_files = 10 [default = false];
4723   if (has_java_multiple_files()) {
4724     ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->java_multiple_files(), output);
4725   }
4726
4727   // optional string go_package = 11;
4728   if (has_go_package()) {
4729     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4730       this->go_package().data(), this->go_package().length(),
4731       ::google::protobuf::internal::WireFormat::SERIALIZE);
4732     ::google::protobuf::internal::WireFormatLite::WriteString(
4733       11, this->go_package(), output);
4734   }
4735
4736   // optional bool retain_unknown_fields = 12 [default = false];
4737   if (has_retain_unknown_fields()) {
4738     ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->retain_unknown_fields(), output);
4739   }
4740
4741   // optional bool cc_generic_services = 16 [default = false];
4742   if (has_cc_generic_services()) {
4743     ::google::protobuf::internal::WireFormatLite::WriteBool(16, this->cc_generic_services(), output);
4744   }
4745
4746   // optional bool java_generic_services = 17 [default = false];
4747   if (has_java_generic_services()) {
4748     ::google::protobuf::internal::WireFormatLite::WriteBool(17, this->java_generic_services(), output);
4749   }
4750
4751   // optional bool py_generic_services = 18 [default = false];
4752   if (has_py_generic_services()) {
4753     ::google::protobuf::internal::WireFormatLite::WriteBool(18, this->py_generic_services(), output);
4754   }
4755
4756   // optional bool java_generate_equals_and_hash = 20 [default = false];
4757   if (has_java_generate_equals_and_hash()) {
4758     ::google::protobuf::internal::WireFormatLite::WriteBool(20, this->java_generate_equals_and_hash(), output);
4759   }
4760
4761   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
4762   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
4763     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
4764       999, this->uninterpreted_option(i), output);
4765   }
4766
4767   // Extension range [1000, 536870912)
4768   _extensions_.SerializeWithCachedSizes(
4769       1000, 536870912, output);
4770
4771   if (!unknown_fields().empty()) {
4772     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
4773         unknown_fields(), output);
4774   }
4775 }
4776
4777 ::google::protobuf::uint8* FileOptions::SerializeWithCachedSizesToArray(
4778     ::google::protobuf::uint8* target) const {
4779   // optional string java_package = 1;
4780   if (has_java_package()) {
4781     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4782       this->java_package().data(), this->java_package().length(),
4783       ::google::protobuf::internal::WireFormat::SERIALIZE);
4784     target =
4785       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4786         1, this->java_package(), target);
4787   }
4788
4789   // optional string java_outer_classname = 8;
4790   if (has_java_outer_classname()) {
4791     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4792       this->java_outer_classname().data(), this->java_outer_classname().length(),
4793       ::google::protobuf::internal::WireFormat::SERIALIZE);
4794     target =
4795       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4796         8, this->java_outer_classname(), target);
4797   }
4798
4799   // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
4800   if (has_optimize_for()) {
4801     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
4802       9, this->optimize_for(), target);
4803   }
4804
4805   // optional bool java_multiple_files = 10 [default = false];
4806   if (has_java_multiple_files()) {
4807     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(10, this->java_multiple_files(), target);
4808   }
4809
4810   // optional string go_package = 11;
4811   if (has_go_package()) {
4812     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4813       this->go_package().data(), this->go_package().length(),
4814       ::google::protobuf::internal::WireFormat::SERIALIZE);
4815     target =
4816       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4817         11, this->go_package(), target);
4818   }
4819
4820   // optional bool retain_unknown_fields = 12 [default = false];
4821   if (has_retain_unknown_fields()) {
4822     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(12, this->retain_unknown_fields(), target);
4823   }
4824
4825   // optional bool cc_generic_services = 16 [default = false];
4826   if (has_cc_generic_services()) {
4827     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(16, this->cc_generic_services(), target);
4828   }
4829
4830   // optional bool java_generic_services = 17 [default = false];
4831   if (has_java_generic_services()) {
4832     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(17, this->java_generic_services(), target);
4833   }
4834
4835   // optional bool py_generic_services = 18 [default = false];
4836   if (has_py_generic_services()) {
4837     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(18, this->py_generic_services(), target);
4838   }
4839
4840   // optional bool java_generate_equals_and_hash = 20 [default = false];
4841   if (has_java_generate_equals_and_hash()) {
4842     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(20, this->java_generate_equals_and_hash(), target);
4843   }
4844
4845   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
4846   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
4847     target = ::google::protobuf::internal::WireFormatLite::
4848       WriteMessageNoVirtualToArray(
4849         999, this->uninterpreted_option(i), target);
4850   }
4851
4852   // Extension range [1000, 536870912)
4853   target = _extensions_.SerializeWithCachedSizesToArray(
4854       1000, 536870912, target);
4855
4856   if (!unknown_fields().empty()) {
4857     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
4858         unknown_fields(), target);
4859   }
4860   return target;
4861 }
4862
4863 int FileOptions::ByteSize() const {
4864   int total_size = 0;
4865
4866   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4867     // optional string java_package = 1;
4868     if (has_java_package()) {
4869       total_size += 1 +
4870         ::google::protobuf::internal::WireFormatLite::StringSize(
4871           this->java_package());
4872     }
4873
4874     // optional string java_outer_classname = 8;
4875     if (has_java_outer_classname()) {
4876       total_size += 1 +
4877         ::google::protobuf::internal::WireFormatLite::StringSize(
4878           this->java_outer_classname());
4879     }
4880
4881     // optional bool java_multiple_files = 10 [default = false];
4882     if (has_java_multiple_files()) {
4883       total_size += 1 + 1;
4884     }
4885
4886     // optional bool retain_unknown_fields = 12 [default = false];
4887     if (has_retain_unknown_fields()) {
4888       total_size += 1 + 1;
4889     }
4890
4891     // optional bool java_generate_equals_and_hash = 20 [default = false];
4892     if (has_java_generate_equals_and_hash()) {
4893       total_size += 2 + 1;
4894     }
4895
4896     // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
4897     if (has_optimize_for()) {
4898       total_size += 1 +
4899         ::google::protobuf::internal::WireFormatLite::EnumSize(this->optimize_for());
4900     }
4901
4902     // optional string go_package = 11;
4903     if (has_go_package()) {
4904       total_size += 1 +
4905         ::google::protobuf::internal::WireFormatLite::StringSize(
4906           this->go_package());
4907     }
4908
4909     // optional bool cc_generic_services = 16 [default = false];
4910     if (has_cc_generic_services()) {
4911       total_size += 2 + 1;
4912     }
4913
4914   }
4915   if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
4916     // optional bool java_generic_services = 17 [default = false];
4917     if (has_java_generic_services()) {
4918       total_size += 2 + 1;
4919     }
4920
4921     // optional bool py_generic_services = 18 [default = false];
4922     if (has_py_generic_services()) {
4923       total_size += 2 + 1;
4924     }
4925
4926   }
4927   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
4928   total_size += 2 * this->uninterpreted_option_size();
4929   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
4930     total_size +=
4931       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
4932         this->uninterpreted_option(i));
4933   }
4934
4935   total_size += _extensions_.ByteSize();
4936
4937   if (!unknown_fields().empty()) {
4938     total_size +=
4939       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
4940         unknown_fields());
4941   }
4942   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
4943   _cached_size_ = total_size;
4944   GOOGLE_SAFE_CONCURRENT_WRITES_END();
4945   return total_size;
4946 }
4947
4948 void FileOptions::MergeFrom(const ::google::protobuf::Message& from) {
4949   GOOGLE_CHECK_NE(&from, this);
4950   const FileOptions* source =
4951     ::google::protobuf::internal::dynamic_cast_if_available<const FileOptions*>(
4952       &from);
4953   if (source == NULL) {
4954     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
4955   } else {
4956     MergeFrom(*source);
4957   }
4958 }
4959
4960 void FileOptions::MergeFrom(const FileOptions& from) {
4961   GOOGLE_CHECK_NE(&from, this);
4962   uninterpreted_option_.MergeFrom(from.uninterpreted_option_);
4963   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4964     if (from.has_java_package()) {
4965       set_java_package(from.java_package());
4966     }
4967     if (from.has_java_outer_classname()) {
4968       set_java_outer_classname(from.java_outer_classname());
4969     }
4970     if (from.has_java_multiple_files()) {
4971       set_java_multiple_files(from.java_multiple_files());
4972     }
4973     if (from.has_retain_unknown_fields()) {
4974       set_retain_unknown_fields(from.retain_unknown_fields());
4975     }
4976     if (from.has_java_generate_equals_and_hash()) {
4977       set_java_generate_equals_and_hash(from.java_generate_equals_and_hash());
4978     }
4979     if (from.has_optimize_for()) {
4980       set_optimize_for(from.optimize_for());
4981     }
4982     if (from.has_go_package()) {
4983       set_go_package(from.go_package());
4984     }
4985     if (from.has_cc_generic_services()) {
4986       set_cc_generic_services(from.cc_generic_services());
4987     }
4988   }
4989   if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
4990     if (from.has_java_generic_services()) {
4991       set_java_generic_services(from.java_generic_services());
4992     }
4993     if (from.has_py_generic_services()) {
4994       set_py_generic_services(from.py_generic_services());
4995     }
4996   }
4997   _extensions_.MergeFrom(from._extensions_);
4998   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
4999 }
5000
5001 void FileOptions::CopyFrom(const ::google::protobuf::Message& from) {
5002   if (&from == this) return;
5003   Clear();
5004   MergeFrom(from);
5005 }
5006
5007 void FileOptions::CopyFrom(const FileOptions& from) {
5008   if (&from == this) return;
5009   Clear();
5010   MergeFrom(from);
5011 }
5012
5013 bool FileOptions::IsInitialized() const {
5014
5015   for (int i = 0; i < uninterpreted_option_size(); i++) {
5016     if (!this->uninterpreted_option(i).IsInitialized()) return false;
5017   }
5018
5019   if (!_extensions_.IsInitialized()) return false;  return true;
5020 }
5021
5022 void FileOptions::Swap(FileOptions* other) {
5023   if (other != this) {
5024     std::swap(java_package_, other->java_package_);
5025     std::swap(java_outer_classname_, other->java_outer_classname_);
5026     std::swap(java_multiple_files_, other->java_multiple_files_);
5027     std::swap(retain_unknown_fields_, other->retain_unknown_fields_);
5028     std::swap(java_generate_equals_and_hash_, other->java_generate_equals_and_hash_);
5029     std::swap(optimize_for_, other->optimize_for_);
5030     std::swap(go_package_, other->go_package_);
5031     std::swap(cc_generic_services_, other->cc_generic_services_);
5032     std::swap(java_generic_services_, other->java_generic_services_);
5033     std::swap(py_generic_services_, other->py_generic_services_);
5034     uninterpreted_option_.Swap(&other->uninterpreted_option_);
5035     std::swap(_has_bits_[0], other->_has_bits_[0]);
5036     _unknown_fields_.Swap(&other->_unknown_fields_);
5037     std::swap(_cached_size_, other->_cached_size_);
5038     _extensions_.Swap(&other->_extensions_);
5039   }
5040 }
5041
5042 ::google::protobuf::Metadata FileOptions::GetMetadata() const {
5043   protobuf_AssignDescriptorsOnce();
5044   ::google::protobuf::Metadata metadata;
5045   metadata.descriptor = FileOptions_descriptor_;
5046   metadata.reflection = FileOptions_reflection_;
5047   return metadata;
5048 }
5049
5050
5051 // ===================================================================
5052
5053 #ifndef _MSC_VER
5054 const int MessageOptions::kMessageSetWireFormatFieldNumber;
5055 const int MessageOptions::kNoStandardDescriptorAccessorFieldNumber;
5056 const int MessageOptions::kUninterpretedOptionFieldNumber;
5057 #endif  // !_MSC_VER
5058
5059 MessageOptions::MessageOptions()
5060   : ::google::protobuf::Message() {
5061   SharedCtor();
5062 }
5063
5064 void MessageOptions::InitAsDefaultInstance() {
5065 }
5066
5067 MessageOptions::MessageOptions(const MessageOptions& from)
5068   : ::google::protobuf::Message() {
5069   SharedCtor();
5070   MergeFrom(from);
5071 }
5072
5073 void MessageOptions::SharedCtor() {
5074   _cached_size_ = 0;
5075   message_set_wire_format_ = false;
5076   no_standard_descriptor_accessor_ = false;
5077   ::memset(_has_bits_, 0, sizeof(_has_bits_));
5078 }
5079
5080 MessageOptions::~MessageOptions() {
5081   SharedDtor();
5082 }
5083
5084 void MessageOptions::SharedDtor() {
5085   if (this != default_instance_) {
5086   }
5087 }
5088
5089 void MessageOptions::SetCachedSize(int size) const {
5090   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
5091   _cached_size_ = size;
5092   GOOGLE_SAFE_CONCURRENT_WRITES_END();
5093 }
5094 const ::google::protobuf::Descriptor* MessageOptions::descriptor() {
5095   protobuf_AssignDescriptorsOnce();
5096   return MessageOptions_descriptor_;
5097 }
5098
5099 const MessageOptions& MessageOptions::default_instance() {
5100   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
5101   return *default_instance_;
5102 }
5103
5104 MessageOptions* MessageOptions::default_instance_ = NULL;
5105
5106 MessageOptions* MessageOptions::New() const {
5107   return new MessageOptions;
5108 }
5109
5110 void MessageOptions::Clear() {
5111   _extensions_.Clear();
5112   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5113     message_set_wire_format_ = false;
5114     no_standard_descriptor_accessor_ = false;
5115   }
5116   uninterpreted_option_.Clear();
5117   ::memset(_has_bits_, 0, sizeof(_has_bits_));
5118   mutable_unknown_fields()->Clear();
5119 }
5120
5121 bool MessageOptions::MergePartialFromCodedStream(
5122     ::google::protobuf::io::CodedInputStream* input) {
5123 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
5124   ::google::protobuf::uint32 tag;
5125   while ((tag = input->ReadTag()) != 0) {
5126     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
5127       // optional bool message_set_wire_format = 1 [default = false];
5128       case 1: {
5129         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5130             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
5131           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5132                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
5133                  input, &message_set_wire_format_)));
5134           set_has_message_set_wire_format();
5135         } else {
5136           goto handle_uninterpreted;
5137         }
5138         if (input->ExpectTag(16)) goto parse_no_standard_descriptor_accessor;
5139         break;
5140       }
5141
5142       // optional bool no_standard_descriptor_accessor = 2 [default = false];
5143       case 2: {
5144         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5145             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
5146          parse_no_standard_descriptor_accessor:
5147           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5148                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
5149                  input, &no_standard_descriptor_accessor_)));
5150           set_has_no_standard_descriptor_accessor();
5151         } else {
5152           goto handle_uninterpreted;
5153         }
5154         if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
5155         break;
5156       }
5157
5158       // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
5159       case 999: {
5160         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5161             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
5162          parse_uninterpreted_option:
5163           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
5164                 input, add_uninterpreted_option()));
5165         } else {
5166           goto handle_uninterpreted;
5167         }
5168         if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
5169         if (input->ExpectAtEnd()) return true;
5170         break;
5171       }
5172
5173       default: {
5174       handle_uninterpreted:
5175         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5176             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
5177           return true;
5178         }
5179         if ((8000u <= tag)) {
5180           DO_(_extensions_.ParseField(tag, input, default_instance_,
5181                                       mutable_unknown_fields()));
5182           continue;
5183         }
5184         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
5185               input, tag, mutable_unknown_fields()));
5186         break;
5187       }
5188     }
5189   }
5190   return true;
5191 #undef DO_
5192 }
5193
5194 void MessageOptions::SerializeWithCachedSizes(
5195     ::google::protobuf::io::CodedOutputStream* output) const {
5196   // optional bool message_set_wire_format = 1 [default = false];
5197   if (has_message_set_wire_format()) {
5198     ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->message_set_wire_format(), output);
5199   }
5200
5201   // optional bool no_standard_descriptor_accessor = 2 [default = false];
5202   if (has_no_standard_descriptor_accessor()) {
5203     ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->no_standard_descriptor_accessor(), output);
5204   }
5205
5206   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
5207   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
5208     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
5209       999, this->uninterpreted_option(i), output);
5210   }
5211
5212   // Extension range [1000, 536870912)
5213   _extensions_.SerializeWithCachedSizes(
5214       1000, 536870912, output);
5215
5216   if (!unknown_fields().empty()) {
5217     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
5218         unknown_fields(), output);
5219   }
5220 }
5221
5222 ::google::protobuf::uint8* MessageOptions::SerializeWithCachedSizesToArray(
5223     ::google::protobuf::uint8* target) const {
5224   // optional bool message_set_wire_format = 1 [default = false];
5225   if (has_message_set_wire_format()) {
5226     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->message_set_wire_format(), target);
5227   }
5228
5229   // optional bool no_standard_descriptor_accessor = 2 [default = false];
5230   if (has_no_standard_descriptor_accessor()) {
5231     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->no_standard_descriptor_accessor(), target);
5232   }
5233
5234   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
5235   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
5236     target = ::google::protobuf::internal::WireFormatLite::
5237       WriteMessageNoVirtualToArray(
5238         999, this->uninterpreted_option(i), target);
5239   }
5240
5241   // Extension range [1000, 536870912)
5242   target = _extensions_.SerializeWithCachedSizesToArray(
5243       1000, 536870912, target);
5244
5245   if (!unknown_fields().empty()) {
5246     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
5247         unknown_fields(), target);
5248   }
5249   return target;
5250 }
5251
5252 int MessageOptions::ByteSize() const {
5253   int total_size = 0;
5254
5255   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5256     // optional bool message_set_wire_format = 1 [default = false];
5257     if (has_message_set_wire_format()) {
5258       total_size += 1 + 1;
5259     }
5260
5261     // optional bool no_standard_descriptor_accessor = 2 [default = false];
5262     if (has_no_standard_descriptor_accessor()) {
5263       total_size += 1 + 1;
5264     }
5265
5266   }
5267   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
5268   total_size += 2 * this->uninterpreted_option_size();
5269   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
5270     total_size +=
5271       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
5272         this->uninterpreted_option(i));
5273   }
5274
5275   total_size += _extensions_.ByteSize();
5276
5277   if (!unknown_fields().empty()) {
5278     total_size +=
5279       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
5280         unknown_fields());
5281   }
5282   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
5283   _cached_size_ = total_size;
5284   GOOGLE_SAFE_CONCURRENT_WRITES_END();
5285   return total_size;
5286 }
5287
5288 void MessageOptions::MergeFrom(const ::google::protobuf::Message& from) {
5289   GOOGLE_CHECK_NE(&from, this);
5290   const MessageOptions* source =
5291     ::google::protobuf::internal::dynamic_cast_if_available<const MessageOptions*>(
5292       &from);
5293   if (source == NULL) {
5294     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
5295   } else {
5296     MergeFrom(*source);
5297   }
5298 }
5299
5300 void MessageOptions::MergeFrom(const MessageOptions& from) {
5301   GOOGLE_CHECK_NE(&from, this);
5302   uninterpreted_option_.MergeFrom(from.uninterpreted_option_);
5303   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5304     if (from.has_message_set_wire_format()) {
5305       set_message_set_wire_format(from.message_set_wire_format());
5306     }
5307     if (from.has_no_standard_descriptor_accessor()) {
5308       set_no_standard_descriptor_accessor(from.no_standard_descriptor_accessor());
5309     }
5310   }
5311   _extensions_.MergeFrom(from._extensions_);
5312   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
5313 }
5314
5315 void MessageOptions::CopyFrom(const ::google::protobuf::Message& from) {
5316   if (&from == this) return;
5317   Clear();
5318   MergeFrom(from);
5319 }
5320
5321 void MessageOptions::CopyFrom(const MessageOptions& from) {
5322   if (&from == this) return;
5323   Clear();
5324   MergeFrom(from);
5325 }
5326
5327 bool MessageOptions::IsInitialized() const {
5328
5329   for (int i = 0; i < uninterpreted_option_size(); i++) {
5330     if (!this->uninterpreted_option(i).IsInitialized()) return false;
5331   }
5332
5333   if (!_extensions_.IsInitialized()) return false;  return true;
5334 }
5335
5336 void MessageOptions::Swap(MessageOptions* other) {
5337   if (other != this) {
5338     std::swap(message_set_wire_format_, other->message_set_wire_format_);
5339     std::swap(no_standard_descriptor_accessor_, other->no_standard_descriptor_accessor_);
5340     uninterpreted_option_.Swap(&other->uninterpreted_option_);
5341     std::swap(_has_bits_[0], other->_has_bits_[0]);
5342     _unknown_fields_.Swap(&other->_unknown_fields_);
5343     std::swap(_cached_size_, other->_cached_size_);
5344     _extensions_.Swap(&other->_extensions_);
5345   }
5346 }
5347
5348 ::google::protobuf::Metadata MessageOptions::GetMetadata() const {
5349   protobuf_AssignDescriptorsOnce();
5350   ::google::protobuf::Metadata metadata;
5351   metadata.descriptor = MessageOptions_descriptor_;
5352   metadata.reflection = MessageOptions_reflection_;
5353   return metadata;
5354 }
5355
5356
5357 // ===================================================================
5358
5359 const ::google::protobuf::EnumDescriptor* FieldOptions_CType_descriptor() {
5360   protobuf_AssignDescriptorsOnce();
5361   return FieldOptions_CType_descriptor_;
5362 }
5363 bool FieldOptions_CType_IsValid(int value) {
5364   switch(value) {
5365     case 0:
5366     case 1:
5367     case 2:
5368       return true;
5369     default:
5370       return false;
5371   }
5372 }
5373
5374 #ifndef _MSC_VER
5375 const FieldOptions_CType FieldOptions::STRING;
5376 const FieldOptions_CType FieldOptions::CORD;
5377 const FieldOptions_CType FieldOptions::STRING_PIECE;
5378 const FieldOptions_CType FieldOptions::CType_MIN;
5379 const FieldOptions_CType FieldOptions::CType_MAX;
5380 const int FieldOptions::CType_ARRAYSIZE;
5381 #endif  // _MSC_VER
5382 #ifndef _MSC_VER
5383 const int FieldOptions::kCtypeFieldNumber;
5384 const int FieldOptions::kPackedFieldNumber;
5385 const int FieldOptions::kLazyFieldNumber;
5386 const int FieldOptions::kDeprecatedFieldNumber;
5387 const int FieldOptions::kExperimentalMapKeyFieldNumber;
5388 const int FieldOptions::kWeakFieldNumber;
5389 const int FieldOptions::kUninterpretedOptionFieldNumber;
5390 #endif  // !_MSC_VER
5391
5392 FieldOptions::FieldOptions()
5393   : ::google::protobuf::Message() {
5394   SharedCtor();
5395 }
5396
5397 void FieldOptions::InitAsDefaultInstance() {
5398 }
5399
5400 FieldOptions::FieldOptions(const FieldOptions& from)
5401   : ::google::protobuf::Message() {
5402   SharedCtor();
5403   MergeFrom(from);
5404 }
5405
5406 void FieldOptions::SharedCtor() {
5407   _cached_size_ = 0;
5408   ctype_ = 0;
5409   packed_ = false;
5410   lazy_ = false;
5411   deprecated_ = false;
5412   experimental_map_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
5413   weak_ = false;
5414   ::memset(_has_bits_, 0, sizeof(_has_bits_));
5415 }
5416
5417 FieldOptions::~FieldOptions() {
5418   SharedDtor();
5419 }
5420
5421 void FieldOptions::SharedDtor() {
5422   if (experimental_map_key_ != &::google::protobuf::internal::GetEmptyString()) {
5423     delete experimental_map_key_;
5424   }
5425   if (this != default_instance_) {
5426   }
5427 }
5428
5429 void FieldOptions::SetCachedSize(int size) const {
5430   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
5431   _cached_size_ = size;
5432   GOOGLE_SAFE_CONCURRENT_WRITES_END();
5433 }
5434 const ::google::protobuf::Descriptor* FieldOptions::descriptor() {
5435   protobuf_AssignDescriptorsOnce();
5436   return FieldOptions_descriptor_;
5437 }
5438
5439 const FieldOptions& FieldOptions::default_instance() {
5440   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
5441   return *default_instance_;
5442 }
5443
5444 FieldOptions* FieldOptions::default_instance_ = NULL;
5445
5446 FieldOptions* FieldOptions::New() const {
5447   return new FieldOptions;
5448 }
5449
5450 void FieldOptions::Clear() {
5451   _extensions_.Clear();
5452   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5453     ctype_ = 0;
5454     packed_ = false;
5455     lazy_ = false;
5456     deprecated_ = false;
5457     if (has_experimental_map_key()) {
5458       if (experimental_map_key_ != &::google::protobuf::internal::GetEmptyString()) {
5459         experimental_map_key_->clear();
5460       }
5461     }
5462     weak_ = false;
5463   }
5464   uninterpreted_option_.Clear();
5465   ::memset(_has_bits_, 0, sizeof(_has_bits_));
5466   mutable_unknown_fields()->Clear();
5467 }
5468
5469 bool FieldOptions::MergePartialFromCodedStream(
5470     ::google::protobuf::io::CodedInputStream* input) {
5471 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
5472   ::google::protobuf::uint32 tag;
5473   while ((tag = input->ReadTag()) != 0) {
5474     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
5475       // optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
5476       case 1: {
5477         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5478             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
5479           int value;
5480           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5481                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
5482                  input, &value)));
5483           if (::google::protobuf::FieldOptions_CType_IsValid(value)) {
5484             set_ctype(static_cast< ::google::protobuf::FieldOptions_CType >(value));
5485           } else {
5486             mutable_unknown_fields()->AddVarint(1, value);
5487           }
5488         } else {
5489           goto handle_uninterpreted;
5490         }
5491         if (input->ExpectTag(16)) goto parse_packed;
5492         break;
5493       }
5494
5495       // optional bool packed = 2;
5496       case 2: {
5497         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5498             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
5499          parse_packed:
5500           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5501                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
5502                  input, &packed_)));
5503           set_has_packed();
5504         } else {
5505           goto handle_uninterpreted;
5506         }
5507         if (input->ExpectTag(24)) goto parse_deprecated;
5508         break;
5509       }
5510
5511       // optional bool deprecated = 3 [default = false];
5512       case 3: {
5513         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5514             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
5515          parse_deprecated:
5516           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5517                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
5518                  input, &deprecated_)));
5519           set_has_deprecated();
5520         } else {
5521           goto handle_uninterpreted;
5522         }
5523         if (input->ExpectTag(40)) goto parse_lazy;
5524         break;
5525       }
5526
5527       // optional bool lazy = 5 [default = false];
5528       case 5: {
5529         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5530             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
5531          parse_lazy:
5532           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5533                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
5534                  input, &lazy_)));
5535           set_has_lazy();
5536         } else {
5537           goto handle_uninterpreted;
5538         }
5539         if (input->ExpectTag(74)) goto parse_experimental_map_key;
5540         break;
5541       }
5542
5543       // optional string experimental_map_key = 9;
5544       case 9: {
5545         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5546             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
5547          parse_experimental_map_key:
5548           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
5549                 input, this->mutable_experimental_map_key()));
5550           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
5551             this->experimental_map_key().data(), this->experimental_map_key().length(),
5552             ::google::protobuf::internal::WireFormat::PARSE);
5553         } else {
5554           goto handle_uninterpreted;
5555         }
5556         if (input->ExpectTag(80)) goto parse_weak;
5557         break;
5558       }
5559
5560       // optional bool weak = 10 [default = false];
5561       case 10: {
5562         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5563             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
5564          parse_weak:
5565           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5566                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
5567                  input, &weak_)));
5568           set_has_weak();
5569         } else {
5570           goto handle_uninterpreted;
5571         }
5572         if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
5573         break;
5574       }
5575
5576       // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
5577       case 999: {
5578         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5579             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
5580          parse_uninterpreted_option:
5581           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
5582                 input, add_uninterpreted_option()));
5583         } else {
5584           goto handle_uninterpreted;
5585         }
5586         if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
5587         if (input->ExpectAtEnd()) return true;
5588         break;
5589       }
5590
5591       default: {
5592       handle_uninterpreted:
5593         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5594             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
5595           return true;
5596         }
5597         if ((8000u <= tag)) {
5598           DO_(_extensions_.ParseField(tag, input, default_instance_,
5599                                       mutable_unknown_fields()));
5600           continue;
5601         }
5602         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
5603               input, tag, mutable_unknown_fields()));
5604         break;
5605       }
5606     }
5607   }
5608   return true;
5609 #undef DO_
5610 }
5611
5612 void FieldOptions::SerializeWithCachedSizes(
5613     ::google::protobuf::io::CodedOutputStream* output) const {
5614   // optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
5615   if (has_ctype()) {
5616     ::google::protobuf::internal::WireFormatLite::WriteEnum(
5617       1, this->ctype(), output);
5618   }
5619
5620   // optional bool packed = 2;
5621   if (has_packed()) {
5622     ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->packed(), output);
5623   }
5624
5625   // optional bool deprecated = 3 [default = false];
5626   if (has_deprecated()) {
5627     ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->deprecated(), output);
5628   }
5629
5630   // optional bool lazy = 5 [default = false];
5631   if (has_lazy()) {
5632     ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->lazy(), output);
5633   }
5634
5635   // optional string experimental_map_key = 9;
5636   if (has_experimental_map_key()) {
5637     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
5638       this->experimental_map_key().data(), this->experimental_map_key().length(),
5639       ::google::protobuf::internal::WireFormat::SERIALIZE);
5640     ::google::protobuf::internal::WireFormatLite::WriteString(
5641       9, this->experimental_map_key(), output);
5642   }
5643
5644   // optional bool weak = 10 [default = false];
5645   if (has_weak()) {
5646     ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->weak(), output);
5647   }
5648
5649   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
5650   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
5651     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
5652       999, this->uninterpreted_option(i), output);
5653   }
5654
5655   // Extension range [1000, 536870912)
5656   _extensions_.SerializeWithCachedSizes(
5657       1000, 536870912, output);
5658
5659   if (!unknown_fields().empty()) {
5660     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
5661         unknown_fields(), output);
5662   }
5663 }
5664
5665 ::google::protobuf::uint8* FieldOptions::SerializeWithCachedSizesToArray(
5666     ::google::protobuf::uint8* target) const {
5667   // optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
5668   if (has_ctype()) {
5669     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
5670       1, this->ctype(), target);
5671   }
5672
5673   // optional bool packed = 2;
5674   if (has_packed()) {
5675     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->packed(), target);
5676   }
5677
5678   // optional bool deprecated = 3 [default = false];
5679   if (has_deprecated()) {
5680     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->deprecated(), target);
5681   }
5682
5683   // optional bool lazy = 5 [default = false];
5684   if (has_lazy()) {
5685     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->lazy(), target);
5686   }
5687
5688   // optional string experimental_map_key = 9;
5689   if (has_experimental_map_key()) {
5690     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
5691       this->experimental_map_key().data(), this->experimental_map_key().length(),
5692       ::google::protobuf::internal::WireFormat::SERIALIZE);
5693     target =
5694       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
5695         9, this->experimental_map_key(), target);
5696   }
5697
5698   // optional bool weak = 10 [default = false];
5699   if (has_weak()) {
5700     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(10, this->weak(), target);
5701   }
5702
5703   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
5704   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
5705     target = ::google::protobuf::internal::WireFormatLite::
5706       WriteMessageNoVirtualToArray(
5707         999, this->uninterpreted_option(i), target);
5708   }
5709
5710   // Extension range [1000, 536870912)
5711   target = _extensions_.SerializeWithCachedSizesToArray(
5712       1000, 536870912, target);
5713
5714   if (!unknown_fields().empty()) {
5715     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
5716         unknown_fields(), target);
5717   }
5718   return target;
5719 }
5720
5721 int FieldOptions::ByteSize() const {
5722   int total_size = 0;
5723
5724   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5725     // optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
5726     if (has_ctype()) {
5727       total_size += 1 +
5728         ::google::protobuf::internal::WireFormatLite::EnumSize(this->ctype());
5729     }
5730
5731     // optional bool packed = 2;
5732     if (has_packed()) {
5733       total_size += 1 + 1;
5734     }
5735
5736     // optional bool lazy = 5 [default = false];
5737     if (has_lazy()) {
5738       total_size += 1 + 1;
5739     }
5740
5741     // optional bool deprecated = 3 [default = false];
5742     if (has_deprecated()) {
5743       total_size += 1 + 1;
5744     }
5745
5746     // optional string experimental_map_key = 9;
5747     if (has_experimental_map_key()) {
5748       total_size += 1 +
5749         ::google::protobuf::internal::WireFormatLite::StringSize(
5750           this->experimental_map_key());
5751     }
5752
5753     // optional bool weak = 10 [default = false];
5754     if (has_weak()) {
5755       total_size += 1 + 1;
5756     }
5757
5758   }
5759   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
5760   total_size += 2 * this->uninterpreted_option_size();
5761   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
5762     total_size +=
5763       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
5764         this->uninterpreted_option(i));
5765   }
5766
5767   total_size += _extensions_.ByteSize();
5768
5769   if (!unknown_fields().empty()) {
5770     total_size +=
5771       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
5772         unknown_fields());
5773   }
5774   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
5775   _cached_size_ = total_size;
5776   GOOGLE_SAFE_CONCURRENT_WRITES_END();
5777   return total_size;
5778 }
5779
5780 void FieldOptions::MergeFrom(const ::google::protobuf::Message& from) {
5781   GOOGLE_CHECK_NE(&from, this);
5782   const FieldOptions* source =
5783     ::google::protobuf::internal::dynamic_cast_if_available<const FieldOptions*>(
5784       &from);
5785   if (source == NULL) {
5786     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
5787   } else {
5788     MergeFrom(*source);
5789   }
5790 }
5791
5792 void FieldOptions::MergeFrom(const FieldOptions& from) {
5793   GOOGLE_CHECK_NE(&from, this);
5794   uninterpreted_option_.MergeFrom(from.uninterpreted_option_);
5795   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5796     if (from.has_ctype()) {
5797       set_ctype(from.ctype());
5798     }
5799     if (from.has_packed()) {
5800       set_packed(from.packed());
5801     }
5802     if (from.has_lazy()) {
5803       set_lazy(from.lazy());
5804     }
5805     if (from.has_deprecated()) {
5806       set_deprecated(from.deprecated());
5807     }
5808     if (from.has_experimental_map_key()) {
5809       set_experimental_map_key(from.experimental_map_key());
5810     }
5811     if (from.has_weak()) {
5812       set_weak(from.weak());
5813     }
5814   }
5815   _extensions_.MergeFrom(from._extensions_);
5816   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
5817 }
5818
5819 void FieldOptions::CopyFrom(const ::google::protobuf::Message& from) {
5820   if (&from == this) return;
5821   Clear();
5822   MergeFrom(from);
5823 }
5824
5825 void FieldOptions::CopyFrom(const FieldOptions& from) {
5826   if (&from == this) return;
5827   Clear();
5828   MergeFrom(from);
5829 }
5830
5831 bool FieldOptions::IsInitialized() const {
5832
5833   for (int i = 0; i < uninterpreted_option_size(); i++) {
5834     if (!this->uninterpreted_option(i).IsInitialized()) return false;
5835   }
5836
5837   if (!_extensions_.IsInitialized()) return false;  return true;
5838 }
5839
5840 void FieldOptions::Swap(FieldOptions* other) {
5841   if (other != this) {
5842     std::swap(ctype_, other->ctype_);
5843     std::swap(packed_, other->packed_);
5844     std::swap(lazy_, other->lazy_);
5845     std::swap(deprecated_, other->deprecated_);
5846     std::swap(experimental_map_key_, other->experimental_map_key_);
5847     std::swap(weak_, other->weak_);
5848     uninterpreted_option_.Swap(&other->uninterpreted_option_);
5849     std::swap(_has_bits_[0], other->_has_bits_[0]);
5850     _unknown_fields_.Swap(&other->_unknown_fields_);
5851     std::swap(_cached_size_, other->_cached_size_);
5852     _extensions_.Swap(&other->_extensions_);
5853   }
5854 }
5855
5856 ::google::protobuf::Metadata FieldOptions::GetMetadata() const {
5857   protobuf_AssignDescriptorsOnce();
5858   ::google::protobuf::Metadata metadata;
5859   metadata.descriptor = FieldOptions_descriptor_;
5860   metadata.reflection = FieldOptions_reflection_;
5861   return metadata;
5862 }
5863
5864
5865 // ===================================================================
5866
5867 #ifndef _MSC_VER
5868 const int EnumOptions::kAllowAliasFieldNumber;
5869 const int EnumOptions::kUninterpretedOptionFieldNumber;
5870 #endif  // !_MSC_VER
5871
5872 EnumOptions::EnumOptions()
5873   : ::google::protobuf::Message() {
5874   SharedCtor();
5875 }
5876
5877 void EnumOptions::InitAsDefaultInstance() {
5878 }
5879
5880 EnumOptions::EnumOptions(const EnumOptions& from)
5881   : ::google::protobuf::Message() {
5882   SharedCtor();
5883   MergeFrom(from);
5884 }
5885
5886 void EnumOptions::SharedCtor() {
5887   _cached_size_ = 0;
5888   allow_alias_ = true;
5889   ::memset(_has_bits_, 0, sizeof(_has_bits_));
5890 }
5891
5892 EnumOptions::~EnumOptions() {
5893   SharedDtor();
5894 }
5895
5896 void EnumOptions::SharedDtor() {
5897   if (this != default_instance_) {
5898   }
5899 }
5900
5901 void EnumOptions::SetCachedSize(int size) const {
5902   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
5903   _cached_size_ = size;
5904   GOOGLE_SAFE_CONCURRENT_WRITES_END();
5905 }
5906 const ::google::protobuf::Descriptor* EnumOptions::descriptor() {
5907   protobuf_AssignDescriptorsOnce();
5908   return EnumOptions_descriptor_;
5909 }
5910
5911 const EnumOptions& EnumOptions::default_instance() {
5912   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
5913   return *default_instance_;
5914 }
5915
5916 EnumOptions* EnumOptions::default_instance_ = NULL;
5917
5918 EnumOptions* EnumOptions::New() const {
5919   return new EnumOptions;
5920 }
5921
5922 void EnumOptions::Clear() {
5923   _extensions_.Clear();
5924   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5925     allow_alias_ = true;
5926   }
5927   uninterpreted_option_.Clear();
5928   ::memset(_has_bits_, 0, sizeof(_has_bits_));
5929   mutable_unknown_fields()->Clear();
5930 }
5931
5932 bool EnumOptions::MergePartialFromCodedStream(
5933     ::google::protobuf::io::CodedInputStream* input) {
5934 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
5935   ::google::protobuf::uint32 tag;
5936   while ((tag = input->ReadTag()) != 0) {
5937     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
5938       // optional bool allow_alias = 2 [default = true];
5939       case 2: {
5940         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5941             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
5942           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
5943                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
5944                  input, &allow_alias_)));
5945           set_has_allow_alias();
5946         } else {
5947           goto handle_uninterpreted;
5948         }
5949         if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
5950         break;
5951       }
5952
5953       // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
5954       case 999: {
5955         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5956             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
5957          parse_uninterpreted_option:
5958           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
5959                 input, add_uninterpreted_option()));
5960         } else {
5961           goto handle_uninterpreted;
5962         }
5963         if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
5964         if (input->ExpectAtEnd()) return true;
5965         break;
5966       }
5967
5968       default: {
5969       handle_uninterpreted:
5970         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5971             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
5972           return true;
5973         }
5974         if ((8000u <= tag)) {
5975           DO_(_extensions_.ParseField(tag, input, default_instance_,
5976                                       mutable_unknown_fields()));
5977           continue;
5978         }
5979         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
5980               input, tag, mutable_unknown_fields()));
5981         break;
5982       }
5983     }
5984   }
5985   return true;
5986 #undef DO_
5987 }
5988
5989 void EnumOptions::SerializeWithCachedSizes(
5990     ::google::protobuf::io::CodedOutputStream* output) const {
5991   // optional bool allow_alias = 2 [default = true];
5992   if (has_allow_alias()) {
5993     ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->allow_alias(), output);
5994   }
5995
5996   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
5997   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
5998     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
5999       999, this->uninterpreted_option(i), output);
6000   }
6001
6002   // Extension range [1000, 536870912)
6003   _extensions_.SerializeWithCachedSizes(
6004       1000, 536870912, output);
6005
6006   if (!unknown_fields().empty()) {
6007     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
6008         unknown_fields(), output);
6009   }
6010 }
6011
6012 ::google::protobuf::uint8* EnumOptions::SerializeWithCachedSizesToArray(
6013     ::google::protobuf::uint8* target) const {
6014   // optional bool allow_alias = 2 [default = true];
6015   if (has_allow_alias()) {
6016     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->allow_alias(), target);
6017   }
6018
6019   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
6020   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
6021     target = ::google::protobuf::internal::WireFormatLite::
6022       WriteMessageNoVirtualToArray(
6023         999, this->uninterpreted_option(i), target);
6024   }
6025
6026   // Extension range [1000, 536870912)
6027   target = _extensions_.SerializeWithCachedSizesToArray(
6028       1000, 536870912, target);
6029
6030   if (!unknown_fields().empty()) {
6031     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
6032         unknown_fields(), target);
6033   }
6034   return target;
6035 }
6036
6037 int EnumOptions::ByteSize() const {
6038   int total_size = 0;
6039
6040   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6041     // optional bool allow_alias = 2 [default = true];
6042     if (has_allow_alias()) {
6043       total_size += 1 + 1;
6044     }
6045
6046   }
6047   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
6048   total_size += 2 * this->uninterpreted_option_size();
6049   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
6050     total_size +=
6051       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6052         this->uninterpreted_option(i));
6053   }
6054
6055   total_size += _extensions_.ByteSize();
6056
6057   if (!unknown_fields().empty()) {
6058     total_size +=
6059       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
6060         unknown_fields());
6061   }
6062   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
6063   _cached_size_ = total_size;
6064   GOOGLE_SAFE_CONCURRENT_WRITES_END();
6065   return total_size;
6066 }
6067
6068 void EnumOptions::MergeFrom(const ::google::protobuf::Message& from) {
6069   GOOGLE_CHECK_NE(&from, this);
6070   const EnumOptions* source =
6071     ::google::protobuf::internal::dynamic_cast_if_available<const EnumOptions*>(
6072       &from);
6073   if (source == NULL) {
6074     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
6075   } else {
6076     MergeFrom(*source);
6077   }
6078 }
6079
6080 void EnumOptions::MergeFrom(const EnumOptions& from) {
6081   GOOGLE_CHECK_NE(&from, this);
6082   uninterpreted_option_.MergeFrom(from.uninterpreted_option_);
6083   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6084     if (from.has_allow_alias()) {
6085       set_allow_alias(from.allow_alias());
6086     }
6087   }
6088   _extensions_.MergeFrom(from._extensions_);
6089   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
6090 }
6091
6092 void EnumOptions::CopyFrom(const ::google::protobuf::Message& from) {
6093   if (&from == this) return;
6094   Clear();
6095   MergeFrom(from);
6096 }
6097
6098 void EnumOptions::CopyFrom(const EnumOptions& from) {
6099   if (&from == this) return;
6100   Clear();
6101   MergeFrom(from);
6102 }
6103
6104 bool EnumOptions::IsInitialized() const {
6105
6106   for (int i = 0; i < uninterpreted_option_size(); i++) {
6107     if (!this->uninterpreted_option(i).IsInitialized()) return false;
6108   }
6109
6110   if (!_extensions_.IsInitialized()) return false;  return true;
6111 }
6112
6113 void EnumOptions::Swap(EnumOptions* other) {
6114   if (other != this) {
6115     std::swap(allow_alias_, other->allow_alias_);
6116     uninterpreted_option_.Swap(&other->uninterpreted_option_);
6117     std::swap(_has_bits_[0], other->_has_bits_[0]);
6118     _unknown_fields_.Swap(&other->_unknown_fields_);
6119     std::swap(_cached_size_, other->_cached_size_);
6120     _extensions_.Swap(&other->_extensions_);
6121   }
6122 }
6123
6124 ::google::protobuf::Metadata EnumOptions::GetMetadata() const {
6125   protobuf_AssignDescriptorsOnce();
6126   ::google::protobuf::Metadata metadata;
6127   metadata.descriptor = EnumOptions_descriptor_;
6128   metadata.reflection = EnumOptions_reflection_;
6129   return metadata;
6130 }
6131
6132
6133 // ===================================================================
6134
6135 #ifndef _MSC_VER
6136 const int EnumValueOptions::kUninterpretedOptionFieldNumber;
6137 #endif  // !_MSC_VER
6138
6139 EnumValueOptions::EnumValueOptions()
6140   : ::google::protobuf::Message() {
6141   SharedCtor();
6142 }
6143
6144 void EnumValueOptions::InitAsDefaultInstance() {
6145 }
6146
6147 EnumValueOptions::EnumValueOptions(const EnumValueOptions& from)
6148   : ::google::protobuf::Message() {
6149   SharedCtor();
6150   MergeFrom(from);
6151 }
6152
6153 void EnumValueOptions::SharedCtor() {
6154   _cached_size_ = 0;
6155   ::memset(_has_bits_, 0, sizeof(_has_bits_));
6156 }
6157
6158 EnumValueOptions::~EnumValueOptions() {
6159   SharedDtor();
6160 }
6161
6162 void EnumValueOptions::SharedDtor() {
6163   if (this != default_instance_) {
6164   }
6165 }
6166
6167 void EnumValueOptions::SetCachedSize(int size) const {
6168   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
6169   _cached_size_ = size;
6170   GOOGLE_SAFE_CONCURRENT_WRITES_END();
6171 }
6172 const ::google::protobuf::Descriptor* EnumValueOptions::descriptor() {
6173   protobuf_AssignDescriptorsOnce();
6174   return EnumValueOptions_descriptor_;
6175 }
6176
6177 const EnumValueOptions& EnumValueOptions::default_instance() {
6178   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
6179   return *default_instance_;
6180 }
6181
6182 EnumValueOptions* EnumValueOptions::default_instance_ = NULL;
6183
6184 EnumValueOptions* EnumValueOptions::New() const {
6185   return new EnumValueOptions;
6186 }
6187
6188 void EnumValueOptions::Clear() {
6189   _extensions_.Clear();
6190   uninterpreted_option_.Clear();
6191   ::memset(_has_bits_, 0, sizeof(_has_bits_));
6192   mutable_unknown_fields()->Clear();
6193 }
6194
6195 bool EnumValueOptions::MergePartialFromCodedStream(
6196     ::google::protobuf::io::CodedInputStream* input) {
6197 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
6198   ::google::protobuf::uint32 tag;
6199   while ((tag = input->ReadTag()) != 0) {
6200     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
6201       // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
6202       case 999: {
6203         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6204             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6205          parse_uninterpreted_option:
6206           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6207                 input, add_uninterpreted_option()));
6208         } else {
6209           goto handle_uninterpreted;
6210         }
6211         if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
6212         if (input->ExpectAtEnd()) return true;
6213         break;
6214       }
6215
6216       default: {
6217       handle_uninterpreted:
6218         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6219             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
6220           return true;
6221         }
6222         if ((8000u <= tag)) {
6223           DO_(_extensions_.ParseField(tag, input, default_instance_,
6224                                       mutable_unknown_fields()));
6225           continue;
6226         }
6227         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
6228               input, tag, mutable_unknown_fields()));
6229         break;
6230       }
6231     }
6232   }
6233   return true;
6234 #undef DO_
6235 }
6236
6237 void EnumValueOptions::SerializeWithCachedSizes(
6238     ::google::protobuf::io::CodedOutputStream* output) const {
6239   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
6240   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
6241     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
6242       999, this->uninterpreted_option(i), output);
6243   }
6244
6245   // Extension range [1000, 536870912)
6246   _extensions_.SerializeWithCachedSizes(
6247       1000, 536870912, output);
6248
6249   if (!unknown_fields().empty()) {
6250     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
6251         unknown_fields(), output);
6252   }
6253 }
6254
6255 ::google::protobuf::uint8* EnumValueOptions::SerializeWithCachedSizesToArray(
6256     ::google::protobuf::uint8* target) const {
6257   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
6258   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
6259     target = ::google::protobuf::internal::WireFormatLite::
6260       WriteMessageNoVirtualToArray(
6261         999, this->uninterpreted_option(i), target);
6262   }
6263
6264   // Extension range [1000, 536870912)
6265   target = _extensions_.SerializeWithCachedSizesToArray(
6266       1000, 536870912, target);
6267
6268   if (!unknown_fields().empty()) {
6269     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
6270         unknown_fields(), target);
6271   }
6272   return target;
6273 }
6274
6275 int EnumValueOptions::ByteSize() const {
6276   int total_size = 0;
6277
6278   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
6279   total_size += 2 * this->uninterpreted_option_size();
6280   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
6281     total_size +=
6282       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6283         this->uninterpreted_option(i));
6284   }
6285
6286   total_size += _extensions_.ByteSize();
6287
6288   if (!unknown_fields().empty()) {
6289     total_size +=
6290       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
6291         unknown_fields());
6292   }
6293   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
6294   _cached_size_ = total_size;
6295   GOOGLE_SAFE_CONCURRENT_WRITES_END();
6296   return total_size;
6297 }
6298
6299 void EnumValueOptions::MergeFrom(const ::google::protobuf::Message& from) {
6300   GOOGLE_CHECK_NE(&from, this);
6301   const EnumValueOptions* source =
6302     ::google::protobuf::internal::dynamic_cast_if_available<const EnumValueOptions*>(
6303       &from);
6304   if (source == NULL) {
6305     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
6306   } else {
6307     MergeFrom(*source);
6308   }
6309 }
6310
6311 void EnumValueOptions::MergeFrom(const EnumValueOptions& from) {
6312   GOOGLE_CHECK_NE(&from, this);
6313   uninterpreted_option_.MergeFrom(from.uninterpreted_option_);
6314   _extensions_.MergeFrom(from._extensions_);
6315   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
6316 }
6317
6318 void EnumValueOptions::CopyFrom(const ::google::protobuf::Message& from) {
6319   if (&from == this) return;
6320   Clear();
6321   MergeFrom(from);
6322 }
6323
6324 void EnumValueOptions::CopyFrom(const EnumValueOptions& from) {
6325   if (&from == this) return;
6326   Clear();
6327   MergeFrom(from);
6328 }
6329
6330 bool EnumValueOptions::IsInitialized() const {
6331
6332   for (int i = 0; i < uninterpreted_option_size(); i++) {
6333     if (!this->uninterpreted_option(i).IsInitialized()) return false;
6334   }
6335
6336   if (!_extensions_.IsInitialized()) return false;  return true;
6337 }
6338
6339 void EnumValueOptions::Swap(EnumValueOptions* other) {
6340   if (other != this) {
6341     uninterpreted_option_.Swap(&other->uninterpreted_option_);
6342     std::swap(_has_bits_[0], other->_has_bits_[0]);
6343     _unknown_fields_.Swap(&other->_unknown_fields_);
6344     std::swap(_cached_size_, other->_cached_size_);
6345     _extensions_.Swap(&other->_extensions_);
6346   }
6347 }
6348
6349 ::google::protobuf::Metadata EnumValueOptions::GetMetadata() const {
6350   protobuf_AssignDescriptorsOnce();
6351   ::google::protobuf::Metadata metadata;
6352   metadata.descriptor = EnumValueOptions_descriptor_;
6353   metadata.reflection = EnumValueOptions_reflection_;
6354   return metadata;
6355 }
6356
6357
6358 // ===================================================================
6359
6360 #ifndef _MSC_VER
6361 const int ServiceOptions::kUninterpretedOptionFieldNumber;
6362 #endif  // !_MSC_VER
6363
6364 ServiceOptions::ServiceOptions()
6365   : ::google::protobuf::Message() {
6366   SharedCtor();
6367 }
6368
6369 void ServiceOptions::InitAsDefaultInstance() {
6370 }
6371
6372 ServiceOptions::ServiceOptions(const ServiceOptions& from)
6373   : ::google::protobuf::Message() {
6374   SharedCtor();
6375   MergeFrom(from);
6376 }
6377
6378 void ServiceOptions::SharedCtor() {
6379   _cached_size_ = 0;
6380   ::memset(_has_bits_, 0, sizeof(_has_bits_));
6381 }
6382
6383 ServiceOptions::~ServiceOptions() {
6384   SharedDtor();
6385 }
6386
6387 void ServiceOptions::SharedDtor() {
6388   if (this != default_instance_) {
6389   }
6390 }
6391
6392 void ServiceOptions::SetCachedSize(int size) const {
6393   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
6394   _cached_size_ = size;
6395   GOOGLE_SAFE_CONCURRENT_WRITES_END();
6396 }
6397 const ::google::protobuf::Descriptor* ServiceOptions::descriptor() {
6398   protobuf_AssignDescriptorsOnce();
6399   return ServiceOptions_descriptor_;
6400 }
6401
6402 const ServiceOptions& ServiceOptions::default_instance() {
6403   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
6404   return *default_instance_;
6405 }
6406
6407 ServiceOptions* ServiceOptions::default_instance_ = NULL;
6408
6409 ServiceOptions* ServiceOptions::New() const {
6410   return new ServiceOptions;
6411 }
6412
6413 void ServiceOptions::Clear() {
6414   _extensions_.Clear();
6415   uninterpreted_option_.Clear();
6416   ::memset(_has_bits_, 0, sizeof(_has_bits_));
6417   mutable_unknown_fields()->Clear();
6418 }
6419
6420 bool ServiceOptions::MergePartialFromCodedStream(
6421     ::google::protobuf::io::CodedInputStream* input) {
6422 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
6423   ::google::protobuf::uint32 tag;
6424   while ((tag = input->ReadTag()) != 0) {
6425     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
6426       // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
6427       case 999: {
6428         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6429             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6430          parse_uninterpreted_option:
6431           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6432                 input, add_uninterpreted_option()));
6433         } else {
6434           goto handle_uninterpreted;
6435         }
6436         if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
6437         if (input->ExpectAtEnd()) return true;
6438         break;
6439       }
6440
6441       default: {
6442       handle_uninterpreted:
6443         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6444             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
6445           return true;
6446         }
6447         if ((8000u <= tag)) {
6448           DO_(_extensions_.ParseField(tag, input, default_instance_,
6449                                       mutable_unknown_fields()));
6450           continue;
6451         }
6452         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
6453               input, tag, mutable_unknown_fields()));
6454         break;
6455       }
6456     }
6457   }
6458   return true;
6459 #undef DO_
6460 }
6461
6462 void ServiceOptions::SerializeWithCachedSizes(
6463     ::google::protobuf::io::CodedOutputStream* output) const {
6464   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
6465   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
6466     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
6467       999, this->uninterpreted_option(i), output);
6468   }
6469
6470   // Extension range [1000, 536870912)
6471   _extensions_.SerializeWithCachedSizes(
6472       1000, 536870912, output);
6473
6474   if (!unknown_fields().empty()) {
6475     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
6476         unknown_fields(), output);
6477   }
6478 }
6479
6480 ::google::protobuf::uint8* ServiceOptions::SerializeWithCachedSizesToArray(
6481     ::google::protobuf::uint8* target) const {
6482   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
6483   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
6484     target = ::google::protobuf::internal::WireFormatLite::
6485       WriteMessageNoVirtualToArray(
6486         999, this->uninterpreted_option(i), target);
6487   }
6488
6489   // Extension range [1000, 536870912)
6490   target = _extensions_.SerializeWithCachedSizesToArray(
6491       1000, 536870912, target);
6492
6493   if (!unknown_fields().empty()) {
6494     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
6495         unknown_fields(), target);
6496   }
6497   return target;
6498 }
6499
6500 int ServiceOptions::ByteSize() const {
6501   int total_size = 0;
6502
6503   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
6504   total_size += 2 * this->uninterpreted_option_size();
6505   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
6506     total_size +=
6507       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6508         this->uninterpreted_option(i));
6509   }
6510
6511   total_size += _extensions_.ByteSize();
6512
6513   if (!unknown_fields().empty()) {
6514     total_size +=
6515       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
6516         unknown_fields());
6517   }
6518   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
6519   _cached_size_ = total_size;
6520   GOOGLE_SAFE_CONCURRENT_WRITES_END();
6521   return total_size;
6522 }
6523
6524 void ServiceOptions::MergeFrom(const ::google::protobuf::Message& from) {
6525   GOOGLE_CHECK_NE(&from, this);
6526   const ServiceOptions* source =
6527     ::google::protobuf::internal::dynamic_cast_if_available<const ServiceOptions*>(
6528       &from);
6529   if (source == NULL) {
6530     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
6531   } else {
6532     MergeFrom(*source);
6533   }
6534 }
6535
6536 void ServiceOptions::MergeFrom(const ServiceOptions& from) {
6537   GOOGLE_CHECK_NE(&from, this);
6538   uninterpreted_option_.MergeFrom(from.uninterpreted_option_);
6539   _extensions_.MergeFrom(from._extensions_);
6540   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
6541 }
6542
6543 void ServiceOptions::CopyFrom(const ::google::protobuf::Message& from) {
6544   if (&from == this) return;
6545   Clear();
6546   MergeFrom(from);
6547 }
6548
6549 void ServiceOptions::CopyFrom(const ServiceOptions& from) {
6550   if (&from == this) return;
6551   Clear();
6552   MergeFrom(from);
6553 }
6554
6555 bool ServiceOptions::IsInitialized() const {
6556
6557   for (int i = 0; i < uninterpreted_option_size(); i++) {
6558     if (!this->uninterpreted_option(i).IsInitialized()) return false;
6559   }
6560
6561   if (!_extensions_.IsInitialized()) return false;  return true;
6562 }
6563
6564 void ServiceOptions::Swap(ServiceOptions* other) {
6565   if (other != this) {
6566     uninterpreted_option_.Swap(&other->uninterpreted_option_);
6567     std::swap(_has_bits_[0], other->_has_bits_[0]);
6568     _unknown_fields_.Swap(&other->_unknown_fields_);
6569     std::swap(_cached_size_, other->_cached_size_);
6570     _extensions_.Swap(&other->_extensions_);
6571   }
6572 }
6573
6574 ::google::protobuf::Metadata ServiceOptions::GetMetadata() const {
6575   protobuf_AssignDescriptorsOnce();
6576   ::google::protobuf::Metadata metadata;
6577   metadata.descriptor = ServiceOptions_descriptor_;
6578   metadata.reflection = ServiceOptions_reflection_;
6579   return metadata;
6580 }
6581
6582
6583 // ===================================================================
6584
6585 #ifndef _MSC_VER
6586 const int MethodOptions::kUninterpretedOptionFieldNumber;
6587 #endif  // !_MSC_VER
6588
6589 MethodOptions::MethodOptions()
6590   : ::google::protobuf::Message() {
6591   SharedCtor();
6592 }
6593
6594 void MethodOptions::InitAsDefaultInstance() {
6595 }
6596
6597 MethodOptions::MethodOptions(const MethodOptions& from)
6598   : ::google::protobuf::Message() {
6599   SharedCtor();
6600   MergeFrom(from);
6601 }
6602
6603 void MethodOptions::SharedCtor() {
6604   _cached_size_ = 0;
6605   ::memset(_has_bits_, 0, sizeof(_has_bits_));
6606 }
6607
6608 MethodOptions::~MethodOptions() {
6609   SharedDtor();
6610 }
6611
6612 void MethodOptions::SharedDtor() {
6613   if (this != default_instance_) {
6614   }
6615 }
6616
6617 void MethodOptions::SetCachedSize(int size) const {
6618   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
6619   _cached_size_ = size;
6620   GOOGLE_SAFE_CONCURRENT_WRITES_END();
6621 }
6622 const ::google::protobuf::Descriptor* MethodOptions::descriptor() {
6623   protobuf_AssignDescriptorsOnce();
6624   return MethodOptions_descriptor_;
6625 }
6626
6627 const MethodOptions& MethodOptions::default_instance() {
6628   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
6629   return *default_instance_;
6630 }
6631
6632 MethodOptions* MethodOptions::default_instance_ = NULL;
6633
6634 MethodOptions* MethodOptions::New() const {
6635   return new MethodOptions;
6636 }
6637
6638 void MethodOptions::Clear() {
6639   _extensions_.Clear();
6640   uninterpreted_option_.Clear();
6641   ::memset(_has_bits_, 0, sizeof(_has_bits_));
6642   mutable_unknown_fields()->Clear();
6643 }
6644
6645 bool MethodOptions::MergePartialFromCodedStream(
6646     ::google::protobuf::io::CodedInputStream* input) {
6647 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
6648   ::google::protobuf::uint32 tag;
6649   while ((tag = input->ReadTag()) != 0) {
6650     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
6651       // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
6652       case 999: {
6653         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6654             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6655          parse_uninterpreted_option:
6656           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6657                 input, add_uninterpreted_option()));
6658         } else {
6659           goto handle_uninterpreted;
6660         }
6661         if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
6662         if (input->ExpectAtEnd()) return true;
6663         break;
6664       }
6665
6666       default: {
6667       handle_uninterpreted:
6668         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6669             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
6670           return true;
6671         }
6672         if ((8000u <= tag)) {
6673           DO_(_extensions_.ParseField(tag, input, default_instance_,
6674                                       mutable_unknown_fields()));
6675           continue;
6676         }
6677         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
6678               input, tag, mutable_unknown_fields()));
6679         break;
6680       }
6681     }
6682   }
6683   return true;
6684 #undef DO_
6685 }
6686
6687 void MethodOptions::SerializeWithCachedSizes(
6688     ::google::protobuf::io::CodedOutputStream* output) const {
6689   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
6690   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
6691     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
6692       999, this->uninterpreted_option(i), output);
6693   }
6694
6695   // Extension range [1000, 536870912)
6696   _extensions_.SerializeWithCachedSizes(
6697       1000, 536870912, output);
6698
6699   if (!unknown_fields().empty()) {
6700     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
6701         unknown_fields(), output);
6702   }
6703 }
6704
6705 ::google::protobuf::uint8* MethodOptions::SerializeWithCachedSizesToArray(
6706     ::google::protobuf::uint8* target) const {
6707   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
6708   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
6709     target = ::google::protobuf::internal::WireFormatLite::
6710       WriteMessageNoVirtualToArray(
6711         999, this->uninterpreted_option(i), target);
6712   }
6713
6714   // Extension range [1000, 536870912)
6715   target = _extensions_.SerializeWithCachedSizesToArray(
6716       1000, 536870912, target);
6717
6718   if (!unknown_fields().empty()) {
6719     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
6720         unknown_fields(), target);
6721   }
6722   return target;
6723 }
6724
6725 int MethodOptions::ByteSize() const {
6726   int total_size = 0;
6727
6728   // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
6729   total_size += 2 * this->uninterpreted_option_size();
6730   for (int i = 0; i < this->uninterpreted_option_size(); i++) {
6731     total_size +=
6732       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6733         this->uninterpreted_option(i));
6734   }
6735
6736   total_size += _extensions_.ByteSize();
6737
6738   if (!unknown_fields().empty()) {
6739     total_size +=
6740       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
6741         unknown_fields());
6742   }
6743   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
6744   _cached_size_ = total_size;
6745   GOOGLE_SAFE_CONCURRENT_WRITES_END();
6746   return total_size;
6747 }
6748
6749 void MethodOptions::MergeFrom(const ::google::protobuf::Message& from) {
6750   GOOGLE_CHECK_NE(&from, this);
6751   const MethodOptions* source =
6752     ::google::protobuf::internal::dynamic_cast_if_available<const MethodOptions*>(
6753       &from);
6754   if (source == NULL) {
6755     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
6756   } else {
6757     MergeFrom(*source);
6758   }
6759 }
6760
6761 void MethodOptions::MergeFrom(const MethodOptions& from) {
6762   GOOGLE_CHECK_NE(&from, this);
6763   uninterpreted_option_.MergeFrom(from.uninterpreted_option_);
6764   _extensions_.MergeFrom(from._extensions_);
6765   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
6766 }
6767
6768 void MethodOptions::CopyFrom(const ::google::protobuf::Message& from) {
6769   if (&from == this) return;
6770   Clear();
6771   MergeFrom(from);
6772 }
6773
6774 void MethodOptions::CopyFrom(const MethodOptions& from) {
6775   if (&from == this) return;
6776   Clear();
6777   MergeFrom(from);
6778 }
6779
6780 bool MethodOptions::IsInitialized() const {
6781
6782   for (int i = 0; i < uninterpreted_option_size(); i++) {
6783     if (!this->uninterpreted_option(i).IsInitialized()) return false;
6784   }
6785
6786   if (!_extensions_.IsInitialized()) return false;  return true;
6787 }
6788
6789 void MethodOptions::Swap(MethodOptions* other) {
6790   if (other != this) {
6791     uninterpreted_option_.Swap(&other->uninterpreted_option_);
6792     std::swap(_has_bits_[0], other->_has_bits_[0]);
6793     _unknown_fields_.Swap(&other->_unknown_fields_);
6794     std::swap(_cached_size_, other->_cached_size_);
6795     _extensions_.Swap(&other->_extensions_);
6796   }
6797 }
6798
6799 ::google::protobuf::Metadata MethodOptions::GetMetadata() const {
6800   protobuf_AssignDescriptorsOnce();
6801   ::google::protobuf::Metadata metadata;
6802   metadata.descriptor = MethodOptions_descriptor_;
6803   metadata.reflection = MethodOptions_reflection_;
6804   return metadata;
6805 }
6806
6807
6808 // ===================================================================
6809
6810 #ifndef _MSC_VER
6811 const int UninterpretedOption_NamePart::kNamePartFieldNumber;
6812 const int UninterpretedOption_NamePart::kIsExtensionFieldNumber;
6813 #endif  // !_MSC_VER
6814
6815 UninterpretedOption_NamePart::UninterpretedOption_NamePart()
6816   : ::google::protobuf::Message() {
6817   SharedCtor();
6818 }
6819
6820 void UninterpretedOption_NamePart::InitAsDefaultInstance() {
6821 }
6822
6823 UninterpretedOption_NamePart::UninterpretedOption_NamePart(const UninterpretedOption_NamePart& from)
6824   : ::google::protobuf::Message() {
6825   SharedCtor();
6826   MergeFrom(from);
6827 }
6828
6829 void UninterpretedOption_NamePart::SharedCtor() {
6830   _cached_size_ = 0;
6831   name_part_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
6832   is_extension_ = false;
6833   ::memset(_has_bits_, 0, sizeof(_has_bits_));
6834 }
6835
6836 UninterpretedOption_NamePart::~UninterpretedOption_NamePart() {
6837   SharedDtor();
6838 }
6839
6840 void UninterpretedOption_NamePart::SharedDtor() {
6841   if (name_part_ != &::google::protobuf::internal::GetEmptyString()) {
6842     delete name_part_;
6843   }
6844   if (this != default_instance_) {
6845   }
6846 }
6847
6848 void UninterpretedOption_NamePart::SetCachedSize(int size) const {
6849   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
6850   _cached_size_ = size;
6851   GOOGLE_SAFE_CONCURRENT_WRITES_END();
6852 }
6853 const ::google::protobuf::Descriptor* UninterpretedOption_NamePart::descriptor() {
6854   protobuf_AssignDescriptorsOnce();
6855   return UninterpretedOption_NamePart_descriptor_;
6856 }
6857
6858 const UninterpretedOption_NamePart& UninterpretedOption_NamePart::default_instance() {
6859   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
6860   return *default_instance_;
6861 }
6862
6863 UninterpretedOption_NamePart* UninterpretedOption_NamePart::default_instance_ = NULL;
6864
6865 UninterpretedOption_NamePart* UninterpretedOption_NamePart::New() const {
6866   return new UninterpretedOption_NamePart;
6867 }
6868
6869 void UninterpretedOption_NamePart::Clear() {
6870   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6871     if (has_name_part()) {
6872       if (name_part_ != &::google::protobuf::internal::GetEmptyString()) {
6873         name_part_->clear();
6874       }
6875     }
6876     is_extension_ = false;
6877   }
6878   ::memset(_has_bits_, 0, sizeof(_has_bits_));
6879   mutable_unknown_fields()->Clear();
6880 }
6881
6882 bool UninterpretedOption_NamePart::MergePartialFromCodedStream(
6883     ::google::protobuf::io::CodedInputStream* input) {
6884 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
6885   ::google::protobuf::uint32 tag;
6886   while ((tag = input->ReadTag()) != 0) {
6887     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
6888       // required string name_part = 1;
6889       case 1: {
6890         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6891             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6892           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
6893                 input, this->mutable_name_part()));
6894           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
6895             this->name_part().data(), this->name_part().length(),
6896             ::google::protobuf::internal::WireFormat::PARSE);
6897         } else {
6898           goto handle_uninterpreted;
6899         }
6900         if (input->ExpectTag(16)) goto parse_is_extension;
6901         break;
6902       }
6903
6904       // required bool is_extension = 2;
6905       case 2: {
6906         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6907             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
6908          parse_is_extension:
6909           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
6910                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
6911                  input, &is_extension_)));
6912           set_has_is_extension();
6913         } else {
6914           goto handle_uninterpreted;
6915         }
6916         if (input->ExpectAtEnd()) return true;
6917         break;
6918       }
6919
6920       default: {
6921       handle_uninterpreted:
6922         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6923             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
6924           return true;
6925         }
6926         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
6927               input, tag, mutable_unknown_fields()));
6928         break;
6929       }
6930     }
6931   }
6932   return true;
6933 #undef DO_
6934 }
6935
6936 void UninterpretedOption_NamePart::SerializeWithCachedSizes(
6937     ::google::protobuf::io::CodedOutputStream* output) const {
6938   // required string name_part = 1;
6939   if (has_name_part()) {
6940     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
6941       this->name_part().data(), this->name_part().length(),
6942       ::google::protobuf::internal::WireFormat::SERIALIZE);
6943     ::google::protobuf::internal::WireFormatLite::WriteString(
6944       1, this->name_part(), output);
6945   }
6946
6947   // required bool is_extension = 2;
6948   if (has_is_extension()) {
6949     ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->is_extension(), output);
6950   }
6951
6952   if (!unknown_fields().empty()) {
6953     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
6954         unknown_fields(), output);
6955   }
6956 }
6957
6958 ::google::protobuf::uint8* UninterpretedOption_NamePart::SerializeWithCachedSizesToArray(
6959     ::google::protobuf::uint8* target) const {
6960   // required string name_part = 1;
6961   if (has_name_part()) {
6962     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
6963       this->name_part().data(), this->name_part().length(),
6964       ::google::protobuf::internal::WireFormat::SERIALIZE);
6965     target =
6966       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
6967         1, this->name_part(), target);
6968   }
6969
6970   // required bool is_extension = 2;
6971   if (has_is_extension()) {
6972     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->is_extension(), target);
6973   }
6974
6975   if (!unknown_fields().empty()) {
6976     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
6977         unknown_fields(), target);
6978   }
6979   return target;
6980 }
6981
6982 int UninterpretedOption_NamePart::ByteSize() const {
6983   int total_size = 0;
6984
6985   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6986     // required string name_part = 1;
6987     if (has_name_part()) {
6988       total_size += 1 +
6989         ::google::protobuf::internal::WireFormatLite::StringSize(
6990           this->name_part());
6991     }
6992
6993     // required bool is_extension = 2;
6994     if (has_is_extension()) {
6995       total_size += 1 + 1;
6996     }
6997
6998   }
6999   if (!unknown_fields().empty()) {
7000     total_size +=
7001       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
7002         unknown_fields());
7003   }
7004   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
7005   _cached_size_ = total_size;
7006   GOOGLE_SAFE_CONCURRENT_WRITES_END();
7007   return total_size;
7008 }
7009
7010 void UninterpretedOption_NamePart::MergeFrom(const ::google::protobuf::Message& from) {
7011   GOOGLE_CHECK_NE(&from, this);
7012   const UninterpretedOption_NamePart* source =
7013     ::google::protobuf::internal::dynamic_cast_if_available<const UninterpretedOption_NamePart*>(
7014       &from);
7015   if (source == NULL) {
7016     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
7017   } else {
7018     MergeFrom(*source);
7019   }
7020 }
7021
7022 void UninterpretedOption_NamePart::MergeFrom(const UninterpretedOption_NamePart& from) {
7023   GOOGLE_CHECK_NE(&from, this);
7024   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
7025     if (from.has_name_part()) {
7026       set_name_part(from.name_part());
7027     }
7028     if (from.has_is_extension()) {
7029       set_is_extension(from.is_extension());
7030     }
7031   }
7032   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
7033 }
7034
7035 void UninterpretedOption_NamePart::CopyFrom(const ::google::protobuf::Message& from) {
7036   if (&from == this) return;
7037   Clear();
7038   MergeFrom(from);
7039 }
7040
7041 void UninterpretedOption_NamePart::CopyFrom(const UninterpretedOption_NamePart& from) {
7042   if (&from == this) return;
7043   Clear();
7044   MergeFrom(from);
7045 }
7046
7047 bool UninterpretedOption_NamePart::IsInitialized() const {
7048   if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
7049
7050   return true;
7051 }
7052
7053 void UninterpretedOption_NamePart::Swap(UninterpretedOption_NamePart* other) {
7054   if (other != this) {
7055     std::swap(name_part_, other->name_part_);
7056     std::swap(is_extension_, other->is_extension_);
7057     std::swap(_has_bits_[0], other->_has_bits_[0]);
7058     _unknown_fields_.Swap(&other->_unknown_fields_);
7059     std::swap(_cached_size_, other->_cached_size_);
7060   }
7061 }
7062
7063 ::google::protobuf::Metadata UninterpretedOption_NamePart::GetMetadata() const {
7064   protobuf_AssignDescriptorsOnce();
7065   ::google::protobuf::Metadata metadata;
7066   metadata.descriptor = UninterpretedOption_NamePart_descriptor_;
7067   metadata.reflection = UninterpretedOption_NamePart_reflection_;
7068   return metadata;
7069 }
7070
7071
7072 // -------------------------------------------------------------------
7073
7074 #ifndef _MSC_VER
7075 const int UninterpretedOption::kNameFieldNumber;
7076 const int UninterpretedOption::kIdentifierValueFieldNumber;
7077 const int UninterpretedOption::kPositiveIntValueFieldNumber;
7078 const int UninterpretedOption::kNegativeIntValueFieldNumber;
7079 const int UninterpretedOption::kDoubleValueFieldNumber;
7080 const int UninterpretedOption::kStringValueFieldNumber;
7081 const int UninterpretedOption::kAggregateValueFieldNumber;
7082 #endif  // !_MSC_VER
7083
7084 UninterpretedOption::UninterpretedOption()
7085   : ::google::protobuf::Message() {
7086   SharedCtor();
7087 }
7088
7089 void UninterpretedOption::InitAsDefaultInstance() {
7090 }
7091
7092 UninterpretedOption::UninterpretedOption(const UninterpretedOption& from)
7093   : ::google::protobuf::Message() {
7094   SharedCtor();
7095   MergeFrom(from);
7096 }
7097
7098 void UninterpretedOption::SharedCtor() {
7099   _cached_size_ = 0;
7100   identifier_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
7101   positive_int_value_ = GOOGLE_ULONGLONG(0);
7102   negative_int_value_ = GOOGLE_LONGLONG(0);
7103   double_value_ = 0;
7104   string_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
7105   aggregate_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
7106   ::memset(_has_bits_, 0, sizeof(_has_bits_));
7107 }
7108
7109 UninterpretedOption::~UninterpretedOption() {
7110   SharedDtor();
7111 }
7112
7113 void UninterpretedOption::SharedDtor() {
7114   if (identifier_value_ != &::google::protobuf::internal::GetEmptyString()) {
7115     delete identifier_value_;
7116   }
7117   if (string_value_ != &::google::protobuf::internal::GetEmptyString()) {
7118     delete string_value_;
7119   }
7120   if (aggregate_value_ != &::google::protobuf::internal::GetEmptyString()) {
7121     delete aggregate_value_;
7122   }
7123   if (this != default_instance_) {
7124   }
7125 }
7126
7127 void UninterpretedOption::SetCachedSize(int size) const {
7128   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
7129   _cached_size_ = size;
7130   GOOGLE_SAFE_CONCURRENT_WRITES_END();
7131 }
7132 const ::google::protobuf::Descriptor* UninterpretedOption::descriptor() {
7133   protobuf_AssignDescriptorsOnce();
7134   return UninterpretedOption_descriptor_;
7135 }
7136
7137 const UninterpretedOption& UninterpretedOption::default_instance() {
7138   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
7139   return *default_instance_;
7140 }
7141
7142 UninterpretedOption* UninterpretedOption::default_instance_ = NULL;
7143
7144 UninterpretedOption* UninterpretedOption::New() const {
7145   return new UninterpretedOption;
7146 }
7147
7148 void UninterpretedOption::Clear() {
7149   if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
7150     if (has_identifier_value()) {
7151       if (identifier_value_ != &::google::protobuf::internal::GetEmptyString()) {
7152         identifier_value_->clear();
7153       }
7154     }
7155     positive_int_value_ = GOOGLE_ULONGLONG(0);
7156     negative_int_value_ = GOOGLE_LONGLONG(0);
7157     double_value_ = 0;
7158     if (has_string_value()) {
7159       if (string_value_ != &::google::protobuf::internal::GetEmptyString()) {
7160         string_value_->clear();
7161       }
7162     }
7163     if (has_aggregate_value()) {
7164       if (aggregate_value_ != &::google::protobuf::internal::GetEmptyString()) {
7165         aggregate_value_->clear();
7166       }
7167     }
7168   }
7169   name_.Clear();
7170   ::memset(_has_bits_, 0, sizeof(_has_bits_));
7171   mutable_unknown_fields()->Clear();
7172 }
7173
7174 bool UninterpretedOption::MergePartialFromCodedStream(
7175     ::google::protobuf::io::CodedInputStream* input) {
7176 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
7177   ::google::protobuf::uint32 tag;
7178   while ((tag = input->ReadTag()) != 0) {
7179     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
7180       // repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
7181       case 2: {
7182         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
7183             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
7184          parse_name:
7185           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
7186                 input, add_name()));
7187         } else {
7188           goto handle_uninterpreted;
7189         }
7190         if (input->ExpectTag(18)) goto parse_name;
7191         if (input->ExpectTag(26)) goto parse_identifier_value;
7192         break;
7193       }
7194
7195       // optional string identifier_value = 3;
7196       case 3: {
7197         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
7198             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
7199          parse_identifier_value:
7200           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
7201                 input, this->mutable_identifier_value()));
7202           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
7203             this->identifier_value().data(), this->identifier_value().length(),
7204             ::google::protobuf::internal::WireFormat::PARSE);
7205         } else {
7206           goto handle_uninterpreted;
7207         }
7208         if (input->ExpectTag(32)) goto parse_positive_int_value;
7209         break;
7210       }
7211
7212       // optional uint64 positive_int_value = 4;
7213       case 4: {
7214         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
7215             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
7216          parse_positive_int_value:
7217           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
7218                    ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
7219                  input, &positive_int_value_)));
7220           set_has_positive_int_value();
7221         } else {
7222           goto handle_uninterpreted;
7223         }
7224         if (input->ExpectTag(40)) goto parse_negative_int_value;
7225         break;
7226       }
7227
7228       // optional int64 negative_int_value = 5;
7229       case 5: {
7230         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
7231             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
7232          parse_negative_int_value:
7233           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
7234                    ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
7235                  input, &negative_int_value_)));
7236           set_has_negative_int_value();
7237         } else {
7238           goto handle_uninterpreted;
7239         }
7240         if (input->ExpectTag(49)) goto parse_double_value;
7241         break;
7242       }
7243
7244       // optional double double_value = 6;
7245       case 6: {
7246         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
7247             ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) {
7248          parse_double_value:
7249           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
7250                    double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
7251                  input, &double_value_)));
7252           set_has_double_value();
7253         } else {
7254           goto handle_uninterpreted;
7255         }
7256         if (input->ExpectTag(58)) goto parse_string_value;
7257         break;
7258       }
7259
7260       // optional bytes string_value = 7;
7261       case 7: {
7262         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
7263             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
7264          parse_string_value:
7265           DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
7266                 input, this->mutable_string_value()));
7267         } else {
7268           goto handle_uninterpreted;
7269         }
7270         if (input->ExpectTag(66)) goto parse_aggregate_value;
7271         break;
7272       }
7273
7274       // optional string aggregate_value = 8;
7275       case 8: {
7276         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
7277             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
7278          parse_aggregate_value:
7279           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
7280                 input, this->mutable_aggregate_value()));
7281           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
7282             this->aggregate_value().data(), this->aggregate_value().length(),
7283             ::google::protobuf::internal::WireFormat::PARSE);
7284         } else {
7285           goto handle_uninterpreted;
7286         }
7287         if (input->ExpectAtEnd()) return true;
7288         break;
7289       }
7290
7291       default: {
7292       handle_uninterpreted:
7293         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
7294             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
7295           return true;
7296         }
7297         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
7298               input, tag, mutable_unknown_fields()));
7299         break;
7300       }
7301     }
7302   }
7303   return true;
7304 #undef DO_
7305 }
7306
7307 void UninterpretedOption::SerializeWithCachedSizes(
7308     ::google::protobuf::io::CodedOutputStream* output) const {
7309   // repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
7310   for (int i = 0; i < this->name_size(); i++) {
7311     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
7312       2, this->name(i), output);
7313   }
7314
7315   // optional string identifier_value = 3;
7316   if (has_identifier_value()) {
7317     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
7318       this->identifier_value().data(), this->identifier_value().length(),
7319       ::google::protobuf::internal::WireFormat::SERIALIZE);
7320     ::google::protobuf::internal::WireFormatLite::WriteString(
7321       3, this->identifier_value(), output);
7322   }
7323
7324   // optional uint64 positive_int_value = 4;
7325   if (has_positive_int_value()) {
7326     ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->positive_int_value(), output);
7327   }
7328
7329   // optional int64 negative_int_value = 5;
7330   if (has_negative_int_value()) {
7331     ::google::protobuf::internal::WireFormatLite::WriteInt64(5, this->negative_int_value(), output);
7332   }
7333
7334   // optional double double_value = 6;
7335   if (has_double_value()) {
7336     ::google::protobuf::internal::WireFormatLite::WriteDouble(6, this->double_value(), output);
7337   }
7338
7339   // optional bytes string_value = 7;
7340   if (has_string_value()) {
7341     ::google::protobuf::internal::WireFormatLite::WriteBytes(
7342       7, this->string_value(), output);
7343   }
7344
7345   // optional string aggregate_value = 8;
7346   if (has_aggregate_value()) {
7347     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
7348       this->aggregate_value().data(), this->aggregate_value().length(),
7349       ::google::protobuf::internal::WireFormat::SERIALIZE);
7350     ::google::protobuf::internal::WireFormatLite::WriteString(
7351       8, this->aggregate_value(), output);
7352   }
7353
7354   if (!unknown_fields().empty()) {
7355     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
7356         unknown_fields(), output);
7357   }
7358 }
7359
7360 ::google::protobuf::uint8* UninterpretedOption::SerializeWithCachedSizesToArray(
7361     ::google::protobuf::uint8* target) const {
7362   // repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
7363   for (int i = 0; i < this->name_size(); i++) {
7364     target = ::google::protobuf::internal::WireFormatLite::
7365       WriteMessageNoVirtualToArray(
7366         2, this->name(i), target);
7367   }
7368
7369   // optional string identifier_value = 3;
7370   if (has_identifier_value()) {
7371     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
7372       this->identifier_value().data(), this->identifier_value().length(),
7373       ::google::protobuf::internal::WireFormat::SERIALIZE);
7374     target =
7375       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
7376         3, this->identifier_value(), target);
7377   }
7378
7379   // optional uint64 positive_int_value = 4;
7380   if (has_positive_int_value()) {
7381     target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->positive_int_value(), target);
7382   }
7383
7384   // optional int64 negative_int_value = 5;
7385   if (has_negative_int_value()) {
7386     target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(5, this->negative_int_value(), target);
7387   }
7388
7389   // optional double double_value = 6;
7390   if (has_double_value()) {
7391     target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(6, this->double_value(), target);
7392   }
7393
7394   // optional bytes string_value = 7;
7395   if (has_string_value()) {
7396     target =
7397       ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
7398         7, this->string_value(), target);
7399   }
7400
7401   // optional string aggregate_value = 8;
7402   if (has_aggregate_value()) {
7403     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
7404       this->aggregate_value().data(), this->aggregate_value().length(),
7405       ::google::protobuf::internal::WireFormat::SERIALIZE);
7406     target =
7407       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
7408         8, this->aggregate_value(), target);
7409   }
7410
7411   if (!unknown_fields().empty()) {
7412     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
7413         unknown_fields(), target);
7414   }
7415   return target;
7416 }
7417
7418 int UninterpretedOption::ByteSize() const {
7419   int total_size = 0;
7420
7421   if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
7422     // optional string identifier_value = 3;
7423     if (has_identifier_value()) {
7424       total_size += 1 +
7425         ::google::protobuf::internal::WireFormatLite::StringSize(
7426           this->identifier_value());
7427     }
7428
7429     // optional uint64 positive_int_value = 4;
7430     if (has_positive_int_value()) {
7431       total_size += 1 +
7432         ::google::protobuf::internal::WireFormatLite::UInt64Size(
7433           this->positive_int_value());
7434     }
7435
7436     // optional int64 negative_int_value = 5;
7437     if (has_negative_int_value()) {
7438       total_size += 1 +
7439         ::google::protobuf::internal::WireFormatLite::Int64Size(
7440           this->negative_int_value());
7441     }
7442
7443     // optional double double_value = 6;
7444     if (has_double_value()) {
7445       total_size += 1 + 8;
7446     }
7447
7448     // optional bytes string_value = 7;
7449     if (has_string_value()) {
7450       total_size += 1 +
7451         ::google::protobuf::internal::WireFormatLite::BytesSize(
7452           this->string_value());
7453     }
7454
7455     // optional string aggregate_value = 8;
7456     if (has_aggregate_value()) {
7457       total_size += 1 +
7458         ::google::protobuf::internal::WireFormatLite::StringSize(
7459           this->aggregate_value());
7460     }
7461
7462   }
7463   // repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
7464   total_size += 1 * this->name_size();
7465   for (int i = 0; i < this->name_size(); i++) {
7466     total_size +=
7467       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
7468         this->name(i));
7469   }
7470
7471   if (!unknown_fields().empty()) {
7472     total_size +=
7473       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
7474         unknown_fields());
7475   }
7476   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
7477   _cached_size_ = total_size;
7478   GOOGLE_SAFE_CONCURRENT_WRITES_END();
7479   return total_size;
7480 }
7481
7482 void UninterpretedOption::MergeFrom(const ::google::protobuf::Message& from) {
7483   GOOGLE_CHECK_NE(&from, this);
7484   const UninterpretedOption* source =
7485     ::google::protobuf::internal::dynamic_cast_if_available<const UninterpretedOption*>(
7486       &from);
7487   if (source == NULL) {
7488     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
7489   } else {
7490     MergeFrom(*source);
7491   }
7492 }
7493
7494 void UninterpretedOption::MergeFrom(const UninterpretedOption& from) {
7495   GOOGLE_CHECK_NE(&from, this);
7496   name_.MergeFrom(from.name_);
7497   if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
7498     if (from.has_identifier_value()) {
7499       set_identifier_value(from.identifier_value());
7500     }
7501     if (from.has_positive_int_value()) {
7502       set_positive_int_value(from.positive_int_value());
7503     }
7504     if (from.has_negative_int_value()) {
7505       set_negative_int_value(from.negative_int_value());
7506     }
7507     if (from.has_double_value()) {
7508       set_double_value(from.double_value());
7509     }
7510     if (from.has_string_value()) {
7511       set_string_value(from.string_value());
7512     }
7513     if (from.has_aggregate_value()) {
7514       set_aggregate_value(from.aggregate_value());
7515     }
7516   }
7517   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
7518 }
7519
7520 void UninterpretedOption::CopyFrom(const ::google::protobuf::Message& from) {
7521   if (&from == this) return;
7522   Clear();
7523   MergeFrom(from);
7524 }
7525
7526 void UninterpretedOption::CopyFrom(const UninterpretedOption& from) {
7527   if (&from == this) return;
7528   Clear();
7529   MergeFrom(from);
7530 }
7531
7532 bool UninterpretedOption::IsInitialized() const {
7533
7534   for (int i = 0; i < name_size(); i++) {
7535     if (!this->name(i).IsInitialized()) return false;
7536   }
7537   return true;
7538 }
7539
7540 void UninterpretedOption::Swap(UninterpretedOption* other) {
7541   if (other != this) {
7542     name_.Swap(&other->name_);
7543     std::swap(identifier_value_, other->identifier_value_);
7544     std::swap(positive_int_value_, other->positive_int_value_);
7545     std::swap(negative_int_value_, other->negative_int_value_);
7546     std::swap(double_value_, other->double_value_);
7547     std::swap(string_value_, other->string_value_);
7548     std::swap(aggregate_value_, other->aggregate_value_);
7549     std::swap(_has_bits_[0], other->_has_bits_[0]);
7550     _unknown_fields_.Swap(&other->_unknown_fields_);
7551     std::swap(_cached_size_, other->_cached_size_);
7552   }
7553 }
7554
7555 ::google::protobuf::Metadata UninterpretedOption::GetMetadata() const {
7556   protobuf_AssignDescriptorsOnce();
7557   ::google::protobuf::Metadata metadata;
7558   metadata.descriptor = UninterpretedOption_descriptor_;
7559   metadata.reflection = UninterpretedOption_reflection_;
7560   return metadata;
7561 }
7562
7563
7564 // ===================================================================
7565
7566 #ifndef _MSC_VER
7567 const int SourceCodeInfo_Location::kPathFieldNumber;
7568 const int SourceCodeInfo_Location::kSpanFieldNumber;
7569 const int SourceCodeInfo_Location::kLeadingCommentsFieldNumber;
7570 const int SourceCodeInfo_Location::kTrailingCommentsFieldNumber;
7571 #endif  // !_MSC_VER
7572
7573 SourceCodeInfo_Location::SourceCodeInfo_Location()
7574   : ::google::protobuf::Message() {
7575   SharedCtor();
7576 }
7577
7578 void SourceCodeInfo_Location::InitAsDefaultInstance() {
7579 }
7580
7581 SourceCodeInfo_Location::SourceCodeInfo_Location(const SourceCodeInfo_Location& from)
7582   : ::google::protobuf::Message() {
7583   SharedCtor();
7584   MergeFrom(from);
7585 }
7586
7587 void SourceCodeInfo_Location::SharedCtor() {
7588   _cached_size_ = 0;
7589   leading_comments_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
7590   trailing_comments_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
7591   ::memset(_has_bits_, 0, sizeof(_has_bits_));
7592 }
7593
7594 SourceCodeInfo_Location::~SourceCodeInfo_Location() {
7595   SharedDtor();
7596 }
7597
7598 void SourceCodeInfo_Location::SharedDtor() {
7599   if (leading_comments_ != &::google::protobuf::internal::GetEmptyString()) {
7600     delete leading_comments_;
7601   }
7602   if (trailing_comments_ != &::google::protobuf::internal::GetEmptyString()) {
7603     delete trailing_comments_;
7604   }
7605   if (this != default_instance_) {
7606   }
7607 }
7608
7609 void SourceCodeInfo_Location::SetCachedSize(int size) const {
7610   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
7611   _cached_size_ = size;
7612   GOOGLE_SAFE_CONCURRENT_WRITES_END();
7613 }
7614 const ::google::protobuf::Descriptor* SourceCodeInfo_Location::descriptor() {
7615   protobuf_AssignDescriptorsOnce();
7616   return SourceCodeInfo_Location_descriptor_;
7617 }
7618
7619 const SourceCodeInfo_Location& SourceCodeInfo_Location::default_instance() {
7620   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
7621   return *default_instance_;
7622 }
7623
7624 SourceCodeInfo_Location* SourceCodeInfo_Location::default_instance_ = NULL;
7625
7626 SourceCodeInfo_Location* SourceCodeInfo_Location::New() const {
7627   return new SourceCodeInfo_Location;
7628 }
7629
7630 void SourceCodeInfo_Location::Clear() {
7631   if (_has_bits_[2 / 32] & (0xffu << (2 % 32))) {
7632     if (has_leading_comments()) {
7633       if (leading_comments_ != &::google::protobuf::internal::GetEmptyString()) {
7634         leading_comments_->clear();
7635       }
7636     }
7637     if (has_trailing_comments()) {
7638       if (trailing_comments_ != &::google::protobuf::internal::GetEmptyString()) {
7639         trailing_comments_->clear();
7640       }
7641     }
7642   }
7643   path_.Clear();
7644   span_.Clear();
7645   ::memset(_has_bits_, 0, sizeof(_has_bits_));
7646   mutable_unknown_fields()->Clear();
7647 }
7648
7649 bool SourceCodeInfo_Location::MergePartialFromCodedStream(
7650     ::google::protobuf::io::CodedInputStream* input) {
7651 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
7652   ::google::protobuf::uint32 tag;
7653   while ((tag = input->ReadTag()) != 0) {
7654     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
7655       // repeated int32 path = 1 [packed = true];
7656       case 1: {
7657         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
7658             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
7659           DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
7660                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
7661                  input, this->mutable_path())));
7662         } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
7663                    == ::google::protobuf::internal::WireFormatLite::
7664                       WIRETYPE_VARINT) {
7665           DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
7666                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
7667                  1, 10, input, this->mutable_path())));
7668         } else {
7669           goto handle_uninterpreted;
7670         }
7671         if (input->ExpectTag(18)) goto parse_span;
7672         break;
7673       }
7674
7675       // repeated int32 span = 2 [packed = true];
7676       case 2: {
7677         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
7678             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
7679          parse_span:
7680           DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
7681                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
7682                  input, this->mutable_span())));
7683         } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
7684                    == ::google::protobuf::internal::WireFormatLite::
7685                       WIRETYPE_VARINT) {
7686           DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
7687                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
7688                  1, 18, input, this->mutable_span())));
7689         } else {
7690           goto handle_uninterpreted;
7691         }
7692         if (input->ExpectTag(26)) goto parse_leading_comments;
7693         break;
7694       }
7695
7696       // optional string leading_comments = 3;
7697       case 3: {
7698         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
7699             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
7700          parse_leading_comments:
7701           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
7702                 input, this->mutable_leading_comments()));
7703           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
7704             this->leading_comments().data(), this->leading_comments().length(),
7705             ::google::protobuf::internal::WireFormat::PARSE);
7706         } else {
7707           goto handle_uninterpreted;
7708         }
7709         if (input->ExpectTag(34)) goto parse_trailing_comments;
7710         break;
7711       }
7712
7713       // optional string trailing_comments = 4;
7714       case 4: {
7715         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
7716             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
7717          parse_trailing_comments:
7718           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
7719                 input, this->mutable_trailing_comments()));
7720           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
7721             this->trailing_comments().data(), this->trailing_comments().length(),
7722             ::google::protobuf::internal::WireFormat::PARSE);
7723         } else {
7724           goto handle_uninterpreted;
7725         }
7726         if (input->ExpectAtEnd()) return true;
7727         break;
7728       }
7729
7730       default: {
7731       handle_uninterpreted:
7732         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
7733             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
7734           return true;
7735         }
7736         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
7737               input, tag, mutable_unknown_fields()));
7738         break;
7739       }
7740     }
7741   }
7742   return true;
7743 #undef DO_
7744 }
7745
7746 void SourceCodeInfo_Location::SerializeWithCachedSizes(
7747     ::google::protobuf::io::CodedOutputStream* output) const {
7748   // repeated int32 path = 1 [packed = true];
7749   if (this->path_size() > 0) {
7750     ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
7751     output->WriteVarint32(_path_cached_byte_size_);
7752   }
7753   for (int i = 0; i < this->path_size(); i++) {
7754     ::google::protobuf::internal::WireFormatLite::WriteInt32NoTag(
7755       this->path(i), output);
7756   }
7757
7758   // repeated int32 span = 2 [packed = true];
7759   if (this->span_size() > 0) {
7760     ::google::protobuf::internal::WireFormatLite::WriteTag(2, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
7761     output->WriteVarint32(_span_cached_byte_size_);
7762   }
7763   for (int i = 0; i < this->span_size(); i++) {
7764     ::google::protobuf::internal::WireFormatLite::WriteInt32NoTag(
7765       this->span(i), output);
7766   }
7767
7768   // optional string leading_comments = 3;
7769   if (has_leading_comments()) {
7770     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
7771       this->leading_comments().data(), this->leading_comments().length(),
7772       ::google::protobuf::internal::WireFormat::SERIALIZE);
7773     ::google::protobuf::internal::WireFormatLite::WriteString(
7774       3, this->leading_comments(), output);
7775   }
7776
7777   // optional string trailing_comments = 4;
7778   if (has_trailing_comments()) {
7779     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
7780       this->trailing_comments().data(), this->trailing_comments().length(),
7781       ::google::protobuf::internal::WireFormat::SERIALIZE);
7782     ::google::protobuf::internal::WireFormatLite::WriteString(
7783       4, this->trailing_comments(), output);
7784   }
7785
7786   if (!unknown_fields().empty()) {
7787     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
7788         unknown_fields(), output);
7789   }
7790 }
7791
7792 ::google::protobuf::uint8* SourceCodeInfo_Location::SerializeWithCachedSizesToArray(
7793     ::google::protobuf::uint8* target) const {
7794   // repeated int32 path = 1 [packed = true];
7795   if (this->path_size() > 0) {
7796     target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
7797       1,
7798       ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
7799       target);
7800     target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
7801       _path_cached_byte_size_, target);
7802   }
7803   for (int i = 0; i < this->path_size(); i++) {
7804     target = ::google::protobuf::internal::WireFormatLite::
7805       WriteInt32NoTagToArray(this->path(i), target);
7806   }
7807
7808   // repeated int32 span = 2 [packed = true];
7809   if (this->span_size() > 0) {
7810     target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
7811       2,
7812       ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
7813       target);
7814     target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
7815       _span_cached_byte_size_, target);
7816   }
7817   for (int i = 0; i < this->span_size(); i++) {
7818     target = ::google::protobuf::internal::WireFormatLite::
7819       WriteInt32NoTagToArray(this->span(i), target);
7820   }
7821
7822   // optional string leading_comments = 3;
7823   if (has_leading_comments()) {
7824     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
7825       this->leading_comments().data(), this->leading_comments().length(),
7826       ::google::protobuf::internal::WireFormat::SERIALIZE);
7827     target =
7828       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
7829         3, this->leading_comments(), target);
7830   }
7831
7832   // optional string trailing_comments = 4;
7833   if (has_trailing_comments()) {
7834     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
7835       this->trailing_comments().data(), this->trailing_comments().length(),
7836       ::google::protobuf::internal::WireFormat::SERIALIZE);
7837     target =
7838       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
7839         4, this->trailing_comments(), target);
7840   }
7841
7842   if (!unknown_fields().empty()) {
7843     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
7844         unknown_fields(), target);
7845   }
7846   return target;
7847 }
7848
7849 int SourceCodeInfo_Location::ByteSize() const {
7850   int total_size = 0;
7851
7852   if (_has_bits_[2 / 32] & (0xffu << (2 % 32))) {
7853     // optional string leading_comments = 3;
7854     if (has_leading_comments()) {
7855       total_size += 1 +
7856         ::google::protobuf::internal::WireFormatLite::StringSize(
7857           this->leading_comments());
7858     }
7859
7860     // optional string trailing_comments = 4;
7861     if (has_trailing_comments()) {
7862       total_size += 1 +
7863         ::google::protobuf::internal::WireFormatLite::StringSize(
7864           this->trailing_comments());
7865     }
7866
7867   }
7868   // repeated int32 path = 1 [packed = true];
7869   {
7870     int data_size = 0;
7871     for (int i = 0; i < this->path_size(); i++) {
7872       data_size += ::google::protobuf::internal::WireFormatLite::
7873         Int32Size(this->path(i));
7874     }
7875     if (data_size > 0) {
7876       total_size += 1 +
7877         ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
7878     }
7879     GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
7880     _path_cached_byte_size_ = data_size;
7881     GOOGLE_SAFE_CONCURRENT_WRITES_END();
7882     total_size += data_size;
7883   }
7884
7885   // repeated int32 span = 2 [packed = true];
7886   {
7887     int data_size = 0;
7888     for (int i = 0; i < this->span_size(); i++) {
7889       data_size += ::google::protobuf::internal::WireFormatLite::
7890         Int32Size(this->span(i));
7891     }
7892     if (data_size > 0) {
7893       total_size += 1 +
7894         ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
7895     }
7896     GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
7897     _span_cached_byte_size_ = data_size;
7898     GOOGLE_SAFE_CONCURRENT_WRITES_END();
7899     total_size += data_size;
7900   }
7901
7902   if (!unknown_fields().empty()) {
7903     total_size +=
7904       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
7905         unknown_fields());
7906   }
7907   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
7908   _cached_size_ = total_size;
7909   GOOGLE_SAFE_CONCURRENT_WRITES_END();
7910   return total_size;
7911 }
7912
7913 void SourceCodeInfo_Location::MergeFrom(const ::google::protobuf::Message& from) {
7914   GOOGLE_CHECK_NE(&from, this);
7915   const SourceCodeInfo_Location* source =
7916     ::google::protobuf::internal::dynamic_cast_if_available<const SourceCodeInfo_Location*>(
7917       &from);
7918   if (source == NULL) {
7919     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
7920   } else {
7921     MergeFrom(*source);
7922   }
7923 }
7924
7925 void SourceCodeInfo_Location::MergeFrom(const SourceCodeInfo_Location& from) {
7926   GOOGLE_CHECK_NE(&from, this);
7927   path_.MergeFrom(from.path_);
7928   span_.MergeFrom(from.span_);
7929   if (from._has_bits_[2 / 32] & (0xffu << (2 % 32))) {
7930     if (from.has_leading_comments()) {
7931       set_leading_comments(from.leading_comments());
7932     }
7933     if (from.has_trailing_comments()) {
7934       set_trailing_comments(from.trailing_comments());
7935     }
7936   }
7937   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
7938 }
7939
7940 void SourceCodeInfo_Location::CopyFrom(const ::google::protobuf::Message& from) {
7941   if (&from == this) return;
7942   Clear();
7943   MergeFrom(from);
7944 }
7945
7946 void SourceCodeInfo_Location::CopyFrom(const SourceCodeInfo_Location& from) {
7947   if (&from == this) return;
7948   Clear();
7949   MergeFrom(from);
7950 }
7951
7952 bool SourceCodeInfo_Location::IsInitialized() const {
7953
7954   return true;
7955 }
7956
7957 void SourceCodeInfo_Location::Swap(SourceCodeInfo_Location* other) {
7958   if (other != this) {
7959     path_.Swap(&other->path_);
7960     span_.Swap(&other->span_);
7961     std::swap(leading_comments_, other->leading_comments_);
7962     std::swap(trailing_comments_, other->trailing_comments_);
7963     std::swap(_has_bits_[0], other->_has_bits_[0]);
7964     _unknown_fields_.Swap(&other->_unknown_fields_);
7965     std::swap(_cached_size_, other->_cached_size_);
7966   }
7967 }
7968
7969 ::google::protobuf::Metadata SourceCodeInfo_Location::GetMetadata() const {
7970   protobuf_AssignDescriptorsOnce();
7971   ::google::protobuf::Metadata metadata;
7972   metadata.descriptor = SourceCodeInfo_Location_descriptor_;
7973   metadata.reflection = SourceCodeInfo_Location_reflection_;
7974   return metadata;
7975 }
7976
7977
7978 // -------------------------------------------------------------------
7979
7980 #ifndef _MSC_VER
7981 const int SourceCodeInfo::kLocationFieldNumber;
7982 #endif  // !_MSC_VER
7983
7984 SourceCodeInfo::SourceCodeInfo()
7985   : ::google::protobuf::Message() {
7986   SharedCtor();
7987 }
7988
7989 void SourceCodeInfo::InitAsDefaultInstance() {
7990 }
7991
7992 SourceCodeInfo::SourceCodeInfo(const SourceCodeInfo& from)
7993   : ::google::protobuf::Message() {
7994   SharedCtor();
7995   MergeFrom(from);
7996 }
7997
7998 void SourceCodeInfo::SharedCtor() {
7999   _cached_size_ = 0;
8000   ::memset(_has_bits_, 0, sizeof(_has_bits_));
8001 }
8002
8003 SourceCodeInfo::~SourceCodeInfo() {
8004   SharedDtor();
8005 }
8006
8007 void SourceCodeInfo::SharedDtor() {
8008   if (this != default_instance_) {
8009   }
8010 }
8011
8012 void SourceCodeInfo::SetCachedSize(int size) const {
8013   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
8014   _cached_size_ = size;
8015   GOOGLE_SAFE_CONCURRENT_WRITES_END();
8016 }
8017 const ::google::protobuf::Descriptor* SourceCodeInfo::descriptor() {
8018   protobuf_AssignDescriptorsOnce();
8019   return SourceCodeInfo_descriptor_;
8020 }
8021
8022 const SourceCodeInfo& SourceCodeInfo::default_instance() {
8023   if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
8024   return *default_instance_;
8025 }
8026
8027 SourceCodeInfo* SourceCodeInfo::default_instance_ = NULL;
8028
8029 SourceCodeInfo* SourceCodeInfo::New() const {
8030   return new SourceCodeInfo;
8031 }
8032
8033 void SourceCodeInfo::Clear() {
8034   location_.Clear();
8035   ::memset(_has_bits_, 0, sizeof(_has_bits_));
8036   mutable_unknown_fields()->Clear();
8037 }
8038
8039 bool SourceCodeInfo::MergePartialFromCodedStream(
8040     ::google::protobuf::io::CodedInputStream* input) {
8041 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
8042   ::google::protobuf::uint32 tag;
8043   while ((tag = input->ReadTag()) != 0) {
8044     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
8045       // repeated .google.protobuf.SourceCodeInfo.Location location = 1;
8046       case 1: {
8047         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
8048             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
8049          parse_location:
8050           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
8051                 input, add_location()));
8052         } else {
8053           goto handle_uninterpreted;
8054         }
8055         if (input->ExpectTag(10)) goto parse_location;
8056         if (input->ExpectAtEnd()) return true;
8057         break;
8058       }
8059
8060       default: {
8061       handle_uninterpreted:
8062         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
8063             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
8064           return true;
8065         }
8066         DO_(::google::protobuf::internal::WireFormatLite::SkipField(
8067               input, tag, mutable_unknown_fields()));
8068         break;
8069       }
8070     }
8071   }
8072   return true;
8073 #undef DO_
8074 }
8075
8076 void SourceCodeInfo::SerializeWithCachedSizes(
8077     ::google::protobuf::io::CodedOutputStream* output) const {
8078   // repeated .google.protobuf.SourceCodeInfo.Location location = 1;
8079   for (int i = 0; i < this->location_size(); i++) {
8080     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
8081       1, this->location(i), output);
8082   }
8083
8084   if (!unknown_fields().empty()) {
8085     ::google::protobuf::internal::WireFormatLite::SerializeUnknownFields(
8086         unknown_fields(), output);
8087   }
8088 }
8089
8090 ::google::protobuf::uint8* SourceCodeInfo::SerializeWithCachedSizesToArray(
8091     ::google::protobuf::uint8* target) const {
8092   // repeated .google.protobuf.SourceCodeInfo.Location location = 1;
8093   for (int i = 0; i < this->location_size(); i++) {
8094     target = ::google::protobuf::internal::WireFormatLite::
8095       WriteMessageNoVirtualToArray(
8096         1, this->location(i), target);
8097   }
8098
8099   if (!unknown_fields().empty()) {
8100     target = ::google::protobuf::internal::WireFormatLite::SerializeUnknownFieldsToArray(
8101         unknown_fields(), target);
8102   }
8103   return target;
8104 }
8105
8106 int SourceCodeInfo::ByteSize() const {
8107   int total_size = 0;
8108
8109   // repeated .google.protobuf.SourceCodeInfo.Location location = 1;
8110   total_size += 1 * this->location_size();
8111   for (int i = 0; i < this->location_size(); i++) {
8112     total_size +=
8113       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
8114         this->location(i));
8115   }
8116
8117   if (!unknown_fields().empty()) {
8118     total_size +=
8119       ::google::protobuf::internal::WireFormatLite::ComputeUnknownFieldsSize(
8120         unknown_fields());
8121   }
8122   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
8123   _cached_size_ = total_size;
8124   GOOGLE_SAFE_CONCURRENT_WRITES_END();
8125   return total_size;
8126 }
8127
8128 void SourceCodeInfo::MergeFrom(const ::google::protobuf::Message& from) {
8129   GOOGLE_CHECK_NE(&from, this);
8130   const SourceCodeInfo* source =
8131     ::google::protobuf::internal::dynamic_cast_if_available<const SourceCodeInfo*>(
8132       &from);
8133   if (source == NULL) {
8134     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
8135   } else {
8136     MergeFrom(*source);
8137   }
8138 }
8139
8140 void SourceCodeInfo::MergeFrom(const SourceCodeInfo& from) {
8141   GOOGLE_CHECK_NE(&from, this);
8142   location_.MergeFrom(from.location_);
8143   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
8144 }
8145
8146 void SourceCodeInfo::CopyFrom(const ::google::protobuf::Message& from) {
8147   if (&from == this) return;
8148   Clear();
8149   MergeFrom(from);
8150 }
8151
8152 void SourceCodeInfo::CopyFrom(const SourceCodeInfo& from) {
8153   if (&from == this) return;
8154   Clear();
8155   MergeFrom(from);
8156 }
8157
8158 bool SourceCodeInfo::IsInitialized() const {
8159
8160   return true;
8161 }
8162
8163 void SourceCodeInfo::Swap(SourceCodeInfo* other) {
8164   if (other != this) {
8165     location_.Swap(&other->location_);
8166     std::swap(_has_bits_[0], other->_has_bits_[0]);
8167     _unknown_fields_.Swap(&other->_unknown_fields_);
8168     std::swap(_cached_size_, other->_cached_size_);
8169   }
8170 }
8171
8172 ::google::protobuf::Metadata SourceCodeInfo::GetMetadata() const {
8173   protobuf_AssignDescriptorsOnce();
8174   ::google::protobuf::Metadata metadata;
8175   metadata.descriptor = SourceCodeInfo_descriptor_;
8176   metadata.reflection = SourceCodeInfo_reflection_;
8177   return metadata;
8178 }
8179
8180
8181 // @@protoc_insertion_point(namespace_scope)
8182
8183 }  // namespace protobuf
8184 }  // namespace google
8185
8186 // @@protoc_insertion_point(global_scope)