← Back to branch summary

~verterok/ubuntu/lucid/protobuf/2.4.0a-backport

« back to all changes in this revision

Viewing changes to src/google/protobuf/compiler/plugin.pb.h

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2011-05-31 14:41:47 UTC
  • mfrom: (2.2.8 sid)
  • Revision ID: james.westby@ubuntu.com-20110531144147-s41g5fozgvyo462l
Tags: 2.4.0a-2ubuntu1
* Merge with Debian; remaining changes:
  - Fix linking with -lpthread.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/google/protobuf/compiler/plugin.pb.h
8
8
 
9
9
#include <google/protobuf/stubs/common.h>
10
10
 
11
 
#if GOOGLE_PROTOBUF_VERSION < 2003000
 
11
#if GOOGLE_PROTOBUF_VERSION < 2004000
12
12
#error This file was generated by a newer version of protoc which is
13
13
#error incompatible with your Protocol Buffer headers.  Please update
14
14
#error your headers.
15
15
#endif
16
 
#if 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
 
16
#if 2004000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
17
17
#error This file was generated by an older version of protoc which is
18
18
#error incompatible with your Protocol Buffer headers.  Please
19
19
#error regenerate this file with a newer version of protoc.
120
120
  inline void set_parameter(const char* value);
121
121
  inline void set_parameter(const char* value, size_t size);
122
122
  inline ::std::string* mutable_parameter();
 
123
  inline ::std::string* release_parameter();
123
124
  
124
125
  // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
125
126
  inline int proto_file_size() const;
135
136
  
136
137
  // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorRequest)
137
138
 private:
 
139
  inline void set_has_parameter();
 
140
  inline void clear_has_parameter();
 
141
  
138
142
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
139
 
  mutable int _cached_size_;
140
143
  
141
144
  ::google::protobuf::RepeatedPtrField< ::std::string> file_to_generate_;
142
145
  ::std::string* parameter_;
143
 
  static const ::std::string _default_parameter_;
144
146
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto > proto_file_;
 
147
  
 
148
  mutable int _cached_size_;
 
149
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
 
150
  
145
151
  friend void LIBPROTOC_EXPORT protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
146
152
  friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
147
153
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
148
154
  
149
 
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
150
 
  
151
 
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
152
 
  inline bool _has_bit(int index) const {
153
 
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
154
 
  }
155
 
  inline void _set_bit(int index) {
156
 
    _has_bits_[index / 32] |= (1u << (index % 32));
157
 
  }
158
 
  inline void _clear_bit(int index) {
159
 
    _has_bits_[index / 32] &= ~(1u << (index % 32));
160
 
  }
161
 
  
162
155
  void InitAsDefaultInstance();
163
156
  static CodeGeneratorRequest* default_instance_;
164
157
};
227
220
  inline void set_name(const char* value);
228
221
  inline void set_name(const char* value, size_t size);
229
222
  inline ::std::string* mutable_name();
 
223
  inline ::std::string* release_name();
230
224
  
231
225
  // optional string insertion_point = 2;
232
226
  inline bool has_insertion_point() const;
237
231
  inline void set_insertion_point(const char* value);
238
232
  inline void set_insertion_point(const char* value, size_t size);
239
233
  inline ::std::string* mutable_insertion_point();
 
234
  inline ::std::string* release_insertion_point();
240
235
  
241
236
  // optional string content = 15;
242
237
  inline bool has_content() const;
247
242
  inline void set_content(const char* value);
248
243
  inline void set_content(const char* value, size_t size);
249
244
  inline ::std::string* mutable_content();
 
245
  inline ::std::string* release_content();
250
246
  
251
247
  // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse.File)
252
248
 private:
 
249
  inline void set_has_name();
 
250
  inline void clear_has_name();
 
251
  inline void set_has_insertion_point();
 
252
  inline void clear_has_insertion_point();
 
253
  inline void set_has_content();
 
254
  inline void clear_has_content();
 
255
  
253
256
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
254
 
  mutable int _cached_size_;
255
257
  
256
258
  ::std::string* name_;
257
 
  static const ::std::string _default_name_;
258
259
  ::std::string* insertion_point_;
259
 
  static const ::std::string _default_insertion_point_;
260
260
  ::std::string* content_;
261
 
  static const ::std::string _default_content_;
 
261
  
 
262
  mutable int _cached_size_;
 
263
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
 
264
  
262
265
  friend void LIBPROTOC_EXPORT protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
263
266
  friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
