src/third_party/protobuf/src/google/protobuf/compiler/plugin.pb.h

   1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
   2 // source: google/protobuf/compiler/plugin.proto
   3
   4 #ifndef PROTOBUF_google_2fprotobuf_2fcompiler_2fplugin_2eproto__INCLUDED
   5 #define PROTOBUF_google_2fprotobuf_2fcompiler_2fplugin_2eproto__INCLUDED
   6
   7 #include <string>
   8
   9 #include <google/protobuf/stubs/common.h>
  10
  11 #if GOOGLE_PROTOBUF_VERSION < 2005000
  12 #error This file was generated by a newer version of protoc which is
  13 #error incompatible with your Protocol Buffer headers.  Please update
  14 #error your headers.
  15 #endif
  16 #if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
  17 #error This file was generated by an older version of protoc which is
  18 #error incompatible with your Protocol Buffer headers.  Please
  19 #error regenerate this file with a newer version of protoc.
  20 #endif
  21
  22 #include <google/protobuf/generated_message_util.h>
  23 #include <google/protobuf/message.h>
  24 #include <google/protobuf/repeated_field.h>
  25 #include <google/protobuf/extension_set.h>
  26 #include <google/protobuf/unknown_field_set.h>
  27 #include "google/protobuf/descriptor.pb.h"
  28 // @@protoc_insertion_point(includes)
  29
  30 namespace google {
  31 namespace protobuf {
  32 namespace compiler {
  33
  34 // Internal implementation detail -- do not call these.
  35 void LIBPROTOC_EXPORT protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
  36 void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
  37 void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
  38
  39 class CodeGeneratorRequest;
  40 class CodeGeneratorResponse;
  41 class CodeGeneratorResponse_File;
  42
  43 // ===================================================================
  44
  45 class LIBPROTOC_EXPORT CodeGeneratorRequest : public ::google::protobuf::Message {
  46  public:
  47   CodeGeneratorRequest();
  48   virtual ~CodeGeneratorRequest();
  49
  50   CodeGeneratorRequest(const CodeGeneratorRequest& from);
  51
  52   inline CodeGeneratorRequest& operator=(const CodeGeneratorRequest& from) {
  53     CopyFrom(from);
  54     return *this;
  55   }
  56
  57   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
  58     return _unknown_fields_;
  59   }
  60
  61   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
  62     return &_unknown_fields_;
  63   }
  64
  65   static const ::google::protobuf::Descriptor* descriptor();
  66   static const CodeGeneratorRequest& default_instance();
  67
  68   void Swap(CodeGeneratorRequest* other);
  69
  70   // implements Message ----------------------------------------------
  71
  72   CodeGeneratorRequest* New() const;
  73   void CopyFrom(const ::google::protobuf::Message& from);
  74   void MergeFrom(const ::google::protobuf::Message& from);
  75   void CopyFrom(const CodeGeneratorRequest& from);
  76   void MergeFrom(const CodeGeneratorRequest& from);
  77   void Clear();
  78   bool IsInitialized() const;
  79
  80   int ByteSize() const;
  81   bool MergePartialFromCodedStream(
  82       ::google::protobuf::io::CodedInputStream* input);
  83   void SerializeWithCachedSizes(
  84       ::google::protobuf::io::CodedOutputStream* output) const;
  85   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  86   int GetCachedSize() const { return _cached_size_; }
  87   private:
  88   void SharedCtor();
  89   void SharedDtor();
  90   void SetCachedSize(int size) const;
  91   public:
  92
  93   ::google::protobuf::Metadata GetMetadata() const;
  94
  95   // nested types ----------------------------------------------------
  96
  97   // accessors -------------------------------------------------------
  98
  99   // repeated string file_to_generate = 1;
 100   inline int file_to_generate_size() const;
 101   inline void clear_file_to_generate();
 102   static const int kFileToGenerateFieldNumber = 1;
 103   inline const ::std::string& file_to_generate(int index) const;
 104   inline ::std::string* mutable_file_to_generate(int index);
 105   inline void set_file_to_generate(int index, const ::std::string& value);
 106   inline void set_file_to_generate(int index, const char* value);
 107   inline void set_file_to_generate(int index, const char* value, size_t size);
 108   inline ::std::string* add_file_to_generate();
 109   inline void add_file_to_generate(const ::std::string& value);
 110   inline void add_file_to_generate(const char* value);
 111   inline void add_file_to_generate(const char* value, size_t size);
 112   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& file_to_generate() const;
 113   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_file_to_generate();
 114
 115   // optional string parameter = 2;
 116   inline bool has_parameter() const;
 117   inline void clear_parameter();
 118   static const int kParameterFieldNumber = 2;
 119   inline const ::std::string& parameter() const;
 120   inline void set_parameter(const ::std::string& value);
 121   inline void set_parameter(const char* value);
 122   inline void set_parameter(const char* value, size_t size);
 123   inline ::std::string* mutable_parameter();
 124   inline ::std::string* release_parameter();
 125   inline void set_allocated_parameter(::std::string* parameter);
 126
 127   // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
 128   inline int proto_file_size() const;
 129   inline void clear_proto_file();
 130   static const int kProtoFileFieldNumber = 15;
 131   inline const ::google::protobuf::FileDescriptorProto& proto_file(int index) const;
 132   inline ::google::protobuf::FileDescriptorProto* mutable_proto_file(int index);
 133   inline ::google::protobuf::FileDescriptorProto* add_proto_file();
 134   inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >&
 135       proto_file() const;
 136   inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >*
 137       mutable_proto_file();
 138
 139   // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorRequest)
 140  private:
 141   inline void set_has_parameter();
 142   inline void clear_has_parameter();
 143
 144   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 145
 146   ::google::protobuf::RepeatedPtrField< ::std::string> file_to_generate_;
 147   ::std::string* parameter_;
 148   ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto > proto_file_;
 149
 150   mutable int _cached_size_;
 151   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
 152
 153   friend void LIBPROTOC_EXPORT protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
 154   friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
 155   friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
 156
 157   void InitAsDefaultInstance();
 158   static CodeGeneratorRequest* default_instance_;
 159 };
 160 // -------------------------------------------------------------------
 161
 162 class LIBPROTOC_EXPORT CodeGeneratorResponse_File : public ::google::protobuf::Message {
 163  public:
 164   CodeGeneratorResponse_File();
 165   virtual ~CodeGeneratorResponse_File();
 166
 167   CodeGeneratorResponse_File(const CodeGeneratorResponse_File& from);
 168
 169   inline CodeGeneratorResponse_File& operator=(const CodeGeneratorResponse_File& from) {
 170     CopyFrom(from);
 171     return *this;
 172   }
 173
 174   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 175     return _unknown_fields_;
 176   }
 177
 178   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 179     return &_unknown_fields_;
 180   }
 181
 182   static const ::google::protobuf::Descriptor* descriptor();
 183   static const CodeGeneratorResponse_File& default_instance();
 184
 185   void Swap(CodeGeneratorResponse_File* other);
 186
 187   // implements Message ----------------------------------------------
 188
 189   CodeGeneratorResponse_File* New() const;
 190   void CopyFrom(const ::google::protobuf::Message& from);
 191   void MergeFrom(const ::google::protobuf::Message& from);
 192   void CopyFrom(const CodeGeneratorResponse_File& from);
 193   void MergeFrom(const CodeGeneratorResponse_File& from);
 194   void Clear();
 195   bool IsInitialized() const;
 196
 197   int ByteSize() const;
 198   bool MergePartialFromCodedStream(
 199       ::google::protobuf::io::CodedInputStream* input);
 200   void SerializeWithCachedSizes(
 201       ::google::protobuf::io::CodedOutputStream* output) const;
 202   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 203   int GetCachedSize() const { return _cached_size_; }
 204   private:
 205   void SharedCtor();
 206   void SharedDtor();
 207   void SetCachedSize(int size) const;
 208   public:
 209
 210   ::google::protobuf::Metadata GetMetadata() const;
 211
 212   // nested types ----------------------------------------------------
 213
 214   // accessors -------------------------------------------------------
 215
 216   // optional string name = 1;
 217   inline bool has_name() const;
 218   inline void clear_name();
 219   static const int kNameFieldNumber = 1;
 220   inline const ::std::string& name() const;
 221   inline void set_name(const ::std::string& value);
 222   inline void set_name(const char* value);
 223   inline void set_name(const char* value, size_t size);
 224   inline ::std::string* mutable_name();
 225   inline ::std::string* release_name();
 226   inline void set_allocated_name(::std::string* name);
 227
 228   // optional string insertion_point = 2;
 229   inline bool has_insertion_point() const;
 230   inline void clear_insertion_point();
 231   static const int kInsertionPointFieldNumber = 2;
 232   inline const ::std::string& insertion_point() const;
 233   inline void set_insertion_point(const ::std::string& value);
 234   inline void set_insertion_point(const char* value);
 235   inline void set_insertion_point(const char* value, size_t size);
 236   inline ::std::string* mutable_insertion_point();
 237   inline ::std::string* release_insertion_point();
 238   inline void set_allocated_insertion_point(::std::string* insertion_point);
 239
 240   // optional string content = 15;
 241   inline bool has_content() const;
 242   inline void clear_content();
 243   static const int kContentFieldNumber = 15;
 244   inline const ::std::string& content() const;
 245   inline void set_content(const ::std::string& value);
 246   inline void set_content(const char* value);
 247   inline void set_content(const char* value, size_t size);
 248   inline ::std::string* mutable_content();
 249   inline ::std::string* release_content();
 250   inline void set_allocated_content(::std::string* content);
 251
 252   // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse.File)
 253  private:
 254   inline void set_has_name();
 255   inline void clear_has_name();
 256   inline void set_has_insertion_point();
 257   inline void clear_has_insertion_point();
 258   inline void set_has_content();
 259   inline void clear_has_content();
 260
 261   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 262
 263   ::std::string* name_;
 264   ::std::string* insertion_point_;
 265   ::std::string* content_;
 266
 267   mutable int _cached_size_;
 268   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
 269
 270   friend void LIBPROTOC_EXPORT protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
 271   friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
 272   friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
 273
 274   void InitAsDefaultInstance();
 275   static CodeGeneratorResponse_File* default_instance_;
 276 };
 277 // -------------------------------------------------------------------
 278
 279 class LIBPROTOC_EXPORT CodeGeneratorResponse : public ::google::protobuf::Message {
 280  public:
 281   CodeGeneratorResponse();
 282   virtual ~CodeGeneratorResponse();
 283
 284   CodeGeneratorResponse(const CodeGeneratorResponse& from);
 285
 286   inline CodeGeneratorResponse& operator=(const CodeGeneratorResponse& from) {
 287     CopyFrom(from);
 288     return *this;
 289   }
 290
 291   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
 292     return _unknown_fields_;
 293   }
 294
 295   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
 296     return &_unknown_fields_;
 297   }
 298
 299   static const ::google::protobuf::Descriptor* descriptor();
 300   static const CodeGeneratorResponse& default_instance();
 301
 302   void Swap(CodeGeneratorResponse* other);
 303
 304   // implements Message ----------------------------------------------
 305
 306   CodeGeneratorResponse* New() const;
 307   void CopyFrom(const ::google::protobuf::Message& from);
 308   void MergeFrom(const ::google::protobuf::Message& from);
 309   void CopyFrom(const CodeGeneratorResponse& from);
 310   void MergeFrom(const CodeGeneratorResponse& from);
 311   void Clear();
 312   bool IsInitialized() const;
 313
 314   int ByteSize() const;
 315   bool MergePartialFromCodedStream(
 316       ::google::protobuf::io::CodedInputStream* input);
 317   void SerializeWithCachedSizes(
 318       ::google::protobuf::io::CodedOutputStream* output) const;
 319   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
 320   int GetCachedSize() const { return _cached_size_; }
 321   private:
 322   void SharedCtor();
 323   void SharedDtor();
 324   void SetCachedSize(int size) const;
 325   public:
 326
 327   ::google::protobuf::Metadata GetMetadata() const;
 328
 329   // nested types ----------------------------------------------------
 330
 331   typedef CodeGeneratorResponse_File File;
 332
 333   // accessors -------------------------------------------------------
 334
 335   // optional string error = 1;
 336   inline bool has_error() const;
 337   inline void clear_error();
 338   static const int kErrorFieldNumber = 1;
 339   inline const ::std::string& error() const;
 340   inline void set_error(const ::std::string& value);
 341   inline void set_error(const char* value);
 342   inline void set_error(const char* value, size_t size);
 343   inline ::std::string* mutable_error();
 344   inline ::std::string* release_error();
 345   inline void set_allocated_error(::std::string* error);
 346
 347   // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
 348   inline int file_size() const;
 349   inline void clear_file();
 350   static const int kFileFieldNumber = 15;
 351   inline const ::google::protobuf::compiler::CodeGeneratorResponse_File& file(int index) const;
 352   inline ::google::protobuf::compiler::CodeGeneratorResponse_File* mutable_file(int index);
 353   inline ::google::protobuf::compiler::CodeGeneratorResponse_File* add_file();
 354   inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File >&
 355       file() const;
 356   inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File >*
 357       mutable_file();
 358
 359   // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse)
 360  private:
 361   inline void set_has_error();
 362   inline void clear_has_error();
 363
 364   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 365
 366   ::std::string* error_;
 367   ::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File > file_;
 368
 369   mutable int _cached_size_;
 370   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
 371
 372   friend void LIBPROTOC_EXPORT protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
 373   friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
 374   friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
 375
 376   void InitAsDefaultInstance();
 377   static CodeGeneratorResponse* default_instance_;
 378 };
 379 // ===================================================================
 380
 381
 382 // ===================================================================
 383
 384 // CodeGeneratorRequest
 385
 386 // repeated string file_to_generate = 1;
 387 inline int CodeGeneratorRequest::file_to_generate_size() const {
 388   return file_to_generate_.size();
 389 }
 390 inline void CodeGeneratorRequest::clear_file_to_generate() {
 391   file_to_generate_.Clear();
 392 }
 393 inline const ::std::string& CodeGeneratorRequest::file_to_generate(int index) const {
 394   return file_to_generate_.Get(index);
 395 }
 396 inline ::std::string* CodeGeneratorRequest::mutable_file_to_generate(int index) {
 397   return file_to_generate_.Mutable(index);
 398 }
 399 inline void CodeGeneratorRequest::set_file_to_generate(int index, const ::std::string& value) {
 400   file_to_generate_.Mutable(index)->assign(value);
 401 }
 402 inline void CodeGeneratorRequest::set_file_to_generate(int index, const char* value) {
 403   file_to_generate_.Mutable(index)->assign(value);
 404 }
 405 inline void CodeGeneratorRequest::set_file_to_generate(int index, const char* value, size_t size) {
 406   file_to_generate_.Mutable(index)->assign(
 407     reinterpret_cast<const char*>(value), size);
 408 }
 409 inline ::std::string* CodeGeneratorRequest::add_file_to_generate() {
 410   return file_to_generate_.Add();
 411 }
 412 inline void CodeGeneratorRequest::add_file_to_generate(const ::std::string& value) {
 413   file_to_generate_.Add()->assign(value);
 414 }
 415 inline void CodeGeneratorRequest::add_file_to_generate(const char* value) {
 416   file_to_generate_.Add()->assign(value);
 417 }
 418 inline void CodeGeneratorRequest::add_file_to_generate(const char* value, size_t size) {
 419   file_to_generate_.Add()->assign(reinterpret_cast<const char*>(value), size);
 420 }
 421 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
 422 CodeGeneratorRequest::file_to_generate() const {
 423   return file_to_generate_;
 424 }
 425 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
 426 CodeGeneratorRequest::mutable_file_to_generate() {
 427   return &file_to_generate_;
 428 }
 429
 430 // optional string parameter = 2;
 431 inline bool CodeGeneratorRequest::has_parameter() const {
 432   return (_has_bits_[0] & 0x00000002u) != 0;
 433 }
 434 inline void CodeGeneratorRequest::set_has_parameter() {
 435   _has_bits_[0] |= 0x00000002u;
 436 }
 437 inline void CodeGeneratorRequest::clear_has_parameter() {
 438   _has_bits_[0] &= ~0x00000002u;
 439 }
 440 inline void CodeGeneratorRequest::clear_parameter() {
 441   if (parameter_ != &::google::protobuf::internal::kEmptyString) {
 442     parameter_->clear();
 443   }
 444   clear_has_parameter();
 445 }
 446 inline const ::std::string& CodeGeneratorRequest::parameter() const {
 447   return *parameter_;
 448 }
 449 inline void CodeGeneratorRequest::set_parameter(const ::std::string& value) {
 450   set_has_parameter();
 451   if (parameter_ == &::google::protobuf::internal::kEmptyString) {
 452     parameter_ = new ::std::string;
 453   }
 454   parameter_->assign(value);
 455 }
 456 inline void CodeGeneratorRequest::set_parameter(const char* value) {
 457   set_has_parameter();
 458   if (parameter_ == &::google::protobuf::internal::kEmptyString) {
 459     parameter_ = new ::std::string;
 460   }
 461   parameter_->assign(value);
 462 }
 463 inline void CodeGeneratorRequest::set_parameter(const char* value, size_t size) {
 464   set_has_parameter();
 465   if (parameter_ == &::google::protobuf::internal::kEmptyString) {
 466     parameter_ = new ::std::string;
 467   }
 468   parameter_->assign(reinterpret_cast<const char*>(value), size);
 469 }
 470 inline ::std::string* CodeGeneratorRequest::mutable_parameter() {
 471   set_has_parameter();
 472   if (parameter_ == &::google::protobuf::internal::kEmptyString) {
 473     parameter_ = new ::std::string;
 474   }
 475   return parameter_;
 476 }
 477 inline ::std::string* CodeGeneratorRequest::release_parameter() {
 478   clear_has_parameter();
 479   if (parameter_ == &::google::protobuf::internal::kEmptyString) {
 480     return NULL;
 481   } else {
 482     ::std::string* temp = parameter_;
 483     parameter_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 484     return temp;
 485   }
 486 }
 487 inline void CodeGeneratorRequest::set_allocated_parameter(::std::string* parameter) {
 488   if (parameter_ != &::google::protobuf::internal::kEmptyString) {
 489     delete parameter_;
 490   }
 491   if (parameter) {
 492     set_has_parameter();
 493     parameter_ = parameter;
 494   } else {
 495     clear_has_parameter();
 496     parameter_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 497   }
 498 }
 499
 500 // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
 501 inline int CodeGeneratorRequest::proto_file_size() const {
 502   return proto_file_.size();
 503 }
 504 inline void CodeGeneratorRequest::clear_proto_file() {
 505   proto_file_.Clear();
 506 }
 507 inline const ::google::protobuf::FileDescriptorProto& CodeGeneratorRequest::proto_file(int index) const {
 508   return proto_file_.Get(index);
 509 }
 510 inline ::google::protobuf::FileDescriptorProto* CodeGeneratorRequest::mutable_proto_file(int index) {
 511   return proto_file_.Mutable(index);
 512 }
 513 inline ::google::protobuf::FileDescriptorProto* CodeGeneratorRequest::add_proto_file() {
 514   return proto_file_.Add();
 515 }
 516 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >&
 517 CodeGeneratorRequest::proto_file() const {
 518   return proto_file_;
 519 }
 520 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >*
 521 CodeGeneratorRequest::mutable_proto_file() {
 522   return &proto_file_;
 523 }
 524
 525 // -------------------------------------------------------------------
 526
 527 // CodeGeneratorResponse_File
 528
 529 // optional string name = 1;
 530 inline bool CodeGeneratorResponse_File::has_name() const {
 531   return (_has_bits_[0] & 0x00000001u) != 0;
 532 }
 533 inline void CodeGeneratorResponse_File::set_has_name() {
 534   _has_bits_[0] |= 0x00000001u;
 535 }
 536 inline void CodeGeneratorResponse_File::clear_has_name() {
 537   _has_bits_[0] &= ~0x00000001u;
 538 }
 539 inline void CodeGeneratorResponse_File::clear_name() {
 540   if (name_ != &::google::protobuf::internal::kEmptyString) {
 541     name_->clear();
 542   }
 543   clear_has_name();
 544 }
 545 inline const ::std::string& CodeGeneratorResponse_File::name() const {
 546   return *name_;
 547 }
 548 inline void CodeGeneratorResponse_File::set_name(const ::std::string& value) {
 549   set_has_name();
 550   if (name_ == &::google::protobuf::internal::kEmptyString) {
 551     name_ = new ::std::string;
 552   }
 553   name_->assign(value);
 554 }
 555 inline void CodeGeneratorResponse_File::set_name(const char* value) {
 556   set_has_name();
 557   if (name_ == &::google::protobuf::internal::kEmptyString) {
 558     name_ = new ::std::string;
 559   }
 560   name_->assign(value);
 561 }
 562 inline void CodeGeneratorResponse_File::set_name(const char* value, size_t size) {
 563   set_has_name();
 564   if (name_ == &::google::protobuf::internal::kEmptyString) {
 565     name_ = new ::std::string;
 566   }
 567   name_->assign(reinterpret_cast<const char*>(value), size);
 568 }
 569 inline ::std::string* CodeGeneratorResponse_File::mutable_name() {
 570   set_has_name();
 571   if (name_ == &::google::protobuf::internal::kEmptyString) {
 572     name_ = new ::std::string;
 573   }
 574   return name_;
 575 }
 576 inline ::std::string* CodeGeneratorResponse_File::release_name() {
 577   clear_has_name();
 578   if (name_ == &::google::protobuf::internal::kEmptyString) {
 579     return NULL;
 580   } else {
 581     ::std::string* temp = name_;
 582     name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 583     return temp;
 584   }
 585 }
 586 inline void CodeGeneratorResponse_File::set_allocated_name(::std::string* name) {
 587   if (name_ != &::google::protobuf::internal::kEmptyString) {
 588     delete name_;
 589   }
 590   if (name) {
 591     set_has_name();
 592     name_ = name;
 593   } else {
 594     clear_has_name();
 595     name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 596   }
 597 }
 598
 599 // optional string insertion_point = 2;
 600 inline bool CodeGeneratorResponse_File::has_insertion_point() const {
 601   return (_has_bits_[0] & 0x00000002u) != 0;
 602 }
 603 inline void CodeGeneratorResponse_File::set_has_insertion_point() {
 604   _has_bits_[0] |= 0x00000002u;
 605 }
 606 inline void CodeGeneratorResponse_File::clear_has_insertion_point() {
 607   _has_bits_[0] &= ~0x00000002u;
 608 }
 609 inline void CodeGeneratorResponse_File::clear_insertion_point() {
 610   if (insertion_point_ != &::google::protobuf::internal::kEmptyString) {
 611     insertion_point_->clear();
 612   }
 613   clear_has_insertion_point();
 614 }
 615 inline const ::std::string& CodeGeneratorResponse_File::insertion_point() const {
 616   return *insertion_point_;
 617 }
 618 inline void CodeGeneratorResponse_File::set_insertion_point(const ::std::string& value) {
 619   set_has_insertion_point();
 620   if (insertion_point_ == &::google::protobuf::internal::kEmptyString) {
 621     insertion_point_ = new ::std::string;
 622   }
 623   insertion_point_->assign(value);
 624 }
 625 inline void CodeGeneratorResponse_File::set_insertion_point(const char* value) {
 626   set_has_insertion_point();
 627   if (insertion_point_ == &::google::protobuf::internal::kEmptyString) {
 628     insertion_point_ = new ::std::string;
 629   }
 630   insertion_point_->assign(value);
 631 }
 632 inline void CodeGeneratorResponse_File::set_insertion_point(const char* value, size_t size) {
 633   set_has_insertion_point();
 634   if (insertion_point_ == &::google::protobuf::internal::kEmptyString) {
 635     insertion_point_ = new ::std::string;
 636   }
 637   insertion_point_->assign(reinterpret_cast<const char*>(value), size);
 638 }
 639 inline ::std::string* CodeGeneratorResponse_File::mutable_insertion_point() {
 640   set_has_insertion_point();
 641   if (insertion_point_ == &::google::protobuf::internal::kEmptyString) {
 642     insertion_point_ = new ::std::string;
 643   }
 644   return insertion_point_;
 645 }
 646 inline ::std::string* CodeGeneratorResponse_File::release_insertion_point() {
 647   clear_has_insertion_point();
 648   if (insertion_point_ == &::google::protobuf::internal::kEmptyString) {
 649     return NULL;
 650   } else {
 651     ::std::string* temp = insertion_point_;
 652     insertion_point_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 653     return temp;
 654   }
 655 }
 656 inline void CodeGeneratorResponse_File::set_allocated_insertion_point(::std::string* insertion_point) {
 657   if (insertion_point_ != &::google::protobuf::internal::kEmptyString) {
 658     delete insertion_point_;
 659   }
 660   if (insertion_point) {
 661     set_has_insertion_point();
 662     insertion_point_ = insertion_point;
 663   } else {
 664     clear_has_insertion_point();
 665     insertion_point_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 666   }
 667 }
 668
 669 // optional string content = 15;
 670 inline bool CodeGeneratorResponse_File::has_content() const {
 671   return (_has_bits_[0] & 0x00000004u) != 0;
 672 }
 673 inline void CodeGeneratorResponse_File::set_has_content() {
 674   _has_bits_[0] |= 0x00000004u;
 675 }
 676 inline void CodeGeneratorResponse_File::clear_has_content() {
 677   _has_bits_[0] &= ~0x00000004u;
 678 }
 679 inline void CodeGeneratorResponse_File::clear_content() {
 680   if (content_ != &::google::protobuf::internal::kEmptyString) {
 681     content_->clear();
 682   }
 683   clear_has_content();
 684 }
 685 inline const ::std::string& CodeGeneratorResponse_File::content() const {
 686   return *content_;
 687 }
 688 inline void CodeGeneratorResponse_File::set_content(const ::std::string& value) {
 689   set_has_content();
 690   if (content_ == &::google::protobuf::internal::kEmptyString) {
 691     content_ = new ::std::string;
 692   }
 693   content_->assign(value);
 694 }
 695 inline void CodeGeneratorResponse_File::set_content(const char* value) {
 696   set_has_content();
 697   if (content_ == &::google::protobuf::internal::kEmptyString) {
 698     content_ = new ::std::string;
 699   }
 700   content_->assign(value);
 701 }
 702 inline void CodeGeneratorResponse_File::set_content(const char* value, size_t size) {
 703   set_has_content();
 704   if (content_ == &::google::protobuf::internal::kEmptyString) {
 705     content_ = new ::std::string;
 706   }
 707   content_->assign(reinterpret_cast<const char*>(value), size);
 708 }
 709 inline ::std::string* CodeGeneratorResponse_File::mutable_content() {
 710   set_has_content();
 711   if (content_ == &::google::protobuf::internal::kEmptyString) {
 712     content_ = new ::std::string;
 713   }
 714   return content_;
 715 }
 716 inline ::std::string* CodeGeneratorResponse_File::release_content() {
 717   clear_has_content();
 718   if (content_ == &::google::protobuf::internal::kEmptyString) {
 719     return NULL;
 720   } else {
 721     ::std::string* temp = content_;
 722     content_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 723     return temp;
 724   }
 725 }
 726 inline void CodeGeneratorResponse_File::set_allocated_content(::std::string* content) {
 727   if (content_ != &::google::protobuf::internal::kEmptyString) {
 728     delete content_;
 729   }
 730   if (content) {
 731     set_has_content();
 732     content_ = content;
 733   } else {
 734     clear_has_content();
 735     content_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 736   }
 737 }
 738
 739 // -------------------------------------------------------------------
 740
 741 // CodeGeneratorResponse
 742
 743 // optional string error = 1;
 744 inline bool CodeGeneratorResponse::has_error() const {
 745   return (_has_bits_[0] & 0x00000001u) != 0;
 746 }
 747 inline void CodeGeneratorResponse::set_has_error() {
 748   _has_bits_[0] |= 0x00000001u;
 749 }
 750 inline void CodeGeneratorResponse::clear_has_error() {
 751   _has_bits_[0] &= ~0x00000001u;
 752 }
 753 inline void CodeGeneratorResponse::clear_error() {
 754   if (error_ != &::google::protobuf::internal::kEmptyString) {
 755     error_->clear();
 756   }
 757   clear_has_error();
 758 }
 759 inline const ::std::string& CodeGeneratorResponse::error() const {
 760   return *error_;
 761 }
 762 inline void CodeGeneratorResponse::set_error(const ::std::string& value) {
 763   set_has_error();
 764   if (error_ == &::google::protobuf::internal::kEmptyString) {
 765     error_ = new ::std::string;
 766   }
 767   error_->assign(value);
 768 }
 769 inline void CodeGeneratorResponse::set_error(const char* value) {
 770   set_has_error();
 771   if (error_ == &::google::protobuf::internal::kEmptyString) {
 772     error_ = new ::std::string;
 773   }
 774   error_->assign(value);
 775 }
 776 inline void CodeGeneratorResponse::set_error(const char* value, size_t size) {
 777   set_has_error();
 778   if (error_ == &::google::protobuf::internal::kEmptyString) {
 779     error_ = new ::std::string;
 780   }
 781   error_->assign(reinterpret_cast<const char*>(value), size);
 782 }
 783 inline ::std::string* CodeGeneratorResponse::mutable_error() {
 784   set_has_error();
 785   if (error_ == &::google::protobuf::internal::kEmptyString) {
 786     error_ = new ::std::string;
 787   }
 788   return error_;
 789 }
 790 inline ::std::string* CodeGeneratorResponse::release_error() {
 791   clear_has_error();
 792   if (error_ == &::google::protobuf::internal::kEmptyString) {
 793     return NULL;
 794   } else {
 795     ::std::string* temp = error_;
 796     error_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 797     return temp;
 798   }
 799 }
 800 inline void CodeGeneratorResponse::set_allocated_error(::std::string* error) {
 801   if (error_ != &::google::protobuf::internal::kEmptyString) {
 802     delete error_;
 803   }
 804   if (error) {
 805     set_has_error();
 806     error_ = error;
 807   } else {
 808     clear_has_error();
 809     error_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 810   }
 811 }
 812
 813 // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
 814 inline int CodeGeneratorResponse::file_size() const {
 815   return file_.size();
 816 }
 817 inline void CodeGeneratorResponse::clear_file() {
 818   file_.Clear();
 819 }
 820 inline const ::google::protobuf::compiler::CodeGeneratorResponse_File& CodeGeneratorResponse::file(int index) const {
 821   return file_.Get(index);
 822 }
 823 inline ::google::protobuf::compiler::CodeGeneratorResponse_File* CodeGeneratorResponse::mutable_file(int index) {
 824   return file_.Mutable(index);
 825 }
 826 inline ::google::protobuf::compiler::CodeGeneratorResponse_File* CodeGeneratorResponse::add_file() {
 827   return file_.Add();
 828 }
 829 inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File >&
 830 CodeGeneratorResponse::file() const {
 831   return file_;
 832 }
 833 inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File >*
 834 CodeGeneratorResponse::mutable_file() {
 835   return &file_;
 836 }
 837
 838
 839 // @@protoc_insertion_point(namespace_scope)
 840
 841 }  // namespace compiler
 842 }  // namespace protobuf
 843 }  // namespace google
 844
 845 #ifndef SWIG
 846 namespace google {
 847 namespace protobuf {
 848
 849
 850 }  // namespace google
 851 }  // namespace protobuf
 852 #endif  // SWIG
 853
 854 // @@protoc_insertion_point(global_scope)
 855
 856 #endif  // PROTOBUF_google_2fprotobuf_2fcompiler_2fplugin_2eproto__INCLUDED