← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mozc/oneiric

« back to all changes in this revision

Viewing changes to protobuf/files/src/google/protobuf/compiler/plugin.pb.cc

  • Committer: Bazaar Package Importer
  • Author(s): Nobuhiro Iwamatsu
  • Date: 2010-07-14 03:26:47 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100714032647-13qjisj6m8cm8jdx
Tags: 0.12.410.102-1
http://bugs.debian.org/588971
http://bugs.debian.org/588972
* New upstream release (Closes: #588971).
  - Add mozc-server, mozc-utils-gui and scim-mozc packages.
* Update debian/rules.
  Add --gypdir option to build_mozc.py.
* Update debian/control.
  - Bumped standards-version to 3.9.0.
  - Update description.
* Add mozc icon (Closes: #588972).
* Add patch which revises issue 18.
  ibus_mozc_issue18.patch
* kFreeBSD build support.
  support_kfreebsd.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
protobuf/files/src/google/protobuf/compiler/plugin.pb.cc
1
 
// Generated by the protocol buffer compiler.  DO NOT EDIT!
2
 
 
3
 
#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
4
 
#include "google/protobuf/compiler/plugin.pb.h"
5
 
 
6
 
#include <algorithm>
7
 
 
8
 
#include <google/protobuf/stubs/once.h>
9
 
#include <google/protobuf/io/coded_stream.h>
10
 
#include <google/protobuf/wire_format_lite_inl.h>
11
 
#include <google/protobuf/descriptor.h>
12
 
#include <google/protobuf/reflection_ops.h>
13
 
#include <google/protobuf/wire_format.h>
14
 
// @@protoc_insertion_point(includes)
15
 
 
16
 
namespace google {
17
 
namespace protobuf {
18
 
namespace compiler {
19
 
 
20
 
namespace {
21
 
 
22
 
const ::google::protobuf::Descriptor* CodeGeneratorRequest_descriptor_ = NULL;
23
 
const ::google::protobuf::internal::GeneratedMessageReflection*
24
 
  CodeGeneratorRequest_reflection_ = NULL;
25
 
const ::google::protobuf::Descriptor* CodeGeneratorResponse_descriptor_ = NULL;
26
 
const ::google::protobuf::internal::GeneratedMessageReflection*
27
 
  CodeGeneratorResponse_reflection_ = NULL;
28
 
const ::google::protobuf::Descriptor* CodeGeneratorResponse_File_descriptor_ = NULL;
29
 
const ::google::protobuf::internal::GeneratedMessageReflection*
30
 
  CodeGeneratorResponse_File_reflection_ = NULL;
31
 
 
32
 
}  // namespace
33
 
 
34
 
 
35
 
void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto() {
36
 
  protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
37
 
  const ::google::protobuf::FileDescriptor* file =
38
 
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
39
 
      "google/protobuf/compiler/plugin.proto");
40
 
  GOOGLE_CHECK(file != NULL);
41
 
  CodeGeneratorRequest_descriptor_ = file->message_type(0);
42
 
  static const int CodeGeneratorRequest_offsets_[3] = {
43
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, file_to_generate_),
44
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, parameter_),
45
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, proto_file_),
46
 
  };
47
 
  CodeGeneratorRequest_reflection_ =
48
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
49
 
      CodeGeneratorRequest_descriptor_,
50
 
      CodeGeneratorRequest::default_instance_,
51
 
      CodeGeneratorRequest_offsets_,
52
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, _has_bits_[0]),
53
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, _unknown_fields_),
54
 
      -1,
55
 
      ::google::protobuf::DescriptorPool::generated_pool(),
56
 
      ::google::protobuf::MessageFactory::generated_factory(),
57
 
      sizeof(CodeGeneratorRequest));
58
 
  CodeGeneratorResponse_descriptor_ = file->message_type(1);
59
 
  static const int CodeGeneratorResponse_offsets_[2] = {
60
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse, error_),
61
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse, file_),
62
 
  };
63
 
  CodeGeneratorResponse_reflection_ =
64
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
65
 
      CodeGeneratorResponse_descriptor_,
66
 
      CodeGeneratorResponse::default_instance_,
67
 
      CodeGeneratorResponse_offsets_,
68
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse, _has_bits_[0]),
69
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse, _unknown_fields_),
70
 
      -1,
71
 
      ::google::protobuf::DescriptorPool::generated_pool(),
72
 
      ::google::protobuf::MessageFactory::generated_factory(),
73
 
      sizeof(CodeGeneratorResponse));
74
 
  CodeGeneratorResponse_File_descriptor_ = CodeGeneratorResponse_descriptor_->nested_type(0);
75
 
  static const int CodeGeneratorResponse_File_offsets_[3] = {
76
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, name_),
77
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, insertion_point_),
78
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, content_),
79
 
  };
80
 
  CodeGeneratorResponse_File_reflection_ =
81
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
82
 
      CodeGeneratorResponse_File_descriptor_,
83
 
      CodeGeneratorResponse_File::default_instance_,
84
 
      CodeGeneratorResponse_File_offsets_,
85
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, _has_bits_[0]),
86
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, _unknown_fields_),
87
 
      -1,
88
 
      ::google::protobuf::DescriptorPool::generated_pool(),
89
 
      ::google::protobuf::MessageFactory::generated_factory(),
90
 
      sizeof(CodeGeneratorResponse_File));