264
267
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
265
268
  
266
 
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
267
 
  
268
 
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
269
 
  inline bool _has_bit(int index) const {
270
 
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
271
 
  }
272
 
  inline void _set_bit(int index) {
273
 
    _has_bits_[index / 32] |= (1u << (index % 32));
274
 
  }
275
 
  inline void _clear_bit(int index) {
276
 
    _has_bits_[index / 32] &= ~(1u << (index % 32));
277
 
  }
278
 
  
279
269
  void InitAsDefaultInstance();
280
270
  static CodeGeneratorResponse_File* default_instance_;
281
271
};
346
336
  inline void set_error(const char* value);
347
337
  inline void set_error(const char* value, size_t size);
348
338
  inline ::std::string* mutable_error();
 
339
  inline ::std::string* release_error();
349
340
  
350
341
  // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
351
342
  inline int file_size() const;
361
352
  
362
353
  // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse)
363
354
 private:
 
355
  inline void set_has_error();
 
356
  inline void clear_has_error();
 
357
  
364
358
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
365
 
  mutable int _cached_size_;
366
359
  
367
360
  ::std::string* error_;
368
 
  static const ::std::string _default_error_;
369
361
  ::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File > file_;
370
 
  friend void LIBPROTOC_EXPORT protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
371
 
  friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
372
 
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
373
362
  
 
363
  mutable int _cached_size_;
374
364
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
375
365
  
376
 
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
377
 
  inline bool _has_bit(int index) const {
378
 
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
379
 
  }
380
 
  inline void _set_bit(int index) {
381
 
    _has_bits_[index / 32] |= (1u << (index % 32));
382
 
  }
383
 
  inline void _clear_bit(int index) {
384
 
    _has_bits_[index / 32] &= ~(1u << (index % 32));
385
 
  }
 
366
  friend void LIBPROTOC_EXPORT protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
 
367
  friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
 
368
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
386
369
  
387
370
  void InitAsDefaultInstance();
388
371
  static CodeGeneratorResponse* default_instance_;
440
423
 
441
424
// optional string parameter = 2;
442
425
inline bool CodeGeneratorRequest::has_parameter() const {
443
 
  return _has_bit(1);
 
426
  return (_has_bits_[0] & 0x00000002u) != 0;
 
427
}
 
428
inline void CodeGeneratorRequest::set_has_parameter() {
 
429
  _has_bits_[0] |= 0x00000002u;
 
430
}
 