91
 
}
92
 
 
93
 
namespace {
94
 
 
95
 
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
96
 
inline void protobuf_AssignDescriptorsOnce() {
97
 
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
98
 
                 &protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto);
99
 
}
100
 
 
101
 
void protobuf_RegisterTypes(const ::std::string&) {
102
 
  protobuf_AssignDescriptorsOnce();
103
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
104
 
    CodeGeneratorRequest_descriptor_, &CodeGeneratorRequest::default_instance());
105
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
106
 
    CodeGeneratorResponse_descriptor_, &CodeGeneratorResponse::default_instance());
107
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
108
 
    CodeGeneratorResponse_File_descriptor_, &CodeGeneratorResponse_File::default_instance());
109
 
}
110
 
 
111
 
}  // namespace
112
 
 
113
 
void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto() {
114
 
  delete CodeGeneratorRequest::default_instance_;
115
 
  delete CodeGeneratorRequest_reflection_;
116
 
  delete CodeGeneratorResponse::default_instance_;
117
 
  delete CodeGeneratorResponse_reflection_;
118
 
  delete CodeGeneratorResponse_File::default_instance_;
119
 
  delete CodeGeneratorResponse_File_reflection_;
120
 
}
121
 
 
122
 
void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto() {
123
 
  static bool already_here = false;
124
 
  if (already_here) return;
125
 
  already_here = true;
126
 
  GOOGLE_PROTOBUF_VERIFY_VERSION;
127
 
 
128
 
  ::google::protobuf::protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
129
 
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
130
 
    "\n%google/protobuf/compiler/plugin.proto\022"
131
 
    "\030google.protobuf.compiler\032 google/protob"
132
 
    "uf/descriptor.proto\"}\n\024CodeGeneratorRequ"
133
 
    "est\022\030\n\020file_to_generate\030\001 \003(\t\022\021\n\tparamet"
134
 
    "er\030\002 \001(\t\0228\n\nproto_file\030\017 \003(\0132$.google.pr"
135
 
    "otobuf.FileDescriptorProto\"\252\001\n\025CodeGener"
136
 
    "atorResponse\022\r\n\005error\030\001 \001(\t\022B\n\004file\030\017 \003("
137
 
    "\01324.google.protobuf.compiler.CodeGenerat"
138
 
    "orResponse.File\032>\n\004File\022\014\n\004name\030\001 \001(\t\022\027\n"
139
 
    "\017insertion_point\030\002 \001(\t\022\017\n\007content\030\017 \001(\t", 399);
140
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
141
 
    "google/protobuf/compiler/plugin.proto", &protobuf_RegisterTypes);
142
 
  CodeGeneratorRequest::default_instance_ = new CodeGeneratorRequest();
143
 
  CodeGeneratorResponse::default_instance_ = new CodeGeneratorResponse();
144
 
  CodeGeneratorResponse_File::default_instance_ = new CodeGeneratorResponse_File();
145
 
  CodeGeneratorRequest::default_instance_->InitAsDefaultInstance();
146
 
  CodeGeneratorResponse::default_instance_->InitAsDefaultInstance();
147
 
  CodeGeneratorResponse_File::default_instance_->InitAsDefaultInstance();
148
 
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto);
149
 
}
150
 
 
151
 
// Force AddDescriptors() to be called at static initialization time.
152
 
struct StaticDescriptorInitializer_google_2fprotobuf_2fcompiler_2fplugin_2eproto {
153
 
  StaticDescriptorInitializer_google_2fprotobuf_2fcompiler_2fplugin_2eproto() {
154
 
    protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
155
 
  }
156
 
} static_descriptor_initializer_google_2fprotobuf_2fcompiler_2fplugin_2eproto_;
157
 
 
158
 
 
159
 
// ===================================================================
160
 
 
161
 
const ::std::string CodeGeneratorRequest::_default_parameter_;
162
 
#ifndef _MSC_VER
163
 
const int CodeGeneratorRequest::kFileToGenerateFieldNumber;
164
 
const int CodeGeneratorRequest::kParameterFieldNumber;
165
 
const int CodeGeneratorRequest::kProtoFileFieldNumber;
166
 
#endif  // !_MSC_VER
167
 
 
168
 
CodeGeneratorRequest::CodeGeneratorRequest()
169
 
  : ::google::protobuf::Message() {
170
 
  SharedCtor();
171
 
}
172
 
 
173
 
void CodeGeneratorRequest::InitAsDefaultInstance() {
174
 
}
175
 
 
176
 
CodeGeneratorRequest::CodeGeneratorRequest(const CodeGeneratorRequest& from)
177
 
  : ::google::protobuf::Message() {
178
 
  SharedCtor();
179
 
  MergeFrom(from);
180
 
}
181
 
 
182
 
void CodeGeneratorRequest::SharedCtor() {
183
 
  _cached_size_ = 0;
184
 
  parameter_ = const_cast< ::std::string*>(&_default_parameter_);
185
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
186
 
}
187
 
 
188
 
CodeGeneratorRequest::~CodeGeneratorRequest() {
189
 
  SharedDtor();
190
 
}
191
 
 
192
 
void CodeGeneratorRequest::SharedDtor() {
193
 
  if (parameter_ != &_default_parameter_) {
194
 
    delete parameter_;
195
 
  }
196
 
  if (this != default_instance_) {
197
 
  }
198
 
}
199
 
 
200
 
void CodeGeneratorRequest::SetCachedSize(int size) const {
201
 
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
202
 
  _cached_size_ = size;
203
 
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
204
 
}
205
 
const ::google::protobuf::Descriptor* CodeGeneratorRequest::descriptor() {
206
 
  protobuf_AssignDescriptorsOnce();
207
 
  return CodeGeneratorRequest_descriptor_;
208
 
}
209
 
 
210
 
const CodeGeneratorRequest& CodeGeneratorRequest::default_instance() {
211
 
  if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();  return *default_instance_;
212
 
}
213
 
 
214
 
CodeGeneratorRequest* CodeGeneratorRequest::default_instance_ = NULL;
215
 
 
216
 
CodeGeneratorRequest* CodeGeneratorRequest::New() const {
217
 
  return new CodeGeneratorRequest;
218
 
}
219
 
 
220
 
void CodeGeneratorRequest::Clear() {
221
 
  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
222
 
    if (_has_bit(1)) {
223
 
      if (parameter_ != &_default_parameter_) {
224
 
        parameter_->clear();
225
 
      }
226
 
    }
227
 
  }
228
 
  file_to_generate_.Clear();
229
 
  proto_file_.Clear();
230
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
231
 
  mutable_unknown_fields()->Clear();
232
 
}
233
 
 
234
 
bool CodeGeneratorRequest::MergePartialFromCodedStream(
235
 
    ::google::protobuf::io::CodedInputStream* input) {
236
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
237
 
  ::google::protobuf::uint32 tag;
238
 
  while ((tag = input->ReadTag()) != 0) {
239
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
240
 
      // repeated string file_to_generate = 1;
241
 
      case 1: {
242
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
243
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
244
 
         parse_file_to_generate:
245
 
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
246
 
                input, this->add_file_to_generate()));
247
 
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
248
 
            this->file_to_generate(0).data(), this->file_to_generate(0).length(),
249
 
            ::google::protobuf::internal::WireFormat::PARSE);
250
 
        } else {
251
 
          goto handle_uninterpreted;
252
 
        }
253
 
        if (input->ExpectTag(10)) goto parse_file_to_generate;
254
 
        if (input->ExpectTag(18)) goto parse_parameter;
255
 
        break;
256
 
      }
257
 
      
258
 
      // optional string parameter = 2;
259
 
      case 2: {
260
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
261
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
262
 
         parse_parameter:
263
 
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
264
 
                input, this->mutable_parameter()));
265
 
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
266
 
            this->parameter().data(), this->parameter().length(),
267
 
            ::google::protobuf::internal::WireFormat::PARSE);
268
 
        } else {
269
 
          goto handle_uninterpreted;
270
 
        }
271
 
        if (input->ExpectTag(122)) goto parse_proto_file;
272
 
        break;
273
 
      }
274
 
      
275
 
      // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
276
 
      case 15: {
277
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
278
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
279
 
         parse_proto_file:
280
 
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
281
 
                input, add_proto_file()));
282
 
        } else {
283
 
          goto handle_uninterpreted;
284
 
        }
285
 
        if (input->ExpectTag(122)) goto parse_proto_file;
286
 
        if (input->ExpectAtEnd()) return true;
287
 
        break;
288
 
      }
289
 
      
290
 
      default: {
291
 
      handle_uninterpreted:
292
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
293
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
294
 
          return true;
295
 
        }
296
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
297
 
              input, tag, mutable_unknown_fields()));
298
 
        break;
299
 
      }
300
 
    }
301
 
  }
302
 
  return true;
303
 
#undef DO_
304
 
}
305
 
 
306
 
void CodeGeneratorRequest::SerializeWithCachedSizes(
307
 
    ::google::protobuf::io::CodedOutputStream* output) const {
308
 
  // repeated string file_to_generate = 1;
309
 
  for (int i = 0; i < this->file_to_generate_size(); i++) {
310
 
  ::google::protobuf::internal::WireFormat::VerifyUTF8String(
311
 
    this->file_to_generate(i).data(), this->file_to_generate(i).length(),
312
 
    ::google::protobuf::internal::WireFormat::SERIALIZE);
313
 
    ::google::protobuf::internal::WireFormatLite::WriteString(
314
 
      1, this->file_to_generate(i), output);
315
 
  }
316
 
  
317
 
  // optional string parameter = 2;
318
 
  if (_has_bit(1)) {
319
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
320
 
      this->parameter().data(), this->parameter().length(),
321
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
322
 
    ::google::protobuf::internal::WireFormatLite::WriteString(
323
 
      2, this->parameter(), output);
324
 
  }
325
 
  
326
 
  // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
327
 
  for (int i = 0; i < this->proto_file_size(); i++) {
328
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
329
 
      15, this->proto_file(i), output);
330
 
  }
331
 
  
332
 
  if (!unknown_fields().empty()) {
333
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
334
 
        unknown_fields(), output);
335
 
  }
336
 
}
337
 
 
338
 