431
inline void CodeGeneratorRequest::clear_has_parameter() {
 
432
  _has_bits_[0] &= ~0x00000002u;
444
433
}
445
434
inline void CodeGeneratorRequest::clear_parameter() {
446
 
  if (parameter_ != &_default_parameter_) {
 
435
  if (parameter_ != &::google::protobuf::internal::kEmptyString) {
447
436
    parameter_->clear();
448
437
  }
449
 
  _clear_bit(1);
 
438
  clear_has_parameter();
450
439
}
451
440
inline const ::std::string& CodeGeneratorRequest::parameter() const {
452
441
  return *parameter_;
453
442
}
454
443
inline void CodeGeneratorRequest::set_parameter(const ::std::string& value) {
455
 
  _set_bit(1);
456
 
  if (parameter_ == &_default_parameter_) {
 
444
  set_has_parameter();
 
445
  if (parameter_ == &::google::protobuf::internal::kEmptyString) {
457
446
    parameter_ = new ::std::string;
458
447
  }
459
448
  parameter_->assign(value);
460
449
}
461
450
inline void CodeGeneratorRequest::set_parameter(const char* value) {
462
 
  _set_bit(1);
463
 
  if (parameter_ == &_default_parameter_) {
 
451
  set_has_parameter();
 
452
  if (parameter_ == &::google::protobuf::internal::kEmptyString) {
464
453
    parameter_ = new ::std::string;
465
454
  }
466
455
  parameter_->assign(value);
467
456
}
468
457
inline void CodeGeneratorRequest::set_parameter(const char* value, size_t size) {
469
 
  _set_bit(1);
470
 
  if (parameter_ == &_default_parameter_) {
 
458
  set_has_parameter();
 
459
  if (parameter_ == &::google::protobuf::internal::kEmptyString) {
471
460
    parameter_ = new ::std::string;
472
461
  }
473
462
  parameter_->assign(reinterpret_cast<const char*>(value), size);
474
463
}
475
464
inline ::std::string* CodeGeneratorRequest::mutable_parameter() {
476
 
  _set_bit(1);
477
 
  if (parameter_ == &_default_parameter_) {
 
465
  set_has_parameter();
 
466
  if (parameter_ == &::google::protobuf::internal::kEmptyString) {
478
467
    parameter_ = new ::std::string;
479
468
  }
480
469
  return parameter_;
481
470
}
 
471
inline ::std::string* CodeGeneratorRequest::release_parameter() {
 
472
  clear_has_parameter();
 
473
  if (parameter_ == &::google::protobuf::internal::kEmptyString) {
 
474
    return NULL;
 
475
  } else {
 
476
    ::std::string* temp = parameter_;
 
477
    parameter_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 
478
    return temp;
 
479
  }
 
480
}
482
481
 
483
482
// repeated .google.protobuf.FileDescriptorProto proto_file = 15;
484
483
inline int CodeGeneratorRequest::proto_file_size() const {
511
510
 
512
511
// optional string name = 1;
513
512
inline bool CodeGeneratorResponse_File::has_name() const {
514
 
  return _has_bit(0);
 
513
  return (_has_bits_[0] & 0x00000001u) != 0;
 
514
}
 
515
inline void CodeGeneratorResponse_File::set_has_name() {
 
516
  _has_bits_[0] |= 0x00000001u;
 
517
}
 
518
inline void CodeGeneratorResponse_File::clear_has_name() {
 
519
  _has_bits_[0] &= ~0x00000001u;
515
520
}
516
521
inline void CodeGeneratorResponse_File::clear_name() {
517
 
  if (name_ != &_default_name_) {
 
522
  if (name_ != &::google::protobuf::internal::kEmptyString) {
518
523
    name_->clear();
519
524
  }
520
 
  _clear_bit(0);
 
525
  clear_has_name();
521
526
}
522
527
inline const ::std::string& CodeGeneratorResponse_File::name() const {
523
528
  return *name_;
524
529
}
525
530
inline void CodeGeneratorResponse_File::set_name(const ::std::string& value) {
526
 
  _set_bit(0);
527
 
  if (name_ == &_default_name_) {
 
531
  set_has_name();
 
532
  if (name_ == &::google::protobuf::internal::kEmptyString) {
528
533
    name_ = new ::std::string;
529
534
  }
530
535
  name_->assign(value);
531
536
}
532
537
inline void CodeGeneratorResponse_File::set_name(const char* value) {
533
 
  _set_bit(0);
534
 
  if (name_ == &_default_name_) {
 
538
  set_has_name();
 
539
  if (name_ == &::google::protobuf::internal::kEmptyString) {
535
540
    name_ = new ::std::string;
536
541
  }
537
542
  name_->assign(value);
538
543
}
539
544
inline void CodeGeneratorResponse_File::set_name(const char* value, size_t size) {
540
 
  _set_bit(0);
541
 
  if (name_ == &_default_name_) {
 
545
  set_has_name();
 
546
  if (name_ == &::google::protobuf::internal::kEmptyString) {
542
547
    name_ = new ::std::string;
543
548
  }
544
549
  name_->assign(reinterpret_cast<const char*>(value), size);
545
550
}
546
551
inline ::std::string* CodeGeneratorResponse_File::mutable_name() {
547
 
  _set_bit(0);
548
 
  if (name_ == &_default_name_) {
 
552
  set_has_name();
 
553
  if (name_ == &::google::protobuf::internal::kEmptyString) {
549
554
    name_ = new ::std::string;
550
555
  }
551
556
  return name_;
552
557
}
 
558
inline ::std::string* CodeGeneratorResponse_File::release_name() {
 
559
  clear_has_name();
 
560
  if (name_ == &::google::protobuf::internal::kEmptyString) {
 
561
    return NULL;
 
562
  } else {
 
563
    ::std::string* temp = name_;
 
564
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 
565
    return temp;
 
566
  }
 
567
}
553
568
 
554
569
// optional string insertion_point = 2;
555
570
inline bool CodeGeneratorResponse_File::has_insertion_point() const {
556
 
  return _has_bit(1);
 
571
  return (_has_bits_[0] & 0x00000002u) != 0;
 
572
}
 
573
inline void CodeGeneratorResponse_File::set_has_insertion_point() {
 
574
  _has_bits_[0] |= 0x00000002u;
 
575
}
 
576
inline void CodeGeneratorResponse_File::clear_has_insertion_point() {
 
577
  _has_bits_[0] &= ~0x00000002u;
557
578
}
558
579
inline void CodeGeneratorResponse_File::clear_insertion_point() {
559
 
  if (insertion_point_ != &_default_insertion_point_) {
 
580
  if (insertion_point_ != &::google::protobuf::internal::kEmptyString) {
560
581
    insertion_point_->clear();
561
582
  }
562
 
  _clear_bit(1);
 
583
  clear_has_insertion_point();
563
584
}
564
585
inline const ::std::string& CodeGeneratorResponse_File::insertion_point() const {
565
586
  return *insertion_point_;
566
587
}
567
588
inline void CodeGeneratorResponse_File::set_insertion_point(const ::std::string& value) {
568
 
  _set_bit(1);
569
 
  if (insertion_point_ == &_default_insertion_point_) {
 
589
  set_has_insertion_point();
 
590
  if (insertion_point_ == &::google::protobuf::internal::kEmptyString) {
570
591
    insertion_point_ = new ::std::string;
571
592
  }
572
593
  insertion_point_->assign(value);
573
594
}
574
595
inline void CodeGeneratorResponse_File::set_insertion_point(const char* value) {
575
 
  _set_bit(1);
576
 
  if (insertion_point_ == &_default_insertion_point_) {
 
596
  set_has_insertion_point();
 
597
  if (insertion_point_ == &::google::protobuf::internal::kEmptyString) {
577
598
    insertion_point_ = new ::std::string;
578
599
  }
579
600
  insertion_point_->assign(value);
580
601
}
581
602
inline void CodeGeneratorResponse_File::set_insertion_point(const char* value, size_t size) {
582
 
  _set_bit(1);
583
 
  if (insertion_point_ == &_default_insertion_point_) {
 
603
  set_has_insertion_point();
 
604
  if (insertion_point_ == &::google::protobuf::internal::kEmptyString) {
584
605
    insertion_point_ = new ::std::string;
585
606
  }
586
607
  insertion_point_->assign(reinterpret_cast<const char*>(value), size);
587
608
}
588
609
inline ::std::string* CodeGeneratorResponse_File::mutable_insertion_point() {
589
 
  _set_bit(1);
590
 
  if (insertion_point_ == &_default_insertion_point_) {
 
610
  set_has_insertion_point();
 
611
  if (insertion_point_ == &::google::protobuf::internal::kEmptyString) {
591
612
    insertion_point_ = new ::std::string;
592
613
  }
593
614
  return insertion_point_;
594
615
}
 
616
inline ::std::string* CodeGeneratorResponse_File::release_insertion_point() {
 
617
  clear_has_insertion_point();
 
618
  if (insertion_point_ == &::google::protobuf::internal::kEmptyString) {
 
619
    return NULL;
 
620
  } else {
 
621
    ::std::string* temp = insertion_point_;
 
622
    insertion_point_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 
623
    return temp;
 
624
  }
 
625
}
595
626
 
596
627
// optional string content = 15;
597
628
inline bool CodeGeneratorResponse_File::has_content() const {
598
 
  return _has_bit(2);
 
629
  return (_has_bits_[0] & 0x00000004u) != 0;
 
630
}
 
631
inline void CodeGeneratorResponse_File::set_has_content() {
 
632
  _has_bits_[0] |= 0x00000004u;
 
633
}
 
634
inline void CodeGeneratorResponse_File::clear_has_content() {
 
635
  _has_bits_[0] &= ~0x00000004u;
599
636
}
600
637
inline void CodeGeneratorResponse_File::clear_content() {
601
 
  if (content_ != &_default_content_) {
 
638
  if (content_ != &::google::protobuf::internal::kEmptyString) {
602
639
    content_->clear();
603
640
  }
604
 
  _clear_bit(2);
 
641
  clear_has_content();
605
642
}
606
643
inline const ::std::string& CodeGeneratorResponse_File::content() const {
607
644
  return *content_;
608
645
}
609
646
inline void CodeGeneratorResponse_File::set_content(const ::std::string& value) {
610
 
  _set_bit(2);
611
 
  if (content_ == &_default_content_) {
 
647
  set_has_content();
 
648
  if (content_ == &::google::protobuf::internal::kEmptyString) {
612
649
    content_ = new ::std::string;
613
650
  }
614
651
  content_->assign(value);
615
652
}
616
653
inline void CodeGeneratorResponse_File::set_content(const char* value) {
617
 
  _set_bit(2);
618
 
  if (content_ == &_default_content_) {
 
654
  set_has_content();
 
655
  if (content_ == &::google::protobuf::internal::kEmptyString) {
619
656
    content_ = new ::std::string;
620
657
  }
621
658
  content_->assign(value);
622
659
}
623
660
inline void CodeGeneratorResponse_File::set_content(const char* value, size_t size) {
624
 
  _set_bit(2);
625
 
  if (content_ == &_default_content_) {
 
661
  set_has_content();
 
662
  if (content_ == &::google::protobuf::internal::kEmptyString) {
626
663
    content_ = new ::std::string;
627
664
  }
628
665
  content_->assign(reinterpret_cast<const char*>(value), size);
629
666
}
630
667
inline ::std::string* CodeGeneratorResponse_File::mutable_content() {
631
 
  _set_bit(2);
632
 
  if (content_ == &_default_content_) {
 
668
  set_has_content();
 
669
  if (content_ == &::google::protobuf::internal::kEmptyString) {
633
670
    content_ = new ::std::string;
634
671
  }
635
672
  return content_;
636
673
}
 
674
inline ::std::string* CodeGeneratorResponse_File::release_content() {
 
675
  clear_has_content();
 
676
  if (content_ == &::google::protobuf::internal::kEmptyString) {
 
677
    return NULL;
 
678
  } else {
 
679
    ::std::string* temp = content_;
 
680
    content_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 
681
    return temp;
 
682
  }
 
683
}
637
684
 
638
685
// -------------------------------------------------------------------
639
686
 
641
688
 
642
689
// optional string error = 1;
643
690
inline bool CodeGeneratorResponse::has_error() const {
644
 
  return _has_bit(0);
 
691
  return (_has_bits_[0] & 0x00000001u) != 0;
 
692
}
 
693
inline void CodeGeneratorResponse::set_has_error() {
 
694
  _has_bits_[0] |= 0x00000001u;
 
695
}
 
696
inline void CodeGeneratorResponse::clear_has_error() {
 
697
  _has_bits_[0] &= ~0x00000001u;
645
698
}
646
699
inline void CodeGeneratorResponse::clear_error() {
647
 
  if (error_ != &_default_error_) {
 
700
  if (error_ != &::google::protobuf::internal::kEmptyString) {
648
701
    error_->clear();
649
702
  }
650
 
  _clear_bit(0);
 
703
  clear_has_error();
651
704
}
652
705
inline const ::std::string& CodeGeneratorResponse::error() const {
653
706
  return *error_;
654
707
}
655
708
inline void CodeGeneratorResponse::set_error(const ::std::string& value) {
656
 
  _set_bit(0);
657
 
  if (error_ == &_default_error_) {
 
709
  set_has_error();
 
710
  if (error_ == &::google::protobuf::internal::kEmptyString) {
658
711
    error_ = new ::std::string;
659
712
  }
660
713
  error_->assign(value);
661
714
}
662
715
inline void CodeGeneratorResponse::set_error(const char* value) {
663
 
  _set_bit(0);
664
 
  if (error_ == &_default_error_) {
 
716
  set_has_error();
 
717
  if (error_ == &::google::protobuf::internal::kEmptyString) {
665
718
    error_ = new ::std::string;
666
719
  }
667
720
  error_->assign(value);
668
721
}
669
722
inline void CodeGeneratorResponse::set_error(const char* value, size_t size) {
670
 
  _set_bit(0);
671
 
  if (error_ == &_default_error_) {
 
723
  set_has_error();
 
724
  if (error_ == &::google::protobuf::internal::kEmptyString) {
672
725
    error_ = new ::std::string;
673
726
  }
674
727
  error_->assign(reinterpret_cast<const char*>(value), size);
675
728
}
676
729
inline ::std::string* CodeGeneratorResponse::mutable_error() {
677
 
  _set_bit(0);
678
 
  if (error_ == &_default_error_) {
 
730
  set_has_error();
 
731
  if (error_ == &::google::protobuf::internal::kEmptyString) {
679
732
    error_ = new ::std::string;
680
733
  }
681
734
  return error_;
682
735
}
 
736
inline ::std::string* CodeGeneratorResponse::release_error() {
 
737
  clear_has_error();
 
738
  if (error_ == &::google::protobuf::internal::kEmptyString) {
 
739
    return NULL;
 
740
  } else {
 
741
    ::std::string* temp = error_;
 
742
    error_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
 
743
    return temp;
 
744
  }
 
745
}
683
746
 
684
747
// repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
685
748
inline int CodeGeneratorResponse::file_size() const {