::google::protobuf::uint8* CodeGeneratorRequest::SerializeWithCachedSizesToArray(
339
 
    ::google::protobuf::uint8* target) const {
340
 
  // repeated string file_to_generate = 1;
341
 
  for (int i = 0; i < this->file_to_generate_size(); i++) {
342
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
343
 
      this->file_to_generate(i).data(), this->file_to_generate(i).length(),
344
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
345
 
    target = ::google::protobuf::internal::WireFormatLite::
346
 
      WriteStringToArray(1, this->file_to_generate(i), target);
347
 
  }
348
 
  
349
 
  // optional string parameter = 2;
350
 
  if (_has_bit(1)) {
351
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
352
 
      this->parameter().data(), this->parameter().length(),
353
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
354
 
    target =
355
 
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
356
 
        2, this->parameter(), target);
357
 
  }
358
 
  
359
 
  // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
360
 
  for (int i = 0; i < this->proto_file_size(); i++) {
361
 
    target = ::google::protobuf::internal::WireFormatLite::
362
 
      WriteMessageNoVirtualToArray(
363
 
        15, this->proto_file(i), target);
364
 
  }
365
 
  
366
 
  if (!unknown_fields().empty()) {
367
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
368
 
        unknown_fields(), target);
369
 
  }
370
 
  return target;
371
 
}
372
 
 
373
 
int CodeGeneratorRequest::ByteSize() const {
374
 
  int total_size = 0;
375
 
  
376
 
  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
377
 
    // optional string parameter = 2;
378
 
    if (has_parameter()) {
379
 
      total_size += 1 +
380
 
        ::google::protobuf::internal::WireFormatLite::StringSize(
381
 
          this->parameter());
382
 
    }
383
 
    
384
 
  }
385
 
  // repeated string file_to_generate = 1;
386
 
  total_size += 1 * this->file_to_generate_size();
387
 
  for (int i = 0; i < this->file_to_generate_size(); i++) {
388
 
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
389
 
      this->file_to_generate(i));
390
 
  }
391
 
  
392
 
  // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
393
 
  total_size += 1 * this->proto_file_size();
394
 
  for (int i = 0; i < this->proto_file_size(); i++) {
395
 
    total_size +=
396
 
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
397
 
        this->proto_file(i));
398
 
  }
399
 
  
400
 
  if (!unknown_fields().empty()) {
401
 
    total_size +=
402
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
403
 
        unknown_fields());
404
 
  }
405
 
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
406
 
  _cached_size_ = total_size;
407
 
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
408
 
  return total_size;
409
 
}
410
 
 
411
 
void CodeGeneratorRequest::MergeFrom(const ::google::protobuf::Message& from) {
412
 
  GOOGLE_CHECK_NE(&from, this);
413
 
  const CodeGeneratorRequest* source =
414
 
    ::google::protobuf::internal::dynamic_cast_if_available<const CodeGeneratorRequest*>(
415
 
      &from);
416
 
  if (source == NULL) {
417
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
418
 
  } else {
419
 
    MergeFrom(*source);
420
 
  }
421
 
}
422
 
 
423
 
void CodeGeneratorRequest::MergeFrom(const CodeGeneratorRequest& from) {
424
 
  GOOGLE_CHECK_NE(&from, this);
425
 
  file_to_generate_.MergeFrom(from.file_to_generate_);
426
 
  proto_file_.MergeFrom(from.proto_file_);
427
 
  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
428
 
    if (from._has_bit(1)) {
429
 
      set_parameter(from.parameter());
430
 
    }
431
 
  }
432
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
433
 
}
434
 
 
435
 
void CodeGeneratorRequest::CopyFrom(const ::google::protobuf::Message& from) {
436
 
  if (&from == this) return;
437
 
  Clear();
438
 
  MergeFrom(from);
439
 
}
440
 
 
441
 
void CodeGeneratorRequest::CopyFrom(const CodeGeneratorRequest& from) {
442
 
  if (&from == this) return;
443
 
  Clear();
444
 
  MergeFrom(from);
445
 
}
446
 
 
447
 
bool CodeGeneratorRequest::IsInitialized() const {
448
 
  
449
 
  for (int i = 0; i < proto_file_size(); i++) {
450
 
    if (!this->proto_file(i).IsInitialized()) return false;
451
 
  }
452
 
  return true;
453
 
}
454
 
 
455
 
void CodeGeneratorRequest::Swap(CodeGeneratorRequest* other) {
456
 
  if (other != this) {
457
 
    file_to_generate_.Swap(&other->file_to_generate_);
458
 
    std::swap(parameter_, other->parameter_);
459
 
    proto_file_.Swap(&other->proto_file_);
460
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
461
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
462
 
    std::swap(_cached_size_, other->_cached_size_);
463
 
  }
464
 
}
465
 
 
466
 
::google::protobuf::Metadata CodeGeneratorRequest::GetMetadata() const {
467
 
  protobuf_AssignDescriptorsOnce();
468
 
  ::google::protobuf::Metadata metadata;
469
 
  metadata.descriptor = CodeGeneratorRequest_descriptor_;
470
 
  metadata.reflection = CodeGeneratorRequest_reflection_;
471
 
  return metadata;
472
 
}
473
 
 
474
 
 
475
 
// ===================================================================
476
 
 
477
 
const ::std::string CodeGeneratorResponse_File::_default_name_;
478
 
const ::std::string CodeGeneratorResponse_File::_default_insertion_point_;
479
 
const ::std::string CodeGeneratorResponse_File::_default_content_;
480
 
#ifndef _MSC_VER
481
 
const int CodeGeneratorResponse_File::kNameFieldNumber;
482
 
const int CodeGeneratorResponse_File::kInsertionPointFieldNumber;
483
 
const int CodeGeneratorResponse_File::kContentFieldNumber;
484
 
#endif  // !_MSC_VER
485
 
 
486
 
CodeGeneratorResponse_File::CodeGeneratorResponse_File()
487
 
  : ::google::protobuf::Message() {
488
 
  SharedCtor();
489
 
}
490
 
 
491
 
void CodeGeneratorResponse_File::InitAsDefaultInstance() {
492
 
}
493
 
 
494
 
CodeGeneratorResponse_File::CodeGeneratorResponse_File(const CodeGeneratorResponse_File& from)
495
 
  : ::google::protobuf::Message() {
496
 
  SharedCtor();
497
 
  MergeFrom(from);
498
 
}
499
 
 
500
 
void CodeGeneratorResponse_File::SharedCtor() {
501
 
  _cached_size_ = 0;
502
 
  name_ = const_cast< ::std::string*>(&_default_name_);
503
 
  insertion_point_ = const_cast< ::std::string*>(&_default_insertion_point_);
504
 
  content_ = const_cast< ::std::string*>(&_default_content_);
505
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
506
 
}
507
 
 
508
 
CodeGeneratorResponse_File::~CodeGeneratorResponse_File() {
509
 
  SharedDtor();
510
 
}
511
 
 
512
 
void CodeGeneratorResponse_File::SharedDtor() {
513
 
  if (name_ != &_default_name_) {
514
 
    delete name_;
515
 
  }
516
 
  if (insertion_point_ != &_default_insertion_point_) {
517
 
    delete insertion_point_;
518
 
  }
519
 
  if (content_ != &_default_content_) {
520
 
    delete content_;
521
 
  }
522
 
  if (this != default_instance_) {
523
 
  }
524
 
}
525
 
 
526
 
void CodeGeneratorResponse_File::SetCachedSize(int size) const {
527
 
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
528
 
  _cached_size_ = size;
529
 
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
530
 
}
531
 
const ::google::protobuf::Descriptor* CodeGeneratorResponse_File::descriptor() {
532
 
  protobuf_AssignDescriptorsOnce();
533
 
  return CodeGeneratorResponse_File_descriptor_;
534
 
}
535
 
 
536
 
const CodeGeneratorResponse_File& CodeGeneratorResponse_File::default_instance() {
537
 
  if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();  return *default_instance_;
538
 
}
539
 
 
540
 
CodeGeneratorResponse_File* CodeGeneratorResponse_File::default_instance_ = NULL;
541
 
 
542
 
CodeGeneratorResponse_File* CodeGeneratorResponse_File::New() const {
543
 
  return new CodeGeneratorResponse_File;
544
 
}
545
 
 
546
 
void CodeGeneratorResponse_File::Clear() {
547
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
548
 
    if (_has_bit(0)) {
549
 
      if (name_ != &_default_name_) {
550
 
        name_->clear();
551
 
      }
552
 
    }
553
 
    if (_has_bit(1)) {
554
 
      if (insertion_point_ != &_default_insertion_point_) {
555
 
        insertion_point_->clear();
556
 
      }
557
 
    }
558
 
    if (_has_bit(2)) {
559
 
      if (content_ != &_default_content_) {
560
 
        content_->clear();
561
 
      }
562
 
    }
563
 
  }
564
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
565
 
  mutable_unknown_fields()->Clear();
566
 
}
567
 
 
568
 
bool CodeGeneratorResponse_File::MergePartialFromCodedStream(
569
 
    ::google::protobuf::io::CodedInputStream* input) {
570
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
571
 
  ::google::protobuf::uint32 tag;
572
 
  while ((tag = input->ReadTag()) != 0) {
573
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
574
 
      // optional string name = 1;
575
 
      case 1: {
576
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
577
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
578
 
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
579
 
                input, this->mutable_name()));
580
 
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
581
 
            this->name().data(), this->name().length(),
582
 
            ::google::protobuf::internal::WireFormat::PARSE);
583
 
        } else {
584
 
          goto handle_uninterpreted;
585
 
        }
586
 
        if (input->ExpectTag(18)) goto parse_insertion_point;
587
 
        break;
588
 
      }
589
 
      
590
 
      // optional string insertion_point = 2;
591
 
      case 2: {
592
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
593
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
594
 
         parse_insertion_point:
595
 
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
596
 
                input, this->mutable_insertion_point()));
597
 
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
598
 
            this->insertion_point().data(), this->insertion_point().length(),
599
 
            ::google::protobuf::internal::WireFormat::PARSE);
600
 
        } else {
601
 
          goto handle_uninterpreted;
602
 
        }
603
 
        if (input->ExpectTag(122)) goto parse_content;
604
 
        break;
605
 
      }
606
 
      
607
 
      // optional string content = 15;
608
 
      case 15: {
609
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
610
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
611
 
         parse_content:
612
 
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
613
 
                input, this->mutable_content()));
614
 
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
615
 
            this->content().data(), this->content().length(),
616
 
            ::google::protobuf::internal::WireFormat::PARSE);
617
 
        } else {
618
 
          goto handle_uninterpreted;
619
 
        }
620
 
        if (input->ExpectAtEnd()) return true;
621
 
        break;
622
 
      }
623
 
      
624
 
      default: {
625
 
      handle_uninterpreted:
626
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
627
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
628
 
          return true;
629
 
        }
630
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
631
 
              input, tag, mutable_unknown_fields()));
632
 
        break;
633
 
      }
634
 
    }
635
 
  }
636
 
  return true;
637
 
#undef DO_
638
 
}
639
 
 
640
 
void CodeGeneratorResponse_File::SerializeWithCachedSizes(
641
 
    ::google::protobuf::io::CodedOutputStream* output) const {
642
 
  // optional string name = 1;
643
 
  if (_has_bit(0)) {
644
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
645
 
      this->name().data(), this->name().length(),
646
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
647
 
    ::google::protobuf::internal::WireFormatLite::WriteString(
648
 
      1, this->name(), output);
649
 
  }
650
 
  
651
 
  // optional string insertion_point = 2;
652
 
  if (_has_bit(1)) {
653
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
654
 
      this->insertion_point().data(), this->insertion_point().length(),
655
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
656
 
    ::google::protobuf::internal::WireFormatLite::WriteString(
657
 
      2, this->insertion_point(), output);
658
 
  }
659
 
  
660
 
  // optional string content = 15;
661
 
  if (_has_bit(2)) {
662
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
663
 
      this->content().data(), this->content().length(),
664
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
665
 
    ::google::protobuf::internal::WireFormatLite::WriteString(
666
 
      15, this->content(), output);
667
 
  }
668
 
  
669
 
  if (!unknown_fields().empty()) {
670
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
671
 
        unknown_fields(), output);
672
 
  }
673
 
}
674
 
 
675
 
::google::protobuf::uint8* CodeGeneratorResponse_File::SerializeWithCachedSizesToArray(
676
 
    ::google::protobuf::uint8* target) const {
677
 
  // optional string name = 1;
678
 
  if (_has_bit(0)) {
679
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
680
 
      this->name().data(), this->name().length(),
681
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
682
 
    target =
683
 
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
684
 
        1, this->name(), target);
685
 
  }
686
 
  
687
 
  // optional string insertion_point = 2;
688
 
  if (_has_bit(1)) {
689
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
690
 
      this->insertion_point().data(), this->insertion_point().length(),
691
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
692
 
    target =
693
 
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
694
 
        2, this->insertion_point(), target);
695
 
  }
696
 
  
697
 
  // optional string content = 15;
698
 
  if (_has_bit(2)) {
699
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
700
 
      this->content().data(), this->content().length(),
701
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
702
 
    target =
703
 
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
704
 
        15, this->content(), target);
705
 
  }
706
 
  
707
 
  if (!unknown_fields().empty()) {
708
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
709
 
        unknown_fields(), target);
710
 
  }
711
 
  return target;
712
 
}
713
 
 
714
 
int CodeGeneratorResponse_File::ByteSize() const {
715
 
  int total_size = 0;
716
 
  
717
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
718
 
    // optional string name = 1;
719
 
    if (has_name()) {
720
 
      total_size += 1 +
721
 
        ::google::protobuf::internal::WireFormatLite::StringSize(
722
 
          this->name());
723
 
    }
724
 
    
725
 
    // optional string insertion_point = 2;
726
 
    if (has_insertion_point()) {
727
 
      total_size += 1 +
728
 
        ::google::protobuf::internal::WireFormatLite::StringSize(
729
 
          this->insertion_point());
730
 
    }
731
 
    
732
 
    // optional string content = 15;
733
 
    if (has_content()) {
734
 
      total_size += 1 +
735
 
        ::google::protobuf::internal::WireFormatLite::StringSize(
736
 
          this->content());
737
 
    }
738
 
    
739
 
  }
740
 
  if (!unknown_fields().empty()) {
741
 
    total_size +=
742
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
743
 
        unknown_fields());
744
 
  }
745
 
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
746
 
  _cached_size_ = total_size;
747
 
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
748
 
  return total_size;
749
 
}
750
 
 
751
 
void CodeGeneratorResponse_File::MergeFrom(const ::google::protobuf::Message& from) {
752
 
  GOOGLE_CHECK_NE(&from, this);
753
 
  const CodeGeneratorResponse_File* source =
754
 
    ::google::protobuf::internal::dynamic_cast_if_available<const CodeGeneratorResponse_File*>(
755
 
      &from);
756
 
  if (source == NULL) {
757
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
758
 
  } else {
759
 
    MergeFrom(*source);
760
 
  }
761
 
}
762
 
 
763
 
void CodeGeneratorResponse_File::MergeFrom(const CodeGeneratorResponse_File& from) {
764
 
  GOOGLE_CHECK_NE(&from, this);
765
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
766
 
    if (from._has_bit(0)) {
767
 
      set_name(from.name());
768
 
    }
769
 
    if (from._has_bit(1)) {
770
 
      set_insertion_point(from.insertion_point());
771
 
    }
772
 
    if (from._has_bit(2)) {
773
 
      set_content(from.content());
774
 
    }
775
 
  }
776
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
777
 
}
778
 
 
779
 
void CodeGeneratorResponse_File::CopyFrom(const ::google::protobuf::Message& from) {
780
 
  if (&from == this) return;
781
 
  Clear();
782
 
  MergeFrom(from);
783
 
}
784
 
 
785
 
void CodeGeneratorResponse_File::CopyFrom(const CodeGeneratorResponse_File& from) {
786
 
  if (&from == this) return;
787
 
  Clear();
788
 
  MergeFrom(from);
789
 
}
790
 
 
791
 
bool CodeGeneratorResponse_File::IsInitialized() const {
792
 
  
793
 
  return true;
794
 
}
795
 
 
796
 
void CodeGeneratorResponse_File::Swap(CodeGeneratorResponse_File* other) {
797
 
  if (other != this) {
798
 
    std::swap(name_, other->name_);
799
 
    std::swap(insertion_point_, other->insertion_point_);
800
 
    std::swap(content_, other->content_);
801
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
802
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
803
 
    std::swap(_cached_size_, other->_cached_size_);
804
 
  }
805
 
}
806
 
 
807
 
::google::protobuf::Metadata CodeGeneratorResponse_File::GetMetadata() const {
808
 
  protobuf_AssignDescriptorsOnce();
809
 
  ::google::protobuf::Metadata metadata;
810
 
  metadata.descriptor = CodeGeneratorResponse_File_descriptor_;
811
 
  metadata.reflection = CodeGeneratorResponse_File_reflection_;
812
 
  return metadata;
813
 
}
814
 
 
815
 
 
816
 
// -------------------------------------------------------------------
817
 
 
818
 
const ::std::string CodeGeneratorResponse::_default_error_;
819
 
#ifndef _MSC_VER
820
 
const int CodeGeneratorResponse::kErrorFieldNumber;
821
 
const int CodeGeneratorResponse::kFileFieldNumber;
822
 
#endif  // !_MSC_VER
823
 
 
824
 
CodeGeneratorResponse::CodeGeneratorResponse()
825
 
  : ::google::protobuf::Message() {
826
 
  SharedCtor();
827
 
}
828
 
 
829
 
void CodeGeneratorResponse::InitAsDefaultInstance() {
830
 
}
831
 
 
832
 
CodeGeneratorResponse::CodeGeneratorResponse(const CodeGeneratorResponse& from)
833
 
  : ::google::protobuf::Message() {
834
 
  SharedCtor();
835
 
  MergeFrom(from);
836
 
}
837
 
 
838
 
void CodeGeneratorResponse::SharedCtor() {
839
 
  _cached_size_ = 0;
840
 
  error_ = const_cast< ::std::string*>(&_default_error_);
841
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
842
 
}
843
 
 
844
 
CodeGeneratorResponse::~CodeGeneratorResponse() {
845
 
  SharedDtor();
846
 
}
847
 
 
848
 
void CodeGeneratorResponse::SharedDtor() {
849
 
  if (error_ != &_default_error_) {
850
 
    delete error_;
851
 
  }
852
 
  if (this != default_instance_) {
853
 
  }
854
 
}
855
 
 
856
 
void CodeGeneratorResponse::SetCachedSize(int size) const {
857
 
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
858
 
  _cached_size_ = size;
859
 
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
860
 
}
861
 
const ::google::protobuf::Descriptor* CodeGeneratorResponse::descriptor() {
862
 
  protobuf_AssignDescriptorsOnce();
863
 
  return CodeGeneratorResponse_descriptor_;
864
 
}
865
 
 
866
 
const CodeGeneratorResponse& CodeGeneratorResponse::default_instance() {
867
 
  if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();  return *default_instance_;
868
 
}
869
 
 
870
 
CodeGeneratorResponse* CodeGeneratorResponse::default_instance_ = NULL;
871
 
 
872
 
CodeGeneratorResponse* CodeGeneratorResponse::New() const {
873
 
  return new CodeGeneratorResponse;
874
 
}
875
 
 
876
 
void CodeGeneratorResponse::Clear() {
877
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
878
 
    if (_has_bit(0)) {
879
 
      if (error_ != &_default_error_) {
880
 
        error_->clear();
881
 
      }
882
 
    }
883
 
  }
884
 
  file_.Clear();
885
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
886
 
  mutable_unknown_fields()->Clear();
887
 
}
888
 
 
889
 
bool CodeGeneratorResponse::MergePartialFromCodedStream(
890
 
    ::google::protobuf::io::CodedInputStream* input) {
891
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
892
 
  ::google::protobuf::uint32 tag;
893
 
  while ((tag = input->ReadTag()) != 0) {
894
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
895
 
      // optional string error = 1;
896
 
      case 1: {
897
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
898
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
899
 
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
900
 
                input, this->mutable_error()));
901
 
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
902
 
            this->error().data(), this->error().length(),
903
 
            ::google::protobuf::internal::WireFormat::PARSE);
904
 
        } else {
905
 
          goto handle_uninterpreted;
906
 
        }
907
 
        if (input->ExpectTag(122)) goto parse_file;
908
 
        break;
909
 
      }
910
 
      
911
 
      // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
912
 
      case 15: {
913
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
914
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
915
 
         parse_file:
916
 
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
917
 
                input, add_file()));
918
 
        } else {
919
 
          goto handle_uninterpreted;
920
 
        }
921
 
        if (input->ExpectTag(122)) goto parse_file;
922
 
        if (input->ExpectAtEnd()) return true;
923
 
        break;
924
 
      }
925
 
      
926
 
      default: {
927
 
      handle_uninterpreted:
928
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
929
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
930
 
          return true;
931
 
        }
932
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
933
 
              input, tag, mutable_unknown_fields()));
934
 
        break;
935
 
      }
936
 
    }
937
 
  }
938
 
  return true;
939
 
#undef DO_
940
 
}
941
 
 
942
 
void CodeGeneratorResponse::SerializeWithCachedSizes(
943
 
    ::google::protobuf::io::CodedOutputStream* output) const {
944
 
  // optional string error = 1;
945
 
  if (_has_bit(0)) {
946
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
947
 
      this->error().data(), this->error().length(),
948
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
949
 
    ::google::protobuf::internal::WireFormatLite::WriteString(
950
 
      1, this->error(), output);
951
 
  }
952
 
  
953
 
  // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
954
 
  for (int i = 0; i < this->file_size(); i++) {
955
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
956
 
      15, this->file(i), output);
957
 
  }
958
 
  
959
 
  if (!unknown_fields().empty()) {
960
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
961
 
        unknown_fields(), output);
962
 
  }
963
 
}
964
 
 
965
 
::google::protobuf::uint8* CodeGeneratorResponse::SerializeWithCachedSizesToArray(
966
 
    ::google::protobuf::uint8* target) const {
967
 
  // optional string error = 1;
968
 
  if (_has_bit(0)) {
969
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
970
 
      this->error().data(), this->error().length(),
971
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
972
 
    target =
973
 
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
974
 
        1, this->error(), target);
975
 
  }
976
 
  
977
 
  // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
978
 
  for (int i = 0; i < this->file_size(); i++) {
979
 
    target = ::google::protobuf::internal::WireFormatLite::
980
 
      WriteMessageNoVirtualToArray(
981
 
        15, this->file(i), target);
982
 
  }
983
 
  
984
 
  if (!unknown_fields().empty()) {
985
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
986
 
        unknown_fields(), target);
987
 
  }
988
 
  return target;
989
 
}
990
 
 
991
 
int CodeGeneratorResponse::ByteSize() const {
992
 
  int total_size = 0;
993
 
  
994
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
995
 
    // optional string error = 1;
996
 
    if (has_error()) {
997
 
      total_size += 1 +
998
 
        ::google::protobuf::internal::WireFormatLite::StringSize(
999
 
          this->error());
1000
 
    }
1001
 
    
1002
 
  }
1003
 
  // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
1004
 
  total_size += 1 * this->file_size();
1005
 
  for (int i = 0; i < this->file_size(); i++) {
1006
 
    total_size +=
1007
 
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1008
 
        this->file(i));
1009
 
  }
1010
 
  
1011
 
  if (!unknown_fields().empty()) {
1012
 
    total_size +=
1013
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1014
 
        unknown_fields());
1015
 
  }
1016
 
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1017
 
  _cached_size_ = total_size;
1018
 
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
1019
 
  return total_size;
1020
 
}
1021
 
 
1022
 
void CodeGeneratorResponse::MergeFrom(const ::google::protobuf::Message& from) {
1023
 
  GOOGLE_CHECK_NE(&from, this);
1024
 
  const CodeGeneratorResponse* source =
1025
 
    ::google::protobuf::internal::dynamic_cast_if_available<const CodeGeneratorResponse*>(
1026
 
      &from);
1027
 
  if (source == NULL) {
1028
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1029
 
  } else {
1030
 
    MergeFrom(*source);
1031
 
  }
1032
 
}
1033
 
 
1034
 
void CodeGeneratorResponse::MergeFrom(const CodeGeneratorResponse& from) {
1035
 
  GOOGLE_CHECK_NE(&from, this);
1036
 
  file_.MergeFrom(from.file_);
1037
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1038
 
    if (from._has_bit(0)) {
1039
 
      set_error(from.error());
1040
 
    }
1041
 
  }
1042
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
1043
 
}
1044
 
 
1045
 
void CodeGeneratorResponse::CopyFrom(const ::google::protobuf::Message& from) {
1046
 
  if (&from == this) return;
1047
 
  Clear();
1048
 
  MergeFrom(from);
1049
 
}
1050
 
 
1051
 
void CodeGeneratorResponse::CopyFrom(const CodeGeneratorResponse& from) {
1052
 
  if (&from == this) return;
1053
 
  Clear();
1054
 
  MergeFrom(from);
1055
 
}
1056
 
 
1057
 
bool CodeGeneratorResponse::IsInitialized() const {
1058
 
  
1059
 
  return true;
1060
 
}
1061
 
 
1062
 
void CodeGeneratorResponse::Swap(CodeGeneratorResponse* other) {
1063
 
  if (other != this) {
1064
 
    std::swap(error_, other->error_);
1065
 
    file_.Swap(&other->file_);
1066
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
1067
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
1068
 
    std::swap(_cached_size_, other->_cached_size_);
1069
 
  }
1070
 
}
1071
 
 
1072
 
::google::protobuf::Metadata CodeGeneratorResponse::GetMetadata() const {
1073
 
  protobuf_AssignDescriptorsOnce();
1074
 
  ::google::protobuf::Metadata metadata;
1075
 
  metadata.descriptor = CodeGeneratorResponse_descriptor_;
1076
 
  metadata.reflection = CodeGeneratorResponse_reflection_;
1077
 
  return metadata;
1078
 
}
1079
 
 
1080
 
 
1081
 
// @@protoc_insertion_point(namespace_scope)
1082
 
 
1083
 
}  // namespace compiler
1084
 
}  // namespace protobuf
1085
 
}  // namespace google
1086
 
 
1087
 
// @@protoc_insertion_point(global_scope